Shulou(Shulou.com)06/02 Report--

This article mainly introduces the relevant knowledge of "what is the structure of JVM Class file". Xiaobian shows you the operation process through actual cases. The operation method is simple and fast and practical. I hope this article "what is the structure of JVM Class file" can help you solve the problem.

overview

We usually need to run javac command in DOS interface, the direct result of this command is to generate corresponding class file, and then based on this class file can really run the program to get results. Nature. This is due to the Java Virtual Machine, so is it true that the Java Virtual Machine can only compile.java source files? The answer is no. Today, Java virtual machines have achieved language independence. The basis for language independence is the storage format of virtual machines and bytecodes. Java virtual machines are no longer bound to any language, including Java. It is only associated with a specific binary file, a "class" file. The class file contains the Java virtual machine instruction set and symbol table, as well as a number of ancillary information. It's easy to think of Java(not essentially the platform-independence of the Java language itself, but rather the platform-independence of its underlying Java virtual machine). Cross-platform, because any functional language can be represented as a valid class file that can be accepted by the Java Virtual Machine. For example, in addition to the Java virtual machine can directly compile Java source files into class files, using JRuby and other language compilers can also compile program code into class files, it can be seen that the Java virtual machine does not care what language the class file is compiled from.

Class file structure

Class file is a set of binary streams based on 8 bytes. Each data item is arranged in class file in strict order without any separator, which makes the content stored in class file almost all programs running. The Java Virtual Machine specification specifies that the Class file format stores data in pseudo-structures similar to C language structures, which have only two data types: unsigned numbers and tables.

Unsigned numbers belong to basic data types, which can be used to describe numbers, index symbols, quantity values or character string values encoded according to UTF-8. The sizes of u1, u2, u4 and u8 are 1 byte, 2 bytes, 4 bytes and 8 bytes respectively.

A table is a composite data type consisting of multiple unsigned numbers or other tables as data items, all of which end with "_info". So what's a watch for? Tables are mainly used to describe data with hierarchical composite structures, such as methods and fields. Note that class files have no delimiters, so each binary data type is strictly defined. The specific sequence is defined as follows:

Class files are mainly divided into magic number, version number of Class file, constant pool, access flag, class index (also including parent class index and interface index set), field table set, method table set and attribute table set.

Magic Number and Class File Version Number

The first four bytes are magic numbers, and the only purpose of magic numbers is to determine whether this Class file is accepted by the Java Virtual Machine. There is magic in file headers such as gif and jpeg, and using magic instead of extensions is based on security considerations-extensions can be changed at will. The magic value of the Class file is "0xCAFEBABE"(coffee baby?).

The next four bytes of the magic number are the version number of the Class file: the version number is divided into minor version number and major version number. The first two bytes represent the minor version number and the last two bytes represent the major version number. The version number of this is the one that indicates the different version ranges depending on the jdk version. If the version number of the Class file exceeds the virtual machine version, execution is denied.

constant pool

