jvm源码解读--04 常量池 常量项的解析CONSTANT_Class_info
接上篇的继续
ConstantPool* constant_pool = ConstantPool::allocate(_loader_data, length, CHECK_(nullHandle)); _cp = constant_pool; // save in case of errors constantPoolHandle cp (THREAD, constant_pool); // parsing constant pool entries parse_constant_pool_entries(length, CHECK_(nullHandle));
分析橘色的
上面是一个构造方法
定义中是带宏的,先看gdb打印类 (gdb) ptype cp type = /* real type = constantPoolHandle */ class constantPoolHandle : public StackObj { private: ConstantPool *_value; Thread *_thread; protected: ConstantPool * obj(void) const; ConstantPool * non_null_obj(void) const; public: constantPoolHandle(void); constantPoolHandle(ConstantPool *); constantPoolHandle(Thread *, ConstantPool *); constantPoolHandle(const constantPoolHandle &); constantPoolHandle & operator=(const constantPoolHandle &); ~constantPoolHandle(); void remove(void); ConstantPool * operator()(void) const; ConstantPool * operator->(void) const; bool operator==(ConstantPool *) const; bool operator==(const constantPoolHandle &) const; bool is_null(void) const; bool not_null(void) const; }
接着看宏定义
在程序中是用宏定义的 DEF_METADATA_HANDLE_FN(constantPool, ConstantPool) 看下面的宏定义 // Constructors for metadata handles #define DEF_METADATA_HANDLE_FN(name, type) \\这里是初始化列表的构造方法, inline name##Handle::name##Handle(type* obj) : _value(obj), _thread(NULL) { if (obj != NULL) { \ assert(((Metadata*)obj)->is_valid(), "obj is valid"); \ _thread = Thread::current(); \ assert (_thread->is_in_stack((address)this), "not on stack?"); \ _thread->metadata_handles()->push((Metadata*)obj); \ } \ } \ inline name##Handle::name##Handle(Thread* thread, type* obj) : _value(obj), _thread(thread) { \ if (obj != NULL) { \ assert(((Metadata*)obj)->is_valid(), "obj is valid"); \ assert(_thread == Thread::current(), "thread must be current"); \ assert (_thread->is_in_stack((address)this), "not on stack?"); \ _thread->metadata_handles()->push((Metadata*)obj); \ } \ }
在看实际解析
(gdb) p cp $2 = (constantPoolHandle) { <StackObj> = {<AllocatedObj> = {_vptr.AllocatedObj = 0x7f2586b44390 <vtable for constantPoolHandle+16>}, <No data fields>}, _value = 0x7f2563800108, _thread = 0x7f258000b800}
接着进入的常量池条目解析
// parsing constant pool entries parse_constant_pool_entries(length, CHECK_(nullHandle)); //经典的 对象和指针 ClassFileStream* cfs0 = stream(); ClassFileStream cfs1 = *cfs0; ClassFileStream* cfs = &cfs1;
先提供些定义
enum { JVM_CONSTANT_Utf8 = 1, JVM_CONSTANT_Unicode, /* unused */ JVM_CONSTANT_Integer, // 3 JVM_CONSTANT_Float, // 4 JVM_CONSTANT_Long, JVM_CONSTANT_Double, JVM_CONSTANT_Class, JVM_CONSTANT_String, JVM_CONSTANT_Fieldref, JVM_CONSTANT_Methodref, JVM_CONSTANT_InterfaceMethodref, JVM_CONSTANT_NameAndType, JVM_CONSTANT_MethodHandle = 15, // JSR 292 JVM_CONSTANT_MethodType = 16, // JSR 292 //JVM_CONSTANT_(unused) = 17, // JSR 292 early drafts only JVM_CONSTANT_InvokeDynamic = 18, // JSR 292 JVM_CONSTANT_ExternalMax = 18 // Last tag found in classfiles };
还有
CONSTANT_Utf8_info {
u1 tag;
u2 length;
u1 bytes[length];
}
CONSTANT_Integer_info {
u1 tag;
u4 bytes;
}
CONSTANT_Float_info {
u1 tag;
u4 bytes;
}
CONSTANT_Long_info {
u1 tag;
u4 high_bytes;
u4 low_bytes;
}
CONSTANT_Double_info {
u1 tag;
u4 high_bytes;
u4 low_bytes;
}
CONSTANT_Class_info {
u1 tag;
u2 name_index;
}
CONSTANT_String_info {
u1 tag;
u2 string_index;
}
CONSTANT_Fieldref_info {
u1 tag;
u2 class_index;
u2 name_and_type_index;
}
CONSTANT_Methodref_info {
u1 tag;
u2 class_index;
u2 name_and_type_index;
}
CONSTANT_InterfaceMethodref_info {
u1 tag;
u2 class_index;
u2 name_and_type_index;
}
CONSTANT_NameAndType_info {
u1 tag;
u2 name_index;
u2 descriptor_index;
}
CONSTANT_MethodHandle_info {
u1 tag;
u1 reference_kind;
u2 reference_index;
}
CONSTANT_MethodType_info {
u1 tag;
u2 descriptor_index;
}
CONSTANT_InvokeDynamic_info {
u1 tag;
u2 bootstrap_method_attr_index;
u2 name_and_type_index;
}
进入函数
// parsing Index 0 is unused for (int index = 1; index < length; index++) { // Each of the following case guarantees one more byte in the stream // for the following tag or the access_flags following constant pool, // so we don't need bounds-check for reading tag. u1 tag = cfs->get_u1_fast(); switch (tag) { case JVM_CONSTANT_Class : { cfs->guarantee_more(3, CHECK); // name_index, tag/access_flags u2 name_index = cfs->get_u2_fast(); _cp->klass_index_at_put(index, name_index); } break; case JVM_CONSTANT_Fieldref : { cfs->guarantee_more(5, CHECK); // class_index, name_and_type_index, tag/access_flags u2 class_index = cfs->get_u2_fast(); u2 name_and_type_index = cfs->get_u2_fast(); _cp->field_at_put(index, class_index, name_and_type_index); } break; .... }
蓝色的过程就是取出tag的值
看执行前
先看下cfs 对象 (gdb) p cfs $4 = (ClassFileStream *) 0x7f2587845460 (gdb) p * cfs $5 = (ClassFileStream) {<ResourceObj> = {<AllocatedObj> = {_vptr.AllocatedObj = 0x7f2586b588b0 <vtable for ClassFileStream+16>}, _allocation_t = {18446604274545437599, 0}}, _buffer_start = 0x7f258000ea28 "\312\376\272\276", _buffer_end = 0x7f258000f0ee "\253\253\253\253\253\253\253\253\253\253\260\210\265\206%\177", _current = 0x7f258000ea32 "\a", _source = 0x7f258006eb98 "/home/atzhang/atzhang/openjdksource/openjdk8/openjdk/build/linux-x86_64-normal-server-slowdebug/jdk/classes", _need_verify = false} (gdb) x/10x cfs->_current 0x7f258000ea32: 0x0a3a0007 0x3b000100 0x0012000a 0x3d000a3c 0x7f258000ea42: 0x000a3e00 0x083f0001 0x000a4000 0x0a410012 0x7f258000ea52: 0x43004200 0x0001000a
那么取出来u1 就是07
进入switch tag=7 对应的是
CONSTANT_Class_info {
u1 tag;
u2 name_index;
}
与下面的逻辑相应
case JVM_CONSTANT_Class : { cfs->guarantee_more(3, CHECK); // name_index, tag/access_flags u2 name_index = cfs->get_u2_fast(); _cp->klass_index_at_put(index, name_index); }
取u2 =58 对应内存标注蓝色的0x3a
进入黄色函数之前的定义有
enum { // See jvm.h for shared JVM_CONSTANT_XXX tags // NOTE: replicated in SA in vm/agent/sun/jvm/hotspot/utilities/ConstantTag.java // Hotspot specific tags JVM_CONSTANT_Invalid = 0, // For bad value initialization JVM_CONSTANT_InternalMin = 100, // First implementation tag (aside from bad value of course) JVM_CONSTANT_UnresolvedClass = 100, // Temporary tag until actual use JVM_CONSTANT_ClassIndex = 101, // Temporary tag while constructing constant pool JVM_CONSTANT_StringIndex = 102, // Temporary tag while constructing constant pool JVM_CONSTANT_UnresolvedClassInError = 103, // Error tag due to resolution error JVM_CONSTANT_MethodHandleInError = 104, // Error tag due to resolution error JVM_CONSTANT_MethodTypeInError = 105, // Error tag due to resolution error JVM_CONSTANT_InternalMax = 105 // Last implementation tag };
进入黄色函数
// For temporary use while constructing constant pool void klass_index_at_put(int which, int name_index) { tag_at_put(which, JVM_CONSTANT_ClassIndex); *int_at_addr(which) = name_index; } void tag_at_put(int which, jbyte t) { tags()->at_put(which, t); } Array<u1>* tags() const { return _tags; } void at_put(const int i, const T& x) { assert(i >= 0 && i< _length, err_msg("oob: 0 <= %d < %d", i, _length)); _data[i] = x; }
能看到粉色函数是将tags数组索引为1的值设为了101 (JVM_CONSTANT_ClassIndex = 101)
使用内存验证
执行前 (gdb) x/10x _data 0x7f25638000ac: 0x00000000 0x00000000 0x00000000 0x00000000 0x7f25638000bc: 0x00000000 0x00000000 0x00000000 0x00000000 0x7f25638000cc: 0x00000000 0x00000000 执行后 (gdb) x/10x _tags._data 0x7f25638000ac: 0x00006500 0x00000000 0x00000000 0x00000000 0x7f25638000bc: 0x00000000 0x00000000 0x00000000 0x00000000 0x7f25638000cc: 0x00000000 0x00000000
进入灰色函数
jint* int_at_addr(int which) const { assert(is_within_bounds(which), "index out of bounds"); return (jint*) &base()[which]; } intptr_t* base() const { return (intptr_t*) (((char*) this) + sizeof(ConstantPool)); }
解析这个,
//解释 (gdb) p this
//$16 = (const ConstantPool * const) 0x7f2563800108
这里要转换,转换为(char*)指针类型的做加法 + {sizeof(ConstantPool)=88} 就是加88个字节,要是 (long*)类型的加法就会+88*8 了
(gdb) p (jint*) &base()[0]
$20 = (jint *) 0x7f2563800160
(gdb) p (jint*) &base()[which]
$19 = (jint *) 0x7f2563800168 ,这里which等于1,所以移动了8位
实际实现的就是将index=58 存放到了0x7f2563800168,这个地方了,这个地方之前,内存分配的时候为87个变量每个变量分配了一个8字节的空间
那么就是将58 这个变量放到了那个地址中
内存情况
(gdb) p *0x7f2563800168 $21 = 0 执行后 (gdb) p *0x7f2563800168 $22 = 58
