graal-compiler: src/share/vm/runtime/sharedRuntime.cpp comparison

comparison src/share/vm/runtime/sharedRuntime.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	a432e6d43aa1 93c71eb28866
children	e522a00b91aa

comparison

equal deleted inserted replaced

-:fd8832ae511d
+:957c266d8bc5
 RuntimeStub*        SharedRuntime::_resolve_opt_virtual_call_blob;
 RuntimeStub*        SharedRuntime::_resolve_virtual_call_blob;
 RuntimeStub*        SharedRuntime::_resolve_static_call_blob;
 DeoptimizationBlob* SharedRuntime::_deopt_blob;
-RicochetBlob*       SharedRuntime::_ricochet_blob;
 SafepointBlob*      SharedRuntime::_polling_page_safepoint_handler_blob;
 SafepointBlob*      SharedRuntime::_polling_page_return_handler_blob;
 #ifdef COMPILER2
 UncommonTrapBlob*   SharedRuntime::_uncommon_trap_blob;
 _resolve_static_call_blob            = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::resolve_static_call_C),       "resolve_static_call");
 _polling_page_safepoint_handler_blob = generate_handler_blob(CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception), false);
 _polling_page_return_handler_blob    = generate_handler_blob(CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception), true);
-generate_ricochet_blob();
 generate_deopt_blob();
 #ifdef COMPILER2
 generate_uncommon_trap_blob();
 #endif // COMPILER2
 }
-//----------------------------generate_ricochet_blob---------------------------
-void SharedRuntime::generate_ricochet_blob() {
-if (!EnableInvokeDynamic)  return;  // leave it as a null
-// allocate space for the code
-ResourceMark rm;
-// setup code generation tools
-CodeBuffer buffer("ricochet_blob", 256 LP64_ONLY(+ 256), 256);  // XXX x86 LP64L: 512, 512
-MacroAssembler* masm = new MacroAssembler(&buffer);
-int bounce_offset = -1, exception_offset = -1, frame_size_in_words = -1;
-MethodHandles::RicochetFrame::generate_ricochet_blob(masm, &bounce_offset, &exception_offset, &frame_size_in_words);
-// -------------
-// make sure all code is generated
-masm->flush();
-// failed to generate?
-if (bounce_offset < 0 || exception_offset < 0 || frame_size_in_words < 0) {
-assert(false, "bad ricochet blob");
-return;
-}
-_ricochet_blob = RicochetBlob::create(&buffer, bounce_offset, exception_offset, frame_size_in_words);
-}
 #include <math.h>
 #ifndef USDT2
 HS_DTRACE_PROBE_DECL4(hotspot, object__alloc, Thread*, char*, int, size_t);
 return StubRoutines::catch_exception_entry();
 }
 // Interpreted code
 if (Interpreter::contains(return_address)) {
 return Interpreter::rethrow_exception_entry();
-}
-// Ricochet frame unwind code
-if (SharedRuntime::ricochet_blob() != NULL && SharedRuntime::ricochet_blob()->returns_to_bounce_addr(return_address)) {
-return SharedRuntime::ricochet_blob()->exception_addr();
 }
 guarantee(blob == NULL || !blob->is_runtime_stub(), "caller should have skipped stub");
 guarantee(!VtableStubs::contains(return_address), "NULL exceptions in vtables should have been handled already!");
 thread->_ScratchB = Deoptimization::make_trap_request((Deoptimization::DeoptReason)deopt_reason, Deoptimization::Action_reinterpret);
 return (SharedRuntime::deopt_blob()->implicit_exception_uncommon_trap());
 }
 #endif
