United StatesChange Country, Oracle Worldwide Web Sites Communities I am a... I want to...
JDK-5040492 : Async exception installed during monitorenter.

Details
Type:
Bug
Submit Date:
2004-04-30
Status:
Closed
Updated Date:
2012-10-08
Project Name:
JDK
Resolved Date:
2004-06-15
Component:
hotspot
OS:
solaris_8
Sub-Component:
runtime
CPU:
generic
Priority:
P3
Resolution:
Fixed
Affected Versions:
1.4.2_04
Fixed Versions:
1.4.2_06 (06)

Related Reports
Backport:

Sub Tasks

Description
The JVM is crashing during deoptimization, with an async. exception pending -
an illegal state to be in.


This is within ApplicationServer.  An example from the log file with 1.4.1_02:

[15/Apr/2004:10:25:42] WARNING ( 9367): CORE3283: stderr: #
[15/Apr/2004:10:25:42] WARNING ( 9367): CORE3283: stderr: # HotSpot Virtual Machine Error, Internal Error  
[15/Apr/2004:10:25:42] WARNING ( 9367): CORE3283: stderr: # Please report this error at  
[15/Apr/2004:10:25:42] WARNING ( 9367): CORE3283: stderr: # http://java.sun.com/cgi-bin/bugreport.cgi  
[15/Apr/2004:10:25:42] WARNING ( 9367): CORE3283: stderr: #
[15/Apr/2004:10:25:42] WARNING ( 9367): CORE3283: stderr: # Java VM: Java HotSpot(TM) Server VM (1.4.1_02-b06 mixed mode)  
[15/Apr/2004:10:25:42] WARNING ( 9367): CORE3283: stderr: #
[15/Apr/2004:10:25:42] WARNING ( 9367): CORE3283: stderr: # Error ID: 564652414D453F48500E43505000DA 01  
[15/Apr/2004:10:25:42] WARNING ( 9367): CORE3283: stderr: #
[15/Apr/2004:10:25:42] WARNING ( 9367): CORE3283: stderr: # Problematic Thread: 
prio=5 tid=0xb9c9f8 nid=0x24d9b runnable  
[15/Apr/2004:10:25:42] WARNING ( 9367): CORE3283: stderr: #


Error ID from 1.4.2_04 is 564652414D453F48500E43505000EE

The following is a dbx stacktrace with additional information from the Serviceability Agent:


t@108193 (l@108193) terminated by signal ABRT (Abort)
0xfe29f240: __lwp_kill+0x0008:  bgeu,a  __lwp_kill+0x1c
dbx>where -l
current thread: t@108193
=>[1] libc.so.1:__lwp_kill(0x0, 0x1a6a1, 0x0, 0xfe2bc008, 0xfe328000, 0x0), at 0xfe29f240 
  [2] libc.so.1:raise(0x6, 0x0, 0x0, 0xffffffff, 0xfe2c03c4, 0x0), at 0xfe24bce0 
  [3] libc.so.1:abort(0xfe2bc008, 0x705ee238, 0x0, 0x4, 0x0, 0x705ee259), at 0xfe235984 
  [4] libjvm.so:os::abort(0x1, 0xfdd39002, 0x705eeab8, 0xfdd6da1a, 0xfdd6d9b2, 0xff0000), at 0xfdc98498 
  [5] libjvm.so:report_error(0x705eead2, 0xfddc6ab4, 0xfdd38dcc, 0xfdd6a714, 0xfdd38e15, 0x705eec18), at 0xfdb7e454 
  [6] libjvm.so:report_fatal(0xfdd6a6cc, 0xee, 0xfdd6a715, 0x1, 0x705ef494, 0xffff), at 0xfdb7d9dc 
  [7] libjvm.so:deoptimizedVFrame::unpack_vframe_on_stack(0x1, 0x0, 0x0, 0x705ef528, 0xf50fc2b6, 0x0), at 0xfdcf7d08 
  [8] libjvm.so:vframeArray::unpack_to_stack(0x906ff0, 0x705ef818, 0x1, 0x0, 0xf8c35fa4, 0x2c9ade0), at 0xfdcf71c8 
  [9] libjvm.so:Deoptimization::unpack_frames(0x87c390, 0x1, 0x705ef678, 0x1, 0x1, 0x0), at 0xfda7b6f4 

  [10] 0xf8c35f9c(0x8f311810, 0xf8c35e60, 0x2a98030, 0x193ffac, 0x0, 0x0), at 0xf8c35f9b 
