ClassFile - Attributes - Code

The ​​Code​​ Attribute

The ​​Code​​​ attribute is a variable-length attribute in the ​​attributes​​​ table of a ​​method_info​​​ structure (​ ​§4.6​​​). A ​​Code​​​ attribute contains the Java Virtual Machine instructions and auxiliary information for a method, including an instance initialization method or a class or interface initialization method (​ ​§2.9​​).

If the method is either ​​native​​​ or ​​abstract​​​, its ​​method_info​​​ structure must not have a ​​Code​​​ attribute in its ​​attributes​​​ table. Otherwise, its ​​method_info​​​ structure must have exactly one ​​Code​​​ attribute in its ​​attributes​​ table.

The ​​Code​​ attribute has the following format:

Log in and copy

       

        Code_attribute {
        
    u2 attribute_name_index;
        
    u4 attribute_length;
        
    u2 max_stack;
        
    u2 max_locals;
        
    u4 code_length;  #   What is the instruction length 
        
    u1 code[code_length];   #  take code_length length    Instructions 
        
    u2 exception_table_length;
        
    {   u2 start_pc;
        
        u2 end_pc;
        
        u2 handler_pc;
        
        u2 catch_type;
        
    } exception_table[exception_table_length];
        
    u2 attributes_count;
        
    attribute_info attributes[attributes_count];
        
}
       
       

        
1.
        
2.
        
3.
        
4.
        
5.
        
6.
        
7.
        
8.
        
9.
        
10.
        
11.
        
12.
        
13.
        
14.
        
15.
        
16.
       

The items of the ​​Code_attribute​​ structure are as follows:

attribute_name_index

The value of the ​​attribute_name_index​​​ item must be a valid index into the ​​constant_pool​​​ table. The ​​constant_pool​​​ entry at that index must be a ​​CONSTANT_Utf8_info​​​ structure (​ ​§4.4.7​​​) representing the string "​​Code​​".

attribute_length

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

max_stack

The value of the ​​max_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 the ​​max_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 type ​​long​​​ or ​​double​​​ is ​​max_locals - 2​​​. The greatest local variable index for a value of any other type is ​​max_locals - 1​​.

code_length

The value of the ​​code_length​​​ item gives the number of bytes in the ​​code​​ array for this method.

The value of ​​code_length​​​ must be greater than zero (as the ​​code​​ array must not be empty) and less than 65536.

code[]

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

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

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

exception_table_length

The value of the ​​exception_table_length​​​ item gives the number of entries in the ​​exception_table​​ table.

exception_table[]

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

Each ​​exception_table​​ entry contains the following four items:

start_pc, end_pc

The values of the two items ​​start_pc​​​ and ​​end_pc​​​ indicate the ranges in the ​​code​​​ array at which the exception handler is active. The value of ​​start_pc​​​ must be a valid index into the ​​code​​​ array of the opcode of an instruction. The value of ​​end_pc​​​ either must be a valid index into the ​​code​​​ array of the opcode of an instruction or must be equal to ​​code_length​​​, the length of the ​​code​​​ array. The value of ​​start_pc​​​ must be less than the value of ​​end_pc​​.

The ​​start_pc​​​ is inclusive and ​​end_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 that ​​end_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 the ​​handler_pc​​​ item indicates the start of the exception handler. The value of the item must be a valid index into the ​​code​​ array and must be the index of the opcode of an instruction.

catch_type

If the value of the ​​catch_type​​​ item is nonzero, it must be a valid index into the ​​constant_pool​​​ table. The ​​constant_pool​​​ entry at that index must be a ​​CONSTANT_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 is ​​Throwable​​​ or a subclass of ​​Throwable​​​ (​ ​§4.9.2​​).

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

This is used to implement ​​finally​​​ (​ ​§3.13​​).

attributes_count

The value of the ​​attributes_count​​​ item indicates the number of attributes of the ​​Code​​ attribute.

attributes[]

Each value of the ​​attributes​​​ table must be an ​​attribute_info​​​ structure (​ ​§4.7​​).

A ​​Code​​ attribute can have any number of optional attributes associated with it.

The attributes defined by this specification as appearing in the ​​attributes​​​ table of a ​​Code​​​ attribute are listed in ​ ​Table 4.7-C​​.

The rules concerning attributes defined to appear in the ​​attributes​​​ table of a ​​Code​​​ attribute are given in ​ ​§4.7​​.

The rules concerning non-predefined attributes in the ​​attributes​​​ table of a ​​Code​​​ attribute are given in ​ ​§4.7.1​​.