graal-jvmci-8: src/share/vm/ci/ciEnv.cpp comparison

comparison src/share/vm/ci/ciEnv.cpp @ 1930:2d26b0046e0d

Merge.

author	Thomas Wuerthinger <wuerthinger@ssw.jku.at>
date	Tue, 30 Nov 2010 14:53:30 +0100
parents	5571b97fc1ec d5d065957597
children	06f017f7daa7

comparison

equal deleted inserted replaced

-:6b7001391c97
+:2d26b0046e0d
 /*
-* Copyright 1999-2010 Sun Microsystems, Inc.  All Rights Reserved.
+* Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
-* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
-* CA 95054 USA or visit www.sun.com if you need additional information or
+* or visit www.oracle.com if you need additional information or have any
-* have any questions.
+* questions.
 *
 */
 #include "incls/_precompiled.incl"
 #include "incls/_ciEnv.cpp.incl"
 // ------------------------------------------------------------------
 // ciEnv::get_constant_by_index_impl
 //
 // Implementation of get_constant_by_index().
 ciConstant ciEnv::get_constant_by_index_impl(constantPoolHandle cpool,
-int index,
+int pool_index, int cache_index,
 ciInstanceKlass* accessor) {
+bool ignore_will_link;
 EXCEPTION_CONTEXT;
+int index = pool_index;
+if (cache_index >= 0) {
+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");
+ciObject* ciobj = get_object(obj);
+return ciConstant(T_OBJECT, ciobj);
+}
+}
 constantTag tag = cpool->tag_at(index);
 if (tag.is_int()) {
 return ciConstant(T_INT, (jint)cpool->int_at(index));
 } else if (tag.is_long()) {
 return ciConstant((jlong)cpool->long_at(index));
 ciObject* constant = get_object(string);
 assert (constant->is_instance(), "must be an instance, or not? ");
 return ciConstant(T_OBJECT, constant);
 } else if (tag.is_klass() || tag.is_unresolved_klass()) {
 // 4881222: allow ldc to take a class type
-bool ignore;
+ciKlass* klass = get_klass_by_index_impl(cpool, index, ignore_will_link, accessor);
-ciKlass* klass = get_klass_by_index_impl(cpool, index, ignore, accessor);
 if (HAS_PENDING_EXCEPTION) {
 CLEAR_PENDING_EXCEPTION;
 record_out_of_memory_failure();
 return ciConstant();
 }
 assert (klass->is_instance_klass() || klass->is_array_klass(),
 "must be an instance or array klass ");
-return ciConstant(T_OBJECT, 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");
 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_object(cpool->method_type_signature_at(index))->as_symbol();
+ciObject* ciobj = get_unloaded_method_type_constant(signature);
+return ciConstant(T_OBJECT, ciobj);
+} else if (tag.is_method_handle()) {
+// must execute Java code to link this CP entry into cache[i].f1
+int ref_kind        = cpool->method_handle_ref_kind_at(index);
+int callee_index    = cpool->method_handle_klass_index_at(index);
+ciKlass* callee     = get_klass_by_index_impl(cpool, callee_index, ignore_will_link, accessor);
+ciSymbol* name      = get_object(cpool->method_handle_name_ref_at(index))->as_symbol();
+ciSymbol* signature = get_object(cpool->method_handle_signature_ref_at(index))->as_symbol();
+ciObject* ciobj     = get_unloaded_method_handle_constant(callee, name, signature, ref_kind);
+return ciConstant(T_OBJECT, ciobj);
 } else {
 ShouldNotReachHere();
 return ciConstant();
 }
-}
-// ------------------------------------------------------------------
-// ciEnv::is_unresolved_string_impl
-//
-// Implementation of is_unresolved_string().
-bool ciEnv::is_unresolved_string_impl(instanceKlass* accessor, int index) const {
-EXCEPTION_CONTEXT;
-assert(accessor->is_linked(), "must be linked before accessing constant pool");
-constantPoolOop cpool = accessor->constants();
-constantTag tag = cpool->tag_at(index);
-return tag.is_unresolved_string();
-}
-// ------------------------------------------------------------------
-// ciEnv::is_unresolved_klass_impl
-//
-// Implementation of is_unresolved_klass().
-bool ciEnv::is_unresolved_klass_impl(instanceKlass* accessor, int index) const {
-EXCEPTION_CONTEXT;
-assert(accessor->is_linked(), "must be linked before accessing constant pool");
-constantPoolOop cpool = accessor->constants();
-constantTag tag = cpool->tag_at(index);
-return tag.is_unresolved_klass();
 }
 // ------------------------------------------------------------------
 // ciEnv::get_constant_by_index
 //
 // Pull a constant out of the constant pool.  How appropriate.
 //
 // Implementation note: this query is currently in no way cached.
 ciConstant ciEnv::get_constant_by_index(constantPoolHandle cpool,
-int index,
+int pool_index, int cache_index,
 ciInstanceKlass* accessor) {
-GUARDED_VM_ENTRY(return get_constant_by_index_impl(cpool, index, accessor);)
+GUARDED_VM_ENTRY(return get_constant_by_index_impl(cpool, pool_index, cache_index, accessor);)
-}
-// ------------------------------------------------------------------
-// ciEnv::is_unresolved_string
-//
-// Check constant pool
-//
-// Implementation note: this query is currently in no way cached.
-bool ciEnv::is_unresolved_string(ciInstanceKlass* accessor,
-int index) const {
-GUARDED_VM_ENTRY(return is_unresolved_string_impl(accessor->get_instanceKlass(), index); )
-}
-// ------------------------------------------------------------------
-// ciEnv::is_unresolved_klass
-//
-// Check constant pool
-//
-// Implementation note: this query is currently in no way cached.
-bool ciEnv::is_unresolved_klass(ciInstanceKlass* accessor,
-int index) const {
-GUARDED_VM_ENTRY(return is_unresolved_klass_impl(accessor->get_instanceKlass(), index); )
 }
 // ------------------------------------------------------------------
 // ciEnv::get_field_by_index_impl
 //
 // ------------------------------------------------------------------
 // ciEnv::get_fake_invokedynamic_method_impl
 ciMethod* ciEnv::get_fake_invokedynamic_method_impl(constantPoolHandle cpool,
 int index, Bytecodes::Code bc) {
+// Compare the following logic with InterpreterRuntime::resolve_invokedynamic.
 assert(bc == Bytecodes::_invokedynamic, "must be invokedynamic");
-// Get the CallSite from the constant pool cache.
+bool is_resolved = cpool->cache()->main_entry_at(index)->is_resolved(bc);
-ConstantPoolCacheEntry* cpc_entry = cpool->cache()->secondary_entry_at(index);
+if (is_resolved && (oop) cpool->cache()->secondary_entry_at(index)->f1() == NULL)
-assert(cpc_entry != NULL && cpc_entry->is_secondary_entry(), "sanity");
+// FIXME: code generation could allow for null (unlinked) call site
-Handle call_site = cpc_entry->f1();
+is_resolved = false;
-// Call site might not be linked yet.
+// Call site might not be resolved yet.  We could create a real invoker method from the
-if (call_site.is_null()) {
+// compiler, but it is simpler to stop the code path here with an unlinked method.
+if (!is_resolved) {
 ciInstanceKlass* mh_klass = get_object(SystemDictionary::MethodHandle_klass())->as_instance_klass();
-ciSymbol*       sig_sym   = get_object(cpool->signature_ref_at(index))->as_symbol();
+ciSymbol*        sig_sym  = get_object(cpool->signature_ref_at(index))->as_symbol();
-return get_unloaded_method(mh_klass, ciSymbol::invoke_name(), sig_sym);
+return get_unloaded_method(mh_klass, ciSymbol::invokeExact_name(), sig_sym);
 }
-// Get the methodOop from the CallSite.
+// Get the invoker methodOop from the constant pool.
-methodOop method_oop = (methodOop) java_dyn_CallSite::vmmethod(call_site());
+oop f1_value = cpool->cache()->main_entry_at(index)->f1();
-assert(method_oop != NULL, "sanity");
+methodOop signature_invoker = methodOop(f1_value);
-assert(method_oop->is_method_handle_invoke(), "consistent");
+assert(signature_invoker != NULL && signature_invoker->is_method() && signature_invoker->is_method_handle_invoke(),
+"correct result from LinkResolver::resolve_invokedynamic");
-return get_object(method_oop)->as_method();
+return get_object(signature_invoker)->as_method();
 }
 // ------------------------------------------------------------------
 // ciEnv::get_instance_klass_for_declared_method_holder
 // Record successful registration.
 // (Put nm into the task handle *before* publishing to the Java heap.)
 if (task() != NULL)  task()->set_code(nm);
 if (entry_bci == InvocationEntryBci) {
-#ifdef TIERED
+if (TieredCompilation) {
 // If there is an old version we're done with it
 nmethod* old = method->code();
 if (TraceMethodReplacement && old != NULL) {
 ResourceMark rm;
 char *method_name = method->name_and_sig_as_C_string();
 tty->print_cr("Replacing method %s", method_name);
+}
+if (old != NULL ) {
+old->make_not_entrant();
+}
 }
-if (old != NULL ) {
-old->make_not_entrant();
-}
-#endif // TIERED
 if (TraceNMethodInstalls ) {
 ResourceMark rm;
 char *method_name = method->name_and_sig_as_C_string();
 ttyLocker ttyl;
 tty->print_cr("Installing method (%d) %s ",
 }
 // ------------------------------------------------------------------
 // ciEnv::comp_level
 int ciEnv::comp_level() {
-if (task() == NULL)  return CompLevel_full_optimization;
+if (task() == NULL)  return CompLevel_highest_tier;
 return task()->comp_level();
 }
 // ------------------------------------------------------------------
 // ciEnv::compile_id

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/ci/ciEnv.cpp @ 1930:2d26b0046e0d