< 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 >