Compares & Branches

Sometimes we may have portions of a program that we only want executed under certain conditions. You can think of it in plain English. Such as.... If this, then do that. If not this, then don't do that. Compares and Branches will allow you to create alternative routes/paths within your Program. Let's cover Branches first.

To understand the branch instruction better, let's go over a small snippet of code that includes a branch instruction

b 0x8 #Branch to the stw instruction
li r3, 1 #This gets jumped over
stw r3, 0 (r31)

The term "unconditional" means that the branch will occur regardless of any condition (always execute). A branch is a jump. The SIMM value determines how "far" to jump. Any instructions that get jumped over by the branch do *NOT* get executed. Back in Chapter 3, you've learned that every PowerPC instruction is 32-bits (4 bytes) in size. This means a branch SIMM of 0x4 is useless, as the branch will literally go to the very next instruction below.

Since the branch in the above code snippet has a SIMM of 0x8, it will "jump" over and skip execution of the li instruction. Due to the fact the branch instructions use an SIMM value, this means that yes you can "jump" backwards.

The larger the jump, the hardest it is to manually calculate the correct SIMM to use. Therefore, we use a trick called Branch Labels.

b the_label

By using labels, the Assembler will calculate the SIMMs for us. You can name the labels anything you want as long as you omit special characters (i.e. $). Here's the same code as earlier but using labels.

b the_label

li r3, 1

the_label:
stw r3, 0 (r31)

In the above code, the branch will force the execution of the CPU to jump/skip over the li instruction, and "land" at the stw instruction.

When you supply a label for a branch instruction, its "landing spot" must contain the same exact label name, but be appended with a colon.

Moving onto Conditional Branches... Conditional branches are branches that only execute base on an 'if'. For example let's look at the 'branch if equal' instruction...

beq the_label

li r8, 1

the_label:
stw r8, 0 (r31)

the_label will only be 'jumped' to if and only if the most previous condition was met. This type of branch requires a Comparison instruction beforehand. There are only four different integer-based compare instructions for PowerPC. Let's go over the most common one.

Compare Word Immediate
cmpwi rD, SIMM #The comparison is SIGNED! This is important!

What occurs is that a signed comparison is made between what's in rD vs SIMM. A subsequent conditional branch would be placed underneath to branch based on the result of the comparison.

cmpwi r10, 0xC
beq the_label

li r8, 1

the_label:
stw r8, 0 (r31)

Here is a picture of the above example of code.
Magenta Arrows = General Execution Path of CPU
Green Arrows = Path if r10 equals 0xC
Red Arrows = Path if r10 is NOT equal to 0xC

cmpwi r10, 0xC
beq the_label

li r8, 1

b the_end

the_label:
stw r8, 0 (r31)

the_end:
stw r3, 0x0010 (r24)

Let's view an image of the above code.
Magenta Arrows = General Execution Path of CPU
Green Arrows = Path if r10 equals 0xC
Red Arrows = Path if r10 is NOT equal to 0xC

There are many conditional branch instructions, here's a list of some of them...

cmpw is just like cmpwi except that we are now comparing two register values against each other.

Compare Logical Word Immediate
cmplwi rD, UIMM #Compare rD vs UIMM. The comparison is UNsigned!

Compare Logical Word
cmplw rD, rA #Compare rD vs rA. The comparison is UNsigned!

What's important is that you must understand how using the wrong type of compare instruction (signed vs unsigned) can cause unintended consequences. When do I used signed comparisons? When do I used unsigned comparisons? You use signed comparisons if negative values are possible *AND* you want them to be treated as negative values. So let's say 0xFFFFFFF0 is possible, and you want it to be treated as negative (-10), then a signed comparison would be appropriate.

If your subsequent branch is a beq or bne, then the above comparison instruction type (signed vs unsigned) is IRRELEVANT! Why is this?

Well let's say we are comparing r0 vs the immediate value of 50. If r0 is equal to 50, we take a branch. The code would look like this..

cmpwi r0, 50
beq- somewhere

If you used an unsigned comparison, the effects form this code remain the same..

cmplwi r0, 50
beq- somewhere

This is because you are checking for an equal comparison. Whether or not the values are signed or unsigned, makes zero different in the result of the comparisons. This leads to zero difference on whether or not the conditional branch is taken. In conclusion, you can choose either comparison type if and only if the subsequent branch is a beq or bne.

