Update nmethod caching and clean up unused/duplicate methods

src/hotspot/share/asm/codeBuffer.cpp

@@ -144,8 +144,6 @@ CodeBuffer::~CodeBuffer() {
   if (_shared_trampoline_requests != nullptr) {
     delete _shared_trampoline_requests;
   }
-
-  NOT_PRODUCT(clear_strings());
 }
 
 void CodeBuffer::initialize_oop_recorder(OopRecorder* r) {
@@ -1106,19 +1104,20 @@ CHeapString::~CHeapString() {
 // offset is a byte offset into an instruction stream (CodeBuffer, CodeBlob or
 // other memory buffer) and remark is a string (comment).
 //
-AsmRemarks::AsmRemarks() : _remarks(new AsmRemarkCollection()) {
+AsmRemarks::AsmRemarks() {
+  init();
   assert(_remarks != nullptr, "Allocation failure!");
 }
 
 AsmRemarks::~AsmRemarks() {
   if (_remarks != nullptr) {
     clear();
   }
-  assert(_remarks == nullptr, "Must 'clear()' before deleting!");
+  assert(_remarks == nullptr, "must be");
 }
 
-void AsmRemarks::init(AsmRemarks& asm_remarks) {
-  asm_remarks._remarks = new AsmRemarkCollection();
+void AsmRemarks::init() {
+  _remarks = new AsmRemarkCollection();
 }
 
 const char* AsmRemarks::insert(uint offset, const char* remstr) {
@@ -1166,18 +1165,19 @@ uint AsmRemarks::print(uint offset, outputStream* strm) const {
 // in the code generated, and thus requiring a fixed address.
 //
 DbgStrings::DbgStrings() : _strings(new DbgStringCollection()) {
+  init();
   assert(_strings != nullptr, "Allocation failure!");
 }
 
 DbgStrings::~DbgStrings() {
   if (_strings != nullptr) {
     clear();
   }
-  assert(_strings == nullptr, "Must 'clear()' before deleting!");
+  assert(_strings == nullptr, "must be");
 }
 
-void DbgStrings::init(DbgStrings& dbg_strings) {
-  dbg_strings._strings = new DbgStringCollection();
+void DbgStrings::init() {
+  _strings = new DbgStringCollection();
 }
 
 const char* DbgStrings::insert(const char* dbgstr) {

src/hotspot/share/asm/codeBuffer.hpp

@@ -426,7 +426,7 @@ class AsmRemarks {
   AsmRemarks();
  ~AsmRemarks();
 
-  static void init(AsmRemarks& asm_remarks);
+  void init();
 
   const char* insert(uint offset, const char* remstr);
 
@@ -454,7 +454,7 @@ class DbgStrings {
   DbgStrings();
  ~DbgStrings();
 
-  static void init(DbgStrings& dbg_strings);
+  void init();
 
   const char* insert(const char* dbgstr);
 
@@ -825,11 +825,6 @@ class CodeBuffer: public StackObj DEBUG_ONLY(COMMA private Scrubber) {
 #ifndef PRODUCT
   AsmRemarks &asm_remarks() { return _asm_remarks; }
   DbgStrings &dbg_strings() { return _dbg_strings; }
-
-  void clear_strings() {
-    _asm_remarks.clear();
-    _dbg_strings.clear();
-  }
 #endif
 
   // Code generation

src/hotspot/share/ci/ciEnv.cpp

@@ -1114,7 +1114,7 @@ void ciEnv::make_code_usable(JavaThread* thread, ciMethod* target, bool preload,
   }
 }
 
-void ciEnv::register_aot_method(JavaThread* thread,
+nmethod* ciEnv::register_aot_method(JavaThread* thread,
                                 ciMethod* target,
                                 AbstractCompiler* compiler,
                                 nmethod* archived_nm,
@@ -1125,10 +1125,6 @@ void ciEnv::register_aot_method(JavaThread* thread,
                                 address immutable_data,
                                 GrowableArray<Handle>& reloc_imm_oop_list,
                                 GrowableArray<Metadata*>& reloc_imm_metadata_list,
-#ifndef PRODUCT
-                                AsmRemarks& asm_remarks,
-                                DbgStrings& dbg_strings,
-#endif /* PRODUCT */
                                 AOTCodeReader* aot_code_reader)
 {
   AOTCodeEntry* aot_code_entry = task()->aot_code_entry();
@@ -1151,7 +1147,7 @@ void ciEnv::register_aot_method(JavaThread* thread,
     NoSafepointVerifier nsv;
 
     if (!is_compilation_valid(thread, target, preload, true /*install_code*/, nullptr /*code_buffer*/, aot_code_entry)) {
-      return;
+      return nullptr;
     }
 
     nm = nmethod::new_nmethod(archived_nm,
@@ -1165,8 +1161,6 @@ void ciEnv::register_aot_method(JavaThread* thread,
                               immutable_data,
                               reloc_imm_oop_list,
                               reloc_imm_metadata_list,
-                              NOT_PRODUCT_ARG(asm_remarks)
-                              NOT_PRODUCT_ARG(dbg_strings)
                               aot_code_reader);
 
     if (nm != nullptr) {
@@ -1183,6 +1177,7 @@ void ciEnv::register_aot_method(JavaThread* thread,
     // The CodeCache is full.
     record_failure("code cache is full");
   }
+  return nm;
   // safepoints are allowed again
 }
 

src/hotspot/share/ci/ciEnv.hpp

@@ -372,22 +372,18 @@ class ciEnv : StackObj {
   int compile_id();  // task()->compile_id()
 
   // Register method loaded from AOT code cache
-  void register_aot_method(JavaThread* thread,
-                           ciMethod* target,
-                           AbstractCompiler* compiler,
-                           nmethod* archived_nm,
-                           address reloc_data,
-                           GrowableArray<Handle>& oop_list,
-                           GrowableArray<Metadata*>& metadata_list,
-                           ImmutableOopMapSet* oopmaps,
-                           address immutable_data,
-                           GrowableArray<Handle>& reloc_imm_oop_list,
-                           GrowableArray<Metadata*>& reloc_imm_metadata_list,
-#ifndef PRODUCT
-                           AsmRemarks& asm_remarks,
-                           DbgStrings& dbg_strings,
-#endif /* PRODUCT */
-                           AOTCodeReader* aot_code_reader);
+  nmethod* register_aot_method(JavaThread* thread,
+                               ciMethod* target,
+                               AbstractCompiler* compiler,
+                               nmethod* archived_nm,
+                               address reloc_data,
+                               GrowableArray<Handle>& oop_list,
+                               GrowableArray<Metadata*>& metadata_list,
+                               ImmutableOopMapSet* oopmaps,
+                               address immutable_data,
+                               GrowableArray<Handle>& reloc_imm_oop_list,
+                               GrowableArray<Metadata*>& reloc_imm_metadata_list,
+                               AOTCodeReader* aot_code_reader);
 
   // Register the result of a compilation.
   void register_method(ciMethod*                 target,