Introduction to the Java bytecode - So@t - 20130924

2013-09-24 Java ByteCode 1
Yohan BESCHI – Java Developer
@yohanbeschi
+Yohan Beschi

A word about me
⦿ Started coding more than 15 years ago
⦿ Expertise
⦿ RIAs
⦿ Performances
⦿ Industrialization
⦿ Writings
⦿ So@t Blogger
⦿ Developpez.com Writer
⦿ InfoQ FR Editor

Why this talk ?
⦿ To understand JVM exceptions
⦿ Can help dealing with performance issues
⦿ To write a compiler for the JVM
⦿ And the most important, it’s fun !

What we won’t see
⦿ A detailed explanation of the JVMS
⦿ Features from Java 5 and higher
⦿ Tools like ASM, BCEL, Javassist, etc.
⦿ JSR-292

What we will see
⦿ An introduction to the inner working of the
JVM
⦿ A big part of the JVM instruction set
⦿ Unicode and Java
⦿ An introduction to the Class File Format

Terminology used in this talk
⦿ A JVM, THE JVM or Hotspot = A virtual
machine following the JVMS
⦿ Java Compiler = javac

Bytecode - What and Why ?
⦿ Intermediate language between the Java
Source Code and machine code
⦿ Close to an Assembly Language
⦿ Efficient execution by an interpreter

JIT Compilation
⦿ JIT = Just In Time
⦿ Interpreted bytecode is slower than
compiled machine code
⦿ Used to improve the runtime performances
⦿ Optimizations
⦿ Caching

What will I learn ? (1/6)
package org.bytecode;
public class Demo {
public static void main(String[] args) {
final int sum = add(3, 5);
System.out.println(sum);
}
private static int add(int i, int j) {
return i + j;
}
}
$ javac -g:none org/bytecode/Demo.java

public class org.bytecode.Demo
minor version: 0
major version: 51
flags: ACC_PUBLIC, ACC_SUPER
... to be continued ...
$ javap –verbose -p org/bytecode/Demo

Constant pool:
#1 = Methodref #6.#14 // java/lang/Object."<init>":()V
#2 = Methodref #5.#15 // org/bytecode/Demo.add:(II)I
#3 = Fieldref #16.#17 // java/lang/System.out:Ljava/io/PrintStream;
#4 = Methodref #18.#19 // java/io/PrintStream.println:(I)V
#5 = Class #20 // org/bytecode/Demo
#6 = Class #21 // java/lang/Object
#7 = Utf8 <init>
#8 = Utf8 ()V
#9 = Utf8 Code
#10 = Utf8 main
#11 = Utf8 ([Ljava/lang/String;)V
#12 = Utf8 add
#13 = Utf8 (II)I
#14 = NameAndType #7:#8 // "<init>":()V
#15 = NameAndType #12:#13 // add:(II)I
#16 = Class #22 // java/lang/System
#17 = NameAndType #23:#24 // out:Ljava/io/PrintStream;
#18 = Class #25 // java/io/PrintStream
#19 = NameAndType #26:#27 // println:(I)V
#20 = Utf8 org/bytecode/Demo
#21 = Utf8 java/lang/Object
#22 = Utf8 java/lang/System
#23 = Utf8 out
#24 = Utf8 Ljava/io/PrintStream;
#25 = Utf8 java/io/PrintStream
#26 = Utf8 println
#27 = Utf8 (I)V

{
public org.bytecode.Demo();
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return

public static void main(java.lang.String[]);
flags: ACC_PUBLIC, ACC_STATIC
Code:
0: iconst_3
1: iconst_5
2: invokestatic #2 // Method add:(II)I
5: istore_1
6: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
9: iload_1
10: invokevirtual #4 // Method java/io/PrintStream.println:(I)V
13: return

private static int add(int, int);
flags: ACC_PRIVATE, ACC_STATIC
Code:
0: iload_0
1: iload_1
2: iadd
3: ireturn
}
... end ...

Class File as a Text File using PJBA*
.class org/isk/bytecode/Adder
.method add(II)I
iload_0
iload_1
iadd
ireturn
.methodend
.classend
*PJBA: Plume Java Bytecode Assembler

