< prev index next >
src/share/vm/ci/ciEnv.cpp
Print this page
@@ -424,11 +424,11 @@
if (sym->byte_at(0) == '[') {
fail_type = _unloaded_ciobjarrayklass;
} else {
fail_type = _unloaded_ciinstance_klass;
}
- KlassHandle found_klass;
+ Klass* found_klass;
{
ttyUnlocker ttyul; // release tty lock to avoid ordering problems
MutexLocker ml(Compile_lock);
Klass* kls;
if (!require_local) {
@@ -436,11 +436,11 @@
KILL_COMPILE_ON_FATAL_(fail_type));
} else {
kls = SystemDictionary::find_instance_or_array_klass(sym, loader, domain,
KILL_COMPILE_ON_FATAL_(fail_type));
}
- found_klass = KlassHandle(THREAD, kls);
+ found_klass = kls;
}
// If we fail to find an array klass, look again for its element type.
// The element type may be available either locally or via constraints.
// In either case, if we can find the element type in the system dictionary,
@@ -465,26 +465,26 @@
// Now make an array for it
return ciObjArrayKlass::make_impl(elem_klass);
}
}
- if (found_klass() == NULL && !cpool.is_null() && cpool->has_preresolution()) {
+ if (found_klass == NULL && !cpool.is_null() && cpool->has_preresolution()) {
// Look inside the constant pool for pre-resolved class entries.
for (int i = cpool->length() - 1; i >= 1; i--) {
if (cpool->tag_at(i).is_klass()) {
Klass* kls = cpool->resolved_klass_at(i);
if (kls->name() == sym) {
- found_klass = KlassHandle(THREAD, kls);
+ found_klass = kls;
break;
}
}
}
}
- if (found_klass() != NULL) {
+ if (found_klass != NULL) {
// Found it. Build a CI handle.
- return get_klass(found_klass());
+ return get_klass(found_klass);
}
if (require_local) return NULL;
// Not yet loaded into the VM, or not governed by loader constraints.
@@ -510,25 +510,25 @@
ciKlass* ciEnv::get_klass_by_index_impl(const constantPoolHandle& cpool,
int index,
bool& is_accessible,
ciInstanceKlass* accessor) {
EXCEPTION_CONTEXT;
- KlassHandle klass; // = NULL;
+ Klass* klass = NULL;
Symbol* klass_name = NULL;
if (cpool->tag_at(index).is_symbol()) {
klass_name = cpool->symbol_at(index);
} else {
// Check if it's resolved if it's not a symbol constant pool entry.
- klass = KlassHandle(THREAD, ConstantPool::klass_at_if_loaded(cpool, index));
+ klass = ConstantPool::klass_at_if_loaded(cpool, index);
// Try to look it up by name.
- if (klass.is_null()) {
+ if (klass == NULL) {
klass_name = cpool->klass_name_at(index);
}
}
- if (klass.is_null()) {
+ if (klass == NULL) {
// Not found in constant pool. Use the name to do the lookup.
ciKlass* k = get_klass_by_name_impl(accessor,
cpool,
get_symbol(klass_name),
false);
@@ -546,20 +546,20 @@
return k;
}
// Check for prior unloaded klass. The SystemDictionary's answers
// can vary over time but the compiler needs consistency.
- ciSymbol* name = get_symbol(klass()->name());
+ ciSymbol* name = get_symbol(klass->name());
ciKlass* unloaded_klass = check_get_unloaded_klass(accessor, name);
if (unloaded_klass != NULL) {
is_accessible = false;
return unloaded_klass;
}
// It is known to be accessible, since it was found in the constant pool.
is_accessible = true;
- return get_klass(klass());
+ return get_klass(klass);
}
// ------------------------------------------------------------------
// ciEnv::get_klass_by_index
//
@@ -709,15 +709,13 @@
Symbol* name,
Symbol* sig,
Bytecodes::Code bc,
constantTag tag) {
EXCEPTION_CONTEXT;
- KlassHandle h_accessor(THREAD, accessor);
- KlassHandle h_holder(THREAD, holder);
- LinkResolver::check_klass_accessability(h_accessor, h_holder, KILL_COMPILE_ON_FATAL_(NULL));
+ LinkResolver::check_klass_accessability(accessor, holder, KILL_COMPILE_ON_FATAL_(NULL));
methodHandle dest_method;
- LinkInfo link_info(h_holder, name, sig, h_accessor, LinkInfo::needs_access_check, tag);
+ LinkInfo link_info(holder, name, sig, accessor, LinkInfo::needs_access_check, tag);
switch (bc) {
case Bytecodes::_invokestatic:
dest_method =
LinkResolver::resolve_static_call_or_null(link_info);
break;
< prev index next >