Compiling 1

• Interpreters and compilers
• The Java Virtual Machine
• The operand stack
• The local variable array
• Opcodes for common commands

Interpreters and Compilers

• Interpreter: Reads program text and executes it immediately
• Examples: bash, SL1
• Advantage: Immediate feedback
• Compiler: Reads program text and translates it to machine code, to be executed later
• Examples: C/C++, Java
• Advantage: Execution speed
  • Side note: Scala “interpreter” is actually a compiler—compiles everything you type
• Goal: Learn how compilers work

The Java Virtual Machine

• We will translate SL4 code into JVM instructions
• JVM is not a real processor, but its instruction set is somewhat similar to that of a real CPU
• If you know how to generate JVM code, it isn't difficult to generate actual Intel instructions
• The JVM carries out this translation as it runs—“just in time” compilation
  • Side note: Some Java code is faster than the equivalent in C++ because the “just in time” compiler can make better optimizations than a C++ compiler
• Additional benefit of VM: safety
• Benefit for us: BCEL (byte code engineering library) takes care of tedious details
• JVM spec is on the web. We mostly care about chapter 6.

Operand Stack

• Operands are pushed onto a stack
  • iconst n pushes the constant n on the top of the stack
  • Short forms iconst_0 iconst_1 etc. for the most common constants (-1...5)
  • iload n pushes the contents of local variable #n  
  • Short forms iload_0 ... iload_3
  • Don't worry about the short forms when writing JVM code—BCEL takes care of that
• Operations pop the arguments, push the result

  iconst 10
  iconst 20
  iadd // pops 20 and 10, pushes 30

• The i prefix means “integer”. Similar opcodes for double (d), long (l), references (a)

Reverse Polish Calculator

• 3 * 4 + 5

  iconst 3 ; 3
  iconst 4 ; 4 3
  imul     ; 12
  iconst 5 ; 5 12
  iadd     ; 17

• 3 + 4 * 5

  iconst 3 ; 3
  iconst 4 ; 4 3
  iconst 5 ; 5 4 3
  imul     ; 20 3
  iadd     ; 23

• (3 + 4) * 5

  iconst 3 ; 3
  iconst 4 ; 4 3
  iadd     ; 7
  iconst 5 ; 5 7
  imul     ; 35

• 3 * (4 + 5)

  Your turn: http://ActiveLecture.org

Calling Functions

• Parameters are pushed onto the stack
• Function call pops the parameters, pushes the return value

• iconst 3 ; 3
  iconst 7 ; 7 3
  invokestatic java/lang/Math.max:(II)I ; 7

• Function name made up of
  • package name (with / between components in javap listing, for historical reasons)
  • function name (or <init> for constructor)
  • Argument types (with archaic encoding in javap: I is int, V is void, etc.)
  • Return type
• Use invokestatic (static functions), invokespecial (constructors, superclass functions) invokedynamic (everything else)

Parameters and Return Values

• A function accesses its parameters as local variable 0, local variable 1, etc.
• Example: static int sum(int a, int b)
  • a is local variable 0 (iload_0)
  • b is local variable 1 (iload_1)
• In a method, local variable 0 is this
• ireturn pops off top of stack and returns it

  iload_0
  iload_1
  iadd
  ireturn

Local Variables

• Don't confuse operand stack and local variable array
• Can't access anything on the operand stack except the top
• Local variable array filled with parameters when function is called
• Other slots can be used for, well, local variables
• What does this function compute? (Call the parameters a and b)

  iload_0
  iload_1
  iadd
  istore_2
  iload_0
  iload_1
  isub
  iload_2
  imul
  ireturn

  http://ActiveLecture.org

Lab

• Check into eCampus in the usual way
• This lab uses Java, not Scala
• Scribe puts in report
• Buddy puts in comment “I worked with (scribe's name)”

Step 1: The Operand Stack

1. Compile this class

   public class Test
   {
      public static void main(String[] args)
      {
         int r = 3 + 4 * 5;
      }
   }

   Run it through javap -c. What do you get?

2. That was disappointing. What can you do to see the operand stack in action? (Hint: Introduce a variable so the Java compiler can't precompute the result.)
3. What is the javap output now?

Step 2: Parameter passing

1. Compile this class:

   public class Test
   {
      public static void main(String[] args)
      {
         System.out.println(42);
      }
   }

   What byte codes do you get?

2. How are the parameter and return types of println encoded? (Hint: Classes are encoded with the quaint Lname; notation.)
3. How are the parameters of println supplied?

Step 3: Be the disassembler

1. Consider this static mystery method:

      0:iload_1
      1:ifne 8
      4:iconst_1
      5:goto 17
      8:iload_0
      9:iload_0
      10:iload_1
      11:iconst_1
      12:isub
      13:invokestatic #2; //Method mystery:(II)I
      16:imul
      17:ireturn

   Translate it back into Java. What is your code? (You'll have to look up ifne in chapter 6 of the JVM spec.)

2. When you compile your code and run it through javap, what output do you get? Where does it differ from the original?

Step 4: Be the assembler

1. Consider this static method

   int fac(int n)
   {
      if (n == 0) return 1;
      else return n * fac(n - 1)
   }

   Translate it into byte codes by hand. What did you get?

2. Now compile the code and run it through javap. What output do you get? Where does it differ from your hand-assembly?