More booleans, conditionals

While we’re editing the runtime, let’s also add support for booleans.

#include <stdio.h>
#include <inttypes.h>

#define num_shift 2
#define num_mask  0b11
#define num_tag   0b00

#define bool_shift 7
#define bool_mask  0b1111111
#define bool_tag   0b0011111

extern uint64_t entry();

void print_value(uint64_t value) {
  if ((value & num_mask) == num_tag) {
    int64_t ivalue = (int64_t)value;
    printf("%" PRIi64, ivalue >> num_shift);
  } else if ((value & bool_mask) == bool_tag) {
    if (value >> bool_shift) {
      printf("true");
    } else {
      printf("false");
    }
  } else {
    printf("BAD VALUE %" PRIu64, value);
  }
}

int main(int argc, char **argv) {
  print_value(entry());
  return 0;
}

We’ll need to recompile the runtime:

$ gcc -c runtime.c -o runtime.o

We can now add support for true and false pretty easily:

let bool_shift = 7
let bool_mask = 0b1111111
let bool_tag = 0b0011111

let rec compile_exp (exp : s_exp) : directive list =
  match exp with
  (* some cases elided ... *)
  | Sym "true" -> [Mov (Reg Rax, Imm ((1 lsl bool_shift) lor bool_tag))]
  | Sym "false" -> [Mov (Reg Rax, Imm ((0 lsl bool_shift) lor bool_tag))]

Handling our other operations will be a little trickier. Let’s start with not. As a reminder, not should evaluate to true (i.e., should put the runtime representation of true into rax!) when its argument is false; otherwise, it should evaluate to false.

It seems like we need a way to compare the runtime representations of values. For this, we’ll use the x86-64 instruction cmp. cmp X,Y compares X to Y. It then sets processor flags based on the result. There are a bunch of flags, and we’ll talk about more of them later in the class; for now, we just need to know that cmp sets the flag ZF to 1 if its arguments are the same and 0 otherwise.

Flags aren’t like registers–we don’t access them directly in assembly code¹. These flags then modify the behavior of subsequent instructions. We’ll see more examples of this next lecture when we talk about conditionals. For now, we’re going to use another instruction, setz, in order to access ZF. setz takes a register² and sets the last byte of that register to 1 (i.e., 0b00000001) if ZF is set and 0 if ZF is not set.

In pseudo-assembly, how we’re going to implement the not operator:

not:    
        cmp rax, 0b00011111
        mov rax, 0
        setz rax        
        shl rax, 7
        or rax, 0b0011111

So, now we can implement not:

let bool_shift = 7
let bool_mask = 0b1111111
let bool_tag = 0b0011111

let rec compile_exp (exp : s_exp) : directive list =
  match exp with
  (* some cases elided ... *)
  | Sym "true" -> [Mov (Reg Rax, Imm ((1 lsl bool_shift) lor bool_tag))]
  | Sym "false" -> [Mov (Reg Rax, Imm ((0 lsl bool_shift) lor bool_tag))]
  | Lst [Sym "not"; arg] ->
    compile_exp arg @
    [ Cmp (Reg Rax, Imm ((0 lsl bool_shift) lor bool_tag)) (* compare rax to false *)
    ; Mov (Reg Rax, Imm 0) (* zero out rax *)
    ; Setz (Reg Rax) (* 1 if ZF is set (meaning rax contained false), 0 otherwise *)
    ; Shl (Reg Rax, Imm bool_shift) (* rax << bool_shift *)
    ; Or (Reg Rax, Imm bool_tag) (* tag rax as a boolean: rax = rax | bool_tag *)
    ]

There’s some duplicate logic here. We’re going to make a helper function called operand_of_bool, which makes an instruction operand from a boolean using shift and or:

let operand_of_bool (b : bool) : operand =
  Imm (((if b then 1 else 0) lsl bool_shift) lor bool_tag)

We can do the same thing for numbers:

let operand_of_num (x : int) : operand =
  Imm ((x lsl num_shift) lor num_tag)

(We include lor num_tag here to be symmetric with operand_to_bool, but everything would work if we left it off–why?)

Lastly, we’re going to re-use the code to convert ZF to a boolean:

let zf_to_bool: directive list =
  [Mov (Reg Rax, Imm 0) (* zero out rax *)
  ; Setz (Reg Rax) (* 1 if ZF is set, 0 otherwise *)
  ; Shl (Reg Rax, Imm bool_shift) (* rax << bool_shift *)
  ; Or (Reg Rax, Imm bool_tag) (* tag rax as a boolean: rax = rax | bool_tag *)
  ]

zf_to_bool is a list, not a function. How is that possible? Won’t it depend on the value we’re trying to convert? It does not! This is a list of instructions that set rax to the runtime representation of true if ZF is set and to the runtime representation of false otherwise.

Now we can implement zero? easily:

let rec compile_exp (exp : s_exp) : directive list =
  match exp with
  (* some cases elided ... *)
  | Sym "true" -> [Mov (Reg Rax, operand_of_bool true)]
  | Sym "false" -> [Mov (Reg Rax, operand_of_bool false)]
  | Lst [Sym "not"; arg] ->
    compile_exp arg @
    [ Cmp (Reg Rax, operand_of_bool false) ]
    @ zf_to_bool
  | Lst [Sym "zero?"; arg] ->
    compile_exp arg @
    [ Cmp (Reg Rax, operand_of_num 0) ]
    @ zf_to_bool

Lastly, we can implement num?. We can detect if a value is a number by looking at the last two bits and seeing if they are both zero. We can do that like this:

let rec compile_exp (exp : s_exp) : directive list =
  match exp with
  (* some cases elided ... *)
  | Lst [Sym "num?"; arg] ->
    compile_exp arg @
    [ And (Reg Rax, Imm num_mask); Cmp (Reg Rax, Imm num_tag) ]
    @ zf_to_bool

Now that we’ve implemented booleans, we can implement if. Our if form looks like this:

(if <test> <then> <else>)

An if expression evaluates to the then expression if test evaluates to a “truthy” value, and evaluates to the else expression otherwise. Remember that in our language, all values other than false are truthy!

What makes these conditional expressions different from operations we’ve seen before is that we’ll need to evaluate different expressions depending on the value of another expression. This is easy in the interpreter–we’ll just use OCaml’s if expression! In the compiler, we’ll rely on a feature of x86-64 that we haven’t seen yet.

Today we introduced two new concepts in x86-64 machine code: flags and jumps. Next time we’ll implement binary operations, for which we’ll need one more concept: memory. After that, though, we really won’t be further complicating our model of how the processor executes. We’ll need a few more instructions here and there, but there won’t be any more big ideas at the assembly level. This will be a blessing and a curse: the way the processor executes is relatively simple and easy to understand, which means that compiling high-level language constructs like functions is pretty challenging! It’s going to be fun.