src/share/vm/runtime/sharedRuntime.cpp

*** 2569,2601 ****
    return true;
  }
  #endif
  
  
! // Create a native wrapper for this native method.  The wrapper converts the
! // java compiled calling convention to the native convention, handlizes
! // arguments, and transitions to native.  On return from the native we transition
! // 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->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
      nm = method->code();
!     if (nm) {
!       return nm;
      }
  
!     ResourceMark rm;
  
      BufferBlob*  buf = buffer_blob(); // the temporary code buffer in CodeCache
      if (buf != NULL) {
        CodeBuffer buffer(buf);
        double locs_buf[20];
        buffer.insts()->initialize_shared_locs((relocInfo*)locs_buf, sizeof(locs_buf) / sizeof(relocInfo));
--- 2569,2606 ----
    return true;
  }
  #endif
  
  
! /**
!  * Create a native wrapper for this native method.  The wrapper converts the
!  * Java-compiled calling convention to the native convention, handles
!  * arguments, and transitions to native.  On return from the native we transition
!  * back to java blocking if a safepoint is in progress.
!  */
! void AdapterHandlerLibrary::create_native_wrapper(methodHandle method) {
    ResourceMark rm;
    nmethod* nm = NULL;
  
    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
      nm = method->code();
!     if (nm != NULL) {
!       return;
      }
  
!     const int compile_id = CompileBroker::assign_compile_id(method, CompileBroker::standard_entry_bci);
!     assert(compile_id > 0, "Must generate native wrapper");
  
+ 
+     ResourceMark rm;
      BufferBlob*  buf = buffer_blob(); // the temporary code buffer in CodeCache
      if (buf != NULL) {
        CodeBuffer buffer(buf);
        double locs_buf[20];
        buffer.insts()->initialize_shared_locs((relocInfo*)locs_buf, sizeof(locs_buf) / sizeof(relocInfo));
*** 2623,2656 ****
        // 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,
!                                                   sig_bt,
!                                                   regs,
!                                                   ret_type);
      }
    }
  
-   // Must unlock before calling set_code
  
    // Install the generated code.
    if (nm != NULL) {
      if (PrintCompilation) {
        ttyLocker ttyl;
        CompileTask::print_compilation(tty, nm, method->is_static() ? "(static)" : "");
      }
-     method->set_code(method, nm);
      nm->post_compiled_method_load_event();
    } else {
      // CodeCache is full, disable compilation
      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
--- 2628,2657 ----
        // 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, sig_bt, regs, ret_type);
! 
!       if (nm != NULL) {
!         method->set_code(method, nm);
        }
      }
+   } // Unlock AdapterHandlerLibrary_lock
  
  
    // Install the generated code.
    if (nm != NULL) {
      if (PrintCompilation) {
        ttyLocker ttyl;
        CompileTask::print_compilation(tty, nm, method->is_static() ? "(static)" : "");
      }
      nm->post_compiled_method_load_event();
    } else {
      // CodeCache is full, disable compilation
      CompileBroker::handle_full_code_cache();
    }
  }
  
  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