Branching and Calling Functions

We can see all of the relevant combinations of instructions with the following block of code:

  if ( ia ) { printf("x\n"); } else { printf("y\n"); }
  if ( ca ) { printf("x\n"); } else { printf("y\n"); }
  if ( la ) { printf("x\n"); } else { printf("y\n"); }
  if ( ca == 0 ) { printf("x\n"); } else { printf("y\n"); }
  if ( uca == 0 ) { printf("x\n"); } else { printf("y\n"); }

  if ( ia == ib ) { printf("x\n"); } else { printf("y\n"); }
  if ( ca == cb ) { printf("x\n"); } else { printf("y\n"); }
  if ( uca == ucb ) { printf("x\n"); } else { printf("y\n"); }
  if ( la == lb ) { printf("x\n"); } else { printf("y\n"); }

  if ( ia == 2 ) { printf("x\n"); } else { printf("y\n"); }
  if ( ca == 2 ) { printf("x\n"); } else { printf("y\n"); }
  if ( uca == 2 ) { printf("x\n"); } else { printf("y\n"); }
  if ( la == 2 ) { printf("x\n"); } else { printf("y\n"); }

  if ( 2 == ia ) { printf("x\n"); } else { printf("y\n"); }
  if ( 2 == ca ) { printf("x\n"); } else { printf("y\n"); }
  if ( 2 == uca ) { printf("x\n"); } else { printf("y\n"); }
  if ( 2 == la ) { printf("x\n"); } else { printf("y\n"); }

  if ( 0 == ia ) { printf("x\n"); } else { printf("y\n"); }
  if ( 0 == ca ) { printf("x\n"); } else { printf("y\n"); }
  if ( 0 == uca ) { printf("x\n"); } else { printf("y\n"); }
  if ( 0 == la ) { printf("x\n"); } else { printf("y\n"); }

For brevity, in the assembly we will only show the printf calls and else clause for the first case.

AMD64

The equivalent assembly is shown in the following tables, organized by related statements:

Here, we see that evaluating an integer as a boolean expression is equivalent to comparing with 0. The comparison instruction is cmpl, cmpb, or cmpq. This tests for equality, and is typically followed by a jump instruction (je for “jump if equal” or jne for “jump if not equal”).

The argument to the jump instruction is a label in the assembly code, which when run becomes the address of the target instruction. Because of the else clause, the first block ends with a jump (jmp) to the instruction after the if/else statement. The gcc compiler is generating slightly different code for if (ia) than if (ia == 0), choosing a je for the former and jne for the latter, reversing the true and false blocks.

To call a function, we set up the arguments to the function, and then execute the callq instruction. In the assembly, we specify the symbol for the target function, and when run this is replaced with the address of the first instruction of the function. This is similar to what we saw for jmp in the conditional.

The instructions preceding callq will vary greatly, but it is worth taking a quick look at the leaq (load effective address) instruction. While movl -8(%rbp), -12(%rbp) would move the value of ia to ib, the instruction leaq -8(%rbp), -12(%rbp) would move the address rbp-8 to ib.

For variable comparisons, we see familiar patterns. One or both variables is loaded into a register, and then we do a comparison and conditional jump as in the previous block of statements.

Here we see that comparing a variable with a literal integer value, we have very similar code to when we were doing a comparison with 0. The order in which we compare (ia == 2 vs 2 == ia) produces the same assembly.

The comparison 0 == ia interestingly produces different instructions. Instead of using a literal $0, we instead use xorl to set the value of eax to 0, and compare with that. The result of the xor is stored in the second argument.

AArch64

The equivalent assembly is shown in the following table:

For the comparisons, we see the same pattern as for AMD64: compare with 0 and then either “branch-if-equal” (beq) or “branch-if-not-equal” (bne), depending on whether we are doing if(ia) or if(ia==0). The main difference is that, as is often the case, for AArch64 we first load (with ldr or ldrb) the variable’s value into a register.

When calling a function, we again prepare the stack, and then “branch with link” (bl) to the function, which is the equivalent of callq on AMD64. For the conditional flow, the “branch” (b) instruction is the equivalent of jmp.

When comparing two integer variables, we see almost the same pattern, but instead of comparing a register with a literal, we load the values into two registers and compare those. Other than for int, the pattern is identical to what we saw with AMD64.

Comparing with a non-zero literal looks the same as comparing with zero. We still load the value into a register, and compare that register with the literal.

Reversing the order of the variable and literal have no effect on the generated assembly, in contrast with the equivalent assembly generated for AMD64.