Descriptors (1/2)
Descriptor Type
Z boolean
B byte
S short
C char
I int
J long
F float
D double
V void
[<type> Array of type <type>
L<type>; Object of type <type>

Descriptors (2/2)
⦿ Descriptors are used to define fields and
methods
Bytecode Java
add(II)I int add(int i1, int i2)
concat(Ljava/lang/String;Ljava/lang/String;)Lj
ava/lang/String;
String concat(String s1, String s2)
merge([Z[Z)[Z boolean[] merge(boolean[] a1, boolean[] a2)

Introduction to
the JVM

The JVM in few words
⦿ Application Virtual Machine
⦿ Stack based
⦿ Symbolic references
⦿ Garbage collection
⦿ Platform independent
⦿ Network Byte Order (ie. Big-endian)

From Source code to the JVM (1/2)
Java Code
(.java)
Java ByteCode
(.class)
Java Compiler
(javac)
Class Loader
Execution
Engine
Runtime Data Areas
Java Virtual Machine

From Source code to the JVM (2/2)
⦿ ClassLoader: loads the bytecode from class
files into the Runtime Data Areas
⦿ Execution Engine: executes the bytecode
⦿ Runtime Data Areas: areas used during a
program execution
⦿ Some areas are created during the
initialization of the JVM and others are by
threads.

Run-Time Data Areas (1/2)
Run-Time Data Areas
Thread
Program Counter
Java Stack
Native Method Stack
Heap
Method Area
Run-Time Constant Pool

Run-Time Data Areas (2/2)
⦿ Heap: run-time data area from which
memory for all class instances and arrays is
allocated
⦿ Method Area: stores per-class structures
⦿ Run-Time Constant Pool: is a per-class or
per-interface run-time representation of the
constantPool table in a class file

Runtime Data Areas (2/2)
⦿Threads: daemon and non-daemon
⦿ Program counter: address of the Java Virtual
Machine instruction currently being executed
⦿ JVM Stacks: LIFO stacks of Frames
⦿ Native Method Stacks
⦿ Frames: stores data and partial results,
performs dynamic linking, returns values for
methods, and dispatches exceptions.

Threads and Stack Frames
Thread 4
Thread 3
Thread 2
Thread 1F1
F1
F1
F1
F2 F3
F2
F2 F3 F4 F5 F6

Frames (1/2)
PC
Frame Class
Local Variables
0 1 2 3 4 5 6 7 8
Operand Stack
Method
Code
Constant
Pool

Frames (2/2)
⦿ Local Variables: array of variables
⦿ Operand Stack: LIFO stack of operands
⦿ Dynamic Linking: translates symbolic method
references into concrete method references and
translates variable accesses into appropriate
offsets in storage structures associated with the
run-time location of these variables.
⦿ Java Stack (Frame) != Operand Stack

Frame 1 Class
Local Variables
0 1 2 3 4 5 6 7 8
Stack
public static void main(String[] a) {
push literal 1
push literal 2
invoke static method add()
store the result in lv1
// …
}
ra
PC
1/102013-09-24 Java ByteCode 29

Frame 1 Class
Local Variables
0 1 2 3 4 5 6 7 8
Stack
push literal 1
push literal 2
// …
}
ra
PC
1
2/102013-09-24 Java ByteCode 30

Frame 1 Class
Local Variables
0 1 2 3 4 5 6 7 8
Stack
push literal 1
push literal 2
// …
}
ra
PC
2
1
3/102013-09-24 Java ByteCode 31

Class
push literal 1
push literal 2
// …
}
Frame 2 Class
Local Variables
0 1 2 3 4 5 6 7 8
Stack
public static int add(int i1, int i2) {
push lv0
push lv1
add the top of the stack
return the top of the stack
}
1
PC
2
Frame 1
Local Variables
0 1 2 3 4 5 6 7 8
Stack
ra
2
1
Inactive Frame
4/102013-09-24 Java ByteCode 32

Cadre 1 Class
Variables Locales
0 1 2 3 4 5 6 7 8
Pile
push literal 1
push literal 2
// …
}
ra
Frame 2 Class
Local Variables
0 1 2 3 4 5 6 7 8
Stack
push lv0
push lv1
}
1
PC
2
2
1
Cadre inactif
Frame 1
Local Variable
0 1 2 3 4 5 6 7 8
Stack
ra
2
1
Inactive Frame
Frame 1
Local Variables
0 1 2 3 4 5 6 7 8
Stack
ra
2
1
Inactive Frame
5/102013-09-24 Java ByteCode 33

