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

comparison src/share/vm/runtime/sharedRuntime.cpp @ 6948:e522a00b91aa

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works

author	Doug Simon <doug.simon@oracle.com>
date	Mon, 12 Nov 2012 23:14:12 +0100
parents	957c266d8bc5 d8ce2825b193
children	2cb439954abf

comparison

equal deleted inserted replaced

-:ae13cc658b80
+:e522a00b91aa
 RuntimeStub*        SharedRuntime::_resolve_opt_virtual_call_blob;
 RuntimeStub*        SharedRuntime::_resolve_virtual_call_blob;
 RuntimeStub*        SharedRuntime::_resolve_static_call_blob;
 DeoptimizationBlob* SharedRuntime::_deopt_blob;
+SafepointBlob*      SharedRuntime::_polling_page_vectors_safepoint_handler_blob;
 SafepointBlob*      SharedRuntime::_polling_page_safepoint_handler_blob;
 SafepointBlob*      SharedRuntime::_polling_page_return_handler_blob;
 #ifdef COMPILER2
 UncommonTrapBlob*   SharedRuntime::_uncommon_trap_blob;
 _ic_miss_blob                        = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::handle_wrong_method_ic_miss), "ic_miss_stub");
 _resolve_opt_virtual_call_blob       = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::resolve_opt_virtual_call_C),  "resolve_opt_virtual_call");
 _resolve_virtual_call_blob           = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::resolve_virtual_call_C),      "resolve_virtual_call");
 _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);
+#ifdef COMPILER2
-_polling_page_return_handler_blob    = generate_handler_blob(CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception), true);
+// Vectors are generated only by C2.
+if (is_wide_vector(MaxVectorSize)) {
+_polling_page_vectors_safepoint_handler_blob = generate_handler_blob(CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception), POLL_AT_VECTOR_LOOP);
+}
+#endif // COMPILER2
+_polling_page_safepoint_handler_blob = generate_handler_blob(CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception), POLL_AT_LOOP);
+_polling_page_return_handler_blob    = generate_handler_blob(CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception), POLL_AT_RETURN);
 generate_deopt_blob();
 #ifdef COMPILER2
 generate_uncommon_trap_blob();
 assert( ((NativeInstruction*)pc)->is_safepoint_poll(),
 "Only polling locations are used for safepoint");
 bool at_poll_return = ((nmethod*)cb)->is_at_poll_return(pc);
