Mastering Java ByteCode

The master plan

• JVM
• javap
• opcode
• ClassLoader
• Toolkits
• Puzzles

Stack

1+2

PUSH 1 1
12+ PUSH 2 2

Stack

1+2

PUSH 1 3
12+ PUSH 2
ADD

Stack

1+2

ICONST_1 3
12+ ICONST_2
IADD

Java Stack Machine

• JVM is a stack-based machine
• Each thread has a stack
• Stack stores frames
• Frame is created on method invocation
• Frame:
o
Operand stack
o
Array of local variables
o
Reference to the runtime constant pool

Compiling to binary

C/C++ (*.h, *.cpp) Java (*.java)

Assembler Bytecode

Intel opcode Sun opcode

javap
• Java class file disassembler
• Used with no options shows class
structure only
• Methods, superclass, interfaces, etc
• -c – shows the bytecode
• -private – shows all classes and
members
• -s – prints internal types signatures
• -verbose – prints stack size, number of
locals and args for methods

public class SimpleProgram
{
public static void main(String[] args)
{
System.out.println("Hello Java Fusion!");
}
}

{
{
}
}

javap SimpleProgram -c

{
{
}
}

Compiled from "SimpleProgram.java"
public class SimpleProgram extends java.lang.Object{
public SimpleProgram();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."":()V
4: return
public static void main(java.lang.String[]);
Code:
0: getstatic #2; //Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #3; //String Hello Java Fusion!
5: invokevirtual #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return

}

{
{
}
}

public SimpleProgram();// The default constructor
Code:
0: aload_0 //Push this sto stack
1: invokespecial #1; //Method java/lang/Object."":()V //Invoke <init> on this
4: return
Code:
0: getstatic #2; //Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #3; //String Hello Java Fusion!
5: invokevirtual #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return

}

{
{
}
}

public SimpleProgram();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."":()V
4: return
Code:
0: getstatic #2; //Field java/lang/System.out:Ljava/io/PrintStream; //get static field
3: ldc #3; //String Hello Java Fusion! //Load String to the stack
5: invokevirtual #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V //invoke method with parameter
8: return

}

{
{
}
}

javap SimpleProgram -c -verbose
Compiled from "SimpleProgram.java“
public class SimpleProgram extends java.lang.Object
SourceFile: "SimpleProgram.java"
minor version: 0
major version: 50
Constant pool:
const #1 = Method #6.#20; // java/lang/Object."<init>":()V
const #2 = Field #21.#22; // java/lang/System.out:Ljava/io/PrintStream;
const #3 = String #23; // Hello Java Fusion!
const #4 = Method #24.#25; // java/io/PrintStream.println:(Ljava/lang/String;)V
const #5 = class #26; // SimpleProgram
const #6 = class #27; // java/lang/Object
сonst #7 = Asciz <init>;
...

Bytecode

One-byte instructions
256 possible opcodes
207 in use
49 currently unassigned for opcodes and are reserved
for future use

TYPE OPERATION
Instructions fall into a number of broad groups:
•Local variables and stack interaction (e.g. aload_0,istore)
•Array operations (aload, astore)
•Arithmetic and logic (e.g. ladd,fcmpl)
•Type conversion (e.g. i2b,d2i)
•Object creation and manipulation (new, putfield)
•Operand stack management (e.g. swap,dup2)
•Control transfer (e.g. ifeq, goto)
•Method invocation and return (e.g. invokespecial,areturn)
•Operations with constant values (ldc, iconst_1)
•Math (add, sub, mul, div)
•Boolean/bitwise operations (iand, ixor)
•Comparisons (cmpg, cmpl, ifne)
•...

Opcode type
Prefix/Suffix Operand Type
i integer
l long
s short
b byte
c char
f float
d double
a reference

public java.lang.String getName();
Code:
Stack=1, Locals=1, Args_size=1
0: aload_0
1: getfield #2; //Field name:Ljava/lang/String;
4: areturn
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this LGet;

ClassLoader

- Works with bytecode
- Has native methods
- Bytecode Verification via SecurityManager.class

Toolkits

JVM:
•ASM
•Javassist
•BCEL (Byte Code Engineering Library)

Jrebel
Terracotta

Common sample
{
{
}
}

