Java bytecode


Java bytecode is the instruction set of the Java virtual machine.

Relation to Java

A Java programmer does not need to be aware of or understand Java bytecode at all. However, as suggested in the IBM developerWorks journal, "Understanding bytecode and what bytecode is likely to be generated by a Java compiler helps the Java programmer in the same way that knowledge of assembly helps the C or C++ programmer."

Instruction set architecture

The JVM is both a stack machine and a register machine. Each frame for a method call has an "operand stack" and an array of "local variables". The operand stack is used for operands to computations and for receiving the return value of a called method, while local variables serve the same purpose as registers and are also used to pass method arguments. The maximum size of the operand stack and local variable array, computed by the compiler, is part of the attributes of each method. Each can be independently sized from 0 to 65535 values, where each value is 32 bits. and types, which are 64 bits, take up two consecutive local variables or one value in the operand stack.

Instruction set

Each bytecode is composed of one byte that represents the opcode, along with zero or more bytes for operands.
Of the 256 possible byte-long opcodes, as of 2015, 202 are in use, 51 are reserved for future use, and 3 instructions are permanently reserved for JVM implementations to use. Two of these are to provide traps for implementation-specific software and hardware, respectively. The third is used for debuggers to implement breakpoints.
Instructions fall into a number of broad groups:
There are also a few instructions for a number of more specialized tasks such as exception throwing, synchronization, etc.
Many instructions have prefixes and/or suffixes referring to the types of operands they operate on. These are as follows:
Prefix/suffixOperand type
iinteger
llong
sshort
bbyte
ccharacter
ffloat
ddouble
areference

For example, iadd will add two integers, while dadd will add two doubles. The const, load, and store instructions may also take a suffix of the form _n, where n is a number from 0–3 for load and store. The maximum n for const differs by type.
The const instructions push a value of the specified type onto the stack. For example, iconst_5 will push an integer with the value 5 onto the stack, while dconst_1 will push a double with the value 1 onto the stack. There is also an aconst_null, which pushes a reference. The n for the load and store instructions specifies the index in the local variable array to load from or store to. The aload_0 instruction pushes the object in local variable 0 onto the stack. istore_1 stores the integer on the top of the stack into local variable 1. For local variables beyond 3 the suffix is dropped and operands must be used.

Example

Consider the following Java code:

outer:
for

A Java compiler might translate the Java code above into byte code as follows, assuming the above was put in a method:

0: iconst_2
1: istore_1
2: iload_1
3: sipush 1000
6: if_icmpge 44
9: iconst_2
10: istore_2
11: iload_2
12: iload_1
13: if_icmpge 31
16: iload_1
17: iload_2
18: irem
19: ifne 25
22: goto 38
25: iinc 2, 1
28: goto 11
31: getstatic #84; // Field java/lang/System.out:Ljava/io/PrintStream;
34: iload_1
35: invokevirtual #85; // Method java/io/PrintStream.println:V
38: iinc 1, 1
41: goto 2
44: return

Generation

The most common language targeting Java virtual machine by producing Java bytecode is Java. Originally only one compiler existed, the javac compiler from Sun Microsystems, which compiles Java source code to Java bytecode; but because all the specifications for Java bytecode are now available, other parties have supplied compilers that produce Java bytecode. Examples of other compilers include:
Some projects provide Java assemblers to enable writing Java bytecode by hand. Assembly code may be also generated by machine, for example by a compiler targeting a Java virtual machine. Notable Java assemblers include:
Others have developed compilers, for different programming languages, to target the Java virtual machine, such as:
There are several machines available today, both free and commercial products.
If executing Java bytecode in a Java virtual machine is undesirable, a developer can also compile Java source code or bytecode directly to native machine code with tools such as the GNU Compiler for Java. Some processors can execute Java bytecode natively. Such processors are termed Java processors.

Support for dynamic languages

The Java virtual machine provides some support for dynamically typed languages. Most of the extant JVM instruction set is statically typed - in the sense that method calls have their signatures type-checked at compile time, without a mechanism to defer this decision to run time, or to choose the method dispatch by an alternative approach.
JSR 292 added a new invokedynamic instruction at the JVM level, to allow method invocation relying on dynamic type checking. The Da Vinci Machine is a prototype virtual machine implementation that hosts JVM extensions aimed at supporting dynamic languages. All JVMs supporting JSE 7 also include the invokedynamic opcode.