*** old/src/share/vm/runtime/sharedRuntime.cpp	Tue Jan  7 07:59:29 2014
--- new/src/share/vm/runtime/sharedRuntime.cpp	Tue Jan  7 07:59:29 2014

*** 2569,2601 ****
--- 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, 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) {
+ /**
+  * 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
!     // 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 nm;
      }
  
!     ResourceMark rm;
!     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 ****
--- 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);
                                                    method,
                                                    compile_id,
                                                    sig_bt,
                                                    regs,
                                                    ret_type);
+ 
+       if (nm != NULL) {
+         method->set_code(method, nm);
        }
      }
+   } // Unlock AdapterHandlerLibrary_lock
  
    // 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