*** old/src/share/vm/runtime/sharedRuntime.cpp	Thu Oct 24 12:06:35 2013
--- new/src/share/vm/runtime/sharedRuntime.cpp	Thu Oct 24 12:06:35 2013

*** 2372,2382 ****
--- 2372,2382 ----
    assert(ic_miss != NULL, "must have handler");
  
    ResourceMark rm;
  
    NOT_PRODUCT(int insts_size);
!   AdapterBlob* B = NULL;
!   AdapterBlob* new_adapter = NULL;
    AdapterHandlerEntry* entry = NULL;
    AdapterFingerPrint* fingerprint = NULL;
    {
      MutexLocker mu(AdapterHandlerLibrary_lock);
      // make sure data structure is initialized

*** 2404,2414 ****
--- 2404,2415 ----
      // Lookup method signature's fingerprint
      entry = _adapters->lookup(total_args_passed, sig_bt);
  
  #ifdef ASSERT
      AdapterHandlerEntry* shared_entry = NULL;
      if (VerifyAdapterSharing && entry != NULL) {
+     // Start adapter sharing verification only after the VM is booted.
+     if (VerifyAdapterSharing && (entry != NULL)) {
        shared_entry = entry;
        entry = NULL;
      }
  #endif
  

*** 2420,2472 ****
--- 2421,2475 ----
      int comp_args_on_stack = SharedRuntime::java_calling_convention(sig_bt, regs, total_args_passed, false);
  
      // Make a C heap allocated version of the fingerprint to store in the adapter
      fingerprint = new AdapterFingerPrint(total_args_passed, sig_bt);
  
      // Create I2C & C2I handlers
+     // StubRoutines::code2() is initialized after this function is called. As a result,
+     // VerifyAdapterCalls and VerifyAdapterSharing can fail if we re-use code that generated
+     // prior to StubRoutines::code2() being set.
+     bool contains_all_checks = (StubRoutines::code2() != NULL) || !VerifyAdapterCalls;
  
+     // Create I2C & C2I handlers
      BufferBlob* buf = buffer_blob(); // the temporary code buffer in CodeCache
      if (buf != NULL) {
        CodeBuffer buffer(buf);
        short buffer_locs[20];
        buffer.insts()->initialize_shared_locs((relocInfo*)buffer_locs,
                                               sizeof(buffer_locs)/sizeof(relocInfo));
        MacroAssembler _masm(&buffer);
  
+       MacroAssembler _masm(&buffer);
        entry = SharedRuntime::generate_i2c2i_adapters(&_masm,
                                                       total_args_passed,
                                                       comp_args_on_stack,
                                                       sig_bt,
                                                       regs,
                                                       fingerprint);
  
  #ifdef ASSERT
        if (VerifyAdapterSharing) {
          if (shared_entry != NULL) {
!           assert(shared_entry->compare_code(buf->code_begin(), buffer.insts_size(), total_args_passed, sig_bt),
                   "code must match");
!           assert(shared_entry->compare_code(buf->code_begin(), buffer.insts_size()), "code must match");
            // Release the one just created and return the original
            _adapters->free_entry(entry);
            return shared_entry;
          } else  {
-           entry->save_code(buf->code_begin(), buffer.insts_size(), total_args_passed, sig_bt);
          }
        }
  #endif
  
!       B = AdapterBlob::create(&buffer);
!       new_adapter = AdapterBlob::create(&buffer);
        NOT_PRODUCT(insts_size = buffer.insts_size());
      }
!     if (B == NULL) {
!     if (new_adapter == NULL) {
        // CodeCache is full, disable compilation
        // Ought to log this but compile log is only per compile thread
        // and we're some non descript Java thread.
        MutexUnlocker mu(AdapterHandlerLibrary_lock);
        CompileBroker::handle_full_code_cache();
        return NULL; // Out of CodeCache space
      }
!     entry->relocate(B->content_begin());
!     entry->relocate(new_adapter->content_begin());
  #ifndef PRODUCT
      // debugging suppport
      if (PrintAdapterHandlers || PrintStubCode) {
        ttyLocker ttyl;
        entry->print_adapter_on(tty);

*** 2481,2506 ****
--- 2484,2512 ----
            tty->cr();
          }
        }
      }
  #endif
  
+     // Add the entry only if the entry contains all required checks (see sharedRuntime_xxx.cpp)
+     // The checks are inserted only if -XX:+VerifyAdapterCalls is specified.
+     if (contains_all_checks) {
        _adapters->add(entry);
      }
+   }
    // Outside of the lock
!   if (B != NULL) {
!   if (new_adapter != NULL) {
      char blob_id[256];
      jio_snprintf(blob_id,
                   sizeof(blob_id),
                   "%s(%s)@" PTR_FORMAT,
!                  B->name(),
!                  new_adapter->name(),
                   fingerprint->as_string(),
!                  B->content_begin());
!     Forte::register_stub(blob_id, B->content_begin(), B->content_end());
!                  new_adapter->content_begin());
!     Forte::register_stub(blob_id, new_adapter->content_begin(),new_adapter->content_end());
  
      if (JvmtiExport::should_post_dynamic_code_generated()) {
!       JvmtiExport::post_dynamic_code_generated(blob_id, B->content_begin(), B->content_end());
!       JvmtiExport::post_dynamic_code_generated(blob_id, new_adapter->content_begin(), new_adapter->content_end());
      }
    }
    return entry;
  }
  

*** 2528,2566 ****
--- 2534,2564 ----
  
  void AdapterHandlerEntry::deallocate() {
    delete _fingerprint;
  #ifdef ASSERT
    if (_saved_code) FREE_C_HEAP_ARRAY(unsigned char, _saved_code, mtCode);
    if (_saved_sig)  FREE_C_HEAP_ARRAY(Basictype, _saved_sig, mtCode);
  #endif
  }
  
  
  #ifdef ASSERT
  // Capture the code before relocation so that it can be compared
  // against other versions.  If the code is captured after relocation
  // then relative instructions won't be equivalent.
- void AdapterHandlerEntry::save_code(unsigned char* buffer, int length, int total_args_passed, BasicType* sig_bt) {
    _saved_code = NEW_C_HEAP_ARRAY(unsigned char, length, mtCode);
!   _saved_code_length = length;
    memcpy(_saved_code, buffer, length);
    _total_args_passed = total_args_passed;
    _saved_sig = NEW_C_HEAP_ARRAY(BasicType, _total_args_passed, mtCode);
    memcpy(_saved_sig, sig_bt, _total_args_passed * sizeof(BasicType));
  }
  
  
- bool AdapterHandlerEntry::compare_code(unsigned char* buffer, int length, int total_args_passed, BasicType* sig_bt) {
!   if (length != _saved_code_length) {
      return false;
    }
    for (int i = 0; i < length; i++) {
      if (buffer[i] != _saved_code[i]) {
      return false;
    }
    }
!   return (memcmp(buffer, _saved_code, length) == 0) ? true : false;
+ 
  }
  #endif
  
  
  // Create a native wrapper for this native method.  The wrapper converts the