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

comparison src/share/vm/runtime/sharedRuntime.cpp @ 4970:33df1aeaebbf

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

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Mon, 27 Feb 2012 13:10:13 +0100
parents	6336b144e391 09d00c18e323
children	18a5539bf19b

comparison

equal deleted inserted replaced

-:2cfb7fb2dce7
+:33df1aeaebbf
 /*
-* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2012, 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.
 //----------------------------generate_ricochet_blob---------------------------
 void SharedRuntime::generate_ricochet_blob() {
 if (!EnableInvokeDynamic)  return;  // leave it as a null
-#ifndef TARGET_ARCH_NYI_6939861
 // 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);
 assert(false, "bad ricochet blob");
 return;
 }
 _ricochet_blob = RicochetBlob::create(&buffer, bounce_offset, exception_offset, frame_size_in_words);
-#endif
 }
 #include <math.h>
 // and processed.
 // For stack overflow in deoptimization blob, cleanup thread.
 if (thread->deopt_mark() != NULL) {
 Deoptimization::cleanup_deopt_info(thread, NULL);
 }
+Events::log_exception(thread, "StackOverflowError at " INTPTR_FORMAT, pc);
 return StubRoutines::throw_StackOverflowError_entry();
 }
 case IMPLICIT_NULL: {
 if (VtableStubs::contains(pc)) {
 // If vt_stub is NULL, then return NULL to signal handler to report the SEGV error.
 if (vt_stub == NULL) return NULL;
 if (vt_stub->is_abstract_method_error(pc)) {
 assert(!vt_stub->is_vtable_stub(), "should never see AbstractMethodErrors from vtable-type VtableStubs");
+Events::log_exception(thread, "AbstractMethodError at " INTPTR_FORMAT, pc);
 return StubRoutines::throw_AbstractMethodError_entry();
 } else {
+Events::log_exception(thread, "NullPointerException at vtable entry " INTPTR_FORMAT, pc);
 return StubRoutines::throw_NullPointerException_at_call_entry();
 }
 } else {
 CodeBlob* cb = CodeCache::find_blob(pc);
 // 3. Implict null exception in nmethod
 if (!cb->is_nmethod()) {
 guarantee(cb->is_adapter_blob() || cb->is_method_handles_adapter_blob(),
 "exception happened outside interpreter, nmethods and vtable stubs (1)");
+Events::log_exception(thread, "NullPointerException in code blob at " INTPTR_FORMAT, pc);
 // There is no handler here, so we will simply unwind.
 return StubRoutines::throw_NullPointerException_at_call_entry();
 }
 // Otherwise, it's an nmethod.  Consult its exception handlers.
 if (nm->inlinecache_check_contains(pc)) {
 // exception happened inside inline-cache check code
 // => the nmethod is not yet active (i.e., the frame
 // is not set up yet) => use return address pushed by
 // 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();
 }
 #ifndef PRODUCT
 _implicit_null_throws++;
 assert(exception_kind == IMPLICIT_NULL || exception_kind == IMPLICIT_DIVIDE_BY_ZERO, "wrong implicit exception kind");
 // for AbortVMOnException flag
 NOT_PRODUCT(Exceptions::debug_check_abort("java.lang.NullPointerException"));
 if (exception_kind == IMPLICIT_NULL) {
-Events::log("Implicit null exception at " INTPTR_FORMAT " to " INTPTR_FORMAT, pc, target_pc);
+Events::log_exception(thread, "Implicit null exception at " INTPTR_FORMAT " to " INTPTR_FORMAT, pc, target_pc);
 } else {
-Events::log("Implicit division by zero exception at " INTPTR_FORMAT " to " INTPTR_FORMAT, pc, target_pc);
+Events::log_exception(thread, "Implicit division by zero exception at " INTPTR_FORMAT " to " INTPTR_FORMAT, pc, target_pc);
 }
 return target_pc;
 }
 ShouldNotReachHere();
 // so no update to the caller is needed.
 if (caller.is_compiled_frame() && !caller.is_deoptimized_frame()) {
 address pc = caller.pc();
-Events::log("update call-site at pc " INTPTR_FORMAT, pc);
 // Default call_addr is the location of the "basic" call.
 // Determine the address of the call we a reresolving. With
 // Inline Caches we will always find a recognizable call.
 // With Inline Caches disabled we may or may not find a
 CompileBroker::handle_full_code_cache();
 }
 return nm;
 }
+JRT_ENTRY_NO_ASYNC(void, SharedRuntime::block_for_jni_critical(JavaThread* thread))
+assert(thread == JavaThread::current(), "must be");
+// The code is about to enter a JNI lazy critical native method and
+// _needs_gc is true, so if this thread is already in a critical
+// section then just return, otherwise this thread should block
+// until needs_gc has been cleared.
+if (thread->in_critical()) {
+return;
+}
+// Lock and unlock a critical section to give the system a chance to block
+GC_locker::lock_critical(thread);
+GC_locker::unlock_critical(thread);
+JRT_END
 #ifdef HAVE_DTRACE_H
 // Create a dtrace nmethod for this method.  The wrapper converts the
 // java compiled calling convention to the native convention, makes a dummy call
 // (actually nops for the size of the call instruction, which become a trap if
 // probe is enabled). The returns to the caller. Since this all looks like a

Mercurial > hg > truffle

comparison src/share/vm/runtime/sharedRuntime.cpp @ 4970:33df1aeaebbf