+bool has_wide_vectors = ((nmethod*)cb)->has_wide_vectors();
 if (at_poll_return) {
 assert(SharedRuntime::polling_page_return_handler_blob() != NULL,
 "polling page return stub not created yet");
 stub = SharedRuntime::polling_page_return_handler_blob()->entry_point();
+} else if (has_wide_vectors) {
+assert(SharedRuntime::polling_page_vectors_safepoint_handler_blob() != NULL,
+"polling page vectors safepoint stub not created yet");
+stub = SharedRuntime::polling_page_vectors_safepoint_handler_blob()->entry_point();
 } else {
 assert(SharedRuntime::polling_page_safepoint_handler_blob() != NULL,
 "polling page safepoint stub not created yet");
 stub = SharedRuntime::polling_page_safepoint_handler_blob()->entry_point();
 }
 // called/generated when TraceRedefineClasses has the right bits
 // set. Since obsolete methods are never compiled, we don't have
 // to modify the compilers to generate calls to this function.
 //
 JRT_LEAF(int, SharedRuntime::rc_trace_method_entry(
-JavaThread* thread, methodOopDesc* method))
+JavaThread* thread, Method* method))
 assert(RC_TRACE_IN_RANGE(0x00001000, 0x00002000), "wrong call");
 if (method->is_obsolete()) {
 // We are calling an obsolete method, but this is not necessarily
 // an error. Our method could have been redefined just after we
-// fetched the methodOop from the constant pool.
+// fetched the Method* from the constant pool.
 // RC_TRACE macro has an embedded ResourceMark
 RC_TRACE_WITH_THREAD(0x00001000, thread,
 ("calling obsolete method '%s'",
 method->name_and_sig_as_C_string()));
 JRT_END
 JRT_ENTRY(void, SharedRuntime::throw_StackOverflowError(JavaThread* thread))
 // We avoid using the normal exception construction in this case because
 // it performs an upcall to Java, and we're already out of stack space.
-klassOop k = SystemDictionary::StackOverflowError_klass();
+Klass* k = SystemDictionary::StackOverflowError_klass();
-oop exception_oop = instanceKlass::cast(k)->allocate_instance(CHECK);
+oop exception_oop = InstanceKlass::cast(k)->allocate_instance(CHECK);
 Handle exception (thread, exception_oop);
 if (StackTraceInThrowable) {
 java_lang_Throwable::fill_in_stack_trace(exception);
 }
 throw_and_post_jvmti_exception(thread, exception);
 JRT_END
 JRT_ENTRY_NO_ASYNC(void, SharedRuntime::register_finalizer(JavaThread* thread, oopDesc* obj))
 assert(obj->is_oop(), "must be a valid oop");
-assert(obj->klass()->klass_part()->has_finalizer(), "shouldn't be here otherwise");
+assert(obj->klass()->has_finalizer(), "shouldn't be here otherwise");
-instanceKlass::register_finalizer(instanceOop(obj), CHECK);
+InstanceKlass::register_finalizer(instanceOop(obj), CHECK);
 JRT_END
 jlong SharedRuntime::get_java_tid(Thread* thread) {
 if (thread != NULL) {
 return dtrace_object_alloc_base(Thread::current(), o);
 }
 int SharedRuntime::dtrace_object_alloc_base(Thread* thread, oopDesc* o) {
 assert(DTraceAllocProbes, "wrong call");
-Klass* klass = o->blueprint();
+Klass* klass = o->klass();
 int size = o->size();
 Symbol* name = klass->name();
 #ifndef USDT2
 HS_DTRACE_PROBE4(hotspot, object__alloc, get_java_tid(thread),
 name->bytes(), name->utf8_length(), size * HeapWordSize);
 #endif /* USDT2 */
 return 0;
 }
 JRT_LEAF(int, SharedRuntime::dtrace_method_entry(
-JavaThread* thread, methodOopDesc* method))
+JavaThread* thread, Method* method))
 assert(DTraceMethodProbes, "wrong call");
 Symbol* kname = method->klass_name();
 Symbol* name = method->name();
 Symbol* sig = method->signature();
 #ifndef USDT2
 #endif /* USDT2 */
 return 0;
 JRT_END
 JRT_LEAF(int, SharedRuntime::dtrace_method_exit(
-JavaThread* thread, methodOopDesc* method))
+JavaThread* thread, Method* method))
 assert(DTraceMethodProbes, "wrong call");
 Symbol* kname = method->klass_name();
 Symbol* name = method->name();
 Symbol* sig = method->signature();
 #ifndef USDT2
 #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());