Address 0xf8c35f9c: In instructions in sun.jvm.hotspot.code.DeoptimizationBlob 
instructions: [0xf8c35e60, 0xf8c35fcc),  data: [0xf8c35fcc, 0xf8c35fcc),  oops: [0xf8c35fcc, 0xf8c35fcc),  frame size: 112


  [11] 0xf8c063e0(0x8f311810, 0xf8c35e60, 0x2a98030, 0x193ffa8, 0x1, 0x0), at 0xf8c063df 
Address 0xf8c063e0: In interpreter codelet "deoptimization entry points"
deoptimization entry points [0xf8c05eb0, 0xf8c092c0)  13328 bytes  not safepoint safe


  [12] 0xf8c05804(0x8f311810, 0xf8c35e60, 0xf595a54c, 0x193ffa4, 0x4, 0x705ef958), at 0xf8c05803 
Address 0xf8c05804: In interpreter codelet "return entry points"
return entry points [0xf8c05310, 0xf8c05ea0)  2960 bytes  not safepoint safe


  [13] 0xf8c3e844(0x8f311810, 0xf8c35e60, 0x2a98030, 0x193ffa0, 0x0, 0x705ef9e8), at 0xf8c3e843 
Address 0xf8c3e844: In instructions in sun.jvm.hotspot.code.C2IAdapter instructions: [0xf8c3e7e0, 0xf8c3e880),  data: [0xf8c3e880, 0xf8c3e880),  oops: [0xf8c3e880, 0xf8c3e880),  frame size: 80

  [14] 0xf8d5b438(0x8f2de9c0, 0x91a97888, 0x0, 0x40, 0x0, 0x91a978d0), at 0xf8d5b437 