ASM sample
public class ASMSample extends ClassLoader implements Opcodes {
{
{
ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
cw.visit(V1_1, ACC_PUBLIC, "SimpleProgram", null, "java/lang/Object", null);
}
}

ASM sample
{
{
cw.visit(V1_1, ACC_PUBLIC, "SimpleProgram", null, "java/lang/Object", null); // creates a GeneratorAdapter
for the (implicit) constructor
Method m = Method.getMethod("void <init> ()");
GeneratorAdapter mg = new GeneratorAdapter(ACC_PUBLIC, m, null, null, cw);
mg.loadThis();
mg.invokeConstructor(Type.getType(Object.class), m);
mg.returnValue();
mg.endMethod();
}
}

ASM sample
{
{
// creates a GeneratorAdapter for the (implicit) constructor
mg.loadThis();
mg.returnValue();
mg.endMethod(); // creates a GeneratorAdapter for the 'main' method
m = Method.getMethod("void main (String[])");
mg = new GeneratorAdapter(ACC_PUBLIC + ACC_STATIC, m, null, null, cw);
mg.getStatic(Type.getType(System.class), "out",Type.getType(PrintStream.class));
mg.push("Hello Java Fusion!");
mg.invokeVirtual(Type.getType(PrintStream.class),
Method.getMethod("void println (String)"));
mg.returnValue();
mg.endMethod();
cw.visitEnd();
}
}

ASM sample
{
{
// creates a GeneratorAdapter for the (implicit) constructor
mg.loadThis();
mg.returnValue();
mg.endMethod();
// creates a GeneratorAdapter for the 'main' method
m = Method.getMethod("void main (String[])");
mg = new GeneratorAdapter(ACC_PUBLIC + ACC_STATIC, m, null, null, cw);
mg.getStatic(Type.getType(System.class), "out",Type.getType(PrintStream.class));
mg.push("Hello Java Fusion!");
mg.invokeVirtual(Type.getType(PrintStream.class),
Method.getMethod("void println (String)"));
mg.returnValue();
mg.endMethod();
cw.visitEnd(); byte[] code = cw.toByteArray();
ASMSample loader = new ASMSample ();
Class<?> exampleClass = loader.defineClass("SimpleProgram", code, 0, code.length);
// uses the dynamically generated class to print 'Hello Java Fusion'
exampleClass.getMethods()[0].invoke(null, new Object[] { null } );
}
}

ASM vs. Javassist
• Javassist source level API is much easier to use than the
actual bytecode manipulation in ASM
• Javassist provides a higher level abstraction layer over complex
bytecode level operations. Javassist source level API requires very less or
no knowledge of actual bytecodes, so much easier & faster to
implement.
• Javassist uses reflection mechanism which makes it slower
compared to ASM which uses Classworking techniques at runtime.
• Overall ASM is much faster & gives better performance than
Javassist. Javassist uses a simplified version of Java source code, which
it then compiles into bytecode. That makes Javassist very easy to use, but
it also limits the use of bytecode to what can be expressed within the limits
of the Javassist source code.
• In conclusion, if someone needs easier way of dynamically
manipulating or creating Java classes Javassist API should be used &
where the performance is the key issue ASM library should be used.

JRebel
Redeploying sucks, so JRebel
eliminates it. How?

JRebel maps your project workspace directly to the
application under development. When you change any
class or resource in your IDE, the change is immediately
reflected in the application, skipping the build and
redeploy phases.

How JRebel works
1) Classes

• JRebel integrates with the JVM and rewrites each class to be
updateable
• JRebel versions each class individually, instead of an application or
module at a time
• It does not use classloaders!
• Changes to classes are always visible in the Reflection API

How JRebel works
2) Workspace mapping

petclinic.war

• JRebel integrates with application
servers, frameworks and your IDE
• When a class or resource is being
looked up, JRebel redirects straight
to the workspace
• When an HTTP resource needs to
be served, JRebel serves it from the
workspace

Size and speed issues

top1 and top2 are functionally identical

Method int top1()
0 aload_0 //Push the object reference(this) at index
//0 of the local variable table.
1 getfield #6 <Field int intArr[]>
//Pop the object reference(this) and push
//the object reference for intArr accessed
//from the constant pool.
4 iconst_0 //Push 0.
5 iaload //Pop the top two values and push the
//value at index 0 of intArr.
6 ireturn //Pop top value and push it on the operand
//stack of the invoking method. Exit.

Method int top2()
0 aload_0
1 astore_2
2 aload_2
3 monitorenter
4 aload_0
5 getfield #6 <Field int intArr[]>
8 iconst_0 //Push 0.
9 iaload
10 istore_1
11 jsr 19
14 iload_1 .
15 ireturn
16 aload_2
17 monitorexit . Exception table: //If any exception occurs between
18 athrow . from to target type //location 4 (inclusive) and location
19 astore_3 4 16 16 any //16 (exclusive) jump to location 16
20 aload_2
21 monitorexit
22 ret 3
.


top1 and top2 are functionally identical
top1 is 13% faster than top2 as well as much smaller.

Puzzle Cutting Class
public class Strange2 {
public static void main(String[] args) {
Missing m; try {
try {
m = new Missing(); } catch
Missing m = new Missing(); } catch
(java.lang.NoClassDefFoundError ex) {
System.out.println("Got it!");
}
}
}
}
}
}

class Missing {
Missing() { }
}

Missing m; try {
try {
}
}
}
}
}
}
class Missing {
Missing() { }
}

???
System.out.println("Got it!"); throws an uncaught
NoClassDefFoundError

Missing m; try {
try {
}
}
}
}

class Missing {
Missing() { }
}

System.out.println("Got it!"); Expected throws an uncaught

throws an uncaught Result System.out.println("Got it!");

0: new #2; // class Missing

3: dup

4: invokespecial #3; // Method Missing."<init>":()V

7: astore_1

8: goto 20

11: astore_1

12: getstatic #5; // Field System.out:Ljava/io/PrintStream;

15: ldc #6; // String "Got it!"

17: invokevirtual #7; // Method PrintStream.println:(String;)V

20: return

Exception table:

from to target type

0 8 11 Class java/lang/NoClassDefFoundError

The corresponding code for Strange2.main differs in only one instruction:
11: astore_2 //Store ex catch parameter

javap -c Strange1

Using reflection
public class Strange {

public static void main(String[] args) throws Exception {

try {

Object m = Class.forName("Missing").newInstance();

} catch (ClassNotFoundException ex) {

System.err.println("Got it!");

}

}

}

Benefits

• Improve speed and size of your applications
• Critical when debugging and doing performance and
memory usage tuning
• Realtime injection
• Build ORM project
• Clustering with AOP
• Know your platform!
• Create your own compile/decompiler?

Mastering Java ByteCode

More Related Content

What's hot

Viewers also liked

Similar to Mastering Java ByteCode

More from Ecommerce Solution Provider SysIQ

Recently uploaded

Mastering Java ByteCode

Editor's Notes