Class
push literal 1
push literal 2
// …
}
Frame 2 Class
Local Variables
0 1 2 3 4 5 6 7 8
Stack
push lv0
push lv1
}
1
PC
2
1
Cadre 1
Variables Locales
0 1 2 3 4 5 6 7 8
Pile
ra
2
1
Cadre inactif
Cadre 1
Variables Locales
0 1 2 3 4 5 6 7 8
Pile
ra
2
1
Cadre inactif
Frame 1
Local Variable
0 1 2 3 4 5 6 7 8
Stack
ra
2
1
Inactive Frame
Frame 1
Local Variables
0 1 2 3 4 5 6 7 8
Stack
ra
2
1
Inactive Frame
6/102013-09-24 Java ByteCode 34

Class
push literal 1
push literal 2
// …
}
Frame 2 Class
Local Variables
0 1 2 3 4 5 6 7 8
Stack
push lv0
push lv1
}
1
PC
2
2
1
Cadre 1
Variables Locales
0 1 2 3 4 5 6 7 8
Pile
ra
2
1
Cadre inactif
Frame 1
Local Variable
0 1 2 3 4 5 6 7 8
Stack
ra
2
1
Inactive Frame
Frame 1
Local Variables
0 1 2 3 4 5 6 7 8
Stack
ra
2
1
Inactive Frame
7/102013-09-24 Java ByteCode 35

Class
push literal 1
push literal 2
// …
}
Frame 2 Class
Local Variables
0 1 2 3 4 5 6 7 8
Stack
push lv0
push lv1
}
1
PC
2
3
Cadre 1
Variables Locales
0 1 2 3 4 5 6 7 8
Pile
ra
2
1
Cadre inactif
Frame 1
Local Variable
0 1 2 3 4 5 6 7 8
Stack
ra
2
1
Inactive Frame
Frame 1
Local Variables
0 1 2 3 4 5 6 7 8
Stack
ra
2
1
Inactive Frame
8/102013-09-24 Java ByteCode 36

Class
push literal 1
push literal 2
// …
}
Frame 2 Class
Local Variables
0 1 2 3 4 5 6 7 8
Stack
push lv0
push lv1
}
1
PC
2
3
Cadre 1
Variables Locales
0 1 2 3 4 5 6 7 8
Pile
ra
3
Cadre inactif
Frame 1
Local Variable
0 1 2 3 4 5 6 7 8
Stack
ra
2
1
Inactive Frame
Frame 1
Local Variables
0 1 2 3 4 5 6 7 8
Stack
ra
2
1
Inactive Frame
9/102013-09-24 Java ByteCode 37

Class
push literal 1
push literal 2
// …
}
PC
Frame 1
Local Variables
0 1 2 3 4 5 6 7 8
Stack
ra
3
3
10/102013-09-24 Java ByteCode 38

JVM Instructions

JVM types (1/2)
⦿ int
⦿ long
⦿ float
⦿ double
⦿ reference

JVM types (2/2)
⦿ boolean, byte, short and char are treated as
int
⦿ But we can have arrays of byte, short and
char
⦿ long and double values take two slots in the
operand stack and the local variables
⦿ A reference is a pointer to an object in the
heap

Mnemonics (1/3)
⦿ An mnemonic is a textual form of an
operation (iadd, lload_1, etc.)
⦿ Each mnemonic matches a number between
0 and 255 (1 byte) in a class file.
⦿ This number is called an operation code or
simply an opcode

Mnemonics (2/3)
Letter Type Size (in bit)
b byte 8
s short 16
c char 16
i int 32
l long 64
f float 32
d double 64
a reference 32/64*
* Depending on the JVM

Mnemonics (3/3)
⦿ Instructions dealing with the stack or the
local variables start with a letter
corresponding to a type
⦿ The instruction « iadd » will add 2 integers
⦿ In a class file, instructions can only exist in a
method.

Arguments and operands
⦿ An argument follows an instruction
⦿ ldc « Hello World! »
⦿ An operand is from the operand stack
⦿ iadd

Returning a value (1/2)
Hex Mnemonic
0xac ireturn
0xad lreturn
0xae freturn
0xaf dreturn
0xb0 areturn
0xb1 return

public static void doNothing() {
return; // Optional
}
.method doNothing()V
return
.methodend