Address 0xf8d5b438: In instructions in NMethod for java/io/DataInputStream.readFully([BII)V instructions: [0xf8d5b3c0, 0xf8d5b588),  data: [0xf8d5b588, 0xf8d5b714),  oops: [0xf8d5b6d8, 0xf8d5b6e7),  frame size: 64

  [15] 0xf8eee228(0xf4ae7020, 0x8f2df910, 0x0, 0x8f2dd778, 0xf576b730, 0x8f3114e0), at 0xf8eee227 
Address 0xf8eee228: In instructions in NMethod for bea/jolt/NwReader.run()V instructions: [0xf8eede00, 0xf8eef2a8),  data: [0xf8eef2a8, 0xf8ef040c),  oops: [0xf8ef0210, 0xf8ef028f),  frame size: 112

  [16] 0xf8c5f980(0x705efba0, 0x0, 0x0, 0x705efbc0, 0x467860, 0xfd90ce30), at 0xf8c5f97f 
Address 0xf8c5f980: In instructions in sun.jvm.hotspot.code.I2CAdapter instructions: [0xf8c5f960, 0xf8c5f9a0),  data: [0xf8c5f9a0, 0xf8c5f9a0),  oops: [0xf8c5f9a0, 0xf8c5f9a0),  frame size: 64

  [17] 0xf8c0010c(0x705efc28, 0x705efe90, 0xa, 0xf575ea00, 0x4, 0x705efb40), at 0xf8c0010b 
Address 0xf8c0010c: In instructions in sun.jvm.hotspot.code.BufferBlob instructions: [0xf8c00040, 0xf8c04e60),  data: [0xf8c04e60, 0xf8c04e60),  oops: [0xf8c04e60, 0xf8c04e60),  frame size: 0

  [18] libjvm.so:JavaCalls::call_helper(0x705efe88, 0x705efcf0, 0x705efda8, 0x87c390, 0x87c390, 0x705efd00), at 0xfd95d48c 
  [19] libjvm.so:JavaCalls::call_virtual(0xfdd70000, 0x1237b58, 0x705efd9c, 0x705efd98, 0x705efda8, 0x87c390), at 0xfda4b784 
  [20] libjvm.so:JavaCalls::call_virtual(0x705efe88, 0x705efe84, 0x705efe7c, 0x705efe74, 0x705efe6c, 0x87c390), at 0xfda5e8dc 
  [21] libjvm.so:thread_entry(0x87c390, 0x87c390, 0x26743e8, 0x1237b58, 0x306d10, 0xfda69254), at 0xfda6fc74 
  [22] libjvm.so:JavaThread::run(0x87c390, 0x1a6a1, 0x40, 0x0, 0x40, 0x0), at 0xfda6927c 
  [23] libjvm.so:_start(0x87c390, 0x6f340600, 0x0, 0x0, 0x0, 0x0), at 0xfda6575c 


Core file attached
case-10523972-core-20040420

                                    

Comments
EVALUATION

This is actually the same bug as 4998314. Note that the fix for 4998314
is incorrect and will be replaced with a new fix.


###@###.### 2004-06-09
                                     
2004-06-09
PUBLIC COMMENTS

The JVM is crashing during deoptimization, with an async. exception pending -
an illegal state to be in.
                                     
2004-08-18
SUGGESTED FIX

nd diverting is painful from assembly language.
  //
  
  
! JRT_ENTRY_NO_ASYNC(static address, exception_handler_for_pc_helper(JavaThread* thread, oop ex, address pc, nmethod*& nm))
  
    address continuation = NULL;
    Handle exception(thread, ex);
    pc = thread->safepoint_state()->compute_adjusted_pc(pc);
    nm = CodeCache::find_nmethod(pc);
    assert(nm != NULL, "this is not an nmethod");
  #ifdef ASSERT
    assert(exception.not_null(), "NULL exceptions should be handled by throw_exception");
    assert(exception->is_oop(), "just checking");
    // Check that exception is a subclass of Throwable, otherwise we have a VerifyError

*** 594,614 ****
--- 594,614 ----
    SharedRuntime::throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_ClassCastException(), Klass::cast(obj->klass())->external_name());
  JRT_END
  
  
  JRT_ENTRY(void, Runtime1::throw_incompatible_class_change_error(JavaThread* thread))
    ResourceMark rm(thread);
    SharedRuntime::throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_IncompatibleClassChangeError());
  JRT_END
  
  
  JRT_ENTRY_FOR_MONITORENTER(void, Runtime1::monitorenter(JavaThread* thread, oop obj, BasicObjectLock* lock))
+ JRT_ENTRY_NO_ASYNC(void, Runtime1::monitorenter(JavaThread* thread, oop obj, BasicObjectLock* lock))
    Handle h_obj(thread, obj);
    assert(h_obj()->is_oop(), "must be NULL or an object");
    if (UseFastLocking) {
      // When using fast locking, the compiled code has already tried the fast case
      assert(obj == lock->obj(), "must match");
      ObjectSynchronizer::slow_enter(h_obj, lock->lock(), THREAD);
    } else {
      lock->set_obj(obj);
      ObjectSynchronizer::fast_enter(h_obj, lock->lock(), THREAD);
    }

  }
  
                                     
2004-08-18
SUGGESTED FIX

  #ifdef USE_PRAGMA_IDENT_SRC
