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

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 http://jakarta.apache.org/bcel/manual.html
• 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("Hello17", "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("Hello17.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", "Hello17", // 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

  LocalVariableGen 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.INT, 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)

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

Lab

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

Step 1: Install BCEL

1. Download the BCEL library and unzip in a location of your choice.
2. In Eclipse, make a Scala project Lab17
3. Right-click on the project. Select Build Path → Add Libraries → User Library → User Libraries → New
4. Give the name bcel-5.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-5.2 and click Ok
7. In the package explorer, expand your lab17 project. What children do you have?

Step 2: Hello, World!

1. Hopefully, one of the children of your project was bcel-5.2 with grandchild bcel-5.2.jar
2. Make a package lab17 in the usual way and add a Scala Application inside
3. In the main function, copy/paste all the code from slides 4 - 6, in the right order. (Nest the method inside the class and the method implementation inside the method.)
4. Build and run.
5. Where is the Hello17.class file located?
6. Open a shell window; change to that directory. Run java Hello17. What happens?
7. 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 SL4 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?