Constant pool can be simply understood as the resource slave library of class file. This data type is the data type most associated with other items in Class file structure, and it is also one of the items occupying the largest space in Class file. Literal and symbolic references are mainly stored in the constant pool. Literals are closer to constant concepts at the Java language level, such as text strings, constant values declared as final, etc.(Baidu encyclopedia's interpretation is that literals are a series of characters quoted with double references). Symbolic references include three main types of constants:

The names and descriptors of the fully qualified name fields of classes and interfaces and the names and descriptors of the methods.

Association of symbolic references with direct references

A symbolic reference is a set of symbols used to describe the referenced object. A symbol is a literal in any form. There are no strict restrictions on symbolic references to the Java Virtual Machine. It is only necessary to specify that the target can be located without ambiguity when it is used. The constant pool exists in the Class file, and the Class file must first be loaded into memory through the Java virtual machine's class loading mechanism (specifically, the memory area of the method area, recalling that the method area stores mainly instances of objects, and this Class file is the interface that the virtual machine accepts external access). A symbol reference belongs to the constant pool. Does that mean that the target of the symbol reference has been loaded into memory? The answer is no, because symbol references are independent of the memory layout of the virtual machine, and the target of the symbol reference is not necessarily loaded into memory.

A direct reference can be a pointer directly to the target of the reference, a relative offset, or a handle that indirectly locates the target. Direct references are related to the memory layout of the virtual machine, and the direct references translated by the same symbol reference on different virtual machines are generally different. If there is a direct reference, then the target of the reference must be stored in memory.

Each constant in the constant pool is a table. There are 14 constant types in jdk1.7, so the items in the constant pool correspond to 14 tables. Each type of these 14 tables is different. But there is one common feature: the first bit at the beginning of the table is a flag bit of type u1, indicating which type the constant belongs to.

It should be noted that in the Class file, methods and fields need to refer to constants of type CONSTANT-Utf8_info, so the length of this type of constant has a certain limit, that is, the maximum length of methods and fields in Java. In CONSTANT-Utf8_info, the value u2 for length indicates that the Java virtual machine can compile only variable or method names up to about 64KB. More than that will not be compiled.

access flag

The data structure behind the constant pool is the access flag (access_flags), which is mainly used to identify some class or interface level access information, mainly including: whether the Class is a class or an interface, whether it is defined as public, whether it is defined as abstract type; if it is a class, whether it is declared as final, etc. Specific logo visits are as follows:

Class index, parent class index, and interface index collections

This data item is primarily used to determine inheritance relationships for this class.

The class index and parent class index are both data of type u2, and the interface index collection is a set of data of type u2. Since multiple inheritance is not allowed in Java, the parent class index is unique, but a class can implement multiple interfaces, so the interface index obtained is a collection, indicating which interfaces the class implements.

field table set

Field tables are used to describe variables declared in interfaces or classes.

Fields include class-level variables and instance-level variables, but do not include local variables declared inside methods (these variables are stored in local variable tables in the Java virtual machine stack). Naturally, information describing a field includes: the scope of the field (public, protected, private), instance variable (static), final, concurrent visibility (volatile), serializable (transient), field data type (primitive data type, object, array), field name. Information about fields is also stored in a table, which includes three types of fields:

u2 type access flags (access_flags), whose access flags are in access_flags u2 type name_index (simple name of field) u2 type descriptor (descriptor_index)

What's the difference between the simple name that appears above, the fully qualified name that appears above, and the descriptor that appears here? Among them, the fully qualified name is easier to understand, which is the complete path information of the class. A simple name refers to a method or field name that is not decorated with types and parameters. For example, a method is as follows:

public void inc(int a,int b){ System.out.println(a+b);}

The simple name of this method is inc.

Compared to the above two, descriptors are relatively complex. The main purpose of descriptors is to describe the data type of the field, the parameter list of the method, and the return value. The familiar void is represented by V in the Class file. Here is what the full descriptor flags mean:

For array types, each dimension is described by a leading "[" character, or two "[" characters for two-dimensional arrays. For example,"java.lang.String[][]" would be recorded as "[Ljava.lang.String;"

For methods, they are described in the order in which values are returned after the county parameter list. For example, the descriptor for method int inc(int a,int[] b,char[][] c,int d) is "(I[I [CI)I".

method table collection

The description of heap method tables in JVM is consistent with field tables, including access flags, name indexes, descriptor indexes, and attribute table collections. The structure of the method table is consistent with that of the field table, except for the difference in access flags. Methods cannot be modified with the volatile and transient keywords, so these two flags cannot be used in method tables. Access flags that cannot be used in fields are added to methods, such as synchronized, native, strictfp, abstract keywords, so corresponding access flags are added to the method table.

Note that method information from the parent class does not automatically appear in the method if the parent class method is not overridden in the child class. Similarly, it is possible to add methods that the compiler automatically adds, such as methods.

attribute sheet collection

The Class file, field table and method table above can all carry their own attribute information, which is described by attribute table and used to describe some scene-specific information. There are no strict requirements for the type and order of data items like Class files in the attribute sheet. As long as the new attribute does not duplicate the existing attribute name, anyone can write his own attribute information to the attribute sheet.

Code attribute

Java program method body code through javac compilation of the final compiled bytecode instructions are stored in the Code attribute. However, not all method tables must have this attribute. The Code attribute is the most important attribute in the Class file. If the information in a Java program is divided into two parts: Code and Metadata (including class, field, method definition and other information), then in the whole Class file, the Code attribute is used to describe the code, and all other data items are used to describe the metadata.

Exceptions Properties

This property enumerates checked exceptions that may be thrown in the method, i.e., enumerates exceptions that describe throws.

LineNumberTable property

It is mainly used to describe the correspondence between Java source code line numbers and byte code line numbers. This attribute is not necessary. Without this property, the direct impact on the program is that it cannot display the line number when an exception is thrown; and the method that cannot set breakpoints during debugging is debugging the program.

LocalVariableTable property

Used to describe the relationship between variables in the local variable table in the stack frame and variables defined in Java source code. It is also not a required attribute. Without this attribute, the immediate effect is that when someone references this method, all parameter names are lost and the IDE displays them with parameters such as args0 and args1. Naturally, when debugging a program, the parameter names displayed are agnostic.

SourceFile Properties

The source file name used to record this Class file. If this attribute is not used, the file name of the offending code will not be displayed on the stack when an exception is thrown.

ConstantValue property

It tells the virtual machine to assign values to static variables automatically. Note that this attribute (class variable) can only be used for variables modified by the static keyword. For non-class variables, initialization is done in the method; for class variables, there are two ways to initialize the variable: one is to use it in the class constructor method, and the other is to use the ConstantValue attribute. Sun Hotspot's current selection principle is that if a variable is modified with both static and final keywords, and the variable is of primitive data type or java.lang.String, it is initialized with the ConstantValue attribute. If it is not final-qualified or a primitive data type, it will choose to initialize using methods.

InnerClass Properties

This attribute is primarily used to record associations between inner classes and host classes.

Deprecated and Synthetic properties

These two attributes are Boolean attributes of the flag type, and there is only a difference between them.

Deprecated attribute is used to indicate that a class, field, or method has been designated as no longer recommended by the program author. It can be implemented by annotation @deprecated.

The Synthetic attribute indicates that this field is not generated by Java source code, but added by the compiler itself.

StackMapTable Properties

This property is intended to replace the previous data-flow analysis-based type inference validator, which compares performance expensively.

Signature property

This attribute is specifically used to record generic types, because in Java the generic implementation of erasure is used, and in bytecode (Code attribute), generic information is erased after compilation. The advantage of erasure is that it saves memory space for generics. The disadvantage is that generic information cannot be obtained through reflection at runtime. The Signature attribute compensates for this deficiency. The Java reflection API now has access to generic information, thanks to this attribute.

BootstrapMethods property

This property is used to hold the bootstrap method qualifier referenced by the invokedynamic directive. This instruction is used to dynamically resolve the method referenced by the call-point qualifier at runtime and execute the method.

About "JVM class file structure is what kind of" content introduced here, thank you for reading. If you want to know more about industry-related knowledge, you can pay attention to the industry information channel. Xiaobian will update different knowledge points for you every day.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.