- #pragma ident "@(#)vframeArray.cpp    1.122 04/03/19 20:08:11 JVM"
+ #pragma ident "@(#)vframeArray.cpp    1.123 04/06/08 13:02:44 JVM"
  #endif
  /*
   * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
   * SUN PROPRIETARY/CONFIDENTIAL.  Use is subject to license terms.
   */
  
  # include "incls/_precompiled.incl"
  # include "incls/_vframeArray.cpp.incl"
  
  

*** 133,153 ****
--- 133,153 ----
      bcp = method()->bcp_from(bci());
      pc  = Interpreter::continuation_for(method(), bcp, callee_parameters, is_top_frame, use_next_mdp);
    }
    assert(Bytecodes::is_defined(*bcp), "must be a valid bytecode");
  
    // Monitorenter and pending exceptions:
    //
    // For Compiler2, there should be no pending exception when deoptimizing at monitorenter
    // because there is no safepoint at the null pointer check (it is either handled explicitly
    // or prior to the monitorenter) and asynchronous exceptions are not made "pending" by the
-   // runtime interface for the slow case (see JRT_ENTRY_FOR_MONITORENTER).  If an asynchronous 
+   // runtime interface for the slow case (see JRT_ENTRY_NO_ASYNC).  If an asynchronous 
    // exception was processed, the bytecode pointer would have to be extended one bytecode beyond
    // the monitorenter to place it in the proper exception range.
    //
    // For Compiler1, deoptimization can occur while throwing a NullPointerException at monitorenter,
    // in which case bcp should point to the monitorenter since it is within the exception's range.
  
    assert(*bcp != Bytecodes::_monitorenter || is_top_frame, "a _monitorenter must be a top frame");
    COMPILER2_ONLY(guarantee(*bcp != Bytecodes::_monitorenter || exec_mode != Deoptimization::Unpack_exception,
                             "shouldn't get exception during monitorenter");)
  
*** 1,12 ****
--- 1,12 ----
  #ifdef USE_PRAGMA_IDENT_HDR
- #pragma ident "@(#)interfaceSupport.hpp       1.154 03/12/23 16:43:50 JVM"
+ #pragma ident "@(#)interfaceSupport.hpp       1.155 04/06/08 13:02:40 JVM"
  #endif
  /*
   * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
   * SUN PROPRIETARY/CONFIDENTIAL.  Use is subject to license terms.
   */
  
  // Wrapper for all entry points to the virtual machine.
  // The HandleMarkCleaner is a faster version of HandleMark.
  // It relies on the fact that there is a HandleMark further 
  // down the stack (in JavaCalls::call_helper), and just resets

*** 196,224 ****
--- 196,224 ----
      thread->frame_anchor()->make_walkable(thread);
      trans(_thread_in_vm, _thread_blocked); 
    }
    ~ThreadBlockInVM() { 
      trans(_thread_blocked, _thread_in_vm); 
      // We don't need to clear_walkable because it will happen automagically when we return to java
    }
  };
  
  