Signed vs UNsigned comparison matters when you are dealing with any subsequent branch that involves a "greater than" or "less than". Those branches would be blt, bgt, ble, and bge.

cmpw r7, r9

Now remember we can determine how the values are treated via what kind of compare instruction we are using. Let's say we want the values to be treated as Signed. We will also pretend, we want the execution of this code to take a branch if and only if r7 is greater than r9. Since we want the values treated as Signed and we want a Branch for when r7 > r9, we have the following two instructions

cmpw r7, r9 #Compare r7 vs r9, Signed
bgt somewhere #If r7 > r9, take the branch

Now in the above code, the conditional branch (bgt), will **NOT** be taken. r7 contains the value of -1 because 0xFFFFFFFF is being treated as Signed. r9 contains the value of 160 (0xA0). -1 is **NOT** greater than 160. Thus, the conditional branch is skipped.

cmplw r7, r9 #Compare r7 vs w9 as unsigned
bgt somewhere #If r7 > r9take the branch

Would the branch be taken? YES, it would. Confused? Let's go over it. Since the comparison of r7 vs r9 is UNsigned this will cause r7 to be interpreted as the value of 4,294,967,295 instead of -1. r9 is still 160.

Okay, you've now learned about compares and branches. Let's do a quick exercise using your new skills. We want to write a Source of code that does the following...

Let's pretend the word value in question is located at the address in r12. We will use r6 for our multiplication operation. Now we need to start off with a lwz instruction ofc. Let's write it out...

lwz r6, 0 (r12) #Load our word value from memory into r6

Our word value is now in r6. Remember we can only perform the multiplication if it's 0 or positive. Well we know we need a comparison instruction + conditional branch instruction. We should be using a compare instruction against the value of 0. Why? Well since the multiplication can only be allowed to perform if the loaded value is 0 or positive, it would make sense to use 0 as the "reference point" or "middle ground" for our compare instruction.

What kind of conditional branch though? Well the phrase "0 or positive" is just an alternative saying for "greater than equal to 0". This implies that negative values are indeed possible. Since that is the case, we should be using a Signed Compariosn instruction..

Therefore, we should be using the cmpwi instruction followed by a blt branch instruction. Let's apply the blt branch with the attached label name "done" and see what our code looks like now.

lwz r6, 0 (r12) #Load our word value from memory into r6
cmpwi r6, 0 #Compare value in r6 against Zero; Signed compare
blt done #If w6 is less than Zero, branch to the "done:" label

Now the question is, where do we make the conditional branch land at? Well that's simple, we will have it at the very end of our Source. To do that, the "done:" label will be at the very bottom of our Source. Before we place that in and view our current progress, let's cover the multiplication operation.

mulli r6, r6, 13 #old r6 x 13 = new r6

In the mulli instruction, we've set r6 as the Destination Register to overwrite the old r6 value. You could of course use a different register as a scratch/temp register, but there's no need to waste an unnecessary use of a another register.

Okay we got our multiplication completed. We need to store it back to where we've loaded it from.

stw r6, 0 (r12) #Store new value back to where we've loaded it from

Alright, remember that "done:" label that we need? Well since it has to be the last item of our Source, and the stw instruction is our last PPC instruction, the label must be underneath the stw instruction. With all of that being stated, here is our complete source...

lwz r6, (r12) #Load our value from memory into r6
cmpwi r6, 0 #Compare value in r6 against Zero; Signed
blt done #If r6 is less than Zero, branch to the "done:" label
mulli r6, r6, 13 #old r6 x 13 = new r6
stw r6, 0 (r12) #Store new value back to where we've loaded it from
done:

Final Notes:
It's important to understand the conditional branch instruction "analyzes" the results from the MOST RECENT compare instruction.

Also, in a lot of PowerPC programs, you will see a "+" or "-" symbol appended to a conditional branch mnemonic. Example...

cmplw r10, r20
bgt+ somewhere

These are branch hints. They give the PPC CPU a hint if a conditional branch is more or less likely to occur.

If no hint is supplied to the Assembler, then a less-likely hint (-) is used. As a beginner, you don't need to worry about supplying branch hints in your code.

PowerPC Tutorial