nstanceKlass对象

oop java_lang_Class::create_mirror(KlassHandle k, Handle protection_domain, TRAPS) {
assert(k->java_mirror() == NULL, “should only assign mirror once”);
// …

// Class_klass has to be loaded because it is used to allocate the mirror.

if (SystemDictionary::Class_klass_loaded()) {
// 注意 allocate_instance 内部会根据 k 中的信息，计算需要分配的空间，包含静态变量的大小。然后对 mirror 的空间进行分配。
// Allocate mirror (java.lang.Class instance)
InstanceMirrorKlass* imk = InstanceMirrorKlass::cast(SystemDictionary::Class_klass());
Handle mirror = imk->allocate_instance(k, CHECK_0); // 返回的是instanceOop对象

// mirror是instanceOop对象，而mirror->klass()就是InstanceMirrorKlass*类型
InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(mirror->klass()); // mk代表的是java.lang.Class类
oop                  moop = mirror(); // moop代表的是java.lang.Class对象
int                  sofc = mk->compute_static_oop_field_count(moop);
java_lang_Class::set_static_oop_field_count(moop, sofc);

// It might also have a component mirror.  This mirror must already exist.
if (k->oop_is_array()) {       // 数组
  Handle comp_mirror;
  if (k->oop_is_typeArray()) { // 基本类型数组
    BasicType type = TypeArrayKlass::cast(k())->element_type();
    comp_mirror = Universe::java_mirror(type); // oop转换为Handle类型，会调用转换构造函数
  } else {                     // 对象类型数组
    assert(k->oop_is_objArray(), "Must be");
    Klass* element_klass = ObjArrayKlass::cast(k())->element_klass();
    assert(element_klass != NULL, "Must have an element klass");
    comp_mirror = element_klass->java_mirror(); // oop转换为Handle类型，会调用转换构造函数
  }
  assert(comp_mirror.not_null(), "must have a mirror");

  // Two-way link between the array klass and its component mirror:
  oop tmp = comp_mirror();
  ArrayKlass::cast(k())->set_component_mirror(tmp);
  set_array_klass(tmp, k());
} else {
  assert(k->oop_is_instance(), "Must be");
  // ...
  // do_local_static_fields 会对静态字段进行初始化。 注意此是传入的函数指针表示的 initialize_static_field 函数，
  // do_local_static_fields 会在内部遍历所有静态字段，然后调用这个函数对他们进行初始化。
  // Initialize static fields
  InstanceKlass* ik = InstanceKlass::cast(k());
  ik->do_local_static_fields(&initialize_static_field, CHECK_NULL);
}
return mirror();

}

else {
if (fixup_mirror_list() == NULL) {
GrowableArray<Klass*>* list = new (ResourceObj::C_HEAP, mtClass) GrowableArray<Klass*>(40, true);
set_fixup_mirror_list(list);
}
GrowableArray<Klass*>* list = fixup_mirror_list();
Klass* kls = k();
list->push(kls);
return NULL;
}

}
由于任何一个Java类都有一个Class对象来表示，所以在创建了表示普通Java类的InstanceKlass对象后，还需要创建对应的InstanceOop对象（代表Class对象）。如果java.lang.Class类还没有被解析，则将相关信息暂时存储到数组中，后续在类解析后会做处理，处理逻辑和当前类处理java.lang.Class类被加载时的逻辑基本一致。

调用的InstanceMirrorKlass::allocate_instance()方法创建的表示java中java.lang.Class对象的instanceOop实例。实现如下：

instanceOop InstanceMirrorKlass::allocate_instance(KlassHandle k, TRAPS) {
// Query before forming handle.
int size = instance_size(k);
KlassHandle h_k(THREAD, this);
instanceOop i = (instanceOop) CollectedHeap::Class_obj_allocate(h_k, size, k, CHECK_NULL);
return i;
}

oop CollectedHeap::Class_obj_allocate(KlassHandle klass, int size, KlassHandle real_klass, TRAPS) {

HeapWord* obj;
obj = common_mem_allocate_init(real_klass, size, CHECK_NULL); // 分配内存并初始化为0

assert(Universe::is_bootstrapping() || !((oop)obj)->is_array(), “must not be an array”);
oop mirror = (oop)obj;

java_lang_Class::set_oop_size(mirror, size);

// Setup indirections
if (!real_klass.is_null()) {
java_lang_Class::set_klass(mirror, real_klass());
real_klass->set_java_mirror(mirror);
}

return mirror;
}
创建出表示了java.lang.Class对象的oop实例后，设置到InstanceKlass实例的_java_mirror属性中，同时也设置oop的_klass属性。如果当前类表示数组，那么在java_lang_Class::create_mirror()方法中还会设置表示数组的ArrayKlass对象的_component_mirror属性，同时也会设置表示当前数组的Class对象的_array_klass属性。

如果当前类是普通类，那么调用do_local_static_fields()方法，这个方法的实现如下：

void InstanceKlass::do_local_static_fields(void f(fieldDescriptor*, TRAPS), TRAPS) {
instanceKlassHandle h_this(THREAD, this);
do_local_static_fields_impl(h_this, f, CHECK);
}

void InstanceKlass::do_local_static_fields_impl(instanceKlassHandle this_oop, void f(fieldDescriptor* fd, TRAPS), TRAPS) {
instanceKlassHandle ikh = this_oop();
for (JavaFieldStream fs(ikh); !fs.done(); fs.next()) {
if (fs.access_flags().is_static()) { // 只处理静态字段，因为只有静态字段的值存储到Class对象中
fieldDescriptor& fd = fs.field_descriptor();
f(&fd, CHECK);
}
}
}
调用的initialize_static_field()函数如下：

static void initialize_static_field(fieldDescriptor* fd, TRAPS) {
InstanceKlass* fh = fd->field_holder();
oop tmp = fh->java_mirror();
Handle mirror( THREAD,tmp );
assert(mirror.not_null() && fd->is_static(), “just checking”);
if (fd->has_initial_value()) {
BasicType t = fd->field_type();
switch (t) {
case T_BYTE:
mirror()->byte_field_put(fd->offset(), fd->int_initial_value());
break;
case T_BOOLEAN:
mirror()->bool_field_put(fd->offset(), fd->int_initial_value());
break;
case T_CHAR:
mirror()->char_field_put(fd->offset(), fd->int_initial_value());
break;
case T_SHORT:
mirror()->short_field_put(fd->offset(), fd->int_initial_value());
break;
case T_INT:
mirror()->int_field_put(fd->offset(), fd->int_initial_value());
break;
case T_FLOAT:
mirror()->float_field_put(fd->offset(), fd->float_initial_value());
break;
case T_DOUBLE:
mirror()->double_field_put(fd->offset(), fd->double_initial_value());
break;
case T_LONG:{
jlong offset = fd->offset();
jlong vo = fd->long_initial_value();
oop mr = mirror();
mr->long_field_put(offset,vo);
break;
}
case T_OBJECT:
{
oop string = fd->string_initial_value(CHECK);
mirror()->obj_field_put(fd->offset(), string);
}
break;
default:
THROW_MSG(vmSymbols::java_lang_ClassFormatError(),“Illegal ConstantValue attribute in class file”);
}// end switch
}
}