First, I'm going to do everything in bytes.
A 64-bit word means 8 bytes.
Line size: 8 words in a line, means 8 x 8 bytes = 64 bytes in a line = 26 bytes.
Cache size: 4k words, meaning 4096 x 8 bytes = 32k total bytes.
Cache indexes: 32k total bytes / 8 way set associative = 215 / 23 = 212 index positions in the cache line-set array.
Main memory: 1024 MBits = 1024 * 220 = 230 and, 230 / 8 bits-per-byte = 227 bytes (or 128 Mbytes).
So, that means there are 27 addressing bits in total for the cacheable memory. Those 27 bits break down into 3 parts:
| tag | index | rest |
The "index", which is 12-bits in width, is used to lookup into the cache array to identify one cache line set.
The tag bits are used to isolate one of the lines in the set of 8 (or determine a miss).
The "rest" bits determine which bytes in the 64-byte line are the particular bytes of interest for a given memory reference instruction. More precisely, the rest bits indicate the first byte of interest, and the memory reference instruction encodes the number of bytes of interest (e.g. 1, 2, 4, 8).
Since the line size is 64-bytes, then the "rest" is 6 bits; these 6 bits are used after the cache lookup identifies the line (on hit).
That means that the tag, which makes up the remainder, must be 27-12-6 = 9 bits wide. A tag of this size is stored in the each cache line in the set for comparison with the tag in the address bits.
So, the 27 bits of address break down into 9 tag bits, 12 index bits, and 6 "rest" bits. The cache line lookup operation consumes the 9 tag bits and 12 index bits, and, after the line is identified, the rest bits (and instruction-specified length) are used to extract the bytes of interest.