Predifined Constants (1/3)
Hex Mnemonic
0x01 aconst_null
0x02 iconst_m1
0x03 iconst_0
0x04 iconst_1
0x05 iconst_2
0x06 iconst_3
0x07 iconst_4
0x08 iconst_5
Hex Mnemonic
0x09 lconst_0
0x0a lconst_1
0x0b fconst_0
0x0c fconst_1
0x0d fconst_2
0x0e dconst_0
0x0f dconst_1

Predifined Constants (2/3)
⦿ The JVM supports constants of type
int, float, long, double and String
⦿ These instructions push the constant to the
stack

public static double get() {
return 1.0;
}
.method get()D
dconst_1
dreturn
.methodend

User defined constants (1/3)
Hex Mnemonic Argument
0x10 bipush n
0x11 sipush n
0x12 ldc n
0x13 ldc_w n
0x14 ldc2_w n

⦿ These instructions push the constant to the
stack
⦿ bipush is used for constants between -128
and 127
⦿ sipush is used for constants between -32 768
and 32 767
⦿ « ldc »’s instructions are used for every
other values.

public static short get() {
return 14909;
}
.method get()S
sipush 14909
ireturn
.methodend

ldc, ldc_w, ldc2_w
⦿ For these instructions the argument (n) is not
the actual value, but an index in the Constant
Pool
⦿ « _w » means wide. The size of the index is 2
bytes instead of 1.
⦿ « ldc » and « ldc_w » are used for values of
type int, float and String
⦿ « ldc2_w » is used for values of type double
and long. « 2 » means two slots in the operand
stack

Local Variables (1/6) – Loading
0x15 iload n
0x16 lload n
0x17 fload n
0x18 dload n
0x19 aload n
0x1a iload_0
0x1b iload_1
0x1c iload_2
0x1d iload_3
Hex Mnemonic
0x1e lload_0
0x1f lload_1
0x20 lload_2
0x21 lload_3
0x22 fload_0
0x23 fload_1
0x24 fload_2
0x25 fload_3
Hex Mnemonic
0x26 dload_0
0x27 dload_1
0x28 dload_2
0x29 dload_3
0x2a aload_0
0x2b aload_1
0x2c aload_2
0x2d aload_3

public static int load(int i) {
return i;
}
.method load(I)I
iload_0
ireturn
.methodend

Local Variables (3/6) - Storing
0x36 istore n
0x37 lstore n
0x38 fstore n
0x39 dstore n
0x3a astore n
0x3b istore_0
0x3c istore_1
0x3d istore_2
0x3e istore_3
Hex Mnemonic
0x3f lstore_0
0x40 lstore_1
0x41 lstore_2
0x42 lstore_3
0x43 fstore_0
0x44 fstore_1
0x45 fstore_2
0x46 fstore_3
Hex Mnemonic
0x47 dstore_0
0x48 dstore_1
0x49 dstore_2
0x4a dstore_3
0x4b astore_0
0x4c astore_1
0x4d astore_2
0x4e astore_3

Local Variables (4/6) – Storing
public static void store() {
int i = 17;
double d = 3.5;
}
.method store()V
bipush 17
istore_0
ldc2_w 3.5
dstore_1
return
.methodend

Local Variables (5/6)
⦿ « n » is the index in the Local Variables
⦿ Slots in Local Variables are not typed, but
you need to be careful about the size of each
type (example following)

Local Variables (6/6)
ldc "hello world"
astore_2
ldc2_w 3.14d
dstore_1
aload_2 # error!
# dstore_1 stored a double at index
1 and 2. Therefore, we can’t access
to the String anymore

Math (1/5) – Arithmetic Operations
0x60 iadd
0x61 ladd
0x62 fadd
0x63 dadd
0x64 isub
0x65 lsub
0x66 fsub
0x67 dsub
0x68 imul
0x69 lmul
0x6a fmul
0x6b dmul
0x6c idiv
0x6d ldiv
0x6e fdiv
0x6f ddiv
0x70 irem
0x71 lrem
0x72 frem
0x73 drem
0x74 ineg
0x75 lneg
0x76 fneg
0x77 dneg

Math (2/5) – Notations
⦿ Infix notation : 3 + 4 * 7
⦿ Prefix notation : + 3 * 4 7
⦿ Postfix notation : 3 4 7 * +
Let’s see an example !!