-JRT_ENTRY(void, SharedRuntime::throw_WrongMethodTypeException(JavaThread* thread, oopDesc* required, oopDesc* actual))
-assert(thread == JavaThread::current() && required->is_oop() && actual->is_oop(), "bad args");
-ResourceMark rm;
-char* message = SharedRuntime::generate_wrong_method_type_message(thread, required, actual);
-throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_invoke_WrongMethodTypeException(), message);
-JRT_END
 address SharedRuntime::continuation_for_implicit_exception(JavaThread* thread,
 address pc,
 SharedRuntime::ImplicitExceptionKind exception_kind)
 {
 address target_pc = NULL;
 // caller => don't push another return address
 Events::log_exception(thread, "NullPointerException in IC check " INTPTR_FORMAT, pc);
 return StubRoutines::throw_NullPointerException_at_call_entry();
 }
+if (nm->method()->is_method_handle_intrinsic()) {
+// exception happened inside MH dispatch code, similar to a vtable stub
+Events::log_exception(thread, "NullPointerException in MH adapter " INTPTR_FORMAT, pc);
+return StubRoutines::throw_NullPointerException_at_call_entry();
+}
 #ifndef PRODUCT
 _implicit_null_throws++;
 #endif
 #ifdef GRAAL
 target_pc = deoptimize_for_implicit_exception(thread, pc, nm, Deoptimization::Reason_null_check);
 {
 THROW(vmSymbols::java_lang_UnsatisfiedLinkError());
 }
 JNI_END
+JNI_ENTRY(void, throw_unsupported_operation_exception(JNIEnv* env, ...))
+{
+THROW(vmSymbols::java_lang_UnsupportedOperationException());
+}
+JNI_END
 address SharedRuntime::native_method_throw_unsatisfied_link_error_entry() {
 return CAST_FROM_FN_PTR(address, &throw_unsatisfied_link_error);
+}
+address SharedRuntime::native_method_throw_unsupported_operation_exception_entry() {
+return CAST_FROM_FN_PTR(address, &throw_unsupported_operation_exception);
 }
 #ifndef PRODUCT
 JRT_ENTRY(intptr_t, SharedRuntime::trace_bytecode(JavaThread* thread, intptr_t preserve_this_value, intptr_t tos, intptr_t tos2))
 Handle nullHandle;  //create a handy null handle for exception returns
 assert(!vfst.at_end(), "Java frame must exist");
 // Find caller and bci from vframe
-methodHandle caller (THREAD, vfst.method());
+methodHandle caller(THREAD, vfst.method());
-int          bci    = vfst.bci();
+int          bci   = vfst.bci();
 // Find bytecode
 Bytecode_invoke bytecode(caller, bci);
-bc = bytecode.java_code();
+bc = bytecode.invoke_code();
 int bytecode_index = bytecode.index();
 // Find receiver for non-static call
-if (bc != Bytecodes::_invokestatic) {
+if (bc != Bytecodes::_invokestatic &&
+bc != Bytecodes::_invokedynamic) {
 // This register map must be update since we need to find the receiver for
 // compiled frames. The receiver might be in a register.
 RegisterMap reg_map2(thread);
 frame stubFrame   = thread->last_frame();
 // Caller-frame is a compiled frame
 THROW_(vmSymbols::java_lang_NullPointerException(), nullHandle);
 }
 }
 // Resolve method. This is parameterized by bytecode.
