CS 152 - Lecture 23

Cay S. Horstmann

Compiling 2

• The Bytecode Engineering Library (BCEL)
• Why bytecode engineering?
• Writing a “Hello, World” class in BCEL
• Using constants and variables
• Arithmetic and branch operations

BCEL

• Bytecode Engineering Library
• Java library to read/write class files
• Open-source project, http://jakarta.apache.org/bcel
• Handles binary encoding of class file data, opcodes
• Convenience features for
  • allocating local variables
  • choosing efficient opcodes (such as iconst_0 instead of iconst 0)
  • computing goto locations
• Less commonly used than ASM, but a higher-level API

Why Bytecode Engineering?

• Code optimizers
• Obfuscators
• Static code analysis (e.g. software engineering metrics)
• Code enhancement
  • Aspect-oriented programming
  • Annotation processing
• Compilers (duh)

Write a Class

• Taken from Appendix A of the BCEL manual
• It's a Java library, but we call it from Scala

  import org.apache.bcel._
  import org.apache.bcel.generic._
  import org.apache.bcel.Constants._

• Prepare generators, factories, etc.

  val cg = new ClassGen("HelloBCEL", "java.lang.Object", // Class, superclass
    "(no filename)", ACC_PUBLIC | ACC_SUPER, null)
  val cp = cg.getConstantPool() // cg creates constant pool
  val il = new InstructionList()
  val factory = new InstructionFactory(cg)

• Implement methods—see next slide
• Write class file

  cg.addEmptyConstructor(ACC_PUBLIC) // if no constructor provided
  cg.getJavaClass().dump("HelloBCEL.class")

Write a Method

• Write a method

  val mg = new MethodGen(ACC_STATIC | ACC_PUBLIC, // access flags
    Type.VOID, // return type
    Array(new ArrayType(Type.STRING, 1)), // argument types
    Array("argv"), // arg names
    "main", "HelloBCEL", // method, class
    il, cp)    

• Add implementation—see next slide
• Finish method

  ... // method implementation
  il.append(InstructionFactory.createReturn(Type.VOID))
  mg.setMaxStack()
  cg.addMethod(mg.getMethod())
  il.dispose() // Allow instruction handles to be reused

Hello, World!

• Get the static field System.out (of type java.io.PrintStream)

  il.append(factory.createFieldAccess("java.lang.System", "out", 
    new ObjectType("java.io.PrintStream"),
    Constants.GETSTATIC))

• Push a string

  il.append(factory.createConstant("Hello, World!"))

• Invoke a method

  il.append(factory.createInvoke("java.io.PrintStream", "println",
    Type.VOID, Array(Type.INT), // return type, param types
    Constants.INVOKEVIRTUAL))

• You'll put it all together in step 2 of the lab

Constants and Variables

• createConstant works with Boolean, Int, Double, String

  il.append(factory.createConstant(value))

  Picks the right opcode for push, deals with constant pool

• Create variable

  val fooGen = mg.addLocalVariable("foo", Type.INT, null, null)
  val fooIndex = fooGen.getIndex()
  val loc = il.append(InstructionFactory.createStore(Type.INT, fooIndex))
  fooGen.setStart(loc)

• Variables are accessed by integer index—see last lecture
• JVM tracks the regions in which a variable is defined to make sure it isn't corrupted by rogue code
• Use InstructionFactory.createLoad to load local variable onto stack

  il.append(InstructionFactory.createLoad(Type.STRING, fooIndex))

Arithmetic and Branches

• Use InstructionFactory.createBinaryOperation for add, mul, etc.

  il.append(InstructionFactory.createBinaryOperation("*", Type.INT))

• Use InstructionFactory.createBranchInstruction for creating a conditional or unconditional branch.
• The branch location is the handle returned by il.append.
• If you branch forward, first set the location to null, then add it later.

  val instr = InstructionFactory.createBranchInstruction(Constants.IFNE, null)
  il.append(instr)
   ...
  val loc = il.append(the branch target)
  instr.setTarget(loc)

• This page lists all the various conditional branches. Use Constants.GOTO for an unconditional branch

Lab

Step 1: Install BCEL

1. Download the BCEL library and unzip in a location of your choice.
2. In Eclipse, make a Scala project bcellab
3. Right-click on the project. Select Build Path → Add Libraries → User Library → User Libraries → New
4. Give the name bcel-6.2 and click Ok
5. Click on Add JARs and add the BCEL jar from the directory that you just created. Click OK
6. Check bcel-6.2 and click Ok
7. In the package explorer, expand your bcellab project. What children do you have?

Step 2: Hello, World!

1. Hopefully, one of the children of your project was bcel-6.2 with grandchild bcel-6.2.jar
2. Make a Scala object Main and copy/paste all the code from slides 4 - 6, in the right order.
3. Build and run.
4. Where is the HelloBCEL.class file located?
5. Open a shell window; change to that directory. Run java HelloBCEL. What happens?
6. What did you do to fix that problem?

Step 3: Count bits

1. There is a simple recursive way of counting the bits in the binary representation of a nonnegative number: bits(n) = n % 2 + bits(n / 2). Your task is a BCEL program that generates a class Bits with a static method

   public static int bits(int n)

   and a main method that prints the result of bits(42).

   Let's get the printing out of the way first. Modify the previous program so that it calls java.lang.Math.abs(42) and prints that, rather than "Hello, World!". What modifications did you make to your program?

2. Now implement the code that generates the bytecodes for the bits function. (There is no shame in writing the function in Java and peeking at the javap output. Only your teammate will know :-)) Remember to change java.lang.Math.abs to Bits.bits. What is the code that generates bits?

Step 4: Let's not be so divine

1. To recurse may be divine, but SL3 has a native while loop, so we want to generate code for that. Your task is to change the code that generates the code for bits so that it no longer makes the recursive call but instead uses the loop

   int count = 0;
   while (n > 0) {
     count = count + n % 2;
     n = n / 2;
   } // Put a GOTO to the top of the loop here
   return count;

   What byte codes do you intend to generate?

2. What is the BCEL code that generates them?

Step 5: Function Objects

The Java virtual machine does not have functions or closures as a native type. If we want to generate code for the JVM, we need to implement them as objects. Consider this code:

int fib(int n) // C-like language with nested functions
{
   int fibhelper(int i, int a, int b)
   {
      if (i == n) return b;
      else return fibhelper(i + 1, b, a + b);
   }
   fibhelper(1, 0, 1);
}

Here, fibhelper is an object with a method (which we will call invoke) and with an instance field for each free variable in its body (in this case, n). Every fibhelper(x, y, z) turns into a new FibHelper(n).invoke(x, y, z).

1. Write the code for the fib method in Java. It needs to construct a fibhelper object and call its invoke method.
2. Write the code for the class fibhelper in Java. (It needs one constructor and one invoke method.)
3. What are the byte codes for the fib method? (Hint: javap)
4. What are the byte codes for the fibhelper class? (Hint: javap)
5. Write a BCEL program that generates the code for the main and fib functions in a program Fib, printing fib(30). Hint: Your program needs to generate two classes.