public static int add() {
return 2 * (7 – 5) * (8 – 5);
}
# Infix: 2 * (7 – 5) * (8 – 5)
# Postfix: 2 7 5 - * 8 5 - *

Math (4/5) – Notations
.method add()I
# Stack before -> after
iconst_2 # [] -> 2
bipush 7 # 2 -> 2, 7
iconst_5 # 2, 7 -> 2, 7, 5
isub # 2, 7, 5 - > 2, 2 (7 - 5 = 2)
imul # 2, 2 -> 4 (2 * 2 = 4)
bipush 8 # 4 -> 4, 8
iconst_5 # 4, 8 -> 4, 8, 5
isub # 4, 8, 5 -> 4, 3 (8 - 5 = 3)
imul # 4, 3 -> 12 (4 * 3 = 12)
ireturn
.methodend

Math (5/5) – few more…
<< >> >>>
0x78 ishl
0x79 lshl
0x7a ishr
0x7b lshr
0x7c iushr
0x7b lushr
& | ^
0x7e iand
0x7f land
0x80 ior
0x81 lor
0x82 ixor
0x83 lxor
casting
0x85 i2l
0x86 i2f
0x87 i2d
0x88 l2i
0x89 l2f
0x8a l2d
0x8b f2i
0x8c f2l
0x8d f2d
0x8e d2i
0x8f d2l
0x90 d2f
int to
byte, char
and short
0x91 i2b
0x92 i2c
0x93 i2s

Stack instructions (1/2)
Hex Mnemonic Description
0x57 pop Pop the first element off the stack
0x58 pop2 Pop the first two elements off the stack
0x59 dup Duplicate the first element and push it to the stack
0x5a dup_x1 Duplicate the first element and add it under the second
0x5b dup_x2 Duplicate the first element and add it under the third
0x5c dup2
Duplicate the first two elements and push them to the stack
(keeping the order)
0x5d dup2_x1
Duplicate the first two elements and add them under the third one
(keeping the order)
0x5e dup2_x2
Duplicate the first two elements and add them under the fourth
one (keeping the order)
0x5f swap Swap the first two elements

Stack instructions (2/2)
⦿ One element = one slot in the operand stack
⦿ long and double values must be considered
as two elements each
⦿ The JVMS is refering to long and double as
types of category 2 (taking 2 slots), other
types are of category 1 (see « Types and the
Java Virtual Machine » in the JVMS)

pop - 1/2
Cadre 1
Classe
Variables Locales
0 1 2 3 4 5 6 7 8
Pile
iconst_1
pop
PC
1

pop - 2/2
Cadre 1
Classe
Variables Locales
0 1 2 3 4 5 6 7 8
Pile
iconst_1
popPC

dup – 1/2
Cadre 1
Classe
Variables Locales
0 1 2 3 4 5 6 7 8
Pile
iconst_2
iconst_1
dup
PC
2
1

dup - 2/2
Cadre 1
Classe
Variables Locales
0 1 2 3 4 5 6 7 8
Pile
iconst_2
iconst_1
dupPC
2
1
1

dup2_x2 - (form 3) 1/2
Cadre 1 Classe
Variables Locales
0 1 2 3 4 5 6 7 8
Pile
dconst_1
iconst_1
iconst_2
dup2_x2
PC
1
2
1.0

dup2_x2 - (forme 3) 2/2
Cadre 1 Classe
Variables Locales
0 1 2 3 4 5 6 7 8
Pile
dconst_1
iconst_1
iconst_2
dup2_x2PC
1
2
1.0
2
1

Unicode & Java

Unicode 101
⦿ Unicode 6.2 contains a repertoire of more
than 110,000 characters covering 100 scripts
⦿ Each character is associated with a number
called Code Point
⦿ Unicode defines a codespace of 1,114,112
code points in the range U+0000 to U+10FFFF
⦿ Unicode is a character set, not an encoding
⦿ Unicode defines two encodings the Unicode
Transformation Format (UTF) and the
Universal Character Set (UCS)

UTF 101 – UTF-8
⦿ In UTF-8 a character can be encoded in 1, 2,
3 or 4 bytes
Range Byte 1 Byte 2 Byte 3 Byte 4
U+0000 - U+007F 0xxxxxxx
U+0080 - U+07FF 110xxxxx 10xxxxxx
U+0800 - U+FFFF 1110xxxx 10xxxxxx 10xxxxxx
U+10000 - U+1FFFFF 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

