Chapter 4. Theclass File Format

• A module name must not contain any code point in the range '\u0000' to '\u001F' inclusive.

• The ASCII backslash (\) is reserved for use as an escape character in module names. It must not appear in a module name unless it is followed by an ASCII backslash, an ASCII colon (:), or an ASCII at-sign (@). The ASCII character sequence\\ may be used to encode a backslash in a module name.

• The ASCII colon (:) and at-sign (@) are reserved for future use in module names. They must not appear in module names unless they are escaped. The ASCII character sequences\: and\@ may be used to encode a colon and an at-sign in a module name.

Table 4.3-A. Interpretation of field descriptors

The field descriptor of an instance variable of typeint is simplyI.

The field descriptor of an instance variable of typeObject isLjava/lang/Object;. Note that the internal form of the binary name for classObject is used.

The field descriptor of an instance variable of the multidimensional array typedouble[][][] is[[[D.

The method descriptor for the method:

Object m(int i, double d, Thread t) {...}

is:

(IDLjava/lang/Thread;)Ljava/lang/Object;

Note that the internal forms of the binary names ofThread andObject are used.

tag

Thetag item has the valueCONSTANT_Class (7).

name_index

The value of thename_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing a valid binary class or interface name encoded in internal form (§4.2.1).

For example, the class name representing the two-dimensional array typeint[][] is[[I, while the class name representing the typeThread[] is[Ljava/lang/Thread;.

tag

Thetag item of aCONSTANT_Fieldref_info structure has the valueCONSTANT_Fieldref (9).

Thetag item of aCONSTANT_Methodref_info structure has the valueCONSTANT_Methodref (10).

Thetag item of aCONSTANT_InterfaceMethodref_info structure has the valueCONSTANT_InterfaceMethodref (11).

class_index

The value of theclass_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Class_info structure (§4.4.1) representing a class or interface type that has the field or method as a member.

In aCONSTANT_Fieldref_info structure, theclass_index item may be either a class type or an interface type.

In aCONSTANT_Methodref_info structure, theclass_index item should be a class type, not an interface type.

In aCONSTANT_InterfaceMethodref_info structure, theclass_index item should be an interface type, not a class type.

name_and_type_index

The value of thename_and_type_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_NameAndType_info structure (§4.4.6). Thisconstant_pool entry indicates the name and descriptor of the field or method.

In aCONSTANT_Fieldref_info structure, the indicated descriptor must be a field descriptor (§4.3.2). Otherwise, the indicated descriptor must be a method descriptor (§4.3.3).

If the name of the method in aCONSTANT_Methodref_info structure begins with a '<' ('\u003c'), then the name must be the special name<init>, representing an instance initialization method (§2.9.1). The return type of such a method must bevoid.

tag

Thetag item has the valueCONSTANT_String (8).

string_index

The value of thestring_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing the sequence of Unicode code points to which theString object is to be initialized.

tag

Thetag item of theCONSTANT_Integer_info structure has the valueCONSTANT_Integer (3).

Thetag item of theCONSTANT_Float_info structure has the valueCONSTANT_Float (4).

bytes

Thebytes item of theCONSTANT_Integer_info structure represents the value of theint constant. The bytes of the value are stored in big-endian (high byte first) order.

Thebytes item of theCONSTANT_Float_info structure represents the value of thefloat constant in IEEE 754 binary32 floating-point format (§2.3.2). The bytes of the item are stored in big-endian (high byte first) order.

The value represented by theCONSTANT_Float_info structure is determined as follows. The bytes of the value are first converted into anint constantbits. Then:

• Ifbits is0x7f800000, thefloat value will be positive infinity.

• Ifbits is0xff800000, thefloat value will be negative infinity.

• Ifbits is in the range0x7f800001 through0x7fffffff or in the range0xff800001 through0xffffffff, thefloat value will be NaN.

• In all other cases, lets,e, andm be three values that might be computed frombits:

  int s = ((bits >> 31) == 0) ? 1 : -1;int e = ((bits >> 23) & 0xff);int m = (e == 0) ?          (bits & 0x7fffff) << 1 :          (bits & 0x7fffff) | 0x800000;

Then thefloat value equals the result of the mathematical expressions · m · 2e-150.

tag

Thetag item of theCONSTANT_Long_info structure has the valueCONSTANT_Long (5).

Thetag item of theCONSTANT_Double_info structure has the valueCONSTANT_Double (6).

high_bytes, low_bytes

The unsignedhigh_bytes andlow_bytes items of theCONSTANT_Long_info structure together represent the value of thelong constant

((long) high_bytes << 32) + low_bytes

where the bytes of each ofhigh_bytes andlow_bytes are stored in big-endian (high byte first) order.

Thehigh_bytes andlow_bytes items of theCONSTANT_Double_info structure together represent thedouble value in IEEE 754 binary64 floating-point format (§2.3.2). The bytes of each item are stored in big-endian (high byte first) order.

The value represented by theCONSTANT_Double_info structure is determined as follows. Thehigh_bytes andlow_bytes items are converted into thelong constantbits, which is equal to

((long) high_bytes << 32) + low_bytes

Then:

• Ifbits is0x7ff0000000000000L, thedouble value will be positive infinity.

• Ifbits is0xfff0000000000000L, thedouble value will be negative infinity.

• Ifbits is in the range0x7ff0000000000001L through0x7fffffffffffffffL or in the range0xfff0000000000001L through0xffffffffffffffffL, the double value will be NaN.

• In all other cases, lets,e, andm be three values that might be computed frombits:

  int s = ((bits >> 63) == 0) ? 1 : -1;int e = (int)((bits >> 52) & 0x7ffL);long m = (e == 0) ?           (bits & 0xfffffffffffffL) << 1 :           (bits & 0xfffffffffffffL) | 0x10000000000000L;

Then the floating-point value equals thedouble value of the mathematical expressions · m · 2e-1075.

tag

Thetag item has the valueCONSTANT_NameAndType (12).

name_index

The value of thename_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing either a valid unqualified name denoting a field or method (§4.2.2), or the special method name<init> (§2.9.1).

descriptor_index

The value of thedescriptor_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing a valid field descriptor or method descriptor (§4.3.2,§4.3.3).

tag

Thetag item has the valueCONSTANT_Utf8 (1).

length

The value of thelength item gives the number of bytes in thebytes array (not the length of the resulting string).

bytes[]

Thebytes array contains the bytes of the string.

No byte may have the value(byte)0.

No byte may lie in the range(byte)0xf0 to(byte)0xff.

• Code points in the range '\u0001' to '\u007F' are represented by a single byte:

  Table 4.7. 

  0

  bits 6-0

  
  

  The 7 bits of data in the byte give the value of the code point represented.

• The null code point ('\u0000') and code points in the range '\u0080' to '\u07FF' are represented by a pair of bytesx andy :

  Table 4.8. 

  x:	Table 4.9.  1 1 0 bits 10-6
  y:	Table 4.10.  1 0 bits 5-0

  
  

  The two bytes represent the code point with the value:

  ((x & 0x1f) << 6) + (y & 0x3f)

• Code points in the range '\u0800' to '\uFFFF' are represented by 3 bytesx,y, andz :

  Table 4.11. 

  x:	Table 4.12.  1 1 1 0 bits 15-12
  y:	Table 4.13.  1 0 bits 11-6
  z:	Table 4.14.  1 0 bits 5-0

  
  

  The three bytes represent the code point with the value:

  ((x & 0xf) << 12) + ((y & 0x3f) << 6) + (z & 0x3f)

• Characters with code points above U+FFFF (so-calledsupplementary characters) are represented by separately encoding the two surrogate code units of their UTF-16 representation. Each of the surrogate code units is represented by three bytes. This means supplementary characters are represented by six bytes,u,v,w,x,y, andz :

  Table 4.15. 

  u:	Table 4.16.  1 1 1 0 1 1 0 1
  v:	Table 4.17.  1 0 1 0 (bits 20-16)-1
  w:	Table 4.18.  1 0 bits 15-10
  x:	Table 4.19.  1 1 1 0 1 1 0 1
  y:	Table 4.20.  1 0 1 1 bits 9-6
  z:	Table 4.21.  1 0 bits 5-0

  
  

  The six bytes represent the code point with the value:

  0x10000 + ((v & 0x0f) << 16) + ((w & 0x3f) << 10) +((y & 0x0f) << 6) + (z & 0x3f)

tag

Thetag item has the valueCONSTANT_MethodHandle (15).

reference_kind

The value of thereference_kind item must be in the range 1 to 9. The value denotes thekind of this method handle, which characterizes its bytecode behavior (§5.4.3.5).

reference_index

The value of thereference_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be as follows:

• If the value of thereference_kind item is 1 (REF_getField), 2 (REF_getStatic), 3 (REF_putField), or 4 (REF_putStatic), then theconstant_pool entry at that index must be aCONSTANT_Fieldref_info structure (§4.4.2) representing a field for which a method handle is to be created.

• If the value of thereference_kind item is 5 (REF_invokeVirtual) or 8 (REF_newInvokeSpecial), then theconstant_pool entry at that index must be aCONSTANT_Methodref_info structure (§4.4.2) representing a class's method or constructor (§2.9.1) for which a method handle is to be created.

• If the value of thereference_kind item is 6 (REF_invokeStatic) or 7 (REF_invokeSpecial), then if theclass file version number is less than 52.0, theconstant_pool entry at that index must be aCONSTANT_Methodref_info structure representing a class's method for which a method handle is to be created; if theclass file version number is 52.0 or above, theconstant_pool entry at that index must be either aCONSTANT_Methodref_info structure or aCONSTANT_InterfaceMethodref_info structure (§4.4.2) representing a class's or interface's method for which a method handle is to be created.

• If the value of thereference_kind item is 9 (REF_invokeInterface), then theconstant_pool entry at that index must be aCONSTANT_InterfaceMethodref_info structure representing an interface's method for which a method handle is to be created.

If the value of thereference_kind item is 5 (REF_invokeVirtual), 6 (REF_invokeStatic), 7 (REF_invokeSpecial), or 9 (REF_invokeInterface), the name of the method represented by aCONSTANT_Methodref_info structure or aCONSTANT_InterfaceMethodref_info structure must not be<init> or<clinit>.

If the value is 8 (REF_newInvokeSpecial), the name of the method represented by aCONSTANT_Methodref_info structure must be<init>.

tag

Thetag item has the valueCONSTANT_MethodType (16).

descriptor_index

The value of thedescriptor_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing a method descriptor (§4.3.3).

• TheCONSTANT_Dynamic_info structure is used to represent adynamically-computed constant, an arbitrary value that is produced by invocation of a bootstrap method in the course of anldc instruction (§ldc), among others. The auxiliary type specified by the structure constrains the type of the dynamically-computed constant.

• TheCONSTANT_InvokeDynamic_info structure is used to represent adynamically-computed call site, an instance ofjava.lang.invoke.CallSite that is produced by invocation of a bootstrap method in the course of aninvokedynamic instruction (§invokedynamic). The auxiliary type specified by the structure constrains the method type of the dynamically-computed call site.

tag

Thetag item of aCONSTANT_Dynamic_info structure has the valueCONSTANT_Dynamic (17).

Thetag item of aCONSTANT_InvokeDynamic_info structure has the valueCONSTANT_InvokeDynamic (18).

bootstrap_method_attr_index

The value of thebootstrap_method_attr_index item must be a valid index into thebootstrap_methods array of the bootstrap method table of thisclass file (§4.7.23).

CONSTANT_Dynamic_info structures are unique in that they are syntactically allowed to refer to themselves via the bootstrap method table. Rather than mandating that such cycles are detected when classes are loaded (a potentially expensive check), we permit cycles initially but mandate a failure at resolution (§5.4.3.6).

name_and_type_index

The value of thename_and_type_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_NameAndType_info structure (§4.4.6). Thisconstant_pool entry indicates a name and descriptor.

In aCONSTANT_Dynamic_info structure, the indicated descriptor must be a field descriptor (§4.3.2).

In aCONSTANT_InvokeDynamic_info structure, the indicated descriptor must be a method descriptor (§4.3.3).

tag

Thetag item has the valueCONSTANT_Module (19).

name_index

The value of thename_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing a valid module name (§4.2.3).

tag

Thetag item has the valueCONSTANT_Package (20).

name_index

The value of thename_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing a valid package name encoded in internal form (§4.2.3).

• If theACC_STATIC flag in theaccess_flags item of thefield_info structure is set, then the field represented by thefield_info structure is assigned the value represented by itsConstantValue attribute as part of the initialization of the class or interface declaring the field (§5.5). This occurs prior to the invocation of the class or interface initialization method of that class or interface (§2.9.2).

• Otherwise, the Java Virtual Machine must silently ignore the attribute.

attribute_name_index

The value of theattribute_name_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing the string "ConstantValue".

attribute_length

The value of theattribute_length item must be two.

constantvalue_index

The value of theconstantvalue_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index gives the value represented by this attribute. Theconstant_pool entry must be of a type appropriate to the field, as specified inTable 4.7.2-A.

Table 4.7.2-A. Constant value attribute types

Field Type	Entry Type
int,short,char,byte,boolean	CONSTANT_Integer
float	CONSTANT_Float
long	CONSTANT_Long
double	CONSTANT_Double
String	CONSTANT_String

attribute_name_index

The value of theattribute_name_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing the string "Code".

attribute_length

The value of theattribute_length item indicates the length of the attribute, excluding the initial six bytes.

max_stack

The value of themax_stack item gives the maximum depth of the operand stack of this method (§2.6.2) at any point during execution of the method.

max_locals

The value of themax_locals item gives the number of local variables in the local variable array allocated upon invocation of this method (§2.6.1), including the local variables used to pass parameters to the method on its invocation.

The greatest local variable index for a value of typelong ordouble ismax_locals - 2. The greatest local variable index for a value of any other type ismax_locals - 1.

code_length

The value of thecode_length item gives the number of bytes in thecode array for this method.

The value ofcode_length must be greater than zero (as thecode array must not be empty) and less than 65536.

code[]

Thecode array gives the actual bytes of Java Virtual Machine code that implement the method.

When thecode array is read into memory on a byte-addressable machine, if the first byte of the array is aligned on a 4-byte boundary, thetableswitch andlookupswitch 32-bit offsets will be 4-byte aligned. (Refer to the descriptions of those instructions for more information on the consequences ofcode array alignment.)

The detailed constraints on the contents of thecode array are extensive and are given in a separate section (§4.9).

exception_table_length

The value of theexception_table_length item gives the number of entries in theexception_table array.

exception_table[]

Each entry in theexception_table array describes one exception handler in thecode array. The order of the handlers in theexception_table array is significant (§2.10).

Eachexception_table entry contains the following four items:

start_pc, end_pc

The values of the two itemsstart_pc andend_pc indicate the ranges in thecode array at which the exception handler is active. The value ofstart_pc must be a valid index into thecode array of the opcode of an instruction. The value ofend_pc either must be a valid index into thecode array of the opcode of an instruction or must be equal tocode_length, the length of thecode array. The value ofstart_pc must be less than the value ofend_pc.

Thestart_pc is inclusive andend_pc is exclusive; that is, the exception handler must be active while the program counter is within the interval [start_pc,end_pc).

The fact thatend_pc is exclusive is a historical mistake in the design of the Java Virtual Machine: if the Java Virtual Machine code for a method is exactly 65535 bytes long and ends with an instruction that is 1 byte long, then that instruction cannot be protected by an exception handler. A compiler writer can work around this bug by limiting the maximum size of the generated Java Virtual Machine code for any method, instance initialization method, or static initializer (the size of any code array) to 65534 bytes.

handler_pc

The value of thehandler_pc item indicates the start of the exception handler. The value of the item must be a valid index into thecode array and must be the index of the opcode of an instruction.

catch_type

If the value of thecatch_type item is nonzero, it must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Class_info structure (§4.4.1) representing a class of exceptions that this exception handler is designated to catch. The exception handler will be called only if the thrown exception is an instance of the given class or one of its subclasses.

The verifier checks that the class isThrowable or a subclass ofThrowable (§4.9.2).

If the value of thecatch_type item is zero, this exception handler is called for all exceptions.

This is used to implementfinally (§3.13).

attributes_count

The value of theattributes_count item indicates the number of attributes of theCode attribute.

attributes[]

Each value of theattributes table must be anattribute_info structure (§4.7).

ACode attribute can have any number of optional attributes associated with it.

The attributes defined by this specification as appearing in theattributes table of aCode attribute are listed inTable 4.7-C.

The rules concerning attributes defined to appear in theattributes table of aCode attribute are given in§4.7.

The rules concerning non-predefined attributes in theattributes table of aCode attribute are given in§4.7.1.

attribute_name_index

The value of theattribute_name_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing the string "StackMapTable".

attribute_length

The value of theattribute_length item indicates the length of the attribute, excluding the initial six bytes.

number_of_entries

The value of thenumber_of_entries item gives the number ofstack_map_frame entries in theentries table.

entries[]

Each entry in theentries table describes one stack map frame of the method. The order of the stack map frames in theentries table is significant.

• TheTop_variable_info item indicates that the local variable has the verification typetop.

  Top_variable_info {    u1 tag = ITEM_Top; /* 0 */}

• TheInteger_variable_info item indicates that the location has the verification typeint.

  Integer_variable_info {    u1 tag = ITEM_Integer; /* 1 */}

• TheFloat_variable_info item indicates that the location has the verification typefloat.

  Float_variable_info {    u1 tag = ITEM_Float; /* 2 */}

• TheNull_variable_info type indicates that the location has the verification typenull.

  Null_variable_info {    u1 tag = ITEM_Null; /* 5 */}

• TheUninitializedThis_variable_info item indicates that the location has the verification typeuninitializedThis.

  UninitializedThis_variable_info {    u1 tag = ITEM_UninitializedThis; /* 6 */}

• TheObject_variable_info item indicates that the location has the verification type which is the class represented by theCONSTANT_Class_info structure (§4.4.1) found in theconstant_pool table at the index given bycpool_index.

  Object_variable_info {    u1 tag = ITEM_Object; /* 7 */    u2 cpool_index;}

• TheUninitialized_variable_info item indicates that the location has the verification typeuninitialized(Offset). TheOffset item indicates the offset, in thecode array of theCode attribute that contains thisStackMapTable attribute, of thenew instruction (§new) that created the object being stored in the location.

  Uninitialized_variable_info {    u1 tag = ITEM_Uninitialized; /* 8 */    u2 offset;}

• TheLong_variable_info item indicates that the first of two locations has the verification typelong.

  Long_variable_info {    u1 tag = ITEM_Long; /* 4 */}

• TheDouble_variable_info item indicates that the first of two locations has the verification typedouble.

  Double_variable_info {    u1 tag = ITEM_Double; /* 3 */}

• TheLong_variable_info andDouble_variable_info items indicate the verification type of the second of two locations as follows:

  • If the first of the two locations is a local variable, then:

    • It must not be the local variable with the highest index.

    • The next higher numbered local variable has the verification typetop.

  • If the first of the two locations is an operand stack entry, then:

    • It must not be the topmost location of the operand stack.

    • The next location closer to the top of the operand stack has the verification typetop.

• The frame typesame_frame is represented by tags in the range [0-63]. This frame type indicates that the frame has exactly the same local variables as the previous frame and that the operand stack is empty. Theoffset_delta value for the frame is the value of the tag item,frame_type.

  same_frame {    u1 frame_type = SAME; /* 0-63 */}

• The frame typesame_locals_1_stack_item_frame is represented by tags in the range [64, 127]. This frame type indicates that the frame has exactly the same local variables as the previous frame and that the operand stack has one entry. Theoffset_delta value for the frame is given by the formulaframe_type - 64. The verification type of the one stack entry appears after the frame type.

  same_locals_1_stack_item_frame {    u1 frame_type = SAME_LOCALS_1_STACK_ITEM; /* 64-127 */    verification_type_info stack[1];}

• Tags in the range [128-246] are reserved for future use.

• The frame typesame_locals_1_stack_item_frame_extended is represented by the tag 247. This frame type indicates that the frame has exactly the same local variables as the previous frame and that the operand stack has one entry. Theoffset_delta value for the frame is given explicitly, unlike in the frame typesame_locals_1_stack_item_frame. The verification type of the one stack entry appears afteroffset_delta.

  same_locals_1_stack_item_frame_extended {    u1 frame_type = SAME_LOCALS_1_STACK_ITEM_EXTENDED; /* 247 */    u2 offset_delta;    verification_type_info stack[1];}

• The frame typechop_frame is represented by tags in the range [248-250]. This frame type indicates that the frame has the same local variables as the previous frame except that the lastk local variables are absent, and that the operand stack is empty. The value ofk is given by the formula251 - frame_type. Theoffset_delta value for the frame is given explicitly.

  chop_frame {    u1 frame_type = CHOP; /* 248-250 */    u2 offset_delta;}

  Assume the verification types of local variables in the previous frame are given bylocals, an array structured as in thefull_frame frame type. Iflocals[M-1] in the previous frame represented local variableX andlocals[M] represented local variableY, then the effect of removing one local variable is thatlocals[M-1] in the new frame represents local variableX andlocals[M] is undefined.

  It is an error ifk is larger than the number of local variables inlocals for the previous frame, that is, if the number of local variables in the new frame would be less than zero.

• The frame typesame_frame_extended is represented by the tag 251. This frame type indicates that the frame has exactly the same local variables as the previous frame and that the operand stack is empty. Theoffset_delta value for the frame is given explicitly, unlike in the frame typesame_frame.

  same_frame_extended {    u1 frame_type = SAME_FRAME_EXTENDED; /* 251 */    u2 offset_delta;}

• The frame typeappend_frame is represented by tags in the range [252-254]. This frame type indicates that the frame has the same locals as the previous frame except thatk additional locals are defined, and that the operand stack is empty. The value ofk is given by the formulaframe_type - 251. Theoffset_delta value for the frame is given explicitly.

  append_frame {    u1 frame_type = APPEND; /* 252-254 */    u2 offset_delta;    verification_type_info locals[frame_type - 251];}

  The 0th entry inlocals represents the verification type of the first additional local variable. Iflocals[M] represents local variableN, then:

  • locals[M+1] represents local variableN+1 iflocals[M] is one ofTop_variable_info,Integer_variable_info,Float_variable_info,Null_variable_info,UninitializedThis_variable_info,Object_variable_info, orUninitialized_variable_info; and

  • locals[M+1] represents local variableN+2 iflocals[M] is eitherLong_variable_info orDouble_variable_info.

  It is an error if, for any indexi,locals[i] represents a local variable whose index is greater than the maximum number of local variables for the method.

• The frame typefull_frame is represented by the tag 255. Theoffset_delta value for the frame is given explicitly.

  full_frame {    u1 frame_type = FULL_FRAME; /* 255 */    u2 offset_delta;    u2 number_of_locals;    verification_type_info locals[number_of_locals];    u2 number_of_stack_items;    verification_type_info stack[number_of_stack_items];}

  The 0th entry inlocals represents the verification type of local variable 0. Iflocals[M] represents local variableN, then:

  • locals[M+1] represents local variableN+1 iflocals[M] is one ofTop_variable_info,Integer_variable_info,Float_variable_info,Null_variable_info,UninitializedThis_variable_info,Object_variable_info, orUninitialized_variable_info; and

  • locals[M+1] represents local variableN+2 iflocals[M] is eitherLong_variable_info orDouble_variable_info.

  It is an error if, for any indexi,locals[i] represents a local variable whose index is greater than the maximum number of local variables for the method.

  The 0th entry instack represents the verification type of the bottom of the operand stack, and subsequent entries instack represent the verification types of stack entries closer to the top of the operand stack. We refer to the bottom of the operand stack as stack entry 0, and to subsequent entries of the operand stack as stack entry 1, 2, etc. Ifstack[M] represents stack entryN, then:

  • stack[M+1] represents stack entryN+1 ifstack[M] is one ofTop_variable_info,Integer_variable_info,Float_variable_info,Null_variable_info,UninitializedThis_variable_info,Object_variable_info, orUninitialized_variable_info; and

  • stack[M+1] represents stack entryN+2 ifstack[M] is eitherLong_variable_info orDouble_variable_info.

  It is an error if, for any indexi,stack[i] represents a stack entry whose index is greater than the maximum operand stack size for the method.

attribute_name_index

The value of theattribute_name_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be theCONSTANT_Utf8_info structure (§4.4.7) representing the string "Exceptions".

attribute_length

The value of theattribute_length item indicates the length of the attribute, excluding the initial six bytes.

number_of_exceptions

The value of thenumber_of_exceptions item indicates the number of entries in theexception_index_table.

exception_index_table[]

Each value in theexception_index_table array must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Class_info structure (§4.4.1) representing a class type that this method is declared to throw.

• The exception is an instance ofRuntimeException or one of its subclasses.

• The exception is an instance ofError or one of its subclasses.

• The exception is an instance of one of the exception classes specified in theexception_index_table just described, or one of their subclasses.

attribute_name_index

The value of theattribute_name_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing the string "InnerClasses".

attribute_length

The value of theattribute_length item indicates the length of the attribute, excluding the initial six bytes.

number_of_classes

The value of thenumber_of_classes item indicates the number of entries in theclasses array.

classes[]

EveryCONSTANT_Class_info entry in theconstant_pool table which represents a class or interfaceC that is not a package member must have exactly one corresponding entry in theclasses array.

If a class or interface has members that are classes or interfaces, itsconstant_pool table (and hence itsInnerClasses attribute) must refer to each such member (JLS §13.1), even if that member is not otherwise mentioned by the class.

In addition, theconstant_pool table of every nested class and nested interface must refer to its enclosing class, so altogether, every nested class and nested interface will haveInnerClasses information for each enclosing class and for each of its own nested classes and interfaces.

Each entry in theclasses array contains the following four items:

inner_class_info_index

The value of theinner_class_info_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Class_info structure representingC.

outer_class_info_index

IfC is not a member of a class or an interface - that is, ifC is a top-level class or interface (JLS §7.6) or a local class (JLS §14.3) or an anonymous class (JLS §15.9.5) - then the value of theouter_class_info_index item must be zero.

Otherwise, the value of theouter_class_info_index item must be a valid index into theconstant_pool table, and the entry at that index must be aCONSTANT_Class_info structure representing the class or interface of whichC is a member. The value of theouter_class_info_index item must not equal the the value of theinner_class_info_index item.

inner_name_index

IfC is anonymous (JLS §15.9.5), the value of theinner_name_index item must be zero.

Otherwise, the value of theinner_name_index item must be a valid index into theconstant_pool table, and the entry at that index must be aCONSTANT_Utf8_info structure that represents the original simple name ofC, as given in the source code from which thisclass file was compiled.

inner_class_access_flags

The value of theinner_class_access_flags item is a mask of flags used to denote access permissions to and properties of class or interfaceC as declared in the source code from which thisclass file was compiled. It is used by a compiler to recover the original information when source code is not available. The flags are specified inTable 4.7.6-A.

Table 4.7.6-A. Nested class access and property flags

Flag Name	Value	Interpretation
ACC_PUBLIC	0x0001	Marked or implicitlypublic in source.
ACC_PRIVATE	0x0002	Markedprivate in source.
ACC_PROTECTED	0x0004	Markedprotected in source.
ACC_STATIC	0x0008	Marked or implicitlystatic in source.
ACC_FINAL	0x0010	Marked or implicitlyfinal in source.
ACC_INTERFACE	0x0200	Was aninterface in source.
ACC_ABSTRACT	0x0400	Marked or implicitlyabstract in source.
ACC_SYNTHETIC	0x1000	Declared synthetic; not present in the source code.
ACC_ANNOTATION	0x2000	Declared as an annotation interface.
ACC_ENUM	0x4000	Declared as anenum class.

All bits of theinner_class_access_flags item not assigned inTable 4.7.6-A are reserved for future use. They should be set to zero in generatedclass files and should be ignored by Java Virtual Machine implementations.

If aclass file has a version number that is 51.0 or above, and has anInnerClasses attribute in itsattributes table, then for all entries in theclasses array of theInnerClasses attribute, the value of theouter_class_info_index item must be zero if the value of theinner_name_index item is zero.

attribute_name_index

The value of theattribute_name_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing the string "EnclosingMethod".

attribute_length

The value of theattribute_length item must be four.

class_index

The value of theclass_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Class_info structure (§4.4.1) representing the innermost class that encloses the declaration of the current class.

method_index

If the current class is not immediately enclosed by a method or constructor, then the value of themethod_index item must be zero.

In particular,method_index must be zero if the current class was immediately enclosed in source code by an instance initializer, static initializer, instance variable initializer, or class variable initializer. (The first two concern both local classes and anonymous classes, while the last two concern anonymous classes declared on the right hand side of a field assignment.)

Otherwise, the value of themethod_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_NameAndType_info structure (§4.4.6) representing the name and type of a method in the class referenced by theclass_index attribute above.

It is the responsibility of a Java compiler to ensure that the method identified via themethod_index is indeed the closest lexically enclosing method of the class that contains thisEnclosingMethod attribute.

• an instance initialization method representing a default constructor of the Java programming language (§2.9.1)

• a class or interface initialization method (§2.9.2)

• the implicitly declared members of enum and record classes (JLS §8.9.3, JLS §8.10.3)

attribute_name_index

The value of theattribute_name_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing the string "Synthetic".

attribute_length

The value of theattribute_length item must be zero.

attribute_name_index

The value of theattribute_name_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing the string "Signature".

attribute_length

The value of theattribute_length item must be two.

signature_index

The value of thesignature_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing a class signature if thisSignature attribute is an attribute of aClassFile structure; a method signature if thisSignature attribute is an attribute of amethod_info structure; or a field signature otherwise.

Signatures encode declarations written in the Java programming language that use types outside the type system of the Java Virtual Machine. They support reflection and debugging, as well as compilation when onlyclass files are available.

A Java compiler must emit a signature for any class, interface, constructor, method, field, or record component whose declaration uses type variables or parameterized types. Specifically, a Java compiler must emit:

Signatures are specified using a grammar which follows the notation of§4.3.1. In addition to that notation:

The grammar includes the terminal symbolIdentifier to denote the name of a type, field, method, formal parameter, local variable, or type variable, as generated by a Java compiler. Such a name must not contain any of the ASCII characters.;[/<>: (that is, the characters forbidden in method names (§4.2.2) and also colon) but may contain characters that must not appear in an identifier in the Java programming language (JLS §3.8).

Signatures rely on a hierarchy of nonterminals known astype signatures:

Aclass signature encodes type information about a (possibly generic) class or interface declaration. It describes any type parameters of the class or interface, and lists its (possibly parameterized) direct superclass and direct superinterfaces, if any. A type parameter is described by its name, followed by any class bound and interface bounds.

Amethod signature encodes type information about a (possibly generic) method declaration. It describes any type parameters of the method; the (possibly parameterized) types of any formal parameters; the (possibly parameterized) return type, if any; and the types of any exceptions declared in the method'sthrows clause.

The following production from§4.3.3 is repeated here for convenience:

A method signature encoded by theSignature attribute may not correspond exactly to the method descriptor in themethod_info structure (§4.3.3). In particular, there is no assurance that the number of formal parameter types in the method signature is the same as the number of parameter descriptors in the method descriptor. The numbers are the same for most methods, but certain constructors in the Java programming language have an implicitly declared parameter which a compiler represents with a parameter descriptor but may omit from the method signature. See the note in§4.7.18 for a similar situation involving parameter annotations.

Afield signature encodes the (possibly parameterized) type of a field, formal parameter, local variable, or record component declaration.

attribute_name_index

The value of theattribute_name_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing the string "SourceFile".

attribute_length

The value of theattribute_length item must be two.

sourcefile_index

The value of thesourcefile_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure representing a string.

The string referenced by thesourcefile_index item will be interpreted as indicating the name of the source file from which thisclass file was compiled. It will not be interpreted as indicating the name of a directory containing the file or an absolute path name for the file; such platform-specific additional information must be supplied by the run-time interpreter or development tool at the time the file name is actually used.

attribute_name_index

The value of theattribute_name_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing the string "SourceDebugExtension".

attribute_length

The value of theattribute_length item indicates the length of the attribute, excluding the initial six bytes.

debug_extension[]

Thedebug_extension array holds extended debugging information which has no semantic effect on the Java Virtual Machine. The information is represented using a modified UTF-8 string (§4.4.7) with no terminating zero byte.

Note that thedebug_extension array may denote a string longer than that which can be represented with an instance of classString.

attribute_name_index

The value of theattribute_name_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing the string "LineNumberTable".

attribute_length

The value of theattribute_length item indicates the length of the attribute, excluding the initial six bytes.

line_number_table_length

The value of theline_number_table_length item indicates the number of entries in theline_number_table array.

line_number_table[]

Each entry in theline_number_table array indicates that the line number in the original source file changes at a given point in thecode array. Eachline_number_table entry must contain the following two items:

start_pc

The value of thestart_pc item must be a valid index into thecode array of thisCode attribute. The item indicates the index into thecode array at which the code for a new line in the original source file begins.

line_number

The value of theline_number item gives the corresponding line number in the original source file.

attribute_name_index

The value of theattribute_name_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing the string "LocalVariableTable".

attribute_length

The value of theattribute_length item indicates the length of the attribute, excluding the initial six bytes.

local_variable_table_length

The value of thelocal_variable_table_length item indicates the number of entries in thelocal_variable_table array.

local_variable_table[]

Each entry in thelocal_variable_table array indicates a range ofcode array offsets within which a local variable has a value, and indicates the index into the local variable array of the current frame at which that local variable can be found. Each entry must contain the following five items:

start_pc, length

The value of thestart_pc item must be a valid index into thecode array of thisCode attribute and must be the index of the opcode of an instruction.

The value ofstart_pc + length must either be a valid index into thecode array of thisCode attribute and be the index of the opcode of an instruction, or it must be the first index beyond the end of thatcode array.

Thestart_pc andlength items indicate that the given local variable has a value at indices into thecode array in the interval [start_pc,start_pc + length), that is, betweenstart_pc inclusive andstart_pc + length exclusive.

name_index

The value of thename_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must contain aCONSTANT_Utf8_info structure representing a valid unqualified name denoting a local variable (§4.2.2).

descriptor_index

The value of thedescriptor_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must contain aCONSTANT_Utf8_info structure representing a field descriptor which encodes the type of a local variable in the source program (§4.3.2).

index

The value of theindex item must be a valid index into the local variable array of the current frame. The given local variable is atindex in the local variable array of the current frame.

If the given local variable is of typedouble orlong, it occupies bothindex andindex + 1.

attribute_name_index

The value of theattribute_name_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing the string "LocalVariableTypeTable".

attribute_length

The value of theattribute_length item indicates the length of the attribute, excluding the initial six bytes.

local_variable_type_table_length

The value of thelocal_variable_type_table_length item indicates the number of entries in thelocal_variable_type_table array.

local_variable_type_table[]

Each entry in thelocal_variable_type_table array indicates a range ofcode array offsets within which a local variable has a value, and indicates the index into the local variable array of the current frame at which that local variable can be found. Each entry must contain the following five items:

start_pc, length

The value of thestart_pc item must be a valid index into thecode array of thisCode attribute and must be the index of the opcode of an instruction.

The value ofstart_pc + length must either be a valid index into thecode array of thisCode attribute and be the index of the opcode of an instruction, or it must be the first index beyond the end of thatcode array.

Thestart_pc andlength items indicate that the given local variable has a value at indices into thecode array in the interval [start_pc,start_pc + length), that is, betweenstart_pc inclusive andstart_pc + length exclusive.

name_index

The value of thename_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must contain aCONSTANT_Utf8_info structure representing a valid unqualified name denoting a local variable (§4.2.2).

signature_index

The value of thesignature_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must contain aCONSTANT_Utf8_info structure representing a field signature which encodes the type of a local variable in the source program (§4.7.9.1).

index

The value of theindex item must be a valid index into the local variable array of the current frame. The given local variable is atindex in the local variable array of the current frame.

If the given local variable is of typedouble orlong, it occupies bothindex andindex + 1.

attribute_name_index

The value of theattribute_name_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing the string "Deprecated".

attribute_length

The value of theattribute_length item must be zero.

attribute_name_index

The value of theattribute_name_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing the string "RuntimeVisibleAnnotations".

attribute_length

The value of theattribute_length item indicates the length of the attribute, excluding the initial six bytes.

num_annotations

The value of thenum_annotations item gives the number of run-time visible annotations represented by the structure.

annotations[]

Each entry in theannotations table represents a single run-time visible annotation on a declaration. Theannotation structure has the following format:

annotation {    u2 type_index;    u2 num_element_value_pairs;    {   u2            element_name_index;        element_value value;    } element_value_pairs[num_element_value_pairs];}

The items of theannotation structure are as follows:

type_index

The value of thetype_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing a field descriptor (§4.3.2). The field descriptor denotes the type of the annotation represented by thisannotation structure.

num_element_value_pairs

The value of thenum_element_value_pairs item gives the number of element-value pairs of the annotation represented by thisannotation structure.

element_value_pairs[]

Each value of theelement_value_pairs table represents a single element-value pair in the annotation represented by thisannotation structure. Eachelement_value_pairs entry contains the following two items:

element_name_index

The value of theelement_name_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7). Theconstant_pool entry denotes the name of the element of the element-value pair represented by thiselement_value_pairs entry.

In other words, the entry denotes an element of the annotation interface specified bytype_index.

value

The value of thevalue item represents the value of the element-value pair represented by thiselement_value_pairs entry.

Theelement_value structure is a discriminated union representing the value of an element-value pair. It has the following format:

element_value {    u1 tag;    union {        u2 const_value_index;        {   u2 type_name_index;            u2 const_name_index;        } enum_const_value;        u2 class_info_index;        annotation annotation_value;        {   u2            num_values;            element_value values[num_values];        } array_value;    } value;}

Thetag item uses a single ASCII character to indicate the type of the value of the element-value pair. This determines which item of thevalue union is in use.Table 4.7.16.1-A shows the valid characters for thetag item, the type indicated by each character, and the item used in thevalue union for each character. The table's fourth column is used in the description below of one item of thevalue union.

Thevalue item represents the value of an element-value pair. The item is a union, whose own items are as follows:

attribute_name_index

The value of theattribute_name_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing the string "RuntimeInvisibleAnnotations".

attribute_length

The value of theattribute_length item indicates the length of the attribute, excluding the initial six bytes.

num_annotations

The value of thenum_annotations item gives the number of run-time invisible annotations represented by the structure.

annotations[]

Each entry in theannotations table represents a single run-time invisible annotation on a declaration. Theannotation structure is specified in§4.7.16.

attribute_name_index

The value of theattribute_name_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing the string "RuntimeVisibleParameterAnnotations".

attribute_length

The value of theattribute_length item indicates the length of the attribute, excluding the initial six bytes.

num_parameters

The value of thenum_parameters item gives the number of run-time visible parameter annotations represented by this structure.

There is no assurance that this number is the same as the number of parameter descriptors in the method descriptor.

parameter_annotations[]

Each entry in theparameter_annotations table represents all of the run-time visible annotations on the declaration of a single formal parameter. Eachparameter_annotations entry contains the following two items:

num_annotations

The value of thenum_annotations item indicates the number of run-time visible annotations on the declaration of the formal parameter corresponding to theparameter_annotations entry.

annotations[]

Each entry in theannotations table represents a single run-time visible annotation on the declaration of the formal parameter corresponding to theparameter_annotations entry. Theannotation structure is specified in§4.7.16.

Thei'th entry in theparameter_annotations table may, but is not required to, correspond to thei'th parameter descriptor in the method descriptor (§4.3.3).

For example, a compiler may choose to create entries in the table corresponding only to those parameter descriptors which represent explicitly declared parameters in source code. In the Java programming language, a constructor of an inner class is specified to have an implicitly declared parameter before its explicitly declared parameters (JLS §8.8.1), so the corresponding<init> method in aclass file has a parameter descriptor representing the implicitly declared parameter before any parameter descriptors representing explicitly declared parameters. If the first explicitly declared parameter is annotated in source code, then a compiler may createparameter_annotations[0] to store annotations corresponding to thesecond parameter descriptor.

attribute_name_index

The value of theattribute_name_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure (§4.4.7) representing the string "RuntimeInvisibleParameterAnnotations".

attribute_length

The value of theattribute_length item indicates the length of the attribute, excluding the initial six bytes.

num_parameters

The value of thenum_parameters item gives the number of run-time invisible parameter annotations represented by this structure.

There is no assurance that this number is the same as the number of parameter descriptors in the method descriptor.

parameter_annotations[]

Each entry in theparameter_annotations table represents all of the run-time invisible annotations on the declaration of a single formal parameter. Eachparameter_annotations entry contains the following two items:

num_annotations

The value of thenum_annotations item indicates the number of run-time invisible annotations on the declaration of the formal parameter corresponding to theparameter_annotations entry.

annotations[]

Each entry in theannotations table represents a single run-time invisible annotation on the declaration of the formal parameter corresponding to theparameter_annotations entry. Theannotation structure is specified in§4.7.16.

Thei'th entry in theparameter_annotations table may, but is not required to, correspond to thei'th parameter descriptor in the method descriptor (§4.3.3).

See the note in§4.7.18 for an example of whenparameter_annotations[0] does not correspond to the first parameter descriptor in the method descriptor.

attribute_name_index

The value of theattribute_name_index item must be a valid index into theconstant_pool table. Theconstant_pool entry at that index must be aCONSTANT_Utf8_info structure representing the string "RuntimeVisibleTypeAnnotations".

attribute_length

The value of theattribute_length item indicates the length of the attribute, excluding the initial six bytes.

num_annotations

The value of thenum_annotations item gives the number of run-time visible type annotations represented by the structure.

annotations[]

Each entry in theannotations table represents a single run-time visible annotation on a type used in a declaration or expression. Thetype_annotation structure has the following format:

type_annotation {    u1 target_type;    union {        type_parameter_target;        supertype_target;        type_parameter_bound_target;        empty_target;        formal_parameter_target;        throws_target;        localvar_target;        catch_target;        offset_target;        type_argument_target;    } target_info;    type_path target_path;    u2        type_index;    u2        num_element_value_pairs;    {   u2            element_name_index;        element_value value;    } element_value_pairs[num_element_value_pairs];}

The first three items -target_type,target_info, andtarget_path - specify the precise location of the annotated type. The last three items -type_index,num_element_value_pairs, andelement_value_pairs[] - specify the annotation's own type and element-value pairs.

The items of thetype_annotation structure are as follows:

target_type

The value of thetarget_type item denotes the kind of target on which the annotation appears. The various kinds of target correspond to thetype contexts of the Java programming language where types are used in declarations and expressions (JLS §4.11).

The legal values oftarget_type are specified inTable 4.7.20-A andTable 4.7.20-B. Each value is a one-byte tag indicating which item of thetarget_info union follows thetarget_type item to give more information about the target.

The kinds of target inTable 4.7.20-A andTable 4.7.20-B correspond to the type contexts in JLS §4.11. Namely,target_type values 0x10-0x17 and 0x40-0x42 correspond to type contexts 1-11, whiletarget_type values 0x43-0x4B correspond to type contexts 12-17.

The value of thetarget_type item determines whether thetype_annotation structure appears in aRuntimeVisibleTypeAnnotations attribute in aClassFile structure, afield_info structure, amethod_info structure, or aCode attribute.Table 4.7.20-C gives the location of theRuntimeVisibleTypeAnnotations attribute for atype_annotation structure with each legaltarget_type value.

target_info

The value of thetarget_info item denotes precisely which type in a declaration or expression is annotated.

The items of thetarget_info union are specified in§4.7.20.1.

target_path

The value of thetarget_path item denotes precisely which part of the type indicated bytarget_info is annotated.

The format of thetype_path structure is specified in§4.7.20.2.

type_index, num_element_value_pairs, element_value_pairs[]

The meaning of these items in thetype_annotation structure is the same as their meaning in theannotation structure (§4.7.16).