src/share/vm/runtime/sharedRuntime.cpp

*** 37,46 ****
--- 37,47 ----
  #include "gc/shared/gcLocker.inline.hpp"
  #include "interpreter/interpreter.hpp"
  #include "interpreter/interpreterRuntime.hpp"
  #include "logging/log.hpp"
  #include "memory/universe.inline.hpp"
+ #include "memory/metaspaceShared.hpp"
  #include "oops/oop.inline.hpp"
  #include "prims/forte.hpp"
  #include "prims/jvmtiExport.hpp"
  #include "prims/jvmtiRedefineClassesTrace.hpp"
  #include "prims/methodHandles.hpp"
*** 1789,1799 ****
  // interpreted. If the caller is compiled we attempt to patch the caller
  // so he no longer calls into the interpreter.
  IRT_LEAF(void, SharedRuntime::fixup_callers_callsite(Method* method, address caller_pc))
    Method* moop(method);
  
!   address entry_point = moop->from_compiled_entry();
  
    // It's possible that deoptimization can occur at a call site which hasn't
    // been resolved yet, in which case this function will be called from
    // an nmethod that has been patched for deopt and we can ignore the
    // request for a fixup.
--- 1790,1800 ----
  // interpreted. If the caller is compiled we attempt to patch the caller
  // so he no longer calls into the interpreter.
  IRT_LEAF(void, SharedRuntime::fixup_callers_callsite(Method* method, address caller_pc))
    Method* moop(method);
  
!   address entry_point = moop->from_compiled_entry_no_trampoline();
  
    // It's possible that deoptimization can occur at a call site which hasn't
    // been resolved yet, in which case this function will be called from
    // an nmethod that has been patched for deopt and we can ignore the
    // request for a fixup.
*** 2322,2337 ****
      return (AdapterHandlerEntry*)BasicHashtable<mtCode>::bucket(i);
    }
  
   public:
    AdapterHandlerTable()
!     : BasicHashtable<mtCode>(293, sizeof(AdapterHandlerEntry)) { }
  
    // Create a new entry suitable for insertion in the table
    AdapterHandlerEntry* new_entry(AdapterFingerPrint* fingerprint, address i2c_entry, address c2i_entry, address c2i_unverified_entry) {
      AdapterHandlerEntry* entry = (AdapterHandlerEntry*)BasicHashtable<mtCode>::new_entry(fingerprint->compute_hash());
      entry->init(fingerprint, i2c_entry, c2i_entry, c2i_unverified_entry);
      return entry;
    }
  
    // Insert an entry into the table
    void add(AdapterHandlerEntry* entry) {
--- 2323,2341 ----
      return (AdapterHandlerEntry*)BasicHashtable<mtCode>::bucket(i);
    }
  
   public:
    AdapterHandlerTable()
!     : BasicHashtable<mtCode>(293, (DumpSharedSpaces ? sizeof(CDSAdapterHandlerEntry) : sizeof(AdapterHandlerEntry))) { }
  
    // Create a new entry suitable for insertion in the table
    AdapterHandlerEntry* new_entry(AdapterFingerPrint* fingerprint, address i2c_entry, address c2i_entry, address c2i_unverified_entry) {
      AdapterHandlerEntry* entry = (AdapterHandlerEntry*)BasicHashtable<mtCode>::new_entry(fingerprint->compute_hash());
      entry->init(fingerprint, i2c_entry, c2i_entry, c2i_unverified_entry);
+     if (DumpSharedSpaces) {
+       ((CDSAdapterHandlerEntry*)entry)->init();
+     }
      return entry;
    }
  
    // Insert an entry into the table
    void add(AdapterHandlerEntry* entry) {
*** 2490,2499 ****
--- 2494,2525 ----
                                                        address c2i_unverified_entry) {
    return _adapters->new_entry(fingerprint, i2c_entry, c2i_entry, c2i_unverified_entry);
  }
  
  AdapterHandlerEntry* AdapterHandlerLibrary::get_adapter(const methodHandle& method) {
+   AdapterHandlerEntry* entry = get_adapter0(method);
+   if (method->is_shared()) {
+     MutexLocker mu(AdapterHandlerLibrary_lock);
+     if (method->adapter() == NULL) {
+       method->update_adapter_trampoline(entry);
+     }
+     address trampoline = method->from_compiled_entry();
+     if (*(int*)trampoline == 0) {
+       CodeBuffer buffer(trampoline, (int)SharedRuntime::trampoline_size());
+       MacroAssembler _masm(&buffer);
+       SharedRuntime::generate_trampoline(&_masm, entry->get_c2i_entry());
+ 
+       if (PrintInterpreter) {
+         Disassembler::decode(buffer.insts_begin(), buffer.insts_end());
+       }
+     }
+   }
+ 
+   return entry;
+ }
+ 
+ AdapterHandlerEntry* AdapterHandlerLibrary::get_adapter0(const methodHandle& method) {
    // Use customized signature handler.  Need to lock around updates to
    // the AdapterHandlerTable (it is not safe for concurrent readers
    // and a single writer: this could be fixed if it becomes a
    // problem).
  
*** 2506,2516 ****
    {
      MutexLocker mu(AdapterHandlerLibrary_lock);
      // make sure data structure is initialized
      initialize();
  
!     if (CodeCacheExtensions::skip_compiler_support()) {
        // adapters are useless and should not be used, including the
        // abstract_method_handler. However, some callers check that
        // an adapter was installed.
        // Return the singleton adapter, stored into _abstract_method_handler
        // and modified to cause an error if we ever call it.
--- 2532,2542 ----
    {
      MutexLocker mu(AdapterHandlerLibrary_lock);
      // make sure data structure is initialized
      initialize();
  
!     if (!DumpSharedSpaces && CodeCacheExtensions::skip_compiler_support()) {
        // adapters are useless and should not be used, including the
        // abstract_method_handler. However, some callers check that
        // an adapter was installed.
        // Return the singleton adapter, stored into _abstract_method_handler
        // and modified to cause an error if we ever call it.
*** 2988,2997 ****
--- 3014,3034 ----
                 p2i(this), fingerprint()->as_string(),
                 p2i(get_i2c_entry()), p2i(get_c2i_entry()), p2i(get_c2i_unverified_entry()));
  
  }
  
+ #if INCLUDE_CDS
+ 
+ void CDSAdapterHandlerEntry::init() {
+   assert(DumpSharedSpaces, "used during dump time only");
+   _c2i_entry_trampoline = (address)MetaspaceShared::misc_code_space_alloc(SharedRuntime::trampoline_size());
+   _adapter_trampoline = (AdapterHandlerEntry**)MetaspaceShared::misc_data_space_alloc(sizeof(AdapterHandlerEntry*));
+ };
+ 
+ #endif // INCLUDE_CDS
+ 
+ 
  #ifndef PRODUCT
  
  void AdapterHandlerLibrary::print_statistics() {
    _adapters->print_statistics();
  }