< prev index next >

src/share/vm/classfile/javaClasses.cpp

Print this page

        

@@ -733,31 +733,31 @@
     }
   }
 }
 
 
-void java_lang_Class::fixup_mirror(KlassHandle k, TRAPS) {
+void java_lang_Class::fixup_mirror(Klass* k, TRAPS) {
   assert(InstanceMirrorKlass::offset_of_static_fields() != 0, "must have been computed already");
 
   // If the offset was read from the shared archive, it was fixed up already
   if (!k->is_shared()) {
     if (k->is_instance_klass()) {
       // During bootstrap, java.lang.Class wasn't loaded so static field
       // offsets were computed without the size added it.  Go back and
       // update all the static field offsets to included the size.
-        for (JavaFieldStream fs(InstanceKlass::cast(k())); !fs.done(); fs.next()) {
+        for (JavaFieldStream fs(InstanceKlass::cast(k)); !fs.done(); fs.next()) {
         if (fs.access_flags().is_static()) {
           int real_offset = fs.offset() + InstanceMirrorKlass::offset_of_static_fields();
           fs.set_offset(real_offset);
         }
       }
     }
   }
   create_mirror(k, Handle(), Handle(), Handle(), CHECK);
 }
 
-void java_lang_Class::initialize_mirror_fields(KlassHandle k,
+void java_lang_Class::initialize_mirror_fields(Klass* k,
                                                Handle mirror,
                                                Handle protection_domain,
                                                TRAPS) {
   // Allocate a simple java object for a lock.
   // This needs to be a java object because during class initialization

@@ -767,15 +767,15 @@
 
   // Set protection domain also
   set_protection_domain(mirror(), protection_domain());
 
   // Initialize static fields
-  InstanceKlass::cast(k())->do_local_static_fields(&initialize_static_field, mirror, CHECK);
+  InstanceKlass::cast(k)->do_local_static_fields(&initialize_static_field, mirror, CHECK);
 }
 
 // Set the java.lang.reflect.Module module field in the java_lang_Class mirror
-void java_lang_Class::set_mirror_module_field(KlassHandle k, Handle mirror, Handle module, TRAPS) {
+void java_lang_Class::set_mirror_module_field(Klass* k, Handle mirror, Handle module, TRAPS) {
   if (module.is_null()) {
     // During startup, the module may be NULL only if java.base has not been defined yet.
     // Put the class on the fixup_module_list to patch later when the java.lang.reflect.Module
     // for java.base is known.
     assert(!Universe::is_module_initialized(), "Incorrect java.lang.reflect.Module pre module system initialization");

@@ -789,11 +789,11 @@
           GrowableArray<Klass*>* list =
             new (ResourceObj::C_HEAP, mtModule) GrowableArray<Klass*>(500, true);
           set_fixup_module_field_list(list);
         }
         k->class_loader_data()->inc_keep_alive();
-        fixup_module_field_list()->push(k());
+        fixup_module_field_list()->push(k);
       } else {
         javabase_was_defined = true;
       }
     }
 

@@ -812,11 +812,11 @@
            "Incorrect java.lang.reflect.Module specification while creating mirror");
     set_module(mirror(), module());
   }
 }
 