-constantPoolHandle constants (THREAD, caller->constants());
+constantPoolHandle constants(THREAD, caller->constants());
-assert (receiver.is_null() || receiver->is_oop(), "wrong receiver");
+assert(receiver.is_null() || receiver->is_oop(), "wrong receiver");
 LinkResolver::resolve_invoke(callinfo, receiver, constants, bytecode_index, bc, CHECK_(nullHandle));
 #ifdef ASSERT
 // Check that the receiver klass is of the right subtype and that it is initialized for virtual calls
 if (bc != Bytecodes::_invokestatic && bc != Bytecodes::_invokedynamic) {
 assert(receiver.not_null(), "should have thrown exception");
-KlassHandle receiver_klass (THREAD, receiver->klass());
+KlassHandle receiver_klass(THREAD, receiver->klass());
 klassOop rk = constants->klass_ref_at(bytecode_index, CHECK_(nullHandle));
 // klass is already loaded
-KlassHandle static_receiver_klass (THREAD, rk);
+KlassHandle static_receiver_klass(THREAD, rk);
-assert(receiver_klass->is_subtype_of(static_receiver_klass()), "actual receiver must be subclass of static receiver klass");
+// Method handle invokes might have been optimized to a direct call
+// so don't check for the receiver class.
+// FIXME this weakens the assert too much
+methodHandle callee = callinfo.selected_method();
+assert(receiver_klass->is_subtype_of(static_receiver_klass()) ||
+callee->is_method_handle_intrinsic() ||
+callee->is_compiled_lambda_form(),
+"actual receiver must be subclass of static receiver klass");
 if (receiver_klass->oop_is_instance()) {
 if (instanceKlass::cast(receiver_klass())->is_not_initialized()) {
 tty->print_cr("ERROR: Klass not yet initialized!!");
 receiver_klass.print();
 }
-assert (!instanceKlass::cast(receiver_klass())->is_not_initialized(), "receiver_klass must be initialized");
+assert(!instanceKlass::cast(receiver_klass())->is_not_initialized(), "receiver_klass must be initialized");
 }
 }
 #endif
 return receiver;
 Bytecodes::Code invoke_code = Bytecodes::_illegal;
 Handle receiver = find_callee_info(thread, invoke_code,
 call_info, CHECK_(methodHandle()));
 methodHandle callee_method = call_info.selected_method();
-assert((!is_virtual && invoke_code == Bytecodes::_invokestatic) ||
+assert((!is_virtual && invoke_code == Bytecodes::_invokestatic ) ||
-( is_virtual && invoke_code != Bytecodes::_invokestatic), "inconsistent bytecode");
+(!is_virtual && invoke_code == Bytecodes::_invokehandle ) ||
+(!is_virtual && invoke_code == Bytecodes::_invokedynamic) ||
+( is_virtual && invoke_code != Bytecodes::_invokestatic ), "inconsistent bytecode");
 #ifndef PRODUCT
 // tracing/debugging/statistics
 int *addr = (is_optimized) ? (&_resolve_opt_virtual_ctr) :
 (is_virtual) ? (&_resolve_virtual_ctr) :
 ResourceMark rm(thread);
 tty->print("resolving %s%s (%s) call to",
 (is_optimized) ? "optimized " : "", (is_virtual) ? "virtual" : "static",
 Bytecodes::name(invoke_code));
 callee_method->print_short_name(tty);
-tty->print_cr(" code: " INTPTR_FORMAT, callee_method->code());
+tty->print_cr(" at pc: " INTPTR_FORMAT " to code: " INTPTR_FORMAT, caller_frame.pc(), callee_method->code());
 }
 #endif
-// JSR 292
+// JSR 292 key invariant:
 // If the resolved method is a MethodHandle invoke target the call
-// site must be a MethodHandle call site.
+// site must be a MethodHandle call site, because the lambda form might tail-call
-if (callee_method->is_method_handle_invoke()) {
+// leaving the stack in a state unknown to either caller or callee
-assert(caller_nm->is_method_handle_return(caller_frame.pc()), "must be MH call site");
+// TODO detune for now but we might need it again
-}
+//  assert(!callee_method->is_compiled_lambda_form() ||
+//         caller_nm->is_method_handle_return(caller_frame.pc()), "must be MH call site");
 // Compute entry points. This might require generation of C2I converter
 // frames, so we cannot be holding any locks here. Furthermore, the
 // computation of the entry points is independent of patching the call.  We
 // always return the entry-point, but we only patch the stub if the call has
 RegisterMap reg_map(thread, false);
 frame stub_frame = thread->last_frame();
 assert(stub_frame.is_runtime_frame(), "sanity check");
 frame caller_frame = stub_frame.sender(&reg_map);
 assert(!caller_frame.is_interpreted_frame() && !caller_frame.is_entry_frame(), "unexpected frame");
