jdk-sandbox: comparison hotspot/src/share/vm/ci/ciEnv.cpp

equal deleted inserted replaced

-:43d4a6542551
+:d84de97ad847
 #include "oops/methodDataOop.hpp"
 #include "oops/objArrayKlass.hpp"
 #include "oops/oop.inline.hpp"
 #include "oops/oop.inline2.hpp"
 #include "prims/jvmtiExport.hpp"
+#include "prims/methodHandleWalk.hpp"
 #include "runtime/init.hpp"
 #include "runtime/reflection.hpp"
 #include "runtime/sharedRuntime.hpp"
 #include "utilities/dtrace.hpp"
 #ifdef COMPILER1
 }
 // ------------------------------------------------------------------
 // ciEnv::get_klass_by_name_impl
 ciKlass* ciEnv::get_klass_by_name_impl(ciKlass* accessing_klass,
+constantPoolHandle cpool,
 ciSymbol* name,
 bool require_local) {
 ASSERT_IN_VM;
 EXCEPTION_CONTEXT;
 // Call recursive to keep scope of strippedsym.
 TempNewSymbol strippedsym = SymbolTable::new_symbol(sym->as_utf8()+1,
 sym->utf8_length()-2,
 KILL_COMPILE_ON_FATAL_(_unloaded_ciinstance_klass));
 ciSymbol* strippedname = get_symbol(strippedsym);
-return get_klass_by_name_impl(accessing_klass, strippedname, require_local);
+return get_klass_by_name_impl(accessing_klass, cpool, strippedname, require_local);
 }
 // Check for prior unloaded klass.  The SystemDictionary's answers
 // can vary over time but the compiler needs consistency.
 ciKlass* unloaded_klass = check_get_unloaded_klass(accessing_klass, name);
 KILL_COMPILE_ON_FATAL_(fail_type));
 // Get element ciKlass recursively.
 ciKlass* elem_klass =
 get_klass_by_name_impl(accessing_klass,
+cpool,
 get_symbol(elem_sym),
 require_local);
 if (elem_klass != NULL && elem_klass->is_loaded()) {
 // Now make an array for it
 return ciObjArrayKlass::make_impl(elem_klass);
 }
 }
+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()) {
+klassOop kls = cpool->resolved_klass_at(i);
+if (Klass::cast(kls)->name() == sym) {
+found_klass = KlassHandle(THREAD, kls);
+break;
+}
+}
+}
+}
 if (found_klass() != NULL) {
 // Found it.  Build a CI handle.
 return get_object(found_klass())->as_klass();
 }
 // ciEnv::get_klass_by_name
 ciKlass* ciEnv::get_klass_by_name(ciKlass* accessing_klass,
 ciSymbol* klass_name,
 bool require_local) {
 GUARDED_VM_ENTRY(return get_klass_by_name_impl(accessing_klass,
+constantPoolHandle(),
 klass_name,
 require_local);)
 }
 // ------------------------------------------------------------------
 }
 if (klass.is_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);
 // Calculate accessibility the hard way.
 if (!k->is_loaded()) {
 is_accessible = false;
 } else if (k->loader() != accessor->loader() &&
-get_klass_by_name_impl(accessor, k->name(), true) == NULL) {
+get_klass_by_name_impl(accessor, cpool, k->name(), true) == NULL) {
 // Loaded only remotely.  Not linked yet.
 is_accessible = false;
 } else {
 // Linked locally, and we must also check public/private, etc.
 is_accessible = check_klass_accessibility(accessor, k->get_klassOop());
 assert(index < 0, "only one kind of index at a time");
 ConstantPoolCacheEntry* cpc_entry = cpool->cache()->entry_at(cache_index);
 index = cpc_entry->constant_pool_index();
 oop obj = cpc_entry->f1();
 if (obj != NULL) {
-assert(obj->is_instance(), "must be an instance");
+assert(obj->is_instance() || obj->is_array(), "must be a Java reference");
 ciObject* ciobj = get_object(obj);
 return ciConstant(T_OBJECT, ciobj);
 }
 }
 constantTag tag = cpool->tag_at(index);
 assert (klass->is_instance_klass() || klass->is_array_klass(),
 "must be an instance or array klass ");
 return ciConstant(T_OBJECT, klass->java_mirror());
 } else if (tag.is_object()) {
 oop obj = cpool->object_at(index);
-assert(obj->is_instance(), "must be an instance");
+assert(obj->is_instance() || obj->is_array(), "must be a Java reference");
 ciObject* ciobj = get_object(obj);
 return ciConstant(T_OBJECT, ciobj);
 } else if (tag.is_method_type()) {
 // must execute Java code to link this CP entry into cache[i].f1
 ciSymbol* signature = get_symbol(cpool->method_type_signature_at(index));
 // Get the method's name and signature.
 Symbol* name_sym = cpool->name_ref_at(index);
 Symbol* sig_sym  = cpool->signature_ref_at(index);
+if (cpool->has_preresolution()
+|| (holder == ciEnv::MethodHandle_klass() &&
+methodOopDesc::is_method_handle_invoke_name(name_sym))) {
+// Short-circuit lookups for JSR 292-related call sites.
+// That is, do not rely only on name-based lookups, because they may fail
+// if the names are not resolvable in the boot class loader (7056328).
+switch (bc) {
+case Bytecodes::_invokevirtual:
+case Bytecodes::_invokeinterface:
+case Bytecodes::_invokespecial:
+case Bytecodes::_invokestatic:
+{
+methodOop m = constantPoolOopDesc::method_at_if_loaded(cpool, index, bc);
+if (m != NULL) {
+return get_object(m)->as_method();
+}
+}
+}
+}
 if (holder_is_accessible) { // Our declared holder is loaded.
 instanceKlass* lookup = declared_holder->get_instanceKlass();
 methodOop m = lookup_method(accessor->get_instanceKlass(), lookup, name_sym, sig_sym, bc);
+if (m != NULL &&
+(bc == Bytecodes::_invokestatic
+?  instanceKlass::cast(m->method_holder())->is_not_initialized()
+: !instanceKlass::cast(m->method_holder())->is_loaded())) {
+m = NULL;
+}
 if (m != NULL) {
 // We found the method.
 return get_object(m)->as_method();
 }
 }
 // ------------------------------------------------------------------
 // ciEnv::find_system_klass
 ciKlass* ciEnv::find_system_klass(ciSymbol* klass_name) {
 VM_ENTRY_MARK;
-return get_klass_by_name_impl(NULL, klass_name, false);
+return get_klass_by_name_impl(NULL, constantPoolHandle(), klass_name, false);
 }
 // ------------------------------------------------------------------
 // ciEnv::comp_level
 int ciEnv::comp_level() {

changeset 10008	d84de97ad847
parent 9328	144894b3384b
child 10503	04b74421bdea