9.2 Constant Pool

The next part of the class file is called the constant pool. Its purpose is to contain some constant values where they can be easily referenced elsewhere in the class file. The constant pool for this file follows.

 000008 0020           32 constants 00000a 08001f         1. String #31 00000d 07001d         2. Class name #29 000010 070018         3. Class name #24 000013 07000e         4. Class name #14 000016 070013         5. Class name #19 000019 090002000a     6. Fieldref class #2 name-and-type #10 00001e 0a00040009     7. Methodref class #4 name-and-type #9 000023 0a0003000b     8. Methodref class #3 name-and-type #11 000028 0c000c0017     9. NameAndType name #12 descriptor #23 00002d 0c0016001c     10. NameAndType name #22 descriptor #28 000032 0c001b001e     11. NameAndType name #27 descriptor #30 000037 010007         12. UTF length=7 00003a 7072 696e 746c 6e                         println 000041 01000d         13. UTF length=13 000044 436f 6e73 7461 6e74 5661 6c75 65          ConstantValue 000051 010013         14. UTF length=19 000054 6a61 7661 2f69 6f2f 5072 696e 7453 7472   java/io/PrintStr 000064 6561 6d                                   eam 000067 01000a         15. UTF length=10 00006a 4578 6365 7074 696f 6e73                  Exceptions 000074 01000a         16. UTF length=10 000077 6865 6c6c 6f2e 6a61 7661                  hello.java 000081 01000f         17. UTF length=15 000084 4c69 6e65 4e75 6d62 6572 5461 626c 65     LineNumberTable 000093 01000a         18. UTF length=10 000096 536f 7572 6365 4669 6c65                  SourceFile 0000a0 010005         19. UTF length=5 0000a3 6865 6c6c 6f                              hello 0000a8 01000e         20. UTF length=14 0000ab 4c6f 6361 6c56 6172 6961 626c 6573        LocalVariables 0000b9 010004         21. UTF length=4 0000bc 436f 6465                                 Code 0000c0 010003         22. UTF length=3 0000c3 6f75 74                                   out 0000c6 010015         23. UTF length=21 0000c9 284c 6a61 7661 2f6c 616e 672f 5374 7269   (Ljava/lang/Stri 0000d9 6e67 3b29 56                              ng;)V 0000de 010010         24. UTF length=16 0000e1 6a61 7661 2f6c 616e 672f 4f62 6a65 6374   java/lang/Object 0000f1 010004         25. UTF length=4 0000f4 6d61 696e                                 main 0000f8 010016         26. UTF length=22 0000fb 285b 4c6a 6176 612f 6c61 6e67 2f53 7472   ([Ljava/lang/Stri 00010b 696e 673b 2956                            ng;)V 000111 010006         27. UTF length=6 000114 3c69 6e69 743e                            <init> 00011a 010015         28. UTF length=21 00011d 4c6a 6176 612f 696f 2f50 7269 6e74 5374   Ljava/io/PrintSt  00012d 7265 616d 3b                              ream; 000132 010010         29. UTF length=16 000135 6a61 7661 2f6c 616e 672f 5379 7374 656d   java/lang/System 000145 010003         30. UTF length=3 000148 282956                                    ()V 00014b 01000c         31. UTF length=12 00014e 4865 6c6c 6f2c 2077 6f72 6c64             Hello, world 

The constant pool of the class file begins with a two-byte unsigned number that indicates how many constants are used in the class. There are 32 constants in this class. However, there are only 31 constant entries in the file: constant 0 is reserved for the virtual machine's own use. The first constant in the file is numbered 1, the last 31.

Each constant begins with a one-byte tag that tells what sort of constant is coming up. The tag defines the format of the bytes following it. There are 11 different tags, numbered from 1 to 12 (tag 2 is undefined); they are listed in Table 9.1.

Constant pool entries often reference other constants, using a two-byte unsigned integer as the index into the constant pool. The DumpClass output displays such references by prefixing the index number (in decimal) with a "#." Order is not significant, and both forward and backward references are permitted.

9.2.1 UTF8 Entries

The most common kind of constant is the UTF8 constant, represented by tag 1. UTF-8 stands for "UCS Transformation Format, 8 bits," which is a standard defined by the X/Open Company. It is a way of coding 16-bit Unicode strings so that they mimic 7-bit ASCII text. UTF8 constants are used to store arbitrary strings of information, and they are capable of storing arbitrary-length data. They're used by some of the other constants to hold variable-length information, like the values of strings and the names of methods.

A UTF8 constant starts with two bytes that represent the length of the data, which may be up to 64 kilobytes. For example, in constant 31, the first four bytes are 000c, meaning that there are 12 bytes of data.

The next 12 bytes are the actual data bytes. Each byte between 1 and 127 is interpreted as the ASCII value corresponding to that value. In this case, there are 12 bytes that are interpreted as the ASCII string "Hello, world."

