Java bytecode: Difference between revisions

Revision as of 00:01, 14 November 2023

Latest revision as of 18:21, 24 August 2025

(26 intermediate revisions by 22 users not shown)

Line 3:

{{Use American English|date=November 2023}}

'''Java bytecode''' is the instruction set of the [[Java virtual machine]] (JVM), crucialthe forlanguage executingto programs written in thewhich [[Java (programming language)|Java]] language and other JVM-compatible languages[[source code]] is [[compiler|compiled]].<ref name="oracle jvm spec">{{Cite web|url=http://docs.oracle.com/javase/specs/jvms/se8/html/|title=Java Virtual Machine Specification|publisher=Oracle|access-date=14 November 2023}}</ref>. Each bytecode operation in the JVMinstruction is represented by a single [[byte]], hence the name "[[bytecode"]], making it a compact form of instruction[[data]].<ref name="JVM Book">{{Cite book|last=Lindholm|first=Tim|title=The Java Virtual Machine Specification|year=2015|publisher=Oracle|isbn=978-0133905908}}</ref>. This intermediate form enables Java programs to be platform-independent, as they are compiled not to native machine code but to a universally executable format across different JVM implementations.

Due to the nature of bytecode, a Java bytecode [[computer program|program]] is runnable on any machine with a compatible JVM, without the lengthy process of compiling from source code.

The JVM interprets this bytecode or compiles it on-the-fly into native machine code using a Just-In-Time (JIT) compiler, enhancing the performance of Java applications. The design of Java bytecode aims for a high degree of cross-platform compatibility and security, executed within the JVM's controlled environment. This architecture allows Java applications to run consistently across various hardware and software configurations<ref>{{Cite journal|last=Arnold|first=Ken|title=The Java Programming Language|journal=Sun Microsystems|year=1996|volume=1|issue=1|pages=30–40}}</ref>. While Java programmers typically do not interact directly with bytecode, understanding its structure and execution can be advantageous for optimization and debugging purposes.

Java bytecode is used at [[Runtime (program lifecycle phase)|runtime]] either [[interpreter (computing)|interpreted]] by a JVM or compiled to machine code via [[Just-in-time compilation|just-in-time]] (JIT) compilation and run as a native application.

In the JVM, Java bytecode operates as a set of instructions for both a stack machine and a register machine, utilizing an operand stack and local variables for executing operations<ref name="JVM Book"/>. 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<ref name="oracle jvm spec"/>.

As Java bytecode is designed for a cross-platform compatibility and security, a Java bytecode application tends to run consistently across various [[computer hardware|hardware]] and [[software]] configurations.<ref>{{Cite journal|last=Arnold|first=Ken|title=The Java Programming Language|journal=Sun Microsystems|year=1996|volume=1|issue=1|pages=30–40}}</ref>

== Relation to Java ==

AIn [[Javageneral, (programminga language)|Java [[programmer]] programmer does not need to beunderstand awareJava ofbytecode or understandeven Javabe bytecodeaware atof allit. 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 language|assembly]] helps the [[C (programming language)|C]] or [[C++]] programmer."<ref>{{Cite web |title=IBM Developer |url=https://developer.ibm.com/languages/java/ |access-date=20 February 2006 |website=developer.ibm.com}}</ref>

== Instruction set architecture ==

The JVM is both a [[stack machine]] and a [[register machine]]. Each [[Call stack#STACK-FRAME|frame]] for a method call has an "operand stack" and an array of "local variables".<ref name="jvm">{{cite book |last1=Lindholm |first1=Tim |last2=Yellin |first2=Frank |last3=Bracha |first3=Gilad |last4=Buckley |first4=Alex |title=The Java Virtual Machine Specification |edition=Java SE 8 |date=2015-02-13 |url=http://docs.oracle.com/javase/specs/jvms/se8/html/}}</ref>{{rp|2.6}} 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 [[Processor register|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.<ref name="jvm"/>{{rp|4.7.3}} Each can be independently sized from 0 to 65535 values, where each value is 32 bits. {{code|lang="java"|long}} and {{code|lang="java"|double}} types, which are 64 bits, take up two consecutive local variables<ref name="jvm"/>{{rp|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).<ref name="jvm"/>{{rp|2.6.2}}

In the JVM, Java bytecode operates as a set of instructions for both a stack machine and a register machine, utilizing an operand stack and local variables for executing operations<ref name="JVM Book"/>. 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.<ref name="oracle jvm spec"/>.

The JVM is both a [[stack machine]] and a [[register machine]]. Each [[Call stack#STACK-FRAME|frame]] for a method call has an "operand stack" and an array of "local variables".<ref name="jvm">{{cite book |last1=Lindholm |first1=Tim |last2=Yellin |first2=Frank |last3=Bracha |first3=Gilad |last4=Buckley |first4=Alex |title=The Java Virtual Machine Specification |edition=Java SE 8 |date=2015-02-13 |url=http://docs.oracle.com/javase/specs/jvms/se8/html/}}</ref>{{rp|2.6}} <ref name="JVM Book"/> 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 [[Processor register|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.<ref name="jvm"/>{{rp|4.7.3}} Each can be independently sized from 0 to 65535 values, where each value is 32 bits. {{code|lang="java"|long}} and {{code|lang="java"|double}} types, which are 64 bits, take up two consecutive local variables<ref name="jvm"/>{{rp|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).<ref name="jvm"/>{{rp|2.6.2}}

=== Instruction set ===

{{further|List of Java bytecode instructions}}

Line 33 ⟶ 39:

There are also a few instructions for a number of more specialized tasks such as exception throwing, synchronization, etc.

Many instructions have [[Opcode prefix|prefixes]] and/or suffixes referring to the types of operands they operate on.<ref name="jvm"/>{{rp|2.11.1}} These are as follows:

{| class="wikitable"

Line 71 ⟶ 77:

continue outer;

}

System.out.println (i);

}

</syntaxhighlight>

Line 111 ⟶ 117:

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:

*[[Jasmin (Java assembler)|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<ref>[http{{Cite web|url=https://jasmin.sourceforge.net /|title=Jasmin homeHome page<!-- BotPage|website=jasmin.sourceforge.net|accessdate=2 generated titleJune -->]2024}}</ref>

*Jamaica, a [[Macro (computer science)|macro]] [[assembly language]] for the [[Java virtual machine]]. Java syntax is used for class or interface definition. Method bodies are specified using bytecode instructions.<ref>[{{Cite web|url=https://www.javaworld.com/article/2072355/core-java/learn-to-speak-jamaican.html |title=Jamaica: The Java virtual machine (JVM) macro assembler<!-- Bot generated title -->]|archive-url=https://web.archive.org/web/20231114000632/https://www.infoworld.com/article/2072355/learn-to-speak-jamaican.html|archive-date=14 November 2023|work=JavaWorld |accessdate=2 June 2024 |last1=Huang |first1=James Jianbo }}</ref>

*Krakatau Bytecode Tools, currently contains three tools: a decompiler and disassembler for Java classfiles and an assembler to create classfiles.<ref>[{{Cite web|url=https://github.com/Storyyeller/Krakatau |title=Storyyeller/Krakatau|date=1 June 2024|accessdate=2 homeJune page]2024|via=GitHub}}</ref>

*Lilac, an assembler and disassembler for the [[Java virtual machine]].<ref>[http{{Cite web|url=https://lilac.sourceforge.net /|title=Lilac home- a Java assembler|website=lilac.sourceforge.net|accessdate=2 June page]2024}}</ref>

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

*[[ColdFusion Markup Language|ColdFusion]]

*[[JRuby]] and [[Jython]], two [[scripting language]]s based on [[Ruby (programming language)|Ruby]] and [[Python (programming language)|Python]]

*[[Groovy (programming language)|Apache Groovy]], optionally typed and dynamic general-purpose language, with static-typing and static compilation capabilities

Line 125 ⟶ 131:

*[[Clojure]], a functional, immutable, general-purpose programming language in the [[Lisp (programming language)|Lisp]] family with a strong emphasis on concurrency

*[[Kawa (Scheme implementation)|Kawa]], an implementation of the [[Scheme (programming language)|Scheme]] programming language, also a dialect of [[Lisp (programming language)|Lisp]].

*[[MIDletPascal]]

*[[JavaFX Script]] code is compiled to Java bytecode

*[[Kotlin (programming language)|Kotlin]], a statically-typed general-purpose programming language with type inference

*[[Object Pascal]] source code is compiled to Java bytecode using the [[Free Pascal]] 3.0+ compiler.<ref>[http{{Cite web|url=https://wiki.freepascal.org/FPC_New_Features_3.0#Support_for_the_Java_Virtual_Machine_and_Dalvik_targets|title=FPC FreeNew PascalFeatures 3.0.0 - Free Pascal wiki|website=wiki.freepascal.org|accessdate=2 releaseJune notes]2024}}</ref><ref>[http{{Cite web|url=https://wiki.freepascal.org/FPC_JVM|title=FPC JVM - Free Pascal JVMwiki|website=wiki.freepascal.org|accessdate=2 June Target]2024}}</ref>

== Execution ==

Line 139 ⟶ 145:

The [[Java virtual machine]] provides some support for [[Type system#Dynamic typing|dynamically typed languages]]. Most of the extant JVM instruction set is [[Type system#Static typing|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 (program lifecycle phase)|run time]], or to choose the method dispatch by an alternative approach.<ref>{{cite web

| url=httphttps://headius.blogspot.com/2007/01/invokedynamic-actually-useful.html

| title=InvokeDynamic: Actually Useful?

| date=2007-01-03

Line 145 ⟶ 151:

| access-date=2008-01-25}}</ref>

[[Java Community Process|JSR]] 292 (''Supporting Dynamically Typed Languages on the Java Platform'')<ref>[http{{Cite web|url=https://www.jcp.org/en/jsr/detail?id=292|title=The seeJava Community Process(SM) Program - JSRs: Java Specification Requests - detail JSR# 292]|website=www.jcp.org|accessdate=2 June 2024}}</ref> added a new <code>invokedynamic</code> instruction at the JVM level, to allow method invocation relying on dynamic [[Type system#Type checking|type checking]] (instead of the extant statically type-checked <code>invokevirtual</code> 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 <code>invokedynamic</code> opcode.

== See also ==

{{Portal|Computer programming}}

<!---♦♦♦ Please keep the list in alphabetical order ♦♦♦--->

* [[List of Java bytecode instructions]]

* [[JavaByte classCode fileEngineering Library]]

* [[Common Intermediate Language]] (CIL), Microsoft's rival to Java bytecode

* [[List of JVM languages]]

* [[Java backporting tools]]

* [[Java class file]]

* [[Java virtual machine]]

* [[JStik]]

* [[Common Intermediate Language]] (CIL), Microsoft's rival to Java bytecode

* [[ObjectWeb ASM]]

* [[List of Java bytecode instructions]]

* [[Byte Code Engineering Library]]

* [[List of JVM languages]]

== References ==