- // This special transition class is only used for runtime monitorenter/exit
- // calls to prevent asynchronous exceptions from allowing a frame to
- // exit without unlocking (bug 4324348), or leading to a hang (bug 4854693).
- class ThreadInVMfromJavaForMonitorEnterOrExit : public ThreadStateTransition {
+ // This special transition class is only used to prevent asynchronous exceptions
+ // from being installed on vm exit in situations where we can't tolerate them.
+ // See bugs: 4324348, 4854693, 4998314, 5040492, 5050705.
+ class ThreadInVMfromJavaNoAsyncException : public ThreadStateTransition {
   public:
    ThreadInVMfromJavaForMonitorEnterOrExit(JavaThread* thread) : ThreadStateTransition(thread) { 
+   ThreadInVMfromJavaNoAsyncException(JavaThread* thread) : ThreadStateTransition(thread) { 
      trans_from_java(_thread_in_vm); 
    }
-   ~ThreadInVMfromJavaForMonitorEnterOrExit()  {     
+   ~ThreadInVMfromJavaNoAsyncException()  {     
      trans(_thread_in_vm, _thread_in_Java);
      // NOTE: We do not check for pending. async. exceptions.
      // If we did and moved the pending async exception over into the
      // pending exception field, we would need to deopt (currently C2
      // only). However, to do so would require that we transition back
      // to the _thread_in_vm state. Instead we postpone the handling of
      // the async exception.
  
      // Check for pending. suspends only.
      if (_thread->has_special_runtime_exit_condition())

*** 332,364 ****
--- 332,365 ----
      __ENTRY(result_type, header, thread)                                   debug_only(VMEntryWrapper __vew;)
  
  
  #define IRT_LEAF(result_type, header)                                    result_type header {                                                     __LEAF(result_type, header)                                            debug_only(No_Safepoint_Verifier __nspv(true);)
  
  
- #define IRT_ENTRY_FOR_MONITORENTER_OR_EXIT(result_type, header)      + #define IRT_ENTRY_NO_ASYNC(result_type, header)                          result_type header {                                                     ThreadInVMfromJavaForMonitorEnterOrExit __tiv(thread);           +     ThreadInVMfromJavaNoAsyncException __tiv(thread);                      __ENTRY(result_type, header, thread)                                   debug_only(VMEntryWrapper __vew;)
  
  // Another special case for nmethod_entry_point so the nmethod that the
  // interpreter is about to branch to doesn't get flushed before as we
  // branch to it's interpreter_entry_point.  Skip stress testing here too.
+ // Also we don't allow async exceptions because it is just too painful.
  #define IRT_ENTRY_FOR_NMETHOD(result_type, header)                       result_type header {                                                     nmethodLocker _nmlock(nm);                                       !     ThreadInVMfromJavaNoAsyncException __tiv(thread);                                      __ENTRY(result_type, header, thread)
  
  #define IRT_END }
  
  
  // Definitions for JRT (Java (Compiler/Shared) Runtime)
  
  #define JRT_ENTRY(result_type, header)                                   result_type header {                                                     ThreadInVMfromJava __tiv(thread);                                
*** 365,387 ****
--- 366,388 ----
      __ENTRY(result_type, header, thread)                                   debug_only(VMEntryWrapper __vew;)
  
  
  #define JRT_LEAF(result_type, header)                                    result_type header {                                                   __LEAF(result_type, header)                                            debug_only(JRT_Leaf_Verifier __jlv;)
  
  
- #define JRT_ENTRY_FOR_MONITORENTER(result_type, header)              + #define JRT_ENTRY_NO_ASYNC(result_type, header)                          result_type header {                                                     ThreadInVMfromJavaForMonitorEnterOrExit __tiv(thread);           +     ThreadInVMfromJavaNoAsyncException __tiv(thread);                      __ENTRY(result_type, header, thread)                                   debug_only(VMEntryWrapper __vew;)
  
  // Same as JRT Entry but allows for return value after the safepoint
  // to get back into Java from the VM
  #define JRT_BLOCK_ENTRY(result_type, header)                             result_type header {                                                     TRACE_CALL(result_type, header)                                        HandleMarkCleaner __hm(thread);
  
*** 1,12 ****
--- 1,12 ----
  #ifdef USE_PRAGMA_IDENT_SRC
- #pragma ident "@(#)runtime.cpp        1.420 04/04/30 16:46:56 JVM"
+ #pragma ident "@(#)runtime.cpp        1.421 04/06/08 13:02:38 JVM"
  #endif
  /*
   * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
   * SUN PROPRIETARY/CONFIDENTIAL.  Use is subject to license terms.
   */
  
  #include "incls/_precompiled.incl"
  #include "incls/_runtime.cpp.incl"
  
  

*** 525,551 ****
--- 525,552 ----
  
    // create result type (range)
    fields = TypeTuple::fields(0);
  
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
  
    return TypeFunc::make(domain,range);
  }
  
  // Handles the uncommon case in locking, i.e., contention or an inflated lock.
  JRT_ENTRY_FOR_MONITORENTER(void, OptoRuntime::complete_monitor_locking_C(oop obj, BasicLock* lock, JavaThread* thread))
+ JRT_ENTRY_NO_ASYNC(void, OptoRuntime::complete_monitor_locking_C(oop obj, BasicLock* lock, JavaThread* thread))
  #ifndef PRODUCT
    _mon_enter_ctr++;             // monitor enter slow
  #endif
    Handle h_obj(THREAD, obj);
    ObjectSynchronizer::slow_enter(h_obj, lock, THREAD);
  
+   // Should never happen since async's are suppressed. Remove in 1.5.1
    deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
  JRT_END
  
  
  //-----------------------------------------------------------------------------
  const TypeFunc *OptoRuntime::complete_monitor_exit_Type() {
    // create input type (domain)
    const Type **fields = TypeTuple::fields(2);
    fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL;  // Object to be Locked
    fields[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM;   // Address of stack location for lock

*** 982,1002 ****
--- 983,1004 ----
    fields[TypeFunc::Parms+0] = TypeRawPtr::BOTTOM; // Returned result 
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
  
    return TypeFunc::make(domain, range);
  }
  
  address compute_compiled_exc_handler(nmethod* nm, address ret_pc, Handle& exception, bool force_unwind);
  
  // The method is an entry that is always called by a C++ method not
  // directly from compiled code. Compiled code will call the C++ method following.
- JRT_ENTRY(address, OptoRuntime::handle_exception_C_helper(JavaThread* thread, nmethod* &nm))
+ // We can't allow async exception to be installed during  exception processing.
+ JRT_ENTRY_NO_ASYNC(address, OptoRuntime::handle_exception_C_helper(JavaThread* thread, nmethod* &nm))
  
    // Do not confuse exception_oop with pending_exception. The exception_oop
    // is only used to pass arguments into the method. Not for general
    // exception handling.  DO NOT CHANGE IT to use pending_exception, since
    // the runtime stubs checks this on exit.
    assert(thread->exception_oop() != NULL, "exception oop is found");  
    address handler_address = NULL;
  
    Handle exception(thread, thread->exception_oop());
*** 1092,1149 ****
--- 1107,1155 ----
  address OptoRuntime::handle_exception_C(JavaThread* thread) { 
  //
  // We are in Java not VM and in debug mode we have a NoHandleMark
  // 
  #ifndef PRODUCT
    _find_handler_ctr++;          // find exception handler
  #endif
    debug_only(NoHandleMark __hm;)
    nmethod* nm = NULL;
    address handler_address = NULL;
-   bool overwrite_exception = false;
    do {
+   {
      // Enter the VM 
  
      ResetNoHandleMark rnhm;
      handler_address = handle_exception_C_helper(thread, nm);
      overwrite_exception = false;
      if (thread->has_pending_exception()) { 
        // A pending exception could be created during exit from VM (4998314).
        // If a processed exception is not ThreadDeath overwrite it with 
        // the pending exception and process it.
        if (!thread->exception_oop()->is_a(SystemDictionary::threaddeath_klass())) {
          thread->set_exception_oop(thread->pending_exception());
          overwrite_exception = true;
    }
        thread->clear_pending_exception(); // Cleanup a pending exception.
      }
    } while (overwrite_exception);
  
    // Back in java: Use no oops, DON'T safepoint
  
    // Now check to see if the handler we are returning is in a now
    // deoptimized nmethod
  
    if (nm != NULL && nm->is_patched_for_deopt()) {
      handler_address = SharedRuntime::deopt_blob()->unpack_with_exception();
    }
    return handler_address;--- 1,12 ----
  #ifdef USE_PRAGMA_IDENT_SRC
- #pragma ident "@(#)interpreterRuntime.cpp     1.450 04/05/04 15:55:53 JVM"
+ #pragma ident "@(#)interpreterRuntime.cpp     1.451 04/06/08 13:02:37 JVM"
  #endif
  /*
   * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
   * SUN PROPRIETARY/CONFIDENTIAL.  Use is subject to license terms.
   */
  
  #include "incls/_precompiled.incl"
  #include "incls/_interpreterRuntime.cpp.incl"
  
  class UnlockFlagSaver {

*** 462,497 ****
--- 462,497 ----
  // The interpreter's synchronization code is factored out so that it can
  // be shared by method invocation and synchronized blocks.
  //%note synchronization_3
  
  static void trace_locking(Handle& h_locking_obj, bool is_locking) {
    NOT_CORE(ObjectSynchronizer::trace_locking(h_locking_obj, false, true, is_locking);)
  }
  
  
  //%note monitor_1
  IRT_ENTRY_FOR_MONITORENTER_OR_EXIT(void, InterpreterRuntime::monitorenter(JavaThread* thread, BasicObjectLock* elem))
+ IRT_ENTRY_NO_ASYNC(void, InterpreterRuntime::monitorenter(JavaThread* thread, BasicObjectLock* elem))
  #ifdef ASSERT
    thread->last_frame().interpreter_frame_verify_monitor(elem);
  #endif
    Handle h_obj(thread, elem->obj());  
    assert(Universe::heap()->is_in_or_null(h_obj()), "must be NULL or an object");
    ObjectSynchronizer::slow_enter(h_obj, elem->lock(), CHECK);
    assert(Universe::heap()->is_in_or_null(elem->obj()), "must be NULL or an object");
  #ifdef ASSERT
    thread->last_frame().interpreter_frame_verify_monitor(elem);
  #endif
  IRT_END
  
  
  //%note monitor_1
  IRT_ENTRY_FOR_MONITORENTER_OR_EXIT(void, InterpreterRuntime::monitorexit(JavaThread* thread, BasicObjectLock* elem))
+ IRT_ENTRY_NO_ASYNC(void, InterpreterRuntime::monitorexit(JavaThread* thread, BasicObjectLock* elem))
  #ifdef ASSERT
    thread->last_frame().interpreter_frame_verify_monitor(elem);
  #endif
    Handle h_obj(thread, elem->obj());  
    assert(Universe::heap()->is_in_or_null(h_obj()), "must be NULL or an object");
    if (elem == NULL || h_obj()->is_unlocked()) {
      THROW(vmSymbols::java_lang_IllegalMonitorStateException());
    }
    ObjectSynchronizer::slow_exit(h_obj(), elem->lock(), thread);
    // Free entry. This must be done here, since a pending exception might be installed on

- #pragma ident "@(#)c1_Runtime1.cpp    1.206 04/06/03 18:15:05 JVM"
+ #pragma ident "@(#)c1_Runtime1.cpp    1.207 04/06/08 13:02:36 JVM"
  #endif
  //
  // Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
  // SUN PROPRIETARY/CONFIDENTIAL.  Use is subject to license terms.
  //
  
  #include "incls/_precompiled.incl"
  #include "incls/_c1_Runtime1.cpp.incl"
  
  

*** 371,391 ****
--- 371,391 ----
  // otherwise we will unwind the stack and continue at the caller of top frame method
  // Note: we enter in Java using a special JRT wrapper. This wrapper allows us to
  // control the area where we can allow a safepoint. After we exit the safepoint area we can
  // check to see if the handler we are going to return is now in a nmethod that has
  // been deoptimized. If that is the case we return the deopt blob
  // unpack_with_exception entry instead. This makes life for the exception blob easier
  // because making that same check a
                                     
2004-08-18
CONVERTED DATA

BugTraq+ Release Management Values

COMMIT TO FIX:
1.4.2_06
generic
tiger-rc

FIXED IN:
1.4.2_06
tiger-rc

INTEGRATED IN:
1.4.2_06
tiger-b56
tiger-rc


                                     
2004-08-18



Hardware and Software, Engineered to Work Together