-klassOop rk = constants->klass_ref_at(bytecode_index, CHECK_(nullHandle));
+Klass* rk = constants->klass_ref_at(bytecode_index, CHECK_(nullHandle));
 // klass is already loaded
 KlassHandle static_receiver_klass(THREAD, rk);
 // 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
 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()) {
+if (InstanceKlass::cast(receiver_klass())->is_not_initialized()) {
 tty->print_cr("ERROR: Klass not yet initialized!!");
-receiver_klass.print();
+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;
 // grab lock, check for deoptimization and potentially patch caller
 {
 MutexLocker ml_patch(CompiledIC_lock);
-// Now that we are ready to patch if the methodOop was redefined then
+// Now that we are ready to patch if the Method* was redefined then
 // don't update call site and let the caller retry.
 if (!callee_method->is_old()) {
 #ifdef ASSERT
 // We must not try to patch to jump to an already unloaded method.
 assert(CodeCache::find_blob(dest_entry_point) != NULL,
 "should not unload nmethod while locked");
 }
 #endif
 if (is_virtual) {
-CompiledIC* inline_cache = CompiledIC_before(caller_frame.pc());
+nmethod* nm = callee_nm;
+if (nm == NULL) CodeCache::find_blob(caller_frame.pc());
+CompiledIC* inline_cache = CompiledIC_before(caller_nm, caller_frame.pc());
 if (inline_cache->is_clean()) {
 inline_cache->set_to_monomorphic(virtual_call_info);
 }
 } else {
 CompiledStaticCall* ssc = compiledStaticCall_before(caller_frame.pc());
 #endif /* ASSERT */
 methodHandle callee_method;
 JRT_BLOCK
 callee_method = SharedRuntime::handle_ic_miss_helper(thread, CHECK_NULL);
-// Return methodOop through TLS
+// Return Method* through TLS
-thread->set_vm_result(callee_method());
+thread->set_vm_result_2(callee_method());
 JRT_BLOCK_END
 // return compiled code entry point after potential safepoints
 assert(callee_method->verified_code_entry() != NULL, " Jump to zero!");
 return callee_method->verified_code_entry();
 JRT_END
 CodeBlob* sender_cb = caller_frame.cb();
 nmethod*  sender_nm = sender_cb->as_nmethod_or_null();
 if (caller_frame.is_interpreted_frame() ||
 caller_frame.is_entry_frame()) {
-methodOop callee = thread->callee_target();
+Method* callee = thread->callee_target();
 guarantee(callee != NULL && callee->is_method(), "bad handshake");
-thread->set_vm_result(callee);
+thread->set_vm_result_2(callee);
 thread->set_callee_target(NULL);
 return callee->get_c2i_entry();
 }
 // Must be compiled to compiled path which is safe to stackwalk
 methodHandle callee_method;
 JRT_BLOCK
 // Force resolving of caller (if we called from compiled frame)
 callee_method = SharedRuntime::reresolve_call_site(thread, CHECK_NULL);
-thread->set_vm_result(callee_method());
+thread->set_vm_result_2(callee_method());
 JRT_BLOCK_END
 // return compiled code entry point after potential safepoints
 assert(callee_method->verified_code_entry() != NULL, " Jump to zero!");
 return callee_method->verified_code_entry();
 JRT_END
 // resolve a static call and patch code
 JRT_BLOCK_ENTRY(address, SharedRuntime::resolve_static_call_C(JavaThread *thread ))
 methodHandle callee_method;
 JRT_BLOCK
 callee_method = SharedRuntime::resolve_helper(thread, false, false, CHECK_NULL);
-thread->set_vm_result(callee_method());
+thread->set_vm_result_2(callee_method());
 JRT_BLOCK_END
 // return compiled code entry point after potential safepoints
 assert(callee_method->verified_code_entry() != NULL, " Jump to zero!");
 return callee_method->verified_code_entry();
 JRT_END
 // resolve virtual call and update inline cache to monomorphic
 JRT_BLOCK_ENTRY(address, SharedRuntime::resolve_virtual_call_C(JavaThread *thread ))
 methodHandle callee_method;
 JRT_BLOCK
 callee_method = SharedRuntime::resolve_helper(thread, true, false, CHECK_NULL);
-thread->set_vm_result(callee_method());
+thread->set_vm_result_2(callee_method());
 JRT_BLOCK_END
 // return compiled code entry point after potential safepoints
 assert(callee_method->verified_code_entry() != NULL, " Jump to zero!");
 return callee_method->verified_code_entry();
 JRT_END
 // monomorphic, so it has no inline cache).  Patch code to resolved target.
 JRT_BLOCK_ENTRY(address, SharedRuntime::resolve_opt_virtual_call_C(JavaThread *thread))
 methodHandle callee_method;
 JRT_BLOCK
 callee_method = SharedRuntime::resolve_helper(thread, true, true, CHECK_NULL);
-thread->set_vm_result(callee_method());
+thread->set_vm_result_2(callee_method());
 JRT_BLOCK_END
 // return compiled code entry point after potential safepoints
 assert(callee_method->verified_code_entry() != NULL, " Jump to zero!");
 return callee_method->verified_code_entry();
 JRT_END
 RegisterMap reg_map(thread, false);
 frame caller_frame = thread->last_frame().sender(&reg_map);
 CodeBlob* cb = caller_frame.cb();
 if (cb->is_nmethod() && ((nmethod*)cb)->is_in_use()) {
 // Not a non-entrant nmethod, so find inline_cache
-CompiledIC* inline_cache = CompiledIC_before(caller_frame.pc());
+CompiledIC* inline_cache = CompiledIC_before(((nmethod*)cb), caller_frame.pc());
 bool should_be_mono = false;
 if (inline_cache->is_optimized()) {
 if (TraceCallFixup) {
 ResourceMark rm(thread);
 tty->print("OPTIMIZED IC miss (%s) call to", Bytecodes::name(bc));
 callee_method->print_short_name(tty);
 tty->print_cr(" code: " INTPTR_FORMAT, callee_method->code());
 }
 should_be_mono = true;
-} else {
+} else if (inline_cache->is_icholder_call()) {
-compiledICHolderOop ic_oop = (compiledICHolderOop) inline_cache->cached_oop();
+CompiledICHolder* ic_oop = inline_cache->cached_icholder();
-if ( ic_oop != NULL && ic_oop->is_compiledICHolder()) {
+if ( ic_oop != NULL) {
 if (receiver()->klass() == ic_oop->holder_klass()) {
 // This isn't a real miss. We must have seen that compiled code
 // is now available and we want the call site converted to a
 // monomorphic compiled call site.
 if (is_static_call) {
 CompiledStaticCall* ssc= compiledStaticCall_at(call_addr);
 ssc->set_to_clean();
 } else {
 // compiled, dispatched call (which used to call an interpreted method)
-CompiledIC* inline_cache = CompiledIC_at(call_addr);
+CompiledIC* inline_cache = CompiledIC_at(caller_nm, call_addr);
 inline_cache->set_to_clean();
 }
 }
 }
 }
 #endif
 return callee_method;
 }
+#ifdef ASSERT
+void SharedRuntime::check_member_name_argument_is_last_argument(methodHandle method,
+const BasicType* sig_bt,
+const VMRegPair* regs) {
+ResourceMark rm;
+const int total_args_passed = method->size_of_parameters();
+const VMRegPair*    regs_with_member_name = regs;
+VMRegPair* regs_without_member_name = NEW_RESOURCE_ARRAY(VMRegPair, total_args_passed - 1);
+const int member_arg_pos = total_args_passed - 1;
+assert(member_arg_pos >= 0 && member_arg_pos < total_args_passed, "oob");
+assert(sig_bt[member_arg_pos] == T_OBJECT, "dispatch argument must be an object");
+const bool is_outgoing = method->is_method_handle_intrinsic();
+int comp_args_on_stack = java_calling_convention(sig_bt, regs_without_member_name, total_args_passed - 1, is_outgoing);
+for (int i = 0; i < member_arg_pos; i++) {
+VMReg a =    regs_with_member_name[i].first();
+VMReg b = regs_without_member_name[i].first();
+assert(a->value() == b->value(), err_msg_res("register allocation mismatch: a=%d, b=%d", a->value(), b->value()));
+}
+assert(regs_with_member_name[member_arg_pos].first()->is_valid(), "bad member arg");
+}
+#endif
 // ---------------------------------------------------------------------------
 // We are calling the interpreter via a c2i. Normally this would mean that
 // we were called by a compiled method. However we could have lost a race
 // where we went int -> i2c -> c2i and so the caller could in fact be
 // interpreted. If the caller is compiled we attempt to patch the caller
 // so he no longer calls into the interpreter.
-IRT_LEAF(void, SharedRuntime::fixup_callers_callsite(methodOopDesc* method, address caller_pc))
+IRT_LEAF(void, SharedRuntime::fixup_callers_callsite(Method* method, address caller_pc))
-methodOop moop(method);
+Method* moop(method);
-assert(moop->is_oop(false) && moop->is_method(), "method oop from call site is invalid");
 address entry_point = moop->from_compiled_entry();
 // It's possible that deoptimization can occur at a call site which hasn't
 // been resolved yet, in which case this function will be called from
 // an nmethod that has been patched for deopt and we can ignore the
 // request for a fixup.
 // Also it is possible that we lost a race in that from_compiled_entry
 // is now back to the i2c in that case we don't need to patch and if
 // we did we'd leap into space because the callsite needs to use
-// "to interpreter" stub in order to load up the methodOop. Don't
+// "to interpreter" stub in order to load up the Method*. Don't
 // ask me how I know this...
 CodeBlob* cb = CodeCache::find_blob(caller_pc);
 if (!cb->is_nmethod() || entry_point == moop->get_c2i_entry()) {
 return;
 static int _size_histogram[MAX_ARITY];      // histogram of arg size in words
 static int _max_arity;                      // max. arity seen
 static int _max_size;                       // max. arg size seen
 static void add_method_to_histogram(nmethod* nm) {
-methodOop m = nm->method();
+Method* m = nm->method();
 ArgumentCount args(m->signature());
 int arity   = args.size() + (m->is_static() ? 0 : 1);
 int argsize = m->size_of_parameters();
 arity   = MIN2(arity, MAX_ARITY-1);
 argsize = MIN2(argsize, MAX_ARITY-1);
 }
 entry->relocate(B->content_begin());
 #ifndef PRODUCT
 // debugging suppport
 if (PrintAdapterHandlers || PrintStubCode) {
+ttyLocker ttyl;
 entry->print_adapter_on(tty);
 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(), insts_size);
 tty->print_cr("c2i argument handler starts at %p",entry->get_c2i_entry());
 if (Verbose || PrintStubCode) {
 address first_pc = entry->base_address();
-if (first_pc != NULL)
+if (first_pc != NULL) {
 Disassembler::decode(first_pc, first_pc + insts_size);
+tty->cr();
+}
 }
 }
 #endif
 _adapters->add(entry);
 double locs_buf[20];
 buffer.insts()->initialize_shared_locs((relocInfo*)locs_buf, sizeof(locs_buf) / sizeof(relocInfo));
 MacroAssembler _masm(&buffer);
 // Fill in the signature array, for the calling-convention call.
-int total_args_passed = method->size_of_parameters();
+const int total_args_passed = method->size_of_parameters();
-BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType,total_args_passed);
+BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, total_args_passed);
-VMRegPair*   regs = NEW_RESOURCE_ARRAY(VMRegPair,total_args_passed);
+VMRegPair*   regs = NEW_RESOURCE_ARRAY(VMRegPair, total_args_passed);
 int i=0;
 if( !method->is_static() )  // Pass in receiver first
 sig_bt[i++] = T_OBJECT;
 SignatureStream ss(method->signature());
 for( ; !ss.at_return_type(); ss.next()) {
 sig_bt[i++] = ss.type();  // Collect remaining bits of signature
 if( ss.type() == T_LONG || ss.type() == T_DOUBLE )
 sig_bt[i++] = T_VOID;   // Longs & doubles take 2 Java slots
 }
-assert( i==total_args_passed, "" );
+assert(i == total_args_passed, "");
 BasicType ret_type = ss.type();
 // Now get the compiled-Java layout as input (or output) arguments.
 // NOTE: Stubs for compiled entry points of method handle intrinsics
 // are just trampolines so the argument registers must be outgoing ones.
 // Generate the compiled-to-native wrapper code
 nm = SharedRuntime::generate_native_wrapper(&_masm,
 method,
 compile_id,
-total_args_passed,
+sig_bt,
-comp_args_on_stack,
+regs,
-sig_bt,regs,
 ret_type);
 }
 }
 // Must unlock before calling set_code
 typeArrayOop jlsValue  = java_lang_String::value(src);
 int          jlsOffset = java_lang_String::offset(src);
 int          jlsLen    = java_lang_String::length(src);
 jchar*       jlsPos    = (jlsLen == 0) ? NULL :
 jlsValue->char_at_addr(jlsOffset);
-assert(typeArrayKlass::cast(jlsValue->klass())->element_type() == T_CHAR, "compressed string");
+assert(TypeArrayKlass::cast(jlsValue->klass())->element_type() == T_CHAR, "compressed string");
 (void) UNICODE::as_utf8(jlsPos, jlsLen, (char *)dst, max_dtrace_string_size);
 }
 #endif // ndef HAVE_DTRACE_H
 // -------------------------------------------------------------------------
 }
 // QQQ we could place number of active monitors in the array so that compiled code
 // could double check it.
-methodOop moop = fr.interpreter_frame_method();
+Method* 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, mtCode);

Mercurial > hg > graal-compiler

comparison src/share/vm/runtime/sharedRuntime.cpp @ 6948:e522a00b91aa