Non-ASCII characters are represented using two or three bytes having values greater than 127. The specifics of the code are defined in File System Safe UCS Transformation Format (FSS_UTF), X/Open Preliminary Specification, X/Open Company Ltd., Document number P316. The UTF8 standard is also documented in ISO/IEC 10646, Annex P.

9.2.2 Constant Entries

The first constant in the constant pool is a String constant, identified by the tag byte 1. It's used to represent the value of string literals within the Java program. String constants are used in conjunction with ldc instructions and as field initializers.

The value of a String constant is two bytes, taken together as a 16-bit unsigned integer referring to a UTF8 constant. The UTF8 constant is the value of the String. In constant 1, the two bytes are 001f, which points to constant 31. In hello.class, constant 31 is a UTF8 with the value Hello, world.

Constants 3, 4, 5, and 6 represent the various kinds of numeric constants that can appear in Java programs. This file didn't contain any. Like String constants, these constants are used in conjunction with the ldc (push constant) instruction and with field initializers.

Table 9.1. Constant pool tag definitions
Tag Type Format Meaning
1 UTF8

2-byte unsigned integer


Length of the bytes


3 Integer 4-byte signed integer int constant
4 Float 4-byte floating-point number float constant
5 Long 8-byte signed long integer long constant
6 Double 8-byte double-precision number double constant
7 Class 2-byte UTF8 index Names a class
8 String 2-byte UTF8 index String constant
9 Fieldref 2-byte Class index Class containing the field
    2-byte NameAndType index Field name and type
10 Methodref

2-byte Class index

2-byte NameAndType index

Class containing the method

Method name and type

11 Interface Methodref

2-byte Class index

2-byte NameAndType index

Interface containing the method

Method name and type

12 NameAndType

2-byte UTF8 index

2-byte UTF8 index

Name of the field or method

Type descriptor

Integer and Long constants are written as two's complement signed integers, with 32 and 64 bits respectively, written from most significant byte to least significant byte. For example, suppose the program contained this line:

 long distance_to_sun = 149669000000;    // Distance to sun in                                            meters 

The compiler generates a Long constant. The eight bytes of this constant are:

 0000 0022 D8F7 B340 

Float and Double constants are also 32-and 64-bit values, but they are interpreted as representing floating-point numbers according to the IEEE 754 floating-point format (Table 9.2).

The value is negative if the sign is 1, positive if the sign is 0. The exponent and mantissa are unsigned integers. For example, the line

 double pi = 3.14159265358979323; 

would cause the compiler to add a Double constant with the bytes:

 4009 21FB 5444 2D18 

The sign of this number is 0, since the leftmost bit is 0. The exponent is 400 in hex, or 1024 in decimal. The mantissa is 921FB54442D18, or 2,570,638,124,657,944 decimal. Plugging this into the formula for double, you get the value of pi.

The String, Integer, and Float constants are usually the first in the constant pool. This allows them to have low numbers, which means that the short form of the ldc instruction can be used. If there are more than 255 of these constants in the constant pool, those with numbers 256 or above have to be used in conjunction with the ldc_w instruction, which takes up more space in the bytecodes. (Double and Long constrants require the ldc2_w instruction.)

Table 9.2. Format of floats and doubles
  Float Double
Sign 1 bit 1 bit
Exponent 8 bits 11 bits
Mantissa 23 bits 52 bits
Value (223+Mantissa)x2Exponent 150 (252+Mantissa)x2Exponent 1075

9.2.3 Field, Method, and Class Entries

Constants with the tags 9, 10, or 11 have identical formats. They are used to refer to fields and methods in field and method instructions, such as getfield, putstatic, and invokevirtual.

Constant 7 is an example of the Methodref constant. A Methodref constant contains two values that point to two other constants. The first points to a Class constant, which names the class containing the method. The second points to a NameAndType constant, which gives the name of the method and the method descriptor.

Constant 7 points to constant 4 as the Class constant and constant 9 as the NameAndType constant. The Class constant in 4 contains a single piece of information: a reference to a UTF8 constant naming the class. In this case, that's the UTF8 constant 14: java/io/PrintStream.

The NameAndType constant 9 contains the name and the type descriptor, each of which is a reference to a UTF8 constant. The values in this case are println and (Ljava/lang/String;)V.

Putting all this together provides enough information to name the method to be called. Constant 7 could be used in the assembly of an instruction:

 invokevirtual java/io/PrintStream/println (Ljava/lang/String;)V 

In this instruction, the class is java/io/PrintStream, the method is println, and the descriptor is (Ljava/lang/String;)V.

InterfaceMethodref and Fieldref constants are identical to Methodref constants. For an InterfaceMethodref, the Class entry refers to an interface instead of a class. For a Fieldref, the NameAndType entry points to a field instead of a method.

Programming for the Java Virtual Machine
Programming for the Javaв„ў Virtual Machine
ISBN: 0201309726
EAN: 2147483647
Year: 1998
Pages: 158
Authors: Joshua Engel

Similar book on Amazon

flylib.com © 2008-2017.
If you may any questions please contact us: flylib@qtcs.net