graal-compiler: src/share/vm/oops/methodOop.cpp comparison

comparison src/share/vm/oops/methodOop.cpp @ 6275:957c266d8bc5

Merge with http://hg.openjdk.java.net/hsx/hsx24/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Tue, 21 Aug 2012 10:39:19 +0200
parents	70f715dfbb41 977007096840
children

comparison

equal deleted inserted replaced

-:fd8832ae511d
+:957c266d8bc5
 #include "oops/methodDataOop.hpp"
 #include "oops/methodOop.hpp"
 #include "oops/oop.inline.hpp"
 #include "oops/symbol.hpp"
 #include "prims/jvmtiExport.hpp"
-#include "prims/methodHandleWalk.hpp"
+#include "prims/methodHandles.hpp"
 #include "prims/nativeLookup.hpp"
 #include "runtime/arguments.hpp"
 #include "runtime/compilationPolicy.hpp"
 #include "runtime/frame.inline.hpp"
 #include "runtime/handles.inline.hpp"
 address methodOopDesc::get_c2i_unverified_entry() {
 assert(_adapter != NULL, "must have");
 return _adapter->get_c2i_unverified_entry();
 }
-char* methodOopDesc::name_and_sig_as_C_string() {
+char* methodOopDesc::name_and_sig_as_C_string() const {
 return name_and_sig_as_C_string(Klass::cast(constants()->pool_holder()), name(), signature());
 }
-char* methodOopDesc::name_and_sig_as_C_string(char* buf, int size) {
+char* methodOopDesc::name_and_sig_as_C_string(char* buf, int size) const {
 return name_and_sig_as_C_string(Klass::cast(constants()->pool_holder()), name(), signature(), buf, size);
 }
 char* methodOopDesc::name_and_sig_as_C_string(Klass* klass, Symbol* method_name, Symbol* signature) {
 const char* klass_name = klass->external_name();
 return buf;
 }
 int  methodOopDesc::fast_exception_handler_bci_for(KlassHandle ex_klass, int throw_bci, TRAPS) {
 // exception table holds quadruple entries of the form (beg_bci, end_bci, handler_bci, klass_index)
-const int beg_bci_offset     = 0;
-const int end_bci_offset     = 1;
-const int handler_bci_offset = 2;
-const int klass_index_offset = 3;
-const int entry_size         = 4;
 // access exception table
-typeArrayHandle table (THREAD, constMethod()->exception_table());
+ExceptionTable table(this);
-int length = table->length();
+int length = table.length();
-assert(length % entry_size == 0, "exception table format has changed");
 // iterate through all entries sequentially
 constantPoolHandle pool(THREAD, constants());
-for (int i = 0; i < length; i += entry_size) {
+for (int i = 0; i < length; i ++) {
-int beg_bci = table->int_at(i + beg_bci_offset);
+//reacquire the table in case a GC happened
-int end_bci = table->int_at(i + end_bci_offset);
+ExceptionTable table(this);
+int beg_bci = table.start_pc(i);
+int end_bci = table.end_pc(i);
 assert(beg_bci <= end_bci, "inconsistent exception table");
 if (beg_bci <= throw_bci && throw_bci < end_bci) {
 // exception handler bci range covers throw_bci => investigate further
-int handler_bci = table->int_at(i + handler_bci_offset);
+int handler_bci = table.handler_pc(i);
-int klass_index = table->int_at(i + klass_index_offset);
+int klass_index = table.catch_type_index(i);
 if (klass_index == 0) {
 return handler_bci;
 } else if (ex_klass.is_null()) {
 return handler_bci;
 } else {
 return;
 }
 int methodOopDesc::bci_from(address bcp) const {
-assert(is_native() && bcp == code_base() || contains(bcp) || is_error_reported(), "bcp doesn't belong to this method");
+assert(is_native() && bcp == code_base() || contains(bcp) || is_error_reported(),
+err_msg("bcp doesn't belong to this method: bcp: " INTPTR_FORMAT ", method: %s", bcp, name_and_sig_as_C_string()));
 return bcp - code_base();
 }
 // Return (int)bcx if it appears to be a valid BCI.
 return best_line;
 }
 bool methodOopDesc::is_klass_loaded_by_klass_index(int klass_index) const {
-if( _constants->tag_at(klass_index).is_unresolved_klass() ) {
+if( constants()->tag_at(klass_index).is_unresolved_klass() ) {
 Thread *thread = Thread::current();
-Symbol* klass_name = _constants->klass_name_at(klass_index);
+Symbol* klass_name = constants()->klass_name_at(klass_index);
 Handle loader(thread, instanceKlass::cast(method_holder())->class_loader());
 Handle prot  (thread, Klass::cast(method_holder())->protection_domain());
 return SystemDictionary::find(klass_name, loader, prot, thread) != NULL;
 } else {
 return true;
 }
 }
 bool methodOopDesc::is_klass_loaded(int refinfo_index, bool must_be_resolved) const {
-int klass_index = _constants->klass_ref_index_at(refinfo_index);
+int klass_index = constants()->klass_ref_index_at(refinfo_index);
 if (must_be_resolved) {
 // Make sure klass is resolved in constantpool.
 if (constants()->tag_at(klass_index).is_unresolved_klass()) return false;
 }
 return is_klass_loaded_by_klass_index(klass_index);
 }
 void methodOopDesc::set_native_function(address function, bool post_event_flag) {
 assert(function != NULL, "use clear_native_function to unregister natives");
+assert(!is_method_handle_intrinsic() || function == SharedRuntime::native_method_throw_unsatisfied_link_error_entry(), "");
 address* native_function = native_function_addr();
 // We can see racers trying to place the same native function into place. Once
 // is plenty.
 address current = *native_function;
 }
 }
 bool methodOopDesc::has_native_function() const {
+if (is_method_handle_intrinsic())
+return false;  // special-cased in SharedRuntime::generate_native_wrapper
 address func = native_function();
 return (func != NULL && func != SharedRuntime::native_method_throw_unsatisfied_link_error_entry());
 }
 void methodOopDesc::clear_native_function() {
+// Note: is_method_handle_intrinsic() is allowed here.
 set_native_function(
 SharedRuntime::native_method_throw_unsatisfied_link_error_entry(),
 !native_bind_event_is_interesting);
 clear_code();
 }
 *signature_handler = handler;
 }
 bool methodOopDesc::is_not_compilable(int comp_level) const {
-if (is_method_handle_invoke()) {
-// compilers must recognize this method specially, or not at all
-return true;
-}
 if (number_of_breakpoints() > 0) {
 return true;
+}
+if (is_method_handle_intrinsic()) {
+return !is_synthetic();  // the generated adapters must be compiled
 }
 if (comp_level == CompLevel_any) {
 return is_not_c1_compilable() || is_not_c2_compilable();
 }
 if (is_c1_compile(comp_level)) {
 assert(this == h_method(), "wrong h_method()" );
 address entry = Interpreter::entry_for_method(h_method);
 assert(entry != NULL, "interpreter entry must be non-null");
 // Sets both _i2i_entry and _from_interpreted_entry
 set_interpreter_entry(entry);
-if (is_native() && !is_method_handle_invoke()) {
+if (is_native() && !is_method_handle_intrinsic()) {
 set_native_function(
 SharedRuntime::native_method_throw_unsatisfied_link_error_entry(),
 !native_bind_event_is_interesting);
 }
 }
 OrderAccess::storestore();
 #ifdef SHARK
 mh->_from_interpreted_entry = code->insts_begin();
-#else
+#else //!SHARK
 mh->_from_compiled_entry = code->verified_entry_point();
 OrderAccess::storestore();
 // Instantly compiled code can execute.
-mh->_from_interpreted_entry = mh->get_i2c_entry();
+if (!mh->is_method_handle_intrinsic())
-#endif // SHARK
+mh->_from_interpreted_entry = mh->get_i2c_entry();
+#endif //!SHARK
 }
 bool methodOopDesc::is_overridden_in(klassOop k) const {
 instanceKlass* ik = instanceKlass::cast(k);
 // caching this method should be just fine
 return false;
 }
-bool methodOopDesc::is_method_handle_invoke_name(vmSymbols::SID name_sid) {
-switch (name_sid) {
-case vmSymbols::VM_SYMBOL_ENUM_NAME(invokeExact_name):
-case vmSymbols::VM_SYMBOL_ENUM_NAME(invoke_name):
-return true;
-}
-if (AllowInvokeGeneric
-&& name_sid == vmSymbols::VM_SYMBOL_ENUM_NAME(invokeGeneric_name))
-return true;
-return false;
-}
 // Constant pool structure for invoke methods:
 enum {
-_imcp_invoke_name = 1,        // utf8: 'invokeExact' or 'invokeGeneric'
+_imcp_invoke_name = 1,        // utf8: 'invokeExact', etc.
 _imcp_invoke_signature,       // utf8: (variable Symbol*)
-_imcp_method_type_value,      // string: (variable java/lang/invoke/MethodType, sic)
 _imcp_limit
 };
-oop methodOopDesc::method_handle_type() const {
+// Test if this method is an MH adapter frame generated by Java code.
-if (!is_method_handle_invoke()) { assert(false, "caller resp."); return NULL; }
+// Cf. java/lang/invoke/InvokerBytecodeGenerator
-oop mt = constants()->resolved_string_at(_imcp_method_type_value);
+bool methodOopDesc::is_compiled_lambda_form() const {
-assert(mt->klass() == SystemDictionary::MethodType_klass(), "");
+return intrinsic_id() == vmIntrinsics::_compiledLambdaForm;
-return mt;
+}
-}
+// Test if this method is an internal MH primitive method.
-jint* methodOopDesc::method_type_offsets_chain() {
+bool methodOopDesc::is_method_handle_intrinsic() const {
-static jint pchase[] = { -1, -1, -1 };
+vmIntrinsics::ID iid = intrinsic_id();
-if (pchase[0] == -1) {
+return (MethodHandles::is_signature_polymorphic(iid) &&
-jint step0 = in_bytes(constants_offset());
+MethodHandles::is_signature_polymorphic_intrinsic(iid));
-jint step1 = (constantPoolOopDesc::header_size() + _imcp_method_type_value) * HeapWordSize;
+}
-// do this in reverse to avoid races:
-OrderAccess::release_store(&pchase[1], step1);
+bool methodOopDesc::has_member_arg() const {
-OrderAccess::release_store(&pchase[0], step0);
+vmIntrinsics::ID iid = intrinsic_id();
-}
+return (MethodHandles::is_signature_polymorphic(iid) &&
-return pchase;
+MethodHandles::has_member_arg(iid));
 }
-//------------------------------------------------------------------------------
+// Make an instance of a signature-polymorphic internal MH primitive.
-// methodOopDesc::is_method_handle_adapter
+methodHandle methodOopDesc::make_method_handle_intrinsic(vmIntrinsics::ID iid,
-//
+Symbol* signature,
-// Tests if this method is an internal adapter frame from the
+TRAPS) {
-// MethodHandleCompiler.
-// Must be consistent with MethodHandleCompiler::get_method_oop().
-bool methodOopDesc::is_method_handle_adapter() const {
-if (is_synthetic() &&
-!is_native() &&   // has code from MethodHandleCompiler
-is_method_handle_invoke_name(name()) &&
-MethodHandleCompiler::klass_is_method_handle_adapter_holder(method_holder())) {
-assert(!is_method_handle_invoke(), "disjoint");
-return true;
-} else {
-return false;
-}
-}
-methodHandle methodOopDesc::make_invoke_method(KlassHandle holder,
-Symbol* name,
-Symbol* signature,
-Handle method_type, TRAPS) {
 ResourceMark rm;
 methodHandle empty;
-assert(holder() == SystemDictionary::MethodHandle_klass(),
+KlassHandle holder = SystemDictionary::MethodHandle_klass();
-"must be a JSR 292 magic type");
+Symbol* name = MethodHandles::signature_polymorphic_intrinsic_name(iid);
+assert(iid == MethodHandles::signature_polymorphic_name_id(name), "");
 if (TraceMethodHandles) {
-tty->print("Creating invoke method for ");
+tty->print_cr("make_method_handle_intrinsic MH.%s%s", name->as_C_string(), signature->as_C_string());
-signature->print_value();
-tty->cr();
 }
 // invariant:   cp->symbol_at_put is preceded by a refcount increment (more usually a lookup)
 name->increment_refcount();
 signature->increment_refcount();
-// record non-BCP method types in the constant pool
+int cp_length = _imcp_limit;
-GrowableArray<KlassHandle>* extra_klasses = NULL;
-for (int i = -1, len = java_lang_invoke_MethodType::ptype_count(method_type()); i < len; i++) {
-oop ptype = (i == -1
-? java_lang_invoke_MethodType::rtype(method_type())
-: java_lang_invoke_MethodType::ptype(method_type(), i));
-klassOop klass = check_non_bcp_klass(java_lang_Class::as_klassOop(ptype));
-if (klass != NULL) {
-if (extra_klasses == NULL)
-extra_klasses = new GrowableArray<KlassHandle>(len+1);
-bool dup = false;
-for (int j = 0; j < extra_klasses->length(); j++) {
-if (extra_klasses->at(j) == klass) { dup = true; break; }
-}
-if (!dup)
-extra_klasses->append(KlassHandle(THREAD, klass));
-}
-}
-int extra_klass_count = (extra_klasses == NULL ? 0 : extra_klasses->length());
-int cp_length = _imcp_limit + extra_klass_count;
 constantPoolHandle cp;
 {
 constantPoolOop cp_oop = oopFactory::new_constantPool(cp_length, IsSafeConc, CHECK_(empty));
 cp = constantPoolHandle(THREAD, cp_oop);
 }
 cp->symbol_at_put(_imcp_invoke_name,       name);
 cp->symbol_at_put(_imcp_invoke_signature,  signature);
-cp->string_at_put(_imcp_method_type_value, Universe::the_null_string());
-for (int j = 0; j < extra_klass_count; j++) {
-KlassHandle klass = extra_klasses->at(j);
-cp->klass_at_put(_imcp_limit + j, klass());
-}
 cp->set_preresolution();
 cp->set_pool_holder(holder());
-// set up the fancy stuff:
+// decide on access bits:  public or not?
-cp->pseudo_string_at_put(_imcp_method_type_value, method_type());
+int flags_bits = (JVM_ACC_NATIVE | JVM_ACC_SYNTHETIC | JVM_ACC_FINAL);
+bool must_be_static = MethodHandles::is_signature_polymorphic_static(iid);
+if (must_be_static)  flags_bits |= JVM_ACC_STATIC;
+assert((flags_bits & JVM_ACC_PUBLIC) == 0, "do not expose these methods");
 methodHandle m;
 {
-int flags_bits = (JVM_MH_INVOKE_BITS | JVM_ACC_PUBLIC | JVM_ACC_FINAL);
 methodOop m_oop = oopFactory::new_method(0, accessFlags_from(flags_bits),
-0, 0, 0, IsSafeConc, CHECK_(empty));
+0, 0, 0, 0, IsSafeConc, CHECK_(empty));
 m = methodHandle(THREAD, m_oop);
 }
 m->set_constants(cp());
 m->set_name_index(_imcp_invoke_name);
 m->set_signature_index(_imcp_invoke_signature);
-assert(is_method_handle_invoke_name(m->name()), "");
+assert(MethodHandles::is_signature_polymorphic_name(m->name()), "");
 assert(m->signature() == signature, "");
-assert(m->is_method_handle_invoke(), "");
 #ifdef CC_INTERP
 ResultTypeFinder rtf(signature);
 m->set_result_index(rtf.type());
 #endif
 m->compute_size_of_parameters(THREAD);
-m->set_exception_table(Universe::the_empty_int_array());
 m->init_intrinsic_id();
-assert(m->intrinsic_id() == vmIntrinsics::_invokeExact ||
+assert(m->is_method_handle_intrinsic(), "");
-m->intrinsic_id() == vmIntrinsics::_invokeGeneric, "must be an invoker");
+#ifdef ASSERT
+if (!MethodHandles::is_signature_polymorphic(m->intrinsic_id()))  m->print();
+assert(MethodHandles::is_signature_polymorphic(m->intrinsic_id()), "must be an invoker");
+assert(m->intrinsic_id() == iid, "correctly predicted iid");
+#endif //ASSERT
 // Finally, set up its entry points.
-assert(m->method_handle_type() == method_type(), "");
 assert(m->can_be_statically_bound(), "");
 m->set_vtable_index(methodOopDesc::nonvirtual_vtable_index);
 m->link_method(m, CHECK_(empty));
-#ifdef ASSERT
-// Make sure the pointer chase works.
-address p = (address) m();
-for (jint* pchase = method_type_offsets_chain(); (*pchase) != -1; pchase++) {
-p = *(address*)(p + (*pchase));
-}
-assert((oop)p == method_type(), "pointer chase is correct");
-#endif
 if (TraceMethodHandles && (Verbose || WizardMode))
 m->print_on(tty);
 return m;
 }
 return NULL;
 }
-methodHandle methodOopDesc:: clone_with_new_data(methodHandle m, u_char* new_code, int new_code_length,
+methodHandle methodOopDesc::clone_with_new_data(methodHandle m, u_char* new_code, int new_code_length,
 u_char* new_compressed_linenumber_table, int new_compressed_linenumber_size, TRAPS) {
 // Code below does not work for native methods - they should never get rewritten anyway
 assert(!m->is_native(), "cannot rewrite native methods");
 // Allocate new methodOop
 AccessFlags flags = m->access_flags();
 int checked_exceptions_len = m->checked_exceptions_length();
 int localvariable_len = m->localvariable_table_length();
+int exception_table_len = m->exception_table_length();
 // Allocate newm_oop with the is_conc_safe parameter set
 // to IsUnsafeConc to indicate that newm_oop is not yet
 // safe for concurrent processing by a GC.
 methodOop newm_oop = oopFactory::new_method(new_code_length,
 flags,
 new_compressed_linenumber_size,
 localvariable_len,
+exception_table_len,
 checked_exceptions_len,
 IsUnsafeConc,
 CHECK_(methodHandle()));
 methodHandle newm (THREAD, newm_oop);
 NOT_PRODUCT(int nmsz = newm->is_parsable() ? newm->size() : -1;)
 memcpy(newcm, m->constMethod(), sizeof(constMethodOopDesc));
 m->constMethod()->set_is_conc_safe(oopDesc::IsSafeConc);
 assert(m->constMethod()->is_parsable(), "Should remain parsable");
 // Reset correct method/const method, method size, and parameter info
-newcm->set_method(newm());
 newm->set_constMethod(newcm);
-assert(newcm->method() == newm(), "check");
 newm->constMethod()->set_code_size(new_code_length);
 newm->constMethod()->set_constMethod_size(new_const_method_size);
 newm->set_method_size(new_method_size);
 assert(newm->code_size() == new_code_length, "check");
 assert(newm->checked_exceptions_length() == checked_exceptions_len, "check");
+assert(newm->exception_table_length() == exception_table_len, "check");
 assert(newm->localvariable_table_length() == localvariable_len, "check");
 // Copy new byte codes
 memcpy(newm->code_base(), new_code, new_code_length);
 // Copy line number table
 if (new_compressed_linenumber_size > 0) {
 if (checked_exceptions_len > 0) {
 memcpy(newm->checked_exceptions_start(),
 m->checked_exceptions_start(),
 checked_exceptions_len * sizeof(CheckedExceptionElement));
 }
+// Copy exception table
+if (exception_table_len > 0) {
+memcpy(newm->exception_table_start(),
+m->exception_table_start(),
+exception_table_len * sizeof(ExceptionTableElement));
+}
 // Copy local variable number table
 if (localvariable_len > 0) {
 memcpy(newm->localvariable_table_start(),
 m->localvariable_table_start(),
 localvariable_len * sizeof(LocalVariableTableElement));
 vmSymbols::SID klass_id = klass_id_for_intrinsics(method_holder());
 assert(klass_id != vmSymbols::NO_SID, "caller responsibility");
 // ditto for method and signature:
 vmSymbols::SID  name_id = vmSymbols::find_sid(name());
-if (name_id == vmSymbols::NO_SID)  return;
+if (klass_id != vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_MethodHandle)
+&& name_id == vmSymbols::NO_SID)
+return;
 vmSymbols::SID   sig_id = vmSymbols::find_sid(signature());
 if (klass_id != vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_MethodHandle)
 && sig_id == vmSymbols::NO_SID)  return;
 jshort flags = access_flags().as_short();
 }
 break;
 // Signature-polymorphic methods: MethodHandle.invoke*, InvokeDynamic.*.
 case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_MethodHandle):
-if (is_static() || !is_native())  break;
+if (!is_native())  break;
-switch (name_id) {
+id = MethodHandles::signature_polymorphic_name_id(method_holder(), name());
-case vmSymbols::VM_SYMBOL_ENUM_NAME(invokeGeneric_name):
+if (is_static() != MethodHandles::is_signature_polymorphic_static(id))
-if (!AllowInvokeGeneric)  break;
+id = vmIntrinsics::_none;
-case vmSymbols::VM_SYMBOL_ENUM_NAME(invoke_name):
-id = vmIntrinsics::_invokeGeneric;
-break;
-case vmSymbols::VM_SYMBOL_ENUM_NAME(invokeExact_name):
-id = vmIntrinsics::_invokeExact;
-break;
-}
-break;
-case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_InvokeDynamic):
-if (!is_static() || !is_native())  break;
-id = vmIntrinsics::_invokeDynamic;
 break;
 }
 if (id != vmIntrinsics::_none) {
 // Set up its iid.  It is an alias method.
 }
 }
 // These two methods are static since a GC may move the methodOopDesc
 bool methodOopDesc::load_signature_classes(methodHandle m, TRAPS) {
+if (THREAD->is_Compiler_thread()) {
+// There is nothing useful this routine can do from within the Compile thread.
+// Hopefully, the signature contains only well-known classes.
+// We could scan for this and return true/false, but the caller won't care.
+return false;
+}
 bool sig_is_loaded = true;
 Handle class_loader(THREAD, instanceKlass::cast(m->method_holder())->class_loader());
 Handle protection_domain(THREAD, Klass::cast(m->method_holder())->protection_domain());
 ResourceMark rm(THREAD);
 Symbol*  signature = m->signature();
 #else
 st->print(" %s::", method_holder()->klass_part()->internal_name());
 #endif
 name()->print_symbol_on(st);
 if (WizardMode) signature()->print_symbol_on(st);
+else if (MethodHandles::is_signature_polymorphic(intrinsic_id()))
+MethodHandles::print_as_basic_type_signature_on(st, signature(), true);
 }
 // This is only done during class loading, so it is OK to assume method_idnum matches the methods() array
 static void reorder_based_on_method_index(objArrayOop methods,
 objArrayOop annotations,

Mercurial > hg > graal-compiler

comparison src/share/vm/oops/methodOop.cpp @ 6275:957c266d8bc5