-assert(!caller_frame.is_ricochet_frame(), "unexpected frame");
 #endif /* ASSERT */
 methodHandle callee_method;
 JRT_BLOCK
 callee_method = SharedRuntime::handle_ic_miss_helper(thread, CHECK_NULL);
 // MethodHandle invokes don't have a CompiledIC and should always
 // simply redispatch to the callee_target.
 address   sender_pc = caller_frame.pc();
 CodeBlob* sender_cb = caller_frame.cb();
 nmethod*  sender_nm = sender_cb->as_nmethod_or_null();
-bool is_mh_invoke_via_adapter = false;  // Direct c2c call or via adapter?
-if (sender_nm != NULL && sender_nm->is_method_handle_return(sender_pc)) {
-// If the callee_target is set, then we have come here via an i2c
-// adapter.
-methodOop callee = thread->callee_target();
-if (callee != NULL) {
-assert(callee->is_method(), "sanity");
-is_mh_invoke_via_adapter = true;
-}
-}
 if (caller_frame.is_interpreted_frame() ||
-caller_frame.is_entry_frame()       ||
+caller_frame.is_entry_frame()) {
-caller_frame.is_ricochet_frame()    ||
-is_mh_invoke_via_adapter) {
 methodOop callee = thread->callee_target();
 guarantee(callee != NULL && callee->is_method(), "bad handshake");
 thread->set_vm_result(callee);
 thread->set_callee_target(NULL);
 return callee->get_c2i_entry();
 nmethod* nm = cb->as_nmethod_or_null();
 assert(nm, "must be");
 // Get the return PC for the passed caller PC.
 address return_pc = caller_pc + frame::pc_return_offset;
-// Don't fixup method handle call sites as the executed method
-// handle adapters are doing the required MethodHandle chain work.
-if (nm->is_method_handle_return(return_pc)) {
-return;
-}
 // There is a benign race here. We could be attempting to patch to a compiled
 // entry point at the same time the callee is being deoptimized. If that is
 // the case then entry_point may in fact point to a c2i and we'd patch the
 // call site with the same old data. clear_code will set code() to NULL
 Klass* targetKlass = Klass::cast(vfst.method()->constants()->klass_at(
 cc.index(), thread));
 return generate_class_cast_message(objName, targetKlass->external_name());
 }
