truffle: src/share/vm/ci/ciEnv.cpp comparison

comparison src/share/vm/ci/ciEnv.cpp @ 3464:be4ca325525a

Merge.

author	Thomas Wuerthinger <thomas@wuerthinger.net>
date	Wed, 27 Jul 2011 17:32:44 -0700
parents	0654ee04b214 81d815b05abb
children	22d11b3bc561

comparison

equal deleted inserted replaced

-:7c4b4daac19b
+:be4ca325525a
 #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();
 }
 }
 int index, Bytecodes::Code bc) {
 // Compare the following logic with InterpreterRuntime::resolve_invokedynamic.
 assert(bc == Bytecodes::_invokedynamic, "must be invokedynamic");
 bool is_resolved = cpool->cache()->main_entry_at(index)->is_resolved(bc);
-if (is_resolved && (oop) cpool->cache()->secondary_entry_at(index)->f1() == NULL)
+if (is_resolved && cpool->cache()->secondary_entry_at(index)->is_f1_null())
 // FIXME: code generation could allow for null (unlinked) call site
 is_resolved = false;
 // Call site might not be resolved yet.  We could create a real invoker method from the
 // compiler, but it is simpler to stop the code path here with an unlinked method.
 return get_unloaded_method(mh_klass, ciSymbol::invokeExact_name(), sig_sym);
 }
 // Get the invoker methodOop from the constant pool.
 oop f1_value = cpool->cache()->main_entry_at(index)->f1();
-methodOop signature_invoker = methodOop(f1_value);
+methodOop signature_invoker = (methodOop) f1_value;
 assert(signature_invoker != NULL && signature_invoker->is_method() && signature_invoker->is_method_handle_invoke(),
 "correct result from LinkResolver::resolve_invokedynamic");
 return get_object(signature_invoker)->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() {

Mercurial > hg > truffle

comparison src/share/vm/ci/ciEnv.cpp @ 3464:be4ca325525a