UTF 101 – UTF-16
⦿ In UTF-16 a character can be encoded in 2 or
4 bytes
⦿ Code Points from the BMP
⦿ U+0410 (А - CYRILLIC CAPITAL LETTER A) => 0x04 0x10
⦿ Code Points from a supplementary plane
⦿ U+64321 => 0xD9 0x50 0xDF 0x21

UTF 101 – UTF-32
⦿ In UTF-32 a character is encoded in 4 bytes.
Its code point doesn’t need any
transformation
⦿ U+64321 => 0x00 0x06 0x43 0x21

Why should I
care about
Unicode ?

Java Source File encoding
⦿ Java source files can be encoded in various
encodings (usually UTF-8)…
⦿ But you MUST always indicate to the
compiler what it is…
⦿ Using the option -encoding
http://docs.oracle.com/javase/7/docs/technotes/guides/intl/encoding.doc.html

Class File encoding
⦿ In a class file all strings (packages, classes,
fields, methods and literals) are encoded in
Modified UTF-8
⦿Modified UTF-8 is almost like UTF-8 but:
⦿ The NULL character is encoded using 2 bytes
⦿ Only formats with 1, 2 or 3 bytes are used
(which is enough for the BMP)
⦿ For supplementary planes each surrogate is
encoded as a character

JVM encoding
⦿ The JVM encodes Strings in UTF-16…
⦿ Therefore extreme care should be taken
when handling an external stream of data (a
file or from the network)

Class File Format

Class File Structure (1/2)
ClassFile {
int magic;
short minorVersion;
short majorVersion;
short constantPoolCount;
ConstantPoolEntry[] constantPool;
short accessFlags;
short thisClass;
short superClass;
short interfacesCount;
short[] interfaces;
short fieldsCount;
Field[] fields;
short methodsCount;
Method[] methods;
short attributesCount;
Attribute[] attributes;
}
byte, short and int
should be
considered as
unsigned types

Class File Structure (2/2)
public class org.bytecode.Demo
minor version: 0
major version: 51
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Methodref #6.#14 // java/lang/Object."<init>":()V
#2 = Methodref #5.#15 // org/bytecode/Demo.add:(II)I
#3 = Fieldref #16.#17 // java/lang/System.out:Ljava/io/PrintStream;
#4 = Methodref #18.#19 // java/io/PrintStream.println:(I)V
#5 = Class #20 // org/bytecode/Demo
#6 = Class #21 // java/lang/Object
#7 = Utf8 <init>
#8 = Utf8 ()V
...
private static int add(int, int);
flags: ACC_PRIVATE, ACC_STATIC
Code:
0: iload_0
1: iload_1
2: iadd
3: ireturn
...

Content of a class file (1/2)
⦿ A class file is a binary file where each
elements have a well defined size (except
strings as we shall see).
⦿ To write and read class files, the JDK
provides two classes:
⦿ java.io.DataOutputStream
⦿ java.io.DataInputStream

Content of a class file (2/2)
⦿ From an AST it’s quiet simple to generate a class
file:
DataOutputStream dos = new DataOutputStream(…);
dos.writeInt(this.magic);
dos.writeShort(this.minorVersion);
dos.writeShort(this.majorVersion);
dos.writeShort(this.constantPoolCount);
//…

magic (1/2)
ClassFile {
int magic;
short minorVersion;
short majorVersion;
// ..
}
⦿ It’s value is always 0xCAFEBABE

minorVersion and majorVersion (1/2)
ClassFile {
int magic;
short minorVersion;
short majorVersion;
// ..
}

minorVersion and majorVersion (2/2)
⦿ Indicate the version of the class file format
⦿ Oracle's JVM implementation in:
⦿ JDK release 1.0.2 supports class file format
versions 45.0 through 45.3 inclusive.
⦿ JDK releases 1.1.* support class file format
versions in the range 45.0 through 45.65535
inclusive.
⦿ For k ≥ 2, JDK release 1.k supports class file
format versions in the range 45.0 through 44+k.0
inclusive.

Constant Pool (1/3)
ClassFile {
int magic;
short minorVersion;
short majorVersion;
// ..
}

