CS 152 - Lecture 24

Cay S. Horstmann

Compiling 3

• SL3
• Generating code for expressions
• Generating code for branches and loops

SL3

• Simple imperative language
• All variables hold integers
• Expressions with + - * / function calls
• Assignment var = expr;
• Branch statement

  if (expr rel expr) stat else stat

  • else part is optional
  • rel is one of == != < <= > >=
  • stat is a simple statement or a block (sequence of statements enclosed in { })
• Repetition statement

  while (expr rel expr) stat

  Need as built-in because we don't have closures

SL3 Functions

• funName(param 1, param2, ...) {
    var varName1;
    var varName2;
    ...
    stat1
    stat2
    ...
    return expr;
  }

• Parameters and return values are integers
• Local variables are declared at the top of the function (like in C)
• Local variables are initialized with 0
• Return must be the last statement in the function body

SL3 Example Program

main() {
  print(fac(3));
  return 0;
}

fac(n) {
  var f;
  var i;
  f = 1;
  i = 1;
  while (i <= n) {
    f = f * i;
    i = i + 1;
  }
  return f;
}

• Program execution starts in main
• print is a special function that prints an integer

SL3 Compiler

• Compiles to Java bytecodes
• Uses BCEL
• Generates one class
• SL3 functions → JVM static methods
• public static void main(String[]) calls main()
• print method is always added
• About 250 lines of Scala: SL3.scala

Compiling Arithmetic Expressions

• Expression tree contains subexpressions with correct precedence

    +
   / \
  3   *
     / \
     4 5

• Push left, push right, apply operator

  case Operator(left, right, op) => {
    codeof(left)
    codeof(right)
    il.append(InstructionFactory.createBinaryOperation(op, Type.INT))
  } 

• iconst 3
  iconst 4
  iconst 5
  imul
  iadd

Compiling Expressions

• Constant: Translate to iconst
• Variable: Translate to iload
• Fortunately, BCEL keeps tracks of indexes

  mg.getLocalVariables().find(_.getName() == name) match { case Some(v) => 
    il.append(InstructionFactory.createLoad(v.getType, v.getIndex))
  }

• Function call: Push the arguments, call the function

  args.foreach(codeof _)
  il.append(factory.createInvoke(className, f.name,
    Type.INT, f.params.map(x => Type.INT).toArray, // return type, param types
    Constants.INVOKESTATIC))

• Special case for print

Compiling Branches

• IfStat(BoolOp(expr1, expr2, rel), body1, optBody2) becomes

    expr1
    expr2
    isub
    if !rel goto :label1
    body1
    goto :label2
  :label1 nop
    body2
  :label2 nop

• Code for computing branch condition

  codeof(expr1)
  codeof(expr2)
  il.append(InstructionFactory.createBinaryOperation("-", Type.INT))
  val instr1 = InstructionFactory.createBranchInstruction(notrel2op(rel), null)
  il.append(instr1)
   ...
  instr1.setTarget(il.append(InstructionConstants.NOP))

• The inverted relation is precomputed

  val notrel2op = Map(">=" -> Constants.IFLT, ">" -> Constants.IFLE, 
    "<=" -> Constants.IFGT, "<" -> Constants.IFGE, 
    "!=" -> Constants.IFEQ, "==" -> Constants.IFNE)

Compiling Loops

• WhileStat(BoolOp(expr1, expr2, rel), body) becomes

  :label1 nop
    expr1
    expr2
    isub
    if !rel goto :label2
    body
    goto :label1
  :label2 nop

• Code for body is generated recursively

  val loc = il.append(InstructionConstants.NOP)
  codeof(expr1)
  codeof(expr2)
  il.append(InstructionFactory.createBinaryOperation("-", Type.INT))
  val instr = InstructionFactory.createBranchInstruction(notrel2op(rel), null)
  il.append(instr)
  codeofBlock(body)
  il.append(InstructionFactory.createBranchInstruction(Constants.GOTO, loc))
  instr.setTarget(il.append(InstructionConstants.NOP))

• That's all. Now you know how to write a compiler

What Did We Achieve?

• Parsing: Use Scala combinator parser to turn program text into tree structure
• Evaluating expressions: Simple recursive algorithm on tree structure
• Symbol table: holds (name, value) pairs
• Scope: Use different tables in different places of the program
• Closures: Code + bindings of free variables
• SL1 Interpreter: A language with closures
• SL3 Compiler: Generate JVM instructions
• What else does the Java compiler do? (Not much...classes, fields, exceptions)

What Else Did We Achieve in this Course?

• Functional programming
• Functions are first class citizens
• Recursion and higher-order functions can replace loops
• Mutable state is not necessary
  • Except once, to implement recursion
• Types
  • Compile-time checking beats runtime error reporting
  • Advanced type systems can track much more than array stores
• Logic programming
  • Specify what is true, not how it should be computed
• The languages that you use in your career will have some of these features

Lab

Step 1: Try the Compiler

1. Download and unzip the SBT project in sl3.zip
2. If you use Eclipse, run sbt eclipse in the sl3 directory and import the project.
3. Start the program and paste in the factorial program from slide 5. Hit Ctrl+D/Ctrl+Z. What happens?
4. Where is the compiled program?
5. What happens when you run it?
6. Run javap -c. How many functions are in the class file?
7. What code is generated for the while loop?
8. How did Eclipse know where to find the BCEL library?

Step 2: Rewrite Factorial

1. Rewrite the factorial program to be recursive, not iterative. What is your code?
2. What happens when you compile and run it?
3. What code is generated for the if statement?

Step 3: The if/if/else ambiguity

1. The grammar

   stat ::= "if" "(" expr ")" stat ( "else" stat )? | expr ";"

   is ambiguous. There are two possible parse trees for if (c1) if (c2) e1 else e2. What are these parse trees?

2. In Scala, which of them is actually being used?
3. In SL3, which of them is actually being used?

Step 4: Improve the Compiler

1. The parts of the compiler that generate code for if and while statements contain identical code for generating the branch condition. What is that code?
2. Make a separate function codeofBoolOp that generates this code and deals with the fact that you need to set the branch target later. What is your function?
3. Try your changed compiler with the programs in step 1 and 2 to make sure that it still works.

Step 5: A for loop

1. Add a C style for loop to SL3, like this:

   fac(n) {
     var f;
     var i;
     f = 1;
     for (i = 1; i <= n; i = i + 1) 
       f = f * i;
     return f;
   }

   What change is required in the grammar?

2. Add a class for the AST. What is your class?
3. Generate code: First the code in the first statement, then the same code as for a while statement, followed by the code of the last statement. What change did you need to make in the SL3 compiler?
4. What code is generated for the fac function above?