src/share/vm/compiler/compileBroker.cpp

*** 130,142 ****
  volatile jint CompileBroker::_should_compile_new_jobs = run_compilation;
  
  // The installed compiler(s)
  AbstractCompiler* CompileBroker::_compilers[2];
  
! // These counters are used for assigning id's to each compilation
! uint CompileBroker::_compilation_id        = 0;
! uint CompileBroker::_osr_compilation_id    = 0;
  
  // Debugging information
  int  CompileBroker::_last_compile_type     = no_compile;
  int  CompileBroker::_last_compile_level    = CompLevel_none;
  char CompileBroker::_last_method_compiled[CompileBroker::name_buffer_length];
--- 130,142 ----
  volatile jint CompileBroker::_should_compile_new_jobs = run_compilation;
  
  // The installed compiler(s)
  AbstractCompiler* CompileBroker::_compilers[2];
  
! // These counters are used to assign each compilation an unique ID
! volatile jint CompileBroker::_compilation_id        = 0;
! volatile jint CompileBroker::_osr_compilation_id    = 0;
  
  // Debugging information
  int  CompileBroker::_last_compile_type     = no_compile;
  int  CompileBroker::_last_compile_level    = CompLevel_none;
  char CompileBroker::_last_method_compiled[CompileBroker::name_buffer_length];
*** 1156,1166 ****
      }
  
      // We now know that this compilation is not pending, complete,
      // or prohibited.  Assign a compile_id to this compilation
      // and check to see if it is in our [Start..Stop) range.
!     uint compile_id = assign_compile_id(method, osr_bci);
      if (compile_id == 0) {
        // The compilation falls outside the allowed range.
        return;
      }
  
--- 1156,1166 ----
      }
  
      // We now know that this compilation is not pending, complete,
      // or prohibited.  Assign a compile_id to this compilation
      // and check to see if it is in our [Start..Stop) range.
!     int compile_id = assign_compile_id(method, osr_bci);
      if (compile_id == 0) {
        // The compilation falls outside the allowed range.
        return;
      }
  
*** 1303,1324 ****
    }
  
    // do the compilation
    if (method->is_native()) {
      if (!PreferInterpreterNativeStubs || method->is_method_handle_intrinsic()) {
-       // Acquire our lock.
-       int compile_id;
-       {
-         MutexLocker locker(MethodCompileQueue_lock, THREAD);
-         compile_id = assign_compile_id(method, standard_entry_bci);
-       }
        // To properly handle the appendix argument for out-of-line calls we are using a small trampoline that
        // pops off the appendix argument and jumps to the target (see gen_special_dispatch in SharedRuntime).
        //
        // Since normal compiled-to-compiled calls are not able to handle such a thing we MUST generate an adapter
        // in this case.  If we can't generate one and use it we can not execute the out-of-line method handle calls.
!       (void) AdapterHandlerLibrary::create_native_wrapper(method, compile_id);
      } else {
        return NULL;
      }
    } else {
      // If the compiler is shut off due to code cache getting full
--- 1303,1318 ----
    }
  
    // do the compilation
    if (method->is_native()) {
      if (!PreferInterpreterNativeStubs || method->is_method_handle_intrinsic()) {
        // To properly handle the appendix argument for out-of-line calls we are using a small trampoline that
        // pops off the appendix argument and jumps to the target (see gen_special_dispatch in SharedRuntime).
        //
        // Since normal compiled-to-compiled calls are not able to handle such a thing we MUST generate an adapter
        // in this case.  If we can't generate one and use it we can not execute the out-of-line method handle calls.
!       AdapterHandlerLibrary::create_native_wrapper(method);
      } else {
        return NULL;
      }
    } else {
      // If the compiler is shut off due to code cache getting full
*** 1417,1454 ****
    }
  
    return false;
  }
  
! 
! // ------------------------------------------------------------------
! // CompileBroker::assign_compile_id
! //
! // Assign a serialized id number to this compilation request.  If the
! // number falls out of the allowed range, return a 0.  OSR
! // compilations may be numbered separately from regular compilations
! // if certain debugging flags are used.
! uint CompileBroker::assign_compile_id(methodHandle method, int osr_bci) {
!   assert(MethodCompileQueue_lock->owner() == Thread::current(),
!          "must hold the compilation queue lock");
    bool is_osr = (osr_bci != standard_entry_bci);
!   uint id;
    if (CICountOSR && is_osr) {
!     id = ++_osr_compilation_id;
!     if ((uint)CIStartOSR <= id && id < (uint)CIStopOSR) {
        return id;
      }
    } else {
!     id = ++_compilation_id;
!     if ((uint)CIStart <= id && id < (uint)CIStop) {
        return id;
      }
    }
  
    // Method was not in the appropriate compilation range.
    method->set_not_compilable_quietly();
    return 0;
  }
  
  
  // ------------------------------------------------------------------
  // CompileBroker::is_compile_blocking
--- 1411,1453 ----
    }
  
    return false;
  }
  
! /**
!  * Generate serialized IDs for compilation requests. If certain debugging flags are used
!  * and the ID is within the specified range, the method is not compiled and 0 is returned.
!  * The functions also allows to generate separate compilation IDs for OSR compilations.
!  */
! int CompileBroker::assign_compile_id(methodHandle method, int osr_bci) {
! #ifdef ASSERT
    bool is_osr = (osr_bci != standard_entry_bci);
!   int id;
    if (CICountOSR && is_osr) {
!     id = Atomic::add(1, &_osr_compilation_id);
!     if (CIStartOSR <= id && id < CIStopOSR) {
        return id;
      }
    } else {
!     id = Atomic::add(1, &_compilation_id);
!     if (CIStart <= id && id < CIStop) {
        return id;
      }
    }
  
+   // The compilation falls outside the allowed range. Note that this can only happen in debug
+   // build if the CIStart(OSR) and CIStop(OSR) flags are specified.  Method handle intrinsics
+   // (8026407) must currently be generated, so fail with an assert.
+   assert(!method->is_method_handle_intrinsic(),
+          "Must generate wrapper for method handle intrinsic but compilation is outside allowed range.");
+ 
    // Method was not in the appropriate compilation range.
    method->set_not_compilable_quietly();
    return 0;
+ #else
+   return Atomic::add(1, &_compilation_id);
+ #endif
  }
  
  
  // ------------------------------------------------------------------
  // CompileBroker::is_compile_blocking