Constant Pool (2/3)
⦿ The constant pool is a central part of a class
file.
⦿ It has no equivalent in Java.
⦿ It’s like a symbol table, doing a mapping
between the code and constants of several
kinds.
⦿ The index of the array constantPool
starts from 1.

Constant Pool (3/3)
⦿ A ConstantPoolEntry has this format:
ConstantPoolEntry {
byte tag;
byte[] info;
}
⦿ « tag » defines the type of constant
⦿ The content of the byte array (info) is
different from tag to tag

Constant type
⦿ As for the JDK 1.4 there are 11 kind of
constants:
Constant Type Value
ConstantUtf8 1
ConstantInteger 3
ConstantFloat 4
ConstantLong 5
ConstantDouble 6
ConstantClass 7
ConstantString 8
ConstantFieldref 9
ConstantMethodref 10
ConstantInterfaceMethodref 11
ConstantNameAndType 12

ConstantUTF8
⦿ The most common constant
⦿ Used for all kind of strings (package name,
class name, method name, etc.)
public class ConstantUTF8 {
byte tag = 0x01;
short length;
byte[] string;
}

ConstantInt and ConstantFloat
⦿ Used to store int and float values!
public class ConstantInt {
byte tag = 0x03;
int value;
}
public class ConstantFloat {
byte tag = 0x04;
// The float is converted to an int
int value;
}

ConstantLong and ConstantDouble
⦿ Used to store long and double values!
public class ConstantLong {
byte tag = 0x03;
long value;
}
public class ConstantDouble {
byte tag = 0x04;
// The double is converted to a long
long value;
}

ConstantString
⦿ Used for String constants.
⦿ Unlike ConstantUTF8, ConstantString
contains the index of a ConstantUTF8 in the
constant pool.
public class ConstantString {
byte tag = 0x08;
short utf8Index;
}

