Understanding the Jump Instruction

---

Understanding the Jump Instruction  

 

The implementation of the jump instruction and how MIPS constructs the jump-to-

address leads to an interesting understanding about how MIPS works. We know that the 

jump-to-address is constructed in the following way: 

 

1.

 

We take the immediate address in the jump instruction itself, which is the 26 

lower order bits from the Jump instruction itself. 

2.

 

We shift this immediate address of 26 bits by two bits to make it 28 bits; by-

the-way this can be thought of as concatenating 2 zero bits to the lower order 

end of the 26 bits. This is equivalent to multiplying the 26 bit binary number 

by 4. 

3.

 

Then we take the upper order 4 bits of the PC, which has already been updated 

to reflect the next instruction address in sequence, and concatenate these 4 bits 

on to the higher order – left end – of the 28 bits to give the 32 bit binary 

number, which is now the jump address. 

 

This is clearly explained in our text. But the real deeper question is why do we do this 

and what is the implication or what assumptions about MIPS makes this work. The first 

two steps are fairly straight forward. For example, the shifting in step two, in fact 

implements the multiplying of the 26 bit address by 4, since the immediate address is in 

terms of words and we need the address in terms of bytes for the MIPS machine.  

 

But it is the last step, or third step, that is not self evident. We can explain it this way. In 

MIPS we consider a fully addressable memory space of 2

32 

bytes. Let us suppose that 

memory is subdivided into 16 blocks of 2

28

 bytes each, which is (2

8

)*(2

20

) bytes= 256 

MB = 64 MWords of 32 bits. Now each block is named by a four bit address , so 

there will be the 16 blocks <0000>, <0001>, <0010>, …<1111> . The actual addresses 

within a block will all be 32 bits long and all will start at the higher order end with what 

we have called the 4 bit block address and the lower order 28 bits will be any number 

between zero and (2

28

)-1. Thus the actual addresses within lets say block <0101> will be 

32 bit long and all start with 0101 in the bits [31-28].   

 

The MIPS compiler is forced to put a program within one block only, so that all 

statements within a program will be in actual 32 bit addresses that start with the block 

address.   

 

Now a jump instruction is considered to use pseudo-direct addressing in our book. This is 

so because the immediate address multiplied by 4 is the actual address in a block so it is 

direct addressing within the block of up to 2

28

 addresses. It is pseudo, that is not true 

direct addressing, because we need to add on to the address the block address.  It could as 

easily been called pseudo-relative addressing since the immediate address (multiplied by 

4) of 28 bits is being added to the address of the first byte in the block 

which has the actual 32 bit address of to give the address 

of 32 bits.  Note that the immediate address must be positive since it is a 

cosc2021 M. Mandelbaum Oct. 19, 2003 

---

real address within a block and not an offset in the normal way and thus it is not a signed 

number as it is in the branch or load and store instructions. 

 

Now the .text portion of our program is all put into one block of memory as described 

above by the rules of MIPS. However, if we use two text portions in our program then it 

is possible that MIPS may put one in one block and the other in another block of 

memory. 

 

 

cosc2021 M. Mandelbaum Oct. 19, 2003