PowerPC Tutorial

Previous Chapter

Chapter 14: Logical Operations

Section 1: Fundamentals

Logical Operation Instructions are Instructions that compute a result using Binary/Bit operation. We need to go over some basic vocab first before diving into actual Instructions.

The far left-hand bit of any value in a register is known as the "Sign Bit" or the "Most Significant Bit" (aka MSB). The far right-hand bit of any value in a register is known as the "Least Significant Bit" (aka LSB).

Each Bit has an assigned number that we use for easy reference, so other coders can know which bit within a register we are talking about. The MSB is bit 0. The LSB is bit 31. The bit numbers ascend as you move from left to right within a register.

The far left hand bit (first bit) is bit 0. Next bit is bit 1. Then bit 2. All the way until you hit the LSB which is bit 31. Since bit numbering ascends from left to right, this is called "Big Endian" (there's more to the term Big Endian, we're just talking about the bit numbering system).

Logical Operations are done on a bit-by-bit basis! It's important to understand this.

Let's say we have a value in r3 and we preform a logical operation instruction with the value in r27...

Bit 0 of r3 will have a logical operation done in reference to bit 0 of r27
Bit 1 of r3 will have a logical operation done in reference to bit 1 of r27
Bit 2 of r3 will have a logical operation done in reference to bit 2 of r27
etc etc...
Bit 31 of r3 will have a logical operation done in reference to bit 31 of r27

There are a maximum of 6 types of Logical Operations, they are...

The easiest way to understand each Logical Operation is with its corresponding truth table. A truth table is a table/list of the results of all 4 combinations of possible bit operations for a Logical Operation. Each Logical Operation has a unique truth table. They are actually not too hard to remember. You simply need to remember or, and, & xor. After that the other 3 truth tables (nor, nand, xnor respectively) are the just the the flipped versions of the original 3.

Section 2: Logical OR

Logical ORing is one of the most commonly used logical operations. ORing means if value #1 or value #2 is true, then the result is true.

Logical OR
Truth Table:

Input Input Result
0 0 0
0 1 1
1 0 1
1 1 1

Scaling up from binary to a hex word value, if r3 has a value of 0x00000001, and r27 has a value of 0x80000001, and these two values are OR'd together, it would produce a result of

0x80000001

Confused by this? let's break it down in binary view...

r3 - 0000 0000 0000 0000 0000 0000 0000 0001
r27 - 1000 0000 0000 0000 0000 0000 0000 0001

Remember Logical Operations are done on a per-bit basis. What occurs is this....

Every bit in the Source Register will have the Logical Operation done with its corresponding bit in the other Source Register/Immediate Value. Okay let's look at the full result in Binary view...

1000 0000 0000 0000 0000 0000 0000 0001

Convert that to Hex and you get 0x80000001.

PPC comes with the following Logical OR instructions:

or rD, rA, rB #rA is OR'd with rB, result placed in rD. This instruction comes with the ability to use the Record feature (free use of cmpwi rD, 0).

ori rD, rA, UIMM #rA is OR'd with 0x0000VVVV with VVVV being UIMM, the result is placed in rD.

oris rD, rA, UIMM #rA is OR'd with 0xVVVV0000 with VVVV being UIMM, the result is placed in rD.

Referring back from the Chapter 8, you should now have an understanding of why the usage of the lis + ori instructions was used to write entire 32-bit (word) values from scratch to a GPR.

You may find yourself in a scenario where you need set a bit high and not mess with the other bits in a register. Here's an example where we need load a value into a register, set the MSB high, then store the value back.

lwz rX, 0xZZZZ (rY)
oris rX, rX, 0x8000 #Set MSB high
stw rX, 0xZZZZ (rY)

Fyi: nop is a simplified mnemonic of "ori r0, r0, 0x0000"
Fyi: mr rD, rA is a simplified mnemonic of "or rD, rA, rA" #rA is logically OR'd with itself

Section 3: Logical AND

Another commonly used logical operation is AND. AND means if both inputs are true, then the result is true, otherwise the result is false. Here is the Truth Table for AND~

Logical AND
Truth Table:

Input Input Result
0 0 0
0 1 0
1 0 0
1 1 1

ANDing operations for PPC:

and rD, rA, rB #rA is AND'd with rB; result in rD. Comes with a Record feature if needed.

andi. rD, rA, UIMM #rA is AND'd with 0x0000VVVV with VVVV being UIMM, the result is placed in rD. A form of this instruction withOUT the Record feature does NOT exist. The upper 16 bits of rD will always result in 0x0000!

andis. rD, rA, UIMM #rA is AND'd with 0xVVVV0000 with VVVV being UIMM, the result is placed in rD. A form of this instruction withOUT the Record feature does NOT exist. The lower 16 bits of rD will always result in 0x0000!

ANDing can be a good way to check if a certain bit is high/low. Let's say a r19 has a value and you want to check if bit 30 is high. If not, take the branch...

andi. r0, r19, 0x0002 #Temporarily use r0 to place result in.
bne some_label #Replace with beq to check for low bit

If you were wanting to check if multiple bits are all high, you will need to add in a comparison instruction. Let's redo the same example as earlier but now check if BOTH bits 30 and 31 are high. If not, take branch...