ConstantClass
⦿ A ConstantClass works like a ConstantString.
Except that the ConstantUTF8 is holding a
fully qualified class name. Like
« java/lang/Object » or because an array is
an object « [[I »
public class ConstantClass {
byte tag = 0x07;
short utf8Index;
}

ConstantNameAndType
⦿ Contains the indexes of two ConstantsUTF8
holding the name and type/descriptor of a field
or a method
public class ConstantNameAndType {
byte tag = 0x0C;
short nameUtf8Index;
short descriptorUtf8Index;
}

The Last Three (1/2)
⦿ ConstantFieldref
⦿ ConstantMethodref
⦿ and ConstantInterfaceMethodref contains:
⦿ the index of a ConstantClass
⦿ the index of a ConstantNameAndType

The Last Three (2/2)
public class ConstantFieldref {
byte tag = 0x09;
short classIndex;
short nameAndType8Index;
}
public class ConstantMethodref {
byte tag = 0x0A;
short classIndex;
short nameAndType8Index;
}
public class ConstantInterfaceMethodref {
byte tag = 0x0B;
short nameUtf8Index;
short descriptorUtf8Index;
}

accessFlags (1/3)
ClassFile {
// …
short accessFlags;
short thisClass;
short superClass;
// …
}

accessFlags (2/3)
⦿ Indicate the modifiers of a class using masks.
Each bit is a modifier set if equals to 1 and
not set if equals to 0
Flag name Value Java keyword
ACC_PUBLIC 0x0001 public
ACC_FINAL 0x0010 final
ACC_SUPER 0x0020 -
ACC_INTERFACE 0x0200 interface
ACC_ABSTRACT 0x0400 abstract

accessFlags (3/3)
⦿ For example:
0000 a0b0 00cd 000e
Where:
a = 0x0400 = 0000 1000 0000 0000 (ACC_ABSTRACT)
b = 0x0200 = 0000 0010 0000 0000 (ACC_INTERFACE)
c = 0x0020 = 0000 0000 0010 0000 (ACC_SUPER)
d = 0x0010 = 0000 0000 0001 0000 (ACC_FINAL)
e = 0x0001 = 0000 0000 0000 0001 (ACC_PUBLIC)

thisClass & superClass (1/2)
ClassFile {
// …
short accessFlags;
short thisClass;
short superClass;
// …
}

thisClass & superClass (2/2)
⦿ Contains the index of a ConstantClass.
⦿ « this » and « super » have the same
meaning as in Java.
⦿ thisClass is the fully qualified name of the
current class
⦿ superClass is the fully qualified name of the
superClass. (java/lang/Object) by default.

Not this time…
ClassFile {
// …
short interfacesCount;
short[] interfaces;
short fieldsCount;
Field[] fields;
// …
}

methods
ClassFile {
// …
short methodsCount;
Method[] methods;
// …
}

methods
⦿ Each Java method can be represented like
this in a class File
class Method {
short accessFlags;
short nameIndex;
short descriptorIndex;
}

Method – accessFlags (1/2)
class Method {
short accessFlags;
short nameIndex;
}

Method – accessFlags (2/2)
⦿ Working like accessFlags for a ClassFile,
they indicate the modifiers of a method
Flag Name Value Java Keyword
ACC_PUBLIC 0x0001 public
ACC_PRIVATE 0x0002 private
ACC_PROTECTED 0x0004 protected
ACC_STATIC 0x0008 static
ACC_FINAL 0x0010 final
ACC_SYNCHRONIZED 0x0020 synchronized
ACC_NATIVE 0x0100 native
ACC_ABSTRACT 0x0400 abstract
ACC_STRICT 0x0800 strictfp

nameIndex & descriptorIndex (1/2)
class Method {
short accessFlags;
short nameIndex;
}

nameIndex & descriptorIndex (1/2)
⦿ Contain an index of ConstantUTF8 holding
respectively the name and the descriptor of
the method

attributes
class Method {
short accessFlags;
short nameIndex;
}

Attribute (1/3)
⦿ The Attribute structure can be found inside
other ones:
⦿ ClassFile
⦿ Field
⦿ Method
⦿ Code

Attribute (2/3)
⦿ There are several different kind of attributes (9 for
the JDK 1.4):
⦿ SourceFile
⦿ ConstantValue
⦿ Code
⦿ Exceptions
⦿ InnerClasses
⦿ Synthetic
⦿ LineNumberTable
⦿ LocalVariableTable
⦿ Deprecated
We will see only the Code Attribute today.

Attribute (3/3) - Structure
Attribute {
short nameIndex;
int attributeLength;
byte[] info;
}

Code Attribute
Code {
short attributeNameIndex;
short maxStack;
short maxLocals;
int codeLength;
byte[] code;
short exceptionsCount;
Exception[] exceptions;
}

attributeIndex (1/2)
Code {
short maxStack;
short maxLocals;
int codeLength;
byte[] code;
}

attributeIndex (2/2)
⦿ Contains the index of a ConstantUTF8
containing the value « Code » (The type
name of the attribute)

attributeLength (1/2)
Code {
short maxStack;
short maxLocals;
int codeLength;
byte[] code;
}

attributeLength (2/2)
⦿ Is the length of the attribute (without the six
first bytes) in byte.
⦿ It can be calculated like this :
2 + 2 + 4 // maxStack + maxLocals + codeLength
+ code.length
+ 2 // exceptionsCount
+ 8 * exceptions.length // an Exception takes 8 bytes
+ 2 // attributesCount
+ attributes.length

maxStack & maxLocals (1/2)
Code {
short maxStack;
short maxLocals;
int codeLength;
byte[] code;
}

maxStack & maxLocals (2/2)
⦿ Respectively the maximum size of the
operand stack and the local variables
⦿ These sizes can be find out with the
instructions used in the method.

code (1/2)
Code {
short maxStack;
short maxLocals;
int codeLength;
byte[] code;
}

code (1/2)
⦿ Contains all the instructions of a method
⦿ Each instruction take 1 byte
⦿ + the size of their arguments
⦿ Only ¼ of the instruction set have arguments

It’s only the beginning

Want to know more ?
⦿ Specifications
⦿http://docs.oracle.com/javase/specs/
⦿ invokedynamic
⦿https://blogs.oracle.com/jrose/
⦿http://blog.headius.com/
⦿ JVM Hardcore – The JVM explained
⦿ http://blog.soat.fr/2013/09/01-jvm-hardcore-
part-0-sneak-peek

Introduction to the Java bytecode - So@t - 20130924

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Introduction to the Java bytecode - So@t - 20130924

Similar to Introduction to the Java bytecode - So@t - 20130924 (20)

More from yohanbeschi

More from yohanbeschi (9)

Recently uploaded

Recently uploaded (20)

Introduction to the Java bytecode - So@t - 20130924