Logical

In arithmetic instructions, we view the content of a register as a single number, either signed or unsigned integer. In logical instructions, we have to have a new perspective. We will view the register as a raw 32-bits binary rather than a single 32-bit numbers. In particular, we want to be able to operate on individual bits or bytes within the register.

Operations

Truth Tables

In these truth tables, we use 0 to represent false and 1 to represent true.

From the truth table, we can also see that:

• a NOR b is equivalent to NOT (a OR b) (i.e., not or is combined into nor).
• a XOR b is equivalent to a != b (i.e., exclusive or).

Logical Operations

Shifting

The truth tables are only applicable for the bitwise operations. For shifting, we will have to describe the operation another way.

1

sll $rd, $rt, shamt

1

$rd = $rt << shamt;

1

srl $rd, $rt, shamt

1

$rd = $rt >> shamt;

1

sll $t2, $s0, 4   # $t2 = $s0 << 4; // in MipC

1

srl $t2, $s0, 4   # $t2 = $s0 >> 4; // in MipC

There is a nice property of shifting that has the decimal counterpart. Consider shifting a number to the left and filling the emptied position with zeroes. Assuming that we have enough digits, if we start with a number 123, we will get 1230. That is simply multiplication by 10. Similarly, for binary, shifting to the left is multiplication by 2 since we are looking at base 2.

Right shift is harder. If we start with 1230, then to get 123, we simply divide by 10. But this only works if the last digit is 0. In C, this is basically integer division.

Bitwise

1

and $rd, $rs, $rt

1

$rd = $rs & $rt;

1

or $rd, $rs, $rt

1

$rd = $rs | $rt;

1

xor $rd, $rs, $rt

1

$rd = $rs ^ $rt;

1

nor $rd, $rs, $rt

Bitwise AND, OR and XOR have the immediate variants: andi, ori and xori. Strangely, there is no immediate variant for NOR. In other words, there is no nori. Here, the same design principle as before is applicable.

In particular, we can use other instructions to implement the same functionality as a hypothetical nori.

Another strange fact is that there is no bitwise NOT operation. To be more precise, there is no operation that accepts one operand similar to the hypothetical not $rd, $rs. However, this can be done using bitwise NOR.

1

nor $rd, $rs, $zero

1

xor $rd, $rs, $rt

Large Constant

Let us take a look at the problem of large constant again now that we know about logical operations.

Naive Implementation

A naive implementation will will be to simply perform the following three operations: ori, sll and ori. The first ori is to put the upper half of the large constant into the lower half of the register. We then use the shift left logical operation to move this to the upper half. Once we have done that, the lower half will be all 0s. This 0s can be set into the lower half of the large constant using another ori.

1
2
3

ori $t0, $zero, 0xAAAA    # t0 = 0x0000AAAA
sll $t0, $t0  , 16        # t0 = 0xAAAA0000
ori $t0, $t0, 0xF0F0      # t0 = 0xAAAAF0F0

Special Instruction

Since a large constant may be needed a lot, MIPS provide a way to combine the first two operations. Note that due to the way the instruction is assembled, we cannot combine the three instructions. This special instruction is a real instruction called load upper immediate (lui) and not a pseudo-instruction.

1
2

lui $t0, 0xAAAA           # t0 = 0xAAAA0000
ori $t0, $t0, 0xF0F0      # t0 = 0xAAAAF0F0