andi. r0, r19, 0x0003
cmpwi r0, 0x0003
bne some_label

If you only cared if at least one of the two bits were high, then you remove the 'cmpwi r0, 0x0003' instruction.

You may find yourself in a situation where you need to test if a number is even or odd. Logical ANDing is the easiest method for such a task. Let's say...

  1. You need to check if the halfword value at memory address 0x80123458 is even or odd.
  2. Pretend r25 = 0x80123458. Pretend we will use r4 to load the halfword value into.
  3. You want to take a conditonal branch if and only if the value is odd.
  4. You want to keep r4 intact so you use r0 as a scrap regiser for the AND'ing result

Here's the code--

lhz r4, 0 (r25) #Load halfword
andi. r0, r4, 0x1 #Check if halfword is even or odd
bne- value_is_odd #Branch if odd

Section 4: Logical XOR

XOR aka Exclusive OR is a logical operation that is also pretty common. Logical XOR's only produce a true result when the inputs are opposite values. If both inputs are the same bit value, then the result is false.

Logical XOR
Truth Table:

Input Input Result
0 0 0
0 1 1
1 0 1
1 1 0

XORing operations for PPC:

xor rD, rA, rB #rA is XOR'd with rB; result in rD. Comes with a Record feature if needed.

xori rD, rA, UIMM #rA is XOR'd with 0x0000VVVV with VVVV being UIMM, the result is placed in rD.

xoris rD, rA, UIMM #rA is XOR'd with 0xVVVV0000 with VVVV being UIMM, the result is placed in rD.

A handy trick with XOR is that it can be used to flip a bit value regardless of what the current bit value is. Let's say you are working on a code where r31 is either 0 or 1. For whatever reason, you need this value to flipped (0 to 1; 1 to 0) in your code. A beginner PPC coder who isn't familiar with XORing might write a source like this..

#Check r31
cmpwi r31, 0

#Preset r31 to 1 before branch
li r31, 1

#Do branch. If branch is taken, r31 was originally 0 and is now 1, we're done
beq- done

#r31's original value was 1, make it 0
li r31, 0

#Done
done:

That source is frankly silly. Since r31's value (0 or 1) is determined by bit 31 alone, you can simply XOR bit 31 with the value of 1 to flip r31's value.

xori r31, r31, 0x0001 #Flip slot value. 0 = 1, 1 = 0. Place result in back in r31.

Section 5: Other Logical Operations

PPC also comes with...

Logical NOR is the exact opposite of OR. So if any ORing result would be 0, then NOR's result would be 1 and vice versa.

Logical NOR
Truth Table:

Input Input Result
0 0 1
0 1 0
1 0 0
1 1 0

If you logically NOR a value with itself, you will actually just flip every bit to it's opposite value. This is known as a logical NOT. You can use the simplified mnemonic 'not' to preform this type of operation.

not rD, rA #same thing as nor rD, rA, rA

Logical NAND is simply the opposite of AND.

Logical NAND
Truth Table:

Input Input Result
0 0 1
0 1 1
1 0 1
1 1 0

Now here's EQV aka XNOR (Exclusive NOR); it's the opposite of XOR.

Logical EQV aka XNOR
Truth Table:

Input Input Result
0 0 1
0 1 0
1 0 0
1 1 1

Section 6: Complement Operations; More Terms

There are two more logical operation instructions that PowerPC uses. However we need to discuss the term "complement". Complement means simply flipping every bit value within a Number. It's just another way of saying Logical NOT (NOR a value with itself) which we have just covered in the previous Section. So for example....

0x00000001 becomes 0xFFFFFFFE
0x7FFFC29A becomes 0x80003D65

Here are the two complement PowerPC instructions....

And w/ Complement:
andc rD, rA, rB #rA is AND'd with the Complment of rB. Result placed in rD

Or w/ Complement:
orc rD, rA, rB #rA is OR'd with the Complement of rB. Result in placed in rD.

The andc instruction can be used as a "bit clear" instruction. A program would load a mask. The high bits of the mask indicate which bits in the value to clear (set low) while the other bits are left alone. What does the term mask mean? A Mask is any secondary value you used to apply a logical operation with to a primary value. Back in Section 2 we had a oris example of flipping the MSB bit of a value high. The mask in that example was 0x80000000.

Example usage of andc instruction:

 
lwz r3, 0x11CC (r31) #Pretend a pre-filled mask resides here, load the mask
andc r4, r4, r3 #r3's high bits will clear out the respective bits in r4. Unrelated bits in r4 are LEFT ALONE!

Question: Vega is andc the same as nand, and is orc the same as nor?

Answer: NO, while andc may seem similar to nand, they are not the same and will yield different results. NO, while orc may seem similar to nor, they are not the same and will yield different results.

Section 7: Conclusion

Sometimes it's easier for Coders/Devs to write out Immediate Values of Logical Operation Instructions in binary form. You can do that by prepending the binary value with "0b".

Example (Logically OR r6 with r2, result is placed back into r6)

ori r6, r6, 0b10

Next Chapter

Tutorial Index