Revision as of 13:27, 28 February 2009 edit Hervegirod (talk \| contribs) Autopatrolled, Extended confirmed users 15,455 edits →See also ← Previous edit		Revision as of 22:32, 23 April 2009 edit undo QVanillaQ (talk \| contribs) 504 edits wow! content! Next edit →
Line 1: '''Java bytecode''' is the form of instructions that the [[Java virtual machine]] executes. Each [[bytecode]] ~~instruction or~~ [[opcode]] is one byte in length;, ~~however~~although some require parameters, ~~not~~resulting in some multi-byte instructions. Not all of the possible 256 ~~instructions~~opcodes are used. In fact, [[Sun Microsystems]], the original creators of the [[Java (programming language)\|Java programming language]], the [[Java virtual machine]] and other components of the Java Runtime Environment (JRE), have set aside 3 values to be permanently unimplemented.<ref name="reserved_opcodes">[http://java.sun.com/docs/books/jvms/second_edition/html/Instructions.doc.html#60105 VM Spec - Reserved Opcodes]</ref> == Relation to Java == A [[Java (programming language)\|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 Language\|assembler]] helps the [[C (programming language)\|C]] or [[C++]] programmer."<ref>[http://www-128.ibm.com/developerworks/ibm/library/it-haggar_bytecode/ Understanding bytecode makes you a better programmer]</ref>. == Instructions == As each byte has 256 potential values, there are 256 possible opcodes. Of these, 0x00 through 0xca, 0xfe, and 0xff are assigned values. 0xba is unused for historical reasons. 0xca is reserved as a breakpoint instruction for debuggers and is not used by the language. Similarly, 0xfe and 0xff are not used by the language, and are reserved for internal use by the virtual machine. Instructions fall into a number of broad groups: * Load and store (e.g. aload_0, istore) * 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) 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 "i", "l", "s", "b", "c", "f", "d", and "a", standing for, respectively, "integer", "long", "short", "byte", "character", "float", "double", and "reference". 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-4 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 5, while "dconst_1" will push a double 1. There is also an "aconst_null", which pushes "null". The ''n'' for the "load" and "store" instructions specifies the ___location in the variable table to load from or store to. The "aload_0" instruction pushes the object in variable 0 onto the stack (this is usually the "this" object). "istore_1" stores the integer on the top of the stack into variable 1. For variables with higher numbers the suffix is dropped and operators must be used. == Computational model == The computational model of Java bytecode is that of a [[stack-oriented programming language]]. For example, [[Assembly language\|assembly code]] for an [[x86\|x86 processor]] might look like this: <code> add eax, edx mov ecx, eax</code> This code would add two values and move the result to a different ___location. Similar disassembled bytecode might look like this: <code> 0 iload_1 1 iload_2 2 iadd 3 istore_3</code> Here, the two values to be added are pushed onto the stack, where they are retrieved by the addition instruction, summed, and the result placed back on the stack. The storage instruction then moves the top value of the stack into a variable ___location. The numbers in front of the instructions simply represent the offset of each instruction from the beginning of the method. This stack-oriented model extends to the object oriented aspects of the language as well. A method call called "getName()", for example, may look like the following: <code> Method java.lang.String getName() 0 aload_0 // The "this" object is stored in ___location 0 of the variable table 1 getfield #5 <Field java.lang.String name> // This instructon pops an object from the top of the stack, retrieves the specified field from it, // and pushes the field onto the stack. // In this example, the "name" field is the fifth field of the class. 4 areturn // Returns the object on top of the stack from the method.</code> == Example == Consider the following Java code. <source lang="java"> 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); } </source> A Java compiler might translate the Java code above into byte code as follows, assuming the above was put in a method: <code> Code: 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 # remainder 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</code> == Generation ==

Java bytecode: Difference between revisions