GeezerVison

JVM bytecode is the instruction set architecture (ISA) of the Java virtual machine (JVM), the language to which Java and other JVM-compatible source code is compiled.^[1] Each instruction is represented by one byte, hence the name bytecode, making it a compact form of data.^[2]

Due to the nature of virtual machines and bytecode, a JVM bytecode program is runnable on any machine with a compatible JVM, without the long process of compiling from source code.

JVM bytecode is used at runtime either interpreted by a JVM or compiled to machine code via just-in-time (JIT) compilation and run as a native application.

As JVM bytecode is designed for cross-platform software compatibility and security, a JVM bytecode application tends to run consistently across various hardware and software configurations.^[3]

In general, a Java programmer does not need to understand JVM bytecode or even be aware of it. 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."^[4]

The bytecode comprises various instruction types, including data manipulation, control transfer, object creation and manipulation, and method invocation, all integral to Java's object-oriented programming model.^[1]

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".^{[5]: 2.6  [2]} The operand stack is used for passing 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.^[5]: 4.7.3 Each can be independently sized from 0 to 65535 values, where each value is 32 bits. long and double types, which are 64 bits, take up two consecutive local variables^[5]: 2.6.1 (which need not be 64-bit aligned in the local variables array) or one value in the operand stack (but are counted as two units in the depth of the stack).^[5]: 2.6.2

Consider the following Java code:

outer:
for (int i = 2; i < 1000; i++) {
    for (int j = 2; j < i; j++) {
        if (i % j == 0)
            continue outer;
    }
    System.out.println(i);
}

A Java compiler might translate the Java code above into bytecode 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:(I)V
38:  iinc           1, 1
41:  goto           2
44:  return

The most common language targeting Java virtual machine by producing JVM bytecode is Java. Originally only one compiler existed, the javac compiler from Sun Microsystems, which compiles Java source code to JVM bytecode; but because all the specifications for JVM bytecode are now available, other parties have supplied compilers that produce JVM bytecode. Examples of other compilers include:

• Eclipse compiler for Java (ECJ)
• Jikes, compiles from Java to JVM bytecode (developed by IBM, implemented in C++)
• Espresso, compiles from Java to JVM bytecode (Java 1.0 only)
• GNU Compiler for Java (GCJ), compiles from Java to JVM bytecode; it can also compile to native machine code and was part of the GNU Compiler Collection (GCC) up until version 6.

Some projects provide Java assemblers to enable writing JVM 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:

• Jasmin, takes text descriptions for Java classes, written in a simple assembly-like syntax using Java virtual machine instruction set and generates a Java class file^[6]
• Jamaica, a macro assembly language for the Java virtual machine. Java syntax is used for class or interface definition. Method bodies are specified using bytecode instructions.^[7]
• Krakatau Bytecode Tools, currently contains three tools: a decompiler and disassembler for Java classfiles and an assembler to create classfiles.^[8]
• Lilac, an assembler and disassembler for the Java virtual machine.^[9]

Others have developed compilers, for different programming languages, to target the Java virtual machine, such as:

• ColdFusion
• JRuby and Jython, two scripting languages based on Ruby and Python
• Apache Groovy, optionally typed and dynamic general-purpose language, with static-typing and static compiling abilities
• Scala, a type-safe general-purpose programming language supporting object-oriented and functional programming
• JGNAT and AppletMagic, compile from the language Ada to JVM bytecode
• C to Java byte-code compilers
• Clojure, a functional, immutable, general-purpose language in the Lisp family with a strong emphasis on concurrency
• Kawa, an implementation of the Scheme language, also a dialect of Lisp
• MIDletPascal
• JavaFX Script code is compiled to JVM bytecode
• Kotlin, a statically typed general-purpose language with type inference
• Object Pascal source code is compiled to JVM bytecode using the Free Pascal 3.0+ compiler.^[10][11]

There are several Java virtual machines available today to execute JVM bytecode, both free and commercial products. If executing bytecode in a 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 (GCJ). Some processors can execute JVM bytecode natively. Such processors are termed Java processors.

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 runtime, or to choose the method dispatch by an alternative approach.^[12]

Java Specification Request (JSR) 292 (Supporting Dynamically Typed Languages on the Java Platform)^[13] added a new invokedynamic instruction at the JVM level, to allow method invocation relying on dynamic type checking (instead of the extant statically type-checked invokevirtual instruction). The Da Vinci Machine is a prototype virtual machine implementation that hosts JVM extensions aimed at supporting dynamic languages. All JVMs supporting Java Platform, Standard Edition (JSE) 7 also include the invokedynamic opcode.

• Byte Code Engineering Library
• Common Intermediate Language (CIL), Microsoft's rival to JVM bytecode
• Java backporting tools
• Java class file
• Java virtual machine
• JStik
• ObjectWeb ASM
• List of JVM bytecode instructions
• List of JVM languages

The Wikibook Java Programming has a page on the topic of: Java bytecode

• Oracle's Java Virtual Machine Specification
• Programming Languages for the Java Virtual Machine
• Bytecode Visualizer – bytecode viewer and debugger (free Eclipse plugin)
• AdaptJ StackTrace – bytecode level debugging with a full control of the stack, the local variables, and the execution flow
• Java Class Unpacker – plugin for Total Commander, it lets open class files as compressed archives and see fields and methods as files. The bytecode can be viewed as text using F3