-char* SharedRuntime::generate_wrong_method_type_message(JavaThread* thread,
-oopDesc* required,
-oopDesc* actual) {
-if (TraceMethodHandles) {
-tty->print_cr("WrongMethodType thread="PTR_FORMAT" req="PTR_FORMAT" act="PTR_FORMAT"",
-thread, required, actual);
-}
-assert(EnableInvokeDynamic, "");
-oop singleKlass = wrong_method_type_is_for_single_argument(thread, required);
-char* message = NULL;
-if (singleKlass != NULL) {
-const char* objName = "argument or return value";
-if (actual != NULL) {
-// be flexible about the junk passed in:
-klassOop ak = (actual->is_klass()
-? (klassOop)actual
-: actual->klass());
-objName = Klass::cast(ak)->external_name();
-}
-Klass* targetKlass = Klass::cast(required->is_klass()
-? (klassOop)required
-: java_lang_Class::as_klassOop(required));
-message = generate_class_cast_message(objName, targetKlass->external_name());
-} else {
-// %%% need to get the MethodType string, without messing around too much
-const char* desc = NULL;
-// Get a signature from the invoke instruction
-const char* mhName = "method handle";
-const char* targetType = "the required signature";
-int targetArity = -1, mhArity = -1;
-vframeStream vfst(thread, true);
-if (!vfst.at_end()) {
-Bytecode_invoke call(vfst.method(), vfst.bci());
-methodHandle target;
-{
-EXCEPTION_MARK;
-target = call.static_target(THREAD);
-if (HAS_PENDING_EXCEPTION) { CLEAR_PENDING_EXCEPTION; }
-}
-if (target.not_null()
-&& target->is_method_handle_invoke()
-&& required == target->method_handle_type()) {
-targetType = target->signature()->as_C_string();
-targetArity = ArgumentCount(target->signature()).size();
-}
-}
-KlassHandle kignore; int dmf_flags = 0;
-methodHandle actual_method = MethodHandles::decode_method(actual, kignore, dmf_flags);
-if ((dmf_flags & ~(MethodHandles::_dmf_has_receiver |
-MethodHandles::_dmf_does_dispatch |
-MethodHandles::_dmf_from_interface)) != 0)
-actual_method = methodHandle();  // MH does extra binds, drops, etc.
-bool has_receiver = ((dmf_flags & MethodHandles::_dmf_has_receiver) != 0);
-if (actual_method.not_null()) {
-mhName = actual_method->signature()->as_C_string();
-mhArity = ArgumentCount(actual_method->signature()).size();
-if (!actual_method->is_static())  mhArity += 1;
-} else if (java_lang_invoke_MethodHandle::is_instance(actual)) {
-oopDesc* mhType = java_lang_invoke_MethodHandle::type(actual);
-mhArity = java_lang_invoke_MethodType::ptype_count(mhType);
-stringStream st;
-java_lang_invoke_MethodType::print_signature(mhType, &st);
-mhName = st.as_string();
-}
-if (targetArity != -1 && targetArity != mhArity) {
-if (has_receiver && targetArity == mhArity-1)
-desc = " cannot be called without a receiver argument as ";
-else
-desc = " cannot be called with a different arity as ";
-}
-message = generate_class_cast_message(mhName, targetType,
-desc != NULL ? desc :
-" cannot be called as ");
-}
-if (TraceMethodHandles) {
-tty->print_cr("WrongMethodType => message=%s", message);
-}
-return message;
-}
-oop SharedRuntime::wrong_method_type_is_for_single_argument(JavaThread* thr,
-oopDesc* required) {
-if (required == NULL)  return NULL;
-if (required->klass() == SystemDictionary::Class_klass())
-return required;
-if (required->is_klass())
-return Klass::cast(klassOop(required))->java_mirror();
-return NULL;
-}
 char* SharedRuntime::generate_class_cast_message(
 const char* objName, const char* targetKlassName, const char* desc) {
 size_t msglen = strlen(objName) + strlen(desc) + strlen(targetKlassName) + 1;
 char* message = NEW_RESOURCE_ARRAY(char, msglen);
 #endif
 // A simple wrapper class around the calling convention information
 // that allows sharing of adapters for the same calling convention.
-class AdapterFingerPrint : public CHeapObj {
+class AdapterFingerPrint : public CHeapObj<mtCode> {
 private:
+enum {
+_basic_type_bits = 4,
+_basic_type_mask = right_n_bits(_basic_type_bits),
+_basic_types_per_int = BitsPerInt / _basic_type_bits,
+_compact_int_count = 3
+};
+// TO DO:  Consider integrating this with a more global scheme for compressing signatures.
+// For now, 4 bits per components (plus T_VOID gaps after double/long) is not excessive.
 union {
-int  _compact[3];
+int  _compact[_compact_int_count];
 int* _fingerprint;
 } _value;
 int _length; // A negative length indicates the fingerprint is in the compact form,
 // Otherwise _value._fingerprint is the array.
 // Remap BasicTypes that are handled equivalently by the adapters.
 // These are correct for the current system but someday it might be
 // necessary to make this mapping platform dependent.
-static BasicType adapter_encoding(BasicType in) {
+static int adapter_encoding(BasicType in) {
-assert((~0xf & in) == 0, "must fit in 4 bits");
 switch(in) {
 case T_BOOLEAN:
 case T_BYTE:
 case T_SHORT:
 case T_CHAR:
 // There are all promoted to T_INT in the calling convention
 return T_INT;
 case T_OBJECT:
 case T_ARRAY:
+// In other words, we assume that any register good enough for
+// an int or long is good enough for a managed pointer.
 #ifdef _LP64
 return T_LONG;
 #else
 return T_INT;
 #endif
 public:
 AdapterFingerPrint(int total_args_passed, BasicType* sig_bt) {
 // The fingerprint is based on the BasicType signature encoded
 // into an array of ints with eight entries per int.
 int* ptr;
-int len = (total_args_passed + 7) >> 3;
+int len = (total_args_passed + (_basic_types_per_int-1)) / _basic_types_per_int;
-if (len <= (int)(sizeof(_value._compact) / sizeof(int))) {
+if (len <= _compact_int_count) {
+assert(_compact_int_count == 3, "else change next line");
 _value._compact[0] = _value._compact[1] = _value._compact[2] = 0;
 // Storing the signature encoded as signed chars hits about 98%
 // of the time.
 _length = -len;
 ptr = _value._compact;
 } else {
 _length = len;
-_value._fingerprint = NEW_C_HEAP_ARRAY(int, _length);
+_value._fingerprint = NEW_C_HEAP_ARRAY(int, _length, mtCode);
 ptr = _value._fingerprint;
 }
 // Now pack the BasicTypes with 8 per int
 int sig_index = 0;
 for (int index = 0; index < len; index++) {
 int value = 0;
-for (int byte = 0; byte < 8; byte++) {
+for (int byte = 0; byte < _basic_types_per_int; byte++) {
-if (sig_index < total_args_passed) {
+int bt = ((sig_index < total_args_passed)
-value = (value << 4) | adapter_encoding(sig_bt[sig_index++]);
+? adapter_encoding(sig_bt[sig_index++])
-}
+: 0);
+assert((bt & _basic_type_mask) == bt, "must fit in 4 bits");
+value = (value << _basic_type_bits) | bt;
 }
 ptr[index] = value;
 }
 }
 ~AdapterFingerPrint() {
 if (_length > 0) {
-FREE_C_HEAP_ARRAY(int, _value._fingerprint);
+FREE_C_HEAP_ARRAY(int, _value._fingerprint, mtCode);
 }
 }
 int value(int index) {
 if (_length < 0) {
 bool equals(AdapterFingerPrint* other) {
 if (other->_length != _length) {
 return false;
 }
 if (_length < 0) {
+assert(_compact_int_count == 3, "else change next line");
 return _value._compact[0] == other->_value._compact[0] &&
 _value._compact[1] == other->_value._compact[1] &&
 _value._compact[2] == other->_value._compact[2];
 } else {
 for (int i = 0; i < _length; i++) {
 }
 };
 // A hashtable mapping from AdapterFingerPrints to AdapterHandlerEntries
-class AdapterHandlerTable : public BasicHashtable {
+class AdapterHandlerTable : public BasicHashtable<mtCode> {
 friend class AdapterHandlerTableIterator;
 private:
 #ifndef PRODUCT
 static int _hits;    // number of successful lookups
 static int _compact; // number of equals calls with compact signature
 #endif
 AdapterHandlerEntry* bucket(int i) {
-return (AdapterHandlerEntry*)BasicHashtable::bucket(i);
+return (AdapterHandlerEntry*)BasicHashtable<mtCode>::bucket(i);
 }
 public:
 AdapterHandlerTable()
-: BasicHashtable(293, sizeof(AdapterHandlerEntry)) { }
+: BasicHashtable<mtCode>(293, sizeof(AdapterHandlerEntry)) { }
 // Create a new entry suitable for insertion in the table
 AdapterHandlerEntry* new_entry(AdapterFingerPrint* fingerprint, address i2c_entry, address c2i_entry, address c2i_unverified_entry) {
-AdapterHandlerEntry* entry = (AdapterHandlerEntry*)BasicHashtable::new_entry(fingerprint->compute_hash());
+AdapterHandlerEntry* entry = (AdapterHandlerEntry*)BasicHashtable<mtCode>::new_entry(fingerprint->compute_hash());
 entry->init(fingerprint, i2c_entry, c2i_entry, c2i_unverified_entry);
 return entry;
 }
 // Insert an entry into the table
 add_entry(index, entry);
 }
 void free_entry(AdapterHandlerEntry* entry) {
 entry->deallocate();
-BasicHashtable::free_entry(entry);
+BasicHashtable<mtCode>::free_entry(entry);
 }
 // Find a entry with the same fingerprint if it exists
 AdapterHandlerEntry* lookup(int total_args_passed, BasicType* sig_bt) {
 NOT_PRODUCT(_lookups++);
 return NULL; // Out of CodeCache space
 }
 entry->relocate(B->content_begin());
 #ifndef PRODUCT
 // debugging suppport
-if (PrintAdapterHandlers) {
+if (PrintAdapterHandlers || PrintStubCode) {
-tty->cr();
+entry->print_adapter_on(tty);
-tty->print_cr("i2c argument handler #%d for: %s %s (fingerprint = %s, %d bytes generated)",
+tty->print_cr("i2c argument handler #%d for: %s %s (%d bytes generated)",
 _adapters->number_of_entries(), (method->is_static() ? "static" : "receiver"),
-method->signature()->as_C_string(), fingerprint->as_string(), insts_size );
+method->signature()->as_C_string(), insts_size);
 tty->print_cr("c2i argument handler starts at %p",entry->get_c2i_entry());
-Disassembler::decode(entry->get_i2c_entry(), entry->get_i2c_entry() + insts_size);
+if (Verbose || PrintStubCode) {
+address first_pc = entry->base_address();
+if (first_pc != NULL)
+Disassembler::decode(first_pc, first_pc + insts_size);
+}
 }
 #endif
 _adapters->add(entry);
 }
 }
 }
 return entry;
 }
+address AdapterHandlerEntry::base_address() {
+address base = _i2c_entry;
+if (base == NULL)  base = _c2i_entry;
+assert(base <= _c2i_entry || _c2i_entry == NULL, "");
+assert(base <= _c2i_unverified_entry || _c2i_unverified_entry == NULL, "");
+return base;
+}
 void AdapterHandlerEntry::relocate(address new_base) {
-ptrdiff_t delta = new_base - _i2c_entry;
+address old_base = base_address();
+assert(old_base != NULL, "");
+ptrdiff_t delta = new_base - old_base;
+if (_i2c_entry != NULL)
 _i2c_entry += delta;
+if (_c2i_entry != NULL)
 _c2i_entry += delta;
+if (_c2i_unverified_entry != NULL)
 _c2i_unverified_entry += delta;
+assert(base_address() == new_base, "");
 }
 void AdapterHandlerEntry::deallocate() {
 delete _fingerprint;
 #ifdef ASSERT
-if (_saved_code) FREE_C_HEAP_ARRAY(unsigned char, _saved_code);
+if (_saved_code) FREE_C_HEAP_ARRAY(unsigned char, _saved_code, mtCode);
-if (_saved_sig)  FREE_C_HEAP_ARRAY(Basictype, _saved_sig);
+if (_saved_sig)  FREE_C_HEAP_ARRAY(Basictype, _saved_sig, mtCode);
 #endif
 }
 #ifdef ASSERT
 // Capture the code before relocation so that it can be compared
 // against other versions.  If the code is captured after relocation
 // then relative instructions won't be equivalent.
 void AdapterHandlerEntry::save_code(unsigned char* buffer, int length, int total_args_passed, BasicType* sig_bt) {
-_saved_code = NEW_C_HEAP_ARRAY(unsigned char, length);
+_saved_code = NEW_C_HEAP_ARRAY(unsigned char, length, mtCode);
 _code_length = length;
 memcpy(_saved_code, buffer, length);
 _total_args_passed = total_args_passed;
-_saved_sig = NEW_C_HEAP_ARRAY(BasicType, _total_args_passed);
+_saved_sig = NEW_C_HEAP_ARRAY(BasicType, _total_args_passed, mtCode);
 memcpy(_saved_sig, sig_bt, _total_args_passed * sizeof(BasicType));
 }
 bool AdapterHandlerEntry::compare_code(unsigned char* buffer, int length, int total_args_passed, BasicType* sig_bt) {
 // back to java blocking if a safepoint is in progress.
 nmethod *AdapterHandlerLibrary::create_native_wrapper(methodHandle method, int compile_id) {
 ResourceMark rm;
 nmethod* nm = NULL;
-assert(method->has_native_function(), "must have something valid to call!");
+assert(method->is_native(), "must be native");
+assert(method->is_method_handle_intrinsic() ||
+method->has_native_function(), "must have something valid to call!");
 {
 // perform the work while holding the lock, but perform any printing outside the lock
 MutexLocker mu(AdapterHandlerLibrary_lock);
 // See if somebody beat us to it
 sig_bt[i++] = T_VOID;   // Longs & doubles take 2 Java slots
 }
 assert( i==total_args_passed, "" );
 BasicType ret_type = ss.type();
-// Now get the compiled-Java layout as input arguments
+// Now get the compiled-Java layout as input (or output) arguments.
-int comp_args_on_stack;
+// NOTE: Stubs for compiled entry points of method handle intrinsics
-comp_args_on_stack = SharedRuntime::java_calling_convention(sig_bt, regs, total_args_passed, false);
+// are just trampolines so the argument registers must be outgoing ones.
+const bool is_outgoing = method->is_method_handle_intrinsic();
+int comp_args_on_stack = SharedRuntime::java_calling_convention(sig_bt, regs, total_args_passed, is_outgoing);
 // Generate the compiled-to-native wrapper code
 nm = SharedRuntime::generate_native_wrapper(&_masm,
 method,
 compile_id,
 methodOop moop = fr.interpreter_frame_method();
 int max_locals = moop->max_locals();
 // Allocate temp buffer, 1 word per local & 2 per active monitor
 int buf_size_words = max_locals + active_monitor_count*2;
-intptr_t *buf = NEW_C_HEAP_ARRAY(intptr_t,buf_size_words);
+intptr_t *buf = NEW_C_HEAP_ARRAY(intptr_t,buf_size_words, mtCode);
 // Copy the locals.  Order is preserved so that loading of longs works.
 // Since there's no GC I can copy the oops blindly.
 assert( sizeof(HeapWord)==sizeof(intptr_t), "fix this code");
 Copy::disjoint_words((HeapWord*)fr.interpreter_frame_local_at(max_locals-1),
 return buf;
 JRT_END
 JRT_LEAF(void, SharedRuntime::OSR_migration_end( intptr_t* buf) )
-FREE_C_HEAP_ARRAY(intptr_t,buf);
+FREE_C_HEAP_ARRAY(intptr_t,buf, mtCode);
 JRT_END
 bool AdapterHandlerLibrary::contains(CodeBlob* b) {
 AdapterHandlerTableIterator iter(_adapters);
 while (iter.has_next()) {
 void AdapterHandlerLibrary::print_handler_on(outputStream* st, CodeBlob* b) {
 AdapterHandlerTableIterator iter(_adapters);
 while (iter.has_next()) {
 AdapterHandlerEntry* a = iter.next();
-if ( b == CodeCache::find_blob(a->get_i2c_entry()) ) {
+if (b == CodeCache::find_blob(a->get_i2c_entry())) {
 st->print("Adapter for signature: ");
-st->print_cr("%s i2c: " INTPTR_FORMAT " c2i: " INTPTR_FORMAT " c2iUV: " INTPTR_FORMAT,
+a->print_adapter_on(tty);
-a->fingerprint()->as_string(),
-a->get_i2c_entry(), a->get_c2i_entry(), a->get_c2i_unverified_entry());
 return;
 }
 }
 assert(false, "Should have found handler");
+}
+void AdapterHandlerEntry::print_adapter_on(outputStream* st) const {
+st->print_cr("AHE@" INTPTR_FORMAT ": %s i2c: " INTPTR_FORMAT " c2i: " INTPTR_FORMAT " c2iUV: " INTPTR_FORMAT,
+(intptr_t) this, fingerprint()->as_string(),
+get_i2c_entry(), get_c2i_entry(), get_c2i_unverified_entry());
 }
 #ifndef PRODUCT
 void AdapterHandlerLibrary::print_statistics() {

Mercurial > hg > graal-compiler

comparison src/share/vm/runtime/sharedRuntime.cpp @ 6275:957c266d8bc5