-void java_lang_Class::create_mirror(KlassHandle k, Handle class_loader,
+void java_lang_Class::create_mirror(Klass* k, Handle class_loader,
                                     Handle module, Handle protection_domain, TRAPS) {
   assert(k->java_mirror() == NULL, "should only assign mirror once");
   // Use this moment of initialization to cache modifier_flags also,
   // to support Class.getModifiers().  Instance classes recalculate
   // the cached flags after the class file is parsed, but before the

@@ -829,12 +829,12 @@
     // Allocate mirror (java.lang.Class instance)
     oop mirror_oop = InstanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(k, CHECK);
     Handle mirror(THREAD, mirror_oop);
 
     // Setup indirection from mirror->klass
-    if (!k.is_null()) {
-      java_lang_Class::set_klass(mirror(), k());
+    if (k != NULL) {
+      java_lang_Class::set_klass(mirror(), k);
     }
 
     InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(mirror->klass());
     assert(oop_size(mirror()) == mk->instance_size(k), "should have been set");
 

@@ -842,24 +842,24 @@
 
     // It might also have a component mirror.  This mirror must already exist.
     if (k->is_array_klass()) {
       oop comp_mirror;
       if (k->is_typeArray_klass()) {
-        BasicType type = TypeArrayKlass::cast(k())->element_type();
+        BasicType type = TypeArrayKlass::cast(k)->element_type();
         comp_mirror = Universe::java_mirror(type);
       } else {
         assert(k->is_objArray_klass(), "Must be");
-        Klass* element_klass = ObjArrayKlass::cast(k())->element_klass();
+        Klass* element_klass = ObjArrayKlass::cast(k)->element_klass();
         assert(element_klass != NULL, "Must have an element klass");
         comp_mirror = element_klass->java_mirror();
       }
       assert(comp_mirror != NULL, "must have a mirror");
 
       // Two-way link between the array klass and its component mirror:
       // (array_klass) k -> mirror -> component_mirror -> array_klass -> k
       set_component_mirror(mirror(), comp_mirror);
-      set_array_klass(comp_mirror, k());
+      set_array_klass(comp_mirror, k);
     } else {
       assert(k->is_instance_klass(), "Must be");
 
       initialize_mirror_fields(k, mirror, protection_domain, THREAD);
       if (HAS_PENDING_EXCEPTION) {

@@ -879,24 +879,24 @@
     // set the module field in the java_lang_Class instance
     set_mirror_module_field(k, mirror, module, THREAD);
 
     // Setup indirection from klass->mirror last
     // after any exceptions can happen during allocations.
-    if (!k.is_null()) {
+    if (k != NULL) {
       k->set_java_mirror(mirror());
     }
   } else {
     if (fixup_mirror_list() == NULL) {
       GrowableArray<Klass*>* list =
        new (ResourceObj::C_HEAP, mtClass) GrowableArray<Klass*>(40, true);
       set_fixup_mirror_list(list);
     }
-    fixup_mirror_list()->push(k());
+    fixup_mirror_list()->push(k);
   }
 }
 
-void java_lang_Class::fixup_module_field(KlassHandle k, Handle module) {
+void java_lang_Class::fixup_module_field(Klass* k, Handle module) {
   assert(_module_offset != 0, "must have been computed already");
   java_lang_Class::set_module(k->java_mirror(), module());
 }
 
 int  java_lang_Class::oop_size(oop java_class) {

@@ -1874,11 +1874,11 @@
       // Call getCause() which doesn't necessarily return the _cause field.
       EXCEPTION_MARK;
       JavaValue cause(T_OBJECT);
       JavaCalls::call_virtual(&cause,
                               throwable,
-                              KlassHandle(THREAD, throwable->klass()),
+                              throwable->klass(),
                               vmSymbols::getCause_name(),
                               vmSymbols::void_throwable_signature(),
                               THREAD);
       // Ignore any exceptions. we are in the middle of exception handling. Same as classic VM.
       if (HAS_PENDING_EXCEPTION) {

@@ -1902,11 +1902,11 @@
 void java_lang_Throwable::java_printStackTrace(Handle throwable, TRAPS) {
   assert(throwable->is_a(SystemDictionary::Throwable_klass()), "Throwable instance expected");
   JavaValue result(T_VOID);
   JavaCalls::call_virtual(&result,
                           throwable,
-                          KlassHandle(THREAD, SystemDictionary::Throwable_klass()),
+                          SystemDictionary::Throwable_klass(),
                           vmSymbols::printStackTrace_name(),
                           vmSymbols::void_method_signature(),
                           THREAD);
 }
 

@@ -2151,18 +2151,17 @@
   }
 }
 
 oop java_lang_StackTraceElement::create(const methodHandle& method, int bci, TRAPS) {
   // Allocate java.lang.StackTraceElement instance
-  Klass* k = SystemDictionary::StackTraceElement_klass();
+  InstanceKlass* k = SystemDictionary::StackTraceElement_klass();
   assert(k != NULL, "must be loaded in 1.4+");
-  instanceKlassHandle ik (THREAD, k);
-  if (ik->should_be_initialized()) {
-    ik->initialize(CHECK_0);
+  if (k->should_be_initialized()) {
+    k->initialize(CHECK_0);
   }
 
-  Handle element = ik->allocate_instance_handle(CHECK_0);
+  Handle element = k->allocate_instance_handle(CHECK_0);
 
   int version = method->constants()->version();
   fill_in(element, method->method_holder(), method, version, bci, method->name(), CHECK_0);
   return element();
 }

@@ -2487,14 +2486,14 @@
 
 Handle java_lang_reflect_Constructor::create(TRAPS) {
   assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
   Symbol* name = vmSymbols::java_lang_reflect_Constructor();
   Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
-  instanceKlassHandle klass (THREAD, k);
+  InstanceKlass* ik = InstanceKlass::cast(k);
   // Ensure it is initialized
-  klass->initialize(CHECK_NH);
-  return klass->allocate_instance_handle(THREAD);
+  ik->initialize(CHECK_NH);
+  return ik->allocate_instance_handle(THREAD);
 }
 
 oop java_lang_reflect_Constructor::clazz(oop reflect) {
   assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
   return reflect->obj_field(clazz_offset);

@@ -2627,14 +2626,14 @@
 
 Handle java_lang_reflect_Field::create(TRAPS) {
   assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
   Symbol* name = vmSymbols::java_lang_reflect_Field();
   Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
-  instanceKlassHandle klass (THREAD, k);
+  InstanceKlass* ik = InstanceKlass::cast(k);
   // Ensure it is initialized
-  klass->initialize(CHECK_NH);
-  return klass->allocate_instance_handle(THREAD);
+  ik->initialize(CHECK_NH);
+  return ik->allocate_instance_handle(THREAD);
 }
 
 oop java_lang_reflect_Field::clazz(oop reflect) {
   assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
   return reflect->obj_field(clazz_offset);

@@ -2754,14 +2753,14 @@
 
 Handle java_lang_reflect_Parameter::create(TRAPS) {
   assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
   Symbol* name = vmSymbols::java_lang_reflect_Parameter();
   Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
-  instanceKlassHandle klass (THREAD, k);
+  InstanceKlass* ik = InstanceKlass::cast(k);
   // Ensure it is initialized
-  klass->initialize(CHECK_NH);
-  return klass->allocate_instance_handle(THREAD);
+  ik->initialize(CHECK_NH);
+  return ik->allocate_instance_handle(THREAD);
 }
 
 oop java_lang_reflect_Parameter::name(oop param) {
   assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
   return param->obj_field(name_offset);

@@ -2810,15 +2809,14 @@
 Handle java_lang_reflect_Module::create(Handle loader, Handle module_name, TRAPS) {
   assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
 
   Symbol* name = vmSymbols::java_lang_reflect_Module();
   Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
-  instanceKlassHandle klass (THREAD, k);
-
-  Handle jlrmh = klass->allocate_instance_handle(CHECK_NH);
+  InstanceKlass* ik = InstanceKlass::cast(k);
+  Handle jlrmh = ik->allocate_instance_handle(CHECK_NH);
   JavaValue result(T_VOID);
-  JavaCalls::call_special(&result, jlrmh, KlassHandle(THREAD, klass()),
+  JavaCalls::call_special(&result, jlrmh, ik,
                           vmSymbols::object_initializer_name(),
                           vmSymbols::java_lang_reflect_module_init_signature(),
                           loader, module_name, CHECK_NH);
   return jlrmh;
 }

@@ -2877,15 +2875,14 @@
   module->address_field_put(_module_entry_offset, (address)module_entry);
 }
 
 Handle reflect_ConstantPool::create(TRAPS) {
   assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
-  Klass* k = SystemDictionary::reflect_ConstantPool_klass();
-  instanceKlassHandle klass (THREAD, k);
+  InstanceKlass* k = SystemDictionary::reflect_ConstantPool_klass();
   // Ensure it is initialized
-  klass->initialize(CHECK_NH);
-  return klass->allocate_instance_handle(THREAD);
+  k->initialize(CHECK_NH);
+  return k->allocate_instance_handle(THREAD);
 }
 
 
 void reflect_ConstantPool::set_cp(oop reflect, ConstantPool* value) {
   assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");

@@ -2919,13 +2916,13 @@
 }
 
 oop java_lang_boxing_object::initialize_and_allocate(BasicType type, TRAPS) {
   Klass* k = SystemDictionary::box_klass(type);
   if (k == NULL)  return NULL;
-  instanceKlassHandle h (THREAD, k);
-  if (!h->is_initialized())  h->initialize(CHECK_0);
-  return h->allocate_instance(THREAD);
+  InstanceKlass* ik = InstanceKlass::cast(k);
+  if (!ik->is_initialized())  ik->initialize(CHECK_0);
+  return ik->allocate_instance(THREAD);
 }
 
 
 oop java_lang_boxing_object::create(BasicType type, jvalue* value, TRAPS) {
   oop box = initialize_and_allocate(type, CHECK_0);

@@ -3883,14 +3880,14 @@
 bool JavaClasses::check_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) {
   EXCEPTION_MARK;
   fieldDescriptor fd;
   TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH);
   Klass* k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH);
-  instanceKlassHandle h_klass (THREAD, k);
+  InstanceKlass* ik = InstanceKlass::cast(k);
   TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH);
   TempNewSymbol f_sig  = SymbolTable::new_symbol(field_sig, CATCH);
-  if (!h_klass->find_local_field(f_name, f_sig, &fd)) {
+  if (!ik->find_local_field(f_name, f_sig, &fd)) {
     tty->print_cr("Nonstatic field %s.%s not found", klass_name, field_name);
     return false;
   }
   if (fd.is_static()) {
     tty->print_cr("Nonstatic field %s.%s appears to be static", klass_name, field_name);

@@ -3909,14 +3906,14 @@
 bool JavaClasses::check_static_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) {
   EXCEPTION_MARK;
   fieldDescriptor fd;
   TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH);
   Klass* k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH);
-  instanceKlassHandle h_klass (THREAD, k);
+  InstanceKlass* ik = InstanceKlass::cast(k);
   TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH);
   TempNewSymbol f_sig  = SymbolTable::new_symbol(field_sig, CATCH);
-  if (!h_klass->find_local_field(f_name, f_sig, &fd)) {
+  if (!ik->find_local_field(f_name, f_sig, &fd)) {
     tty->print_cr("Static field %s.%s not found", klass_name, field_name);
     return false;
   }
   if (!fd.is_static()) {
     tty->print_cr("Static field %s.%s appears to be nonstatic", klass_name, field_name);

@@ -3934,14 +3931,14 @@
 bool JavaClasses::check_constant(const char *klass_name, int hardcoded_constant, const char *field_name, const char* field_sig) {
   EXCEPTION_MARK;
   fieldDescriptor fd;
   TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH);
   Klass* k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH);
-  instanceKlassHandle h_klass (THREAD, k);
+  InstanceKlass* ik = InstanceKlass::cast(k);
   TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH);
   TempNewSymbol f_sig  = SymbolTable::new_symbol(field_sig, CATCH);
-  if (!h_klass->find_local_field(f_name, f_sig, &fd)) {
+  if (!ik->find_local_field(f_name, f_sig, &fd)) {
     tty->print_cr("Static field %s.%s not found", klass_name, field_name);
     return false;
   }
   if (!fd.is_static() || !fd.has_initial_value()) {
     tty->print_cr("Static field %s.%s appears to be non-constant", klass_name, field_name);
< prev index next >