truffle: src/share/vm/runtime/sharedRuntime.cpp comparison

comparison src/share/vm/runtime/sharedRuntime.cpp @ 1330:4a9cc99938e3

Merge

author	acorn
date	Fri, 26 Mar 2010 11:10:26 -0400
parents	9eba43136cb5
children	93767e6a2dfd

comparison

equal deleted inserted replaced

-:84043c7507b9
+:4a9cc99938e3
 //
 // exception_handler_for_return_address(...) returns the continuation address.
 // The continuation address is the entry point of the exception handler of the
 // previous frame depending on the return address.
-address SharedRuntime::raw_exception_handler_for_return_address(address return_address) {
+address SharedRuntime::raw_exception_handler_for_return_address(JavaThread* thread, address return_address) {
 assert(frame::verify_return_pc(return_address), "must be a return pc");
 // the fastest case first
 CodeBlob* blob = CodeCache::find_blob(return_address);
 if (blob != NULL && blob->is_nmethod()) {
 nmethod* code = (nmethod*)blob;
 assert(code != NULL, "nmethod must be present");
+// Check if the return address is a MethodHandle call site.
+thread->set_is_method_handle_exception(code->is_method_handle_return(return_address));
 // native nmethods don't have exception handlers
 assert(!code->is_native_method(), "no exception handler");
 assert(code->header_begin() != code->exception_begin(), "no exception handler");
 if (code->is_deopt_pc(return_address)) {
 return SharedRuntime::deopt_blob()->unpack_with_exception();
 if (CodeCache::contains(return_address)) {
 CodeBlob* blob = CodeCache::find_blob(return_address);
 if (blob->is_nmethod()) {
 nmethod* code = (nmethod*)blob;
 assert(code != NULL, "nmethod must be present");
+// Check if the return address is a MethodHandle call site.
+thread->set_is_method_handle_exception(code->is_method_handle_return(return_address));
 assert(code->header_begin() != code->exception_begin(), "no exception handler");
 return code->exception_begin();
 }
 if (blob->is_runtime_stub()) {
 ShouldNotReachHere();   // callers are responsible for skipping runtime stub frames
 ShouldNotReachHere();
 return NULL;
 }
-JRT_LEAF(address, SharedRuntime::exception_handler_for_return_address(address return_address))
+JRT_LEAF(address, SharedRuntime::exception_handler_for_return_address(JavaThread* thread, address return_address))
-return raw_exception_handler_for_return_address(return_address);
+return raw_exception_handler_for_return_address(thread, return_address);
 JRT_END
 address SharedRuntime::get_poll_stub(address pc) {
 address stub;
 // Look up the code blob
 CodeBlob *cb = CodeCache::find_blob(pc);
 // synchonized methods since the unlock path isn't represented in
 // the bytecodes.
 t = table.entry_for(catch_pco, -1, 0);
 }
-#ifdef COMPILER1
-if (nm->is_compiled_by_c1() && t == NULL && handler_bci == -1) {
-// Exception is not handled by this frame so unwind.  Note that
-// this is not the same as how C2 does this.  C2 emits a table
-// entry that dispatches to the unwind code in the nmethod.
-return NULL;
-}
-#endif /* COMPILER1 */
 if (t == NULL) {
 tty->print_cr("MISSING EXCEPTION HANDLER for pc " INTPTR_FORMAT " and handler bci %d", ret_pc, handler_bci);
 tty->print_cr("   Exception:");
 exception->print();
 tty->cr();
 // 1. Inline-cache check in C2I handler blob,
 // 2. Inline-cache check in nmethod, or
 // 3. Implict null exception in nmethod
 if (!cb->is_nmethod()) {
-guarantee(cb->is_adapter_blob(),
+guarantee(cb->is_adapter_blob() || cb->is_method_handles_adapter_blob(),
 "exception happened outside interpreter, nmethods and vtable stubs (1)");
 // There is no handler here, so we will simply unwind.
 return StubRoutines::throw_NullPointerException_at_call_entry();
 }
 ResourceMark rm(thread);
 RegisterMap cbl_map(thread, false);
 frame caller_frame = thread->last_frame().sender(&cbl_map);
-CodeBlob* cb = caller_frame.cb();
+CodeBlob* caller_cb = caller_frame.cb();
-guarantee(cb != NULL && cb->is_nmethod(), "must be called from nmethod");
+guarantee(caller_cb != NULL && caller_cb->is_nmethod(), "must be called from nmethod");
+nmethod* caller_nm = caller_cb->as_nmethod_or_null();
 // make sure caller is not getting deoptimized
 // and removed before we are done with it.
 // CLEANUP - with lazy deopt shouldn't need this lock
-nmethodLocker caller_lock((nmethod*)cb);
+nmethodLocker caller_lock(caller_nm);
 // determine call info & receiver
 // note: a) receiver is NULL for static calls
 //       b) an exception is thrown if receiver is NULL for non-static calls
 callee_method->print_short_name(tty);
 tty->print_cr(" code: " INTPTR_FORMAT, callee_method->code());
 }
 #endif
+// JSR 292
+// If the resolved method is a MethodHandle invoke target the call
+// site must be a MethodHandle call site.
+if (callee_method->is_method_handle_invoke()) {
+assert(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
 // not been deoptimized.  Return values: For a virtual call this is an
 // virtual this is just a destination address.
 StaticCallInfo static_call_info;
 CompiledICInfo virtual_call_info;
 // Make sure the callee nmethod does not get deoptimized and removed before
 // we are done patching the code.
-nmethod* nm = callee_method->code();
+nmethod* callee_nm = callee_method->code();
-nmethodLocker nl_callee(nm);
+nmethodLocker nl_callee(callee_nm);
 #ifdef ASSERT
-address dest_entry_point = nm == NULL ? 0 : nm->entry_point(); // used below
+address dest_entry_point = callee_nm == NULL ? 0 : callee_nm->entry_point(); // used below
 #endif
 if (is_virtual) {
 assert(receiver.not_null(), "sanity check");
 bool static_bound = call_info.resolved_method()->can_be_statically_bound();
 #endif
 // ---------------------------------------------------------------------------
 // Implementation of AdapterHandlerLibrary
-const char* AdapterHandlerEntry::name = "I2C/C2I adapters";
 AdapterHandlerTable* AdapterHandlerLibrary::_adapters = NULL;
 AdapterHandlerEntry* AdapterHandlerLibrary::_abstract_method_handler = NULL;
 const int AdapterHandlerLibrary_size = 16*K;
 BufferBlob* AdapterHandlerLibrary::_buffer = NULL;
 assert(ic_miss != NULL, "must have handler");
 ResourceMark rm;
 NOT_PRODUCT(int code_size);
-BufferBlob *B = NULL;
+AdapterBlob* B = NULL;
 AdapterHandlerEntry* entry = NULL;
 AdapterFingerPrint* fingerprint = NULL;
 {
 MutexLocker mu(AdapterHandlerLibrary_lock);
 // make sure data structure is initialized
 // Make a C heap allocated version of the fingerprint to store in the adapter
 fingerprint = new AdapterFingerPrint(total_args_passed, sig_bt);
 // Create I2C & C2I handlers
-BufferBlob*  buf = buffer_blob(); // the temporary code buffer in CodeCache
+BufferBlob* buf = buffer_blob(); // the temporary code buffer in CodeCache
 if (buf != NULL) {
 CodeBuffer buffer(buf->instructions_begin(), buf->instructions_size());
 short buffer_locs[20];
 buffer.insts()->initialize_shared_locs((relocInfo*)buffer_locs,
 sizeof(buffer_locs)/sizeof(relocInfo));
 entry->save_code(buf->instructions_begin(), buffer.code_size(), total_args_passed, sig_bt);
 }
 }
 #endif
-B = BufferBlob::create(AdapterHandlerEntry::name, &buffer);
+B = AdapterBlob::create(&buffer);
 NOT_PRODUCT(code_size = buffer.code_size());
 }
 if (B == NULL) {
 // CodeCache is full, disable compilation
 // Ought to log this but compile log is only per compile thread
 if (B != NULL) {
 char blob_id[256];
 jio_snprintf(blob_id,
 sizeof(blob_id),
 "%s(%s)@" PTR_FORMAT,
-AdapterHandlerEntry::name,
+B->name(),
 fingerprint->as_string(),
 B->instructions_begin());
 VTune::register_stub(blob_id, B->instructions_begin(), B->instructions_end());
 Forte::register_stub(blob_id, B->instructions_begin(), B->instructions_end());

Mercurial > hg > truffle

comparison src/share/vm/runtime/sharedRuntime.cpp @ 1330:4a9cc99938e3