1 /*
   2  * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 
  26 #include "asm/macroAssembler.hpp"
  27 #include "cds/aotCacheAccess.hpp"
  28 #include "cds/cds_globals.hpp"
  29 #include "cds/cdsConfig.hpp"
  30 #include "cds/heapShared.hpp"
  31 #include "cds/metaspaceShared.hpp"
  32 #include "ci/ciConstant.hpp"
  33 #include "ci/ciEnv.hpp"
  34 #include "ci/ciField.hpp"
  35 #include "ci/ciMethod.hpp"
  36 #include "ci/ciMethodData.hpp"
  37 #include "ci/ciObject.hpp"
  38 #include "ci/ciUtilities.inline.hpp"
  39 #include "classfile/javaAssertions.hpp"
  40 #include "classfile/stringTable.hpp"
  41 #include "classfile/symbolTable.hpp"
  42 #include "classfile/systemDictionary.hpp"
  43 #include "classfile/vmClasses.hpp"
  44 #include "classfile/vmIntrinsics.hpp"
  45 #include "code/aotCodeCache.hpp"
  46 #include "code/codeBlob.hpp"
  47 #include "code/codeCache.hpp"
  48 #include "code/oopRecorder.inline.hpp"
  49 #include "compiler/abstractCompiler.hpp"
  50 #include "compiler/compilationPolicy.hpp"
  51 #include "compiler/compileBroker.hpp"
  52 #include "compiler/compileTask.hpp"
  53 #include "gc/g1/g1BarrierSetRuntime.hpp"
  54 #include "gc/shared/gcConfig.hpp"
  55 #include "logging/logStream.hpp"
  56 #include "memory/memoryReserver.hpp"
  57 #include "memory/universe.hpp"
  58 #include "oops/klass.inline.hpp"
  59 #include "oops/method.inline.hpp"
  60 #include "oops/trainingData.hpp"
  61 #include "prims/jvmtiThreadState.hpp"
  62 #include "runtime/atomic.hpp"
  63 #include "runtime/deoptimization.hpp"
  64 #include "runtime/flags/flagSetting.hpp"
  65 #include "runtime/globals_extension.hpp"
  66 #include "runtime/handles.inline.hpp"
  67 #include "runtime/java.hpp"
  68 #include "runtime/jniHandles.inline.hpp"
  69 #include "runtime/mutexLocker.hpp"
  70 #include "runtime/os.inline.hpp"
  71 #include "runtime/sharedRuntime.hpp"
  72 #include "runtime/stubCodeGenerator.hpp"
  73 #include "runtime/stubRoutines.hpp"
  74 #include "runtime/timerTrace.hpp"
  75 #include "runtime/threadIdentifier.hpp"
  76 #include "utilities/copy.hpp"
  77 #include "utilities/ostream.hpp"
  78 #include "utilities/spinYield.hpp"
  79 #ifdef COMPILER1
  80 #include "c1/c1_Runtime1.hpp"
  81 #include "c1/c1_LIRAssembler.hpp"
  82 #include "gc/shared/c1/barrierSetC1.hpp"
  83 #include "gc/g1/c1/g1BarrierSetC1.hpp"
  84 #if INCLUDE_SHENANDOAHGC
  85 #include "gc/shenandoah/c1/shenandoahBarrierSetC1.hpp"
  86 #endif // INCLUDE_SHENANDOAHGC
  87 #include "gc/z/c1/zBarrierSetC1.hpp"
  88 #endif // COMPILER1
  89 #ifdef COMPILER2
  90 #include "opto/runtime.hpp"
  91 #endif
  92 #if INCLUDE_JVMCI
  93 #include "jvmci/jvmci.hpp"
  94 #endif
  95 #if INCLUDE_G1GC
  96 #include "gc/g1/g1BarrierSetRuntime.hpp"
  97 #endif
  98 #if INCLUDE_SHENANDOAHGC
  99 #include "gc/shenandoah/shenandoahRuntime.hpp"
 100 #endif
 101 #if INCLUDE_ZGC
 102 #include "gc/z/zBarrierSetRuntime.hpp"
 103 #endif
 104 
 105 #include <sys/stat.h>
 106 #include <errno.h>
 107 
 108 const char* aot_code_entry_kind_name[] = {
 109 #define DECL_KIND_STRING(kind) XSTR(kind),
 110   DO_AOTCODEENTRY_KIND(DECL_KIND_STRING)
 111 #undef DECL_KIND_STRING
 112 };
 113 
 114 static elapsedTimer _t_totalLoad;
 115 static elapsedTimer _t_totalRegister;
 116 static elapsedTimer _t_totalFind;
 117 static elapsedTimer _t_totalStore;
 118 
 119 static bool enable_timers() {
 120   return CITime || log_is_enabled(Info, init);
 121 }
 122 
 123 static void report_load_failure() {
 124   if (AbortVMOnAOTCodeFailure) {
 125     vm_exit_during_initialization("Unable to use AOT Code Cache.", nullptr);
 126   }
 127   log_info(aot, codecache, init)("Unable to use AOT Code Cache.");
 128   AOTCodeCache::disable_caching();
 129 }
 130 
 131 static void report_store_failure() {
 132   if (AbortVMOnAOTCodeFailure) {
 133     tty->print_cr("Unable to create AOT Code Cache.");
 134     vm_abort(false);
 135   }
 136   log_info(aot, codecache, exit)("Unable to create AOT Code Cache.");
 137   AOTCodeCache::disable_caching();
 138 }
 139 
 140 // The sequence of AOT code caching flags and parametters settings.
 141 //
 142 // 1. The initial AOT code caching flags setting is done
 143 // during call to CDSConfig::check_vm_args_consistency().
 144 //
 145 // 2. The earliest AOT code state check done in compilationPolicy_init()
 146 // where we set number of compiler threads for AOT assembly phase.
 147 //
 148 // 3. We determine presence of AOT code in AOT Cache in
 149 // MetaspaceShared::open_static_archive() which is calles
 150 // after compilationPolicy_init() but before codeCache_init().
 151 //
 152 // 4. AOTCodeCache::initialize() is called during universe_init()
 153 // and does final AOT state and flags settings.
 154 //
 155 // 5. Finally AOTCodeCache::init2() is called after universe_init()
 156 // when all GC settings are finalized.
 157 
 158 // Next methods determine which action we do with AOT code depending
 159 // on phase of AOT process: assembly or production.
 160 
 161 bool AOTCodeCache::is_dumping_adapter() {
 162   return AOTAdapterCaching && is_on_for_dump();
 163 }
 164 
 165 bool AOTCodeCache::is_using_adapter()   {
 166   return AOTAdapterCaching && is_on_for_use();
 167 }
 168 
 169 bool AOTCodeCache::is_dumping_stub() {
 170   return AOTStubCaching && is_on_for_dump();
 171 }
 172 
 173 bool AOTCodeCache::is_using_stub()   {
 174   return AOTStubCaching && is_on_for_use();
 175 }
 176 
 177 bool AOTCodeCache::is_dumping_code() {
 178   return AOTCodeCaching && is_on_for_dump();
 179 }
 180 
 181 bool AOTCodeCache::is_using_code() {
 182   return AOTCodeCaching && is_on_for_use();
 183 }
 184 
 185 // This is used before AOTCodeCahe is initialized
 186 // but after AOT (CDS) Cache flags consistency is checked.
 187 bool AOTCodeCache::maybe_dumping_code() {
 188   return AOTCodeCaching && CDSConfig::is_dumping_final_static_archive();
 189 }
 190 
 191 // Next methods could be called regardless of AOT code cache status.
 192 // Initially they are called during AOT flags parsing and finilized
 193 // in AOTCodeCache::initialize().
 194 void AOTCodeCache::enable_caching() {
 195   FLAG_SET_ERGO_IF_DEFAULT(AOTCodeCaching, true);
 196   FLAG_SET_ERGO_IF_DEFAULT(AOTStubCaching, true);
 197   FLAG_SET_ERGO_IF_DEFAULT(AOTAdapterCaching, true);
 198 }
 199 
 200 void AOTCodeCache::disable_caching() {
 201   FLAG_SET_ERGO(AOTCodeCaching, false);
 202   FLAG_SET_ERGO(AOTStubCaching, false);
 203   FLAG_SET_ERGO(AOTAdapterCaching, false);
 204 }
 205 
 206 bool AOTCodeCache::is_caching_enabled() {
 207   return AOTCodeCaching || AOTStubCaching || AOTAdapterCaching;
 208 }
 209 
 210 static uint32_t encode_id(AOTCodeEntry::Kind kind, int id) {
 211   assert(AOTCodeEntry::is_valid_entry_kind(kind), "invalid AOTCodeEntry kind %d", (int)kind);
 212   // There can be a conflict of id between an Adapter and *Blob, but that should not cause any functional issue
 213   // becasue both id and kind are used to find an entry, and that combination should be unique
 214   if (kind == AOTCodeEntry::Adapter) {
 215     return id;
 216   } else if (kind == AOTCodeEntry::SharedBlob) {
 217     return id;
 218   } else if (kind == AOTCodeEntry::C1Blob) {
 219     return (int)SharedStubId::NUM_STUBIDS + id;
 220   } else {
 221     // kind must be AOTCodeEntry::C2Blob
 222     return (int)SharedStubId::NUM_STUBIDS + COMPILER1_PRESENT((int)C1StubId::NUM_STUBIDS) + id;
 223   }
 224 }
 225 
 226 static uint _max_aot_code_size = 0;
 227 uint AOTCodeCache::max_aot_code_size() {
 228   return _max_aot_code_size;
 229 }
 230 
 231 bool AOTCodeCache::is_C3_on() {
 232 #if INCLUDE_JVMCI
 233   if (UseJVMCICompiler) {
 234     return (AOTCodeCaching) && UseC2asC3;
 235   }
 236 #endif
 237   return false;
 238 }
 239 
 240 bool AOTCodeCache::is_code_load_thread_on() {
 241   // We cannot trust AOTCodeCache status here, due to bootstrapping circularity.
 242   // Compilation policy init runs before AOT cache is fully initialized, so the
 243   // normal AOT cache status check would always fail.
 244   // See: https://bugs.openjdk.org/browse/JDK-8358690
 245   // return UseCodeLoadThread && is_using_code();
 246   return UseCodeLoadThread && AOTCodeCaching && CDSConfig::is_using_archive();
 247 }
 248 
 249 bool AOTCodeCache::allow_const_field(ciConstant& value) {
 250   return !is_on() || !is_dumping_code() // Restrict only when we generate cache
 251         // Can not trust primitive too   || !is_reference_type(value.basic_type())
 252         // May disable this too for now  || is_reference_type(value.basic_type()) && value.as_object()->should_be_constant()
 253         ;
 254 }
 255 
 256 // It is called from MetaspaceShared::initialize_shared_spaces()
 257 // which is called from universe_init().
 258 // At this point all AOT class linking seetings are finilized
 259 // and AOT cache is open so we can map AOT code region.
 260 void AOTCodeCache::initialize() {
 261   if (!is_caching_enabled()) {
 262     log_info(aot, codecache, init)("AOT Code Cache is not used: disabled.");
 263     return;
 264   }
 265 #if defined(ZERO) || !(defined(AMD64) || defined(AARCH64))
 266   log_info(aot, codecache, init)("AOT Code Cache is not supported on this platform.");
 267   disable_caching();
 268   return;
 269 #else
 270   assert(!FLAG_IS_DEFAULT(AOTCache), "AOTCache should be specified");
 271 
 272   // Disable stubs caching until JDK-8357398 is fixed.
 273   FLAG_SET_ERGO(AOTStubCaching, false);
 274 
 275   if (VerifyOops) {
 276     // Disable AOT stubs caching when VerifyOops flag is on.
 277     // Verify oops code generated a lot of C strings which overflow
 278     // AOT C string table (which has fixed size).
 279     // AOT C string table will be reworked later to handle such cases.
 280     //
 281     // Note: AOT adapters are not affected - they don't have oop operations.
 282     log_info(aot, codecache, init)("AOT Stubs Caching is not supported with VerifyOops.");
 283     FLAG_SET_ERGO(AOTStubCaching, false);
 284   }
 285 
 286   bool is_dumping = false;
 287   bool is_using   = false;
 288   if (CDSConfig::is_dumping_final_static_archive() && CDSConfig::is_dumping_aot_linked_classes()) {
 289     is_dumping = is_caching_enabled();
 290   } else if (CDSConfig::is_using_archive() && CDSConfig::is_using_aot_linked_classes()) {
 291     is_using = is_caching_enabled();
 292   }
 293   if (ClassInitBarrierMode > 0 && !(is_dumping && AOTCodeCaching)) {
 294     log_info(aot, codecache, init)("Set ClassInitBarrierMode to 0 because AOT Code dumping is off.");
 295     FLAG_SET_ERGO(ClassInitBarrierMode, 0);
 296   }
 297   if (!(is_dumping || is_using)) {
 298     log_info(aot, codecache, init)("AOT Code Cache is not used: AOT Class Linking is not used.");
 299     disable_caching();
 300     return; // AOT code caching disabled on command line
 301   }
 302   // Reserve AOT Cache region when we dumping AOT code.
 303   _max_aot_code_size = AOTCodeMaxSize;
 304   if (is_dumping && !FLAG_IS_DEFAULT(AOTCodeMaxSize)) {
 305     if (!is_aligned(AOTCodeMaxSize, os::vm_allocation_granularity())) {
 306       _max_aot_code_size = align_up(AOTCodeMaxSize, os::vm_allocation_granularity());
 307       log_debug(aot,codecache,init)("Max AOT Code Cache size is aligned up to %uK", (int)(max_aot_code_size()/K));
 308     }
 309   }
 310   size_t aot_code_size = is_using ? AOTCacheAccess::get_aot_code_region_size() : 0;
 311   if (is_using && aot_code_size == 0) {
 312     log_info(aot, codecache, init)("AOT Code Cache is empty");
 313     disable_caching();
 314     return;
 315   }
 316   if (!open_cache(is_dumping, is_using)) {
 317     if (is_using) {
 318       report_load_failure();
 319     } else {
 320       report_store_failure();
 321     }
 322     return;
 323   }
 324   if (is_dumping) {
 325     FLAG_SET_DEFAULT(FoldStableValues, false);
 326     FLAG_SET_DEFAULT(ForceUnreachable, true);
 327   }
 328   FLAG_SET_DEFAULT(DelayCompilerStubsGeneration, false);
 329 #endif // defined(AMD64) || defined(AARCH64)
 330 }
 331 
 332 static AOTCodeCache*  opened_cache = nullptr; // Use this until we verify the cache
 333 AOTCodeCache* AOTCodeCache::_cache = nullptr;
 334 DEBUG_ONLY( bool AOTCodeCache::_passed_init2 = false; )
 335 
 336 // It is called after universe_init() when all GC settings are finalized.
 337 void AOTCodeCache::init2() {
 338   DEBUG_ONLY( _passed_init2 = true; )
 339   if (opened_cache == nullptr) {
 340     return;
 341   }
 342   // After Universe initialized
 343   BarrierSet* bs = BarrierSet::barrier_set();
 344   if (bs->is_a(BarrierSet::CardTableBarrierSet)) {
 345     address byte_map_base = ci_card_table_address_as<address>();
 346     if (is_on_for_dump() && !external_word_Relocation::can_be_relocated(byte_map_base)) {
 347       // Bail out since we can't encode card table base address with relocation
 348       log_warning(aot, codecache, init)("Can't create AOT Code Cache because card table base address is not relocatable: " INTPTR_FORMAT, p2i(byte_map_base));
 349       close();
 350       report_load_failure();
 351       return;
 352     }
 353   }
 354   if (!opened_cache->verify_config_on_use()) { // Check on AOT code loading
 355     delete opened_cache;
 356     opened_cache = nullptr;
 357     report_load_failure();
 358     return;
 359   }
 360 
 361   // initialize aot runtime constants as appropriate to this runtime
 362   AOTRuntimeConstants::initialize_from_runtime();
 363 
 364   // initialize the table of external routines and initial stubs so we can save
 365   // generated code blobs that reference them
 366   AOTCodeAddressTable* table = opened_cache->_table;
 367   assert(table != nullptr, "should be initialized already");
 368   table->init_extrs();
 369 
 370   // Now cache and address table are ready for AOT code generation
 371   _cache = opened_cache;
 372 
 373   // Set ClassInitBarrierMode after all checks since it affects code generation
 374   if (is_dumping_code()) {
 375     FLAG_SET_ERGO_IF_DEFAULT(ClassInitBarrierMode, 1);
 376   } else {
 377     FLAG_SET_ERGO(ClassInitBarrierMode, 0);
 378   }
 379 }
 380 
 381 bool AOTCodeCache::open_cache(bool is_dumping, bool is_using) {
 382   opened_cache = new AOTCodeCache(is_dumping, is_using);
 383   if (opened_cache->failed()) {
 384     delete opened_cache;
 385     opened_cache = nullptr;
 386     return false;
 387   }
 388   return true;
 389 }
 390 
 391 static void print_helper(nmethod* nm, outputStream* st) {
 392   AOTCodeCache::iterate([&](AOTCodeEntry* e) {
 393     if (e->method() == nm->method()) {
 394       ResourceMark rm;
 395       stringStream ss;
 396       ss.print("A%s%d", (e->for_preload() ? "P" : ""), e->comp_level());
 397       ss.print("[%s%s%s]",
 398                (e->is_loaded()   ? "L" : ""),
 399                (e->load_fail()   ? "F" : ""),
 400                (e->not_entrant() ? "I" : ""));
 401       ss.print("#%d", e->comp_id());
 402 
 403       st->print(" %s", ss.freeze());
 404     }
 405   });
 406 }
 407 
 408 void AOTCodeCache::close() {
 409   if (is_on()) {
 410     delete _cache; // Free memory
 411     _cache = nullptr;
 412     opened_cache = nullptr;
 413   }
 414 }
 415 
 416 class CachedCodeDirectory : public CachedCodeDirectoryInternal {
 417 public:
 418   uint _aot_code_size;
 419   char* _aot_code_data;
 420 
 421   void set_aot_code_data(uint size, char* aot_data) {
 422     _aot_code_size = size;
 423     AOTCacheAccess::set_pointer(&_aot_code_data, aot_data);
 424   }
 425 
 426   static CachedCodeDirectory* create();
 427 };
 428 
 429 // Storing AOT code in the cached code region of AOT Cache:
 430 //
 431 // [1] Use CachedCodeDirectory to keep track of all of data related to cached code.
 432 //     E.g., you can build a hashtable to record what methods have been archived.
 433 //
 434 // [2] Memory for all data for cached code, including CachedCodeDirectory, should be
 435 //     allocated using AOTCacheAccess::allocate_aot_code_region().
 436 //
 437 // [3] CachedCodeDirectory must be the very first allocation.
 438 //
 439 // [4] Two kinds of pointer can be stored:
 440 //     - A pointer p that points to metadata. AOTCacheAccess::can_generate_aot_code(p) must return true.
 441 //     - A pointer to a buffer returned by AOTCacheAccess::allocate_aot_code_region().
 442 //       (It's OK to point to an interior location within this buffer).
 443 //     Such pointers must be stored using AOTCacheAccess::set_pointer()
 444 //
 445 // The buffers allocated by AOTCacheAccess::allocate_aot_code_region() are in a contiguous region. At runtime, this
 446 // region is mapped to the process address space. All the pointers in this buffer are relocated as necessary
 447 // (e.g., to account for the runtime location of the CodeCache).
 448 //
 449 // This is always at the very beginning of the mmaped CDS "cc" (cached code) region
 450 static CachedCodeDirectory* _aot_code_directory = nullptr;
 451 
 452 CachedCodeDirectory* CachedCodeDirectory::create() {
 453   assert(AOTCacheAccess::is_aot_code_region_empty(), "must be");
 454   CachedCodeDirectory* dir = (CachedCodeDirectory*)AOTCacheAccess::allocate_aot_code_region(sizeof(CachedCodeDirectory));
 455   dir->dumptime_init_internal();
 456   return dir;
 457 }
 458 
 459 #define DATA_ALIGNMENT HeapWordSize
 460 
 461 AOTCodeCache::AOTCodeCache(bool is_dumping, bool is_using) :
 462   _load_header(nullptr),
 463   _load_buffer(nullptr),
 464   _store_buffer(nullptr),
 465   _C_store_buffer(nullptr),
 466   _write_position(0),
 467   _load_size(0),
 468   _store_size(0),
 469   _for_use(is_using),
 470   _for_dump(is_dumping),
 471   _closing(false),
 472   _failed(false),
 473   _lookup_failed(false),
 474   _for_preload(false),
 475   _has_clinit_barriers(false),
 476   _table(nullptr),
 477   _load_entries(nullptr),
 478   _search_entries(nullptr),
 479   _store_entries(nullptr),
 480   _C_strings_buf(nullptr),
 481   _store_entries_cnt(0),
 482   _compile_id(0),
 483   _comp_level(0)
 484 {
 485   // Read header at the begining of cache
 486   if (_for_use) {
 487     // Read cache
 488     size_t load_size = AOTCacheAccess::get_aot_code_region_size();
 489     ReservedSpace rs = MemoryReserver::reserve(load_size, mtCode);
 490     if (!rs.is_reserved()) {
 491       log_warning(aot, codecache, init)("Failed to reserved %u bytes of memory for mapping AOT code region into AOT Code Cache", (uint)load_size);
 492       set_failed();
 493       return;
 494     }
 495     if (!AOTCacheAccess::map_aot_code_region(rs)) {
 496       log_warning(aot, codecache, init)("Failed to read/mmap cached code region into AOT Code Cache");
 497       set_failed();
 498       return;
 499     }
 500     _aot_code_directory = (CachedCodeDirectory*)rs.base();
 501     _aot_code_directory->runtime_init_internal();
 502 
 503     _load_size = _aot_code_directory->_aot_code_size;
 504     _load_buffer = _aot_code_directory->_aot_code_data;
 505     assert(is_aligned(_load_buffer, DATA_ALIGNMENT), "load_buffer is not aligned");
 506     log_info(aot, codecache, init)("Mapped %u bytes at address " INTPTR_FORMAT " from AOT Code Cache", _load_size, p2i(_load_buffer));
 507 
 508     _load_header = (Header*)addr(0);
 509     if (!_load_header->verify(_load_size)) {
 510       set_failed();
 511       return;
 512     }
 513     log_info (aot, codecache, init)("Loaded %u AOT code entries from AOT Code Cache", _load_header->entries_count());
 514     log_debug(aot, codecache, init)("  Adapters: total=%u", _load_header->adapters_count());
 515     log_debug(aot, codecache, init)("  Shared Blobs: total=%u", _load_header->shared_blobs_count());
 516     log_debug(aot, codecache, init)("  C1 Blobs: total=%u", _load_header->C1_blobs_count());
 517     log_debug(aot, codecache, init)("  C2 Blobs: total=%u", _load_header->C2_blobs_count());
 518     log_debug(aot, codecache, init)("  Stubs:    total=%u", _load_header->stubs_count());
 519     log_debug(aot, codecache, init)("  Nmethods: total=%u", _load_header->nmethods_count());
 520     log_debug(aot, codecache, init)("  AOT code cache size: %u bytes", _load_header->cache_size());
 521 
 522     // Read strings
 523     load_strings();
 524   }
 525   if (_for_dump) {
 526     _C_store_buffer = NEW_C_HEAP_ARRAY(char, max_aot_code_size() + DATA_ALIGNMENT, mtCode);
 527     _store_buffer = align_up(_C_store_buffer, DATA_ALIGNMENT);
 528     // Entries allocated at the end of buffer in reverse (as on stack).
 529     _store_entries = (AOTCodeEntry*)align_up(_C_store_buffer + max_aot_code_size(), DATA_ALIGNMENT);
 530     log_debug(aot, codecache, init)("Allocated store buffer at address " INTPTR_FORMAT " of size %u", p2i(_store_buffer), max_aot_code_size());
 531   }
 532   _table = new AOTCodeAddressTable();
 533 }
 534 
 535 void AOTCodeCache::invalidate(AOTCodeEntry* entry) {
 536   // This could be concurent execution
 537   if (entry != nullptr && is_on()) { // Request could come after cache is closed.
 538     _cache->invalidate_entry(entry);
 539   }
 540 }
 541 
 542 bool AOTCodeCache::is_loaded(AOTCodeEntry* entry) {
 543   if (is_on() && _cache->cache_buffer() != nullptr) {
 544     return (uint)((char*)entry - _cache->cache_buffer()) < _cache->load_size();
 545   }
 546   return false;
 547 }
 548 
 549 void AOTCodeCache::init_early_stubs_table() {
 550   AOTCodeAddressTable* table = addr_table();
 551   if (table != nullptr) {
 552     table->init_early_stubs();
 553   }
 554 }
 555 
 556 void AOTCodeCache::init_shared_blobs_table() {
 557   AOTCodeAddressTable* table = addr_table();
 558   if (table != nullptr) {
 559     table->init_shared_blobs();
 560   }
 561 }
 562 
 563 void AOTCodeCache::init_stubs_table() {
 564   AOTCodeAddressTable* table = addr_table();
 565   if (table != nullptr) {
 566     table->init_stubs();
 567   }
 568 }
 569 
 570 void AOTCodeCache::init_early_c1_table() {
 571   AOTCodeAddressTable* table = addr_table();
 572   if (table != nullptr) {
 573     table->init_early_c1();
 574   }
 575 }
 576 
 577 void AOTCodeCache::init_c1_table() {
 578   AOTCodeAddressTable* table = addr_table();
 579   if (table != nullptr) {
 580     table->init_c1();
 581   }
 582 }
 583 
 584 void AOTCodeCache::init_c2_table() {
 585   AOTCodeAddressTable* table = addr_table();
 586   if (table != nullptr) {
 587     table->init_c2();
 588   }
 589 }
 590 
 591 AOTCodeCache::~AOTCodeCache() {
 592   if (_closing) {
 593     return; // Already closed
 594   }
 595   // Stop any further access to cache.
 596   // Checked on entry to load_nmethod() and store_nmethod().
 597   _closing = true;
 598   if (_for_use) {
 599     // Wait for all load_nmethod() finish.
 600     wait_for_no_nmethod_readers();
 601   }
 602   // Prevent writing code into cache while we are closing it.
 603   // This lock held by ciEnv::register_method() which calls store_nmethod().
 604   MutexLocker ml(Compile_lock);
 605   if (for_dump()) { // Finalize cache
 606     finish_write();
 607   }
 608   _load_buffer = nullptr;
 609   if (_C_store_buffer != nullptr) {
 610     FREE_C_HEAP_ARRAY(char, _C_store_buffer);
 611     _C_store_buffer = nullptr;
 612     _store_buffer = nullptr;
 613   }
 614   if (_table != nullptr) {
 615     MutexLocker ml(AOTCodeCStrings_lock, Mutex::_no_safepoint_check_flag);
 616     delete _table;
 617     _table = nullptr;
 618   }
 619 }
 620 
 621 void AOTCodeCache::Config::record() {
 622   _flags = 0;
 623 #ifdef ASSERT
 624   _flags |= debugVM;
 625 #endif
 626   if (UseCompressedOops) {
 627     _flags |= compressedOops;
 628   }
 629   if (UseCompressedClassPointers) {
 630     _flags |= compressedClassPointers;
 631   }
 632   if (UseTLAB) {
 633     _flags |= useTLAB;
 634   }
 635   if (JavaAssertions::systemClassDefault()) {
 636     _flags |= systemClassAssertions;
 637   }
 638   if (JavaAssertions::userClassDefault()) {
 639     _flags |= userClassAssertions;
 640   }
 641   if (EnableContended) {
 642     _flags |= enableContendedPadding;
 643   }
 644   if (RestrictContended) {
 645     _flags |= restrictContendedPadding;
 646   }
 647   if (PreserveFramePointer) {
 648     _flags |= preserveFramePointer;
 649   }
 650   _codeCacheSize         = pointer_delta(CodeCache::high_bound(), CodeCache::low_bound(), 1);
 651   _compressedOopShift    = CompressedOops::shift();
 652   _compressedOopBase     = CompressedOops::base();
 653   _compressedKlassShift  = CompressedKlassPointers::shift();
 654   _compressedKlassBase   = CompressedKlassPointers::base();
 655   _contendedPaddingWidth = ContendedPaddingWidth;
 656   _objectAlignment       = ObjectAlignmentInBytes;
 657 #if !defined(ZERO) && (defined(IA32) || defined(AMD64))
 658   _useSSE                = UseSSE;
 659   _useAVX                = UseAVX;
 660 #endif
 661   _gc                    = (uint)Universe::heap()->kind();
 662 }
 663 
 664 bool AOTCodeCache::Config::verify() const {
 665   // First checks affect all cached AOT code
 666 #ifdef ASSERT
 667   if ((_flags & debugVM) == 0) {
 668     log_debug(aot, codecache, init)("AOT Code Cache disabled: it was created by product VM, it can't be used by debug VM");
 669     return false;
 670   }
 671 #else
 672   if ((_flags & debugVM) != 0) {
 673     log_debug(aot, codecache, init)("AOT Code Cache disabled: it was created by debug VM, it can't be used by product VM");
 674     return false;
 675   }
 676 #endif
 677 
 678 #if !defined(ZERO) && (defined(IA32) || defined(AMD64))
 679   if (UseSSE < _useSSE) {
 680     log_debug(aot, codecache, init)("AOT Code Cache disabled: it was created with UseSSE = %d vs current %d", _useSSE, UseSSE);
 681     return false;
 682   }
 683   if (UseAVX < _useAVX) {
 684     log_debug(aot, codecache, init)("AOT Code Cache disabled: it was created with UseAVX = %d vs current %d", _useAVX, UseAVX);
 685     return false;
 686   }
 687 #endif
 688 
 689   size_t codeCacheSize = pointer_delta(CodeCache::high_bound(), CodeCache::low_bound(), 1);
 690   if (_codeCacheSize != codeCacheSize) {
 691     log_debug(aot, codecache, init)("AOT Code Cache disabled: it was created with CodeCache size = %dKb vs current %dKb", (int)(_codeCacheSize/K), (int)(codeCacheSize/K));
 692     return false;
 693   }
 694 
 695   CollectedHeap::Name aot_gc = (CollectedHeap::Name)_gc;
 696   if (aot_gc != Universe::heap()->kind()) {
 697     log_debug(aot, codecache, init)("AOT Code Cache disabled: it was created with different GC: %s vs current %s", GCConfig::hs_err_name(aot_gc), GCConfig::hs_err_name());
 698     return false;
 699   }
 700 
 701   if (_objectAlignment != (uint)ObjectAlignmentInBytes) {
 702     log_debug(aot, codecache, init)("AOT Code Cache disabled: it was created with ObjectAlignmentInBytes = %d vs current %d", _objectAlignment, ObjectAlignmentInBytes);
 703     return false;
 704   }
 705 
 706   if (((_flags & enableContendedPadding) != 0) != EnableContended) {
 707     log_debug(aot, codecache, init)("AOT Code Cache disabled: it was created with EnableContended = %s vs current %s", (EnableContended ? "false" : "true"), (EnableContended ? "true" : "false"));
 708     return false;
 709   }
 710   if (((_flags & restrictContendedPadding) != 0) != RestrictContended) {
 711     log_debug(aot, codecache, init)("AOT Code Cache disabled: it was created with RestrictContended = %s vs current %s", (RestrictContended ? "false" : "true"), (RestrictContended ? "true" : "false"));
 712     return false;
 713   }
 714   if (_contendedPaddingWidth != (uint)ContendedPaddingWidth) {
 715     log_debug(aot, codecache, init)("AOT Code Cache disabled: it was created with ContendedPaddingWidth = %d vs current %d", _contendedPaddingWidth, ContendedPaddingWidth);
 716     return false;
 717   }
 718 
 719   if (((_flags & preserveFramePointer) != 0) != PreserveFramePointer) {
 720     log_debug(aot, codecache, init)("AOT Code Cache disabled: it was created with PreserveFramePointer = %s vs current %s", (PreserveFramePointer ? "false" : "true"), (PreserveFramePointer ? "true" : "false"));
 721     return false;
 722   }
 723 
 724   if (((_flags & compressedClassPointers) != 0) != UseCompressedClassPointers) {
 725     log_debug(aot, codecache, init)("AOT Code Cache disabled: it was created with UseCompressedClassPointers = %s vs current %s", (UseCompressedClassPointers ? "false" : "true"), (UseCompressedClassPointers ? "true" : "false"));
 726     return false;
 727   }
 728   if (_compressedKlassShift != (uint)CompressedKlassPointers::shift()) {
 729     log_debug(aot, codecache, init)("AOT Code Cache disabled: it was created with CompressedKlassPointers::shift() = %d vs current %d", _compressedKlassShift, CompressedKlassPointers::shift());
 730     return false;
 731   }
 732   if ((_compressedKlassBase == nullptr || CompressedKlassPointers::base() == nullptr) && (_compressedKlassBase != CompressedKlassPointers::base())) {
 733     log_debug(aot, codecache, init)("AOT Code Cache disabled: incompatible CompressedKlassPointers::base(): %p vs current %p", _compressedKlassBase, CompressedKlassPointers::base());
 734     return false;
 735   }
 736 
 737   if (((_flags & compressedOops) != 0) != UseCompressedOops) {
 738     log_debug(aot, codecache, init)("AOT Code Cache disabled: it was created with UseCompressedOops = %s vs current %s", (UseCompressedOops ? "false" : "true"), (UseCompressedOops ? "true" : "false"));
 739     return false;
 740   }
 741   if (_compressedOopShift != (uint)CompressedOops::shift()) {
 742     log_debug(aot, codecache, init)("AOT Code Cache disabled: it was created with different CompressedOops::shift(): %d vs current %d", _compressedOopShift, CompressedOops::shift());
 743     return false;
 744   }
 745   if ((_compressedOopBase == nullptr || CompressedOops::base() == nullptr) && (_compressedOopBase != CompressedOops::base())) {
 746     log_debug(aot, codecache, init)("AOTStubCaching is disabled: incompatible CompressedOops::base(): %p vs current %p", _compressedOopBase, CompressedOops::base());
 747     return false;
 748   }
 749 
 750   // Next affects only AOT nmethod
 751   if (((_flags & systemClassAssertions) != 0) != JavaAssertions::systemClassDefault()) {
 752     log_debug(aot, codecache, init)("AOT Code Cache disabled: it was created with JavaAssertions::systemClassDefault() = %s vs current %s", (JavaAssertions::systemClassDefault() ? "disabled" : "enabled"), (JavaAssertions::systemClassDefault() ? "enabled" : "disabled"));
 753      FLAG_SET_ERGO(AOTCodeCaching, false);
 754   }
 755   if (((_flags & userClassAssertions) != 0) != JavaAssertions::userClassDefault()) {
 756     log_debug(aot, codecache, init)("AOT Code Cache disabled: it was created with JavaAssertions::userClassDefault() = %s vs current %s", (JavaAssertions::userClassDefault() ? "disabled" : "enabled"), (JavaAssertions::userClassDefault() ? "enabled" : "disabled"));
 757     FLAG_SET_ERGO(AOTCodeCaching, false);
 758   }
 759 
 760   return true;
 761 }
 762 
 763 bool AOTCodeCache::Header::verify(uint load_size) const {
 764   if (_version != AOT_CODE_VERSION) {
 765     log_debug(aot, codecache, init)("AOT Code Cache disabled: different AOT Code version %d vs %d recorded in AOT Code header", AOT_CODE_VERSION, _version);
 766     return false;
 767   }
 768   if (load_size < _cache_size) {
 769     log_debug(aot, codecache, init)("AOT Code Cache disabled: AOT Code Cache size %d < %d recorded in AOT Code header", load_size, _cache_size);
 770     return false;
 771   }
 772   return true;
 773 }
 774 
 775 volatile int AOTCodeCache::_nmethod_readers = 0;
 776 
 777 AOTCodeCache* AOTCodeCache::open_for_use() {
 778   if (AOTCodeCache::is_on_for_use()) {
 779     return AOTCodeCache::cache();
 780   }
 781   return nullptr;
 782 }
 783 
 784 AOTCodeCache* AOTCodeCache::open_for_dump() {
 785   if (AOTCodeCache::is_on_for_dump()) {
 786     AOTCodeCache* cache = AOTCodeCache::cache();
 787     cache->clear_lookup_failed(); // Reset bit
 788     return cache;
 789   }
 790   return nullptr;
 791 }
 792 
 793 bool AOTCodeCache::is_address_in_aot_cache(address p) {
 794   AOTCodeCache* cache = open_for_use();
 795   if (cache == nullptr) {
 796     return false;
 797   }
 798   if ((p >= (address)cache->cache_buffer()) &&
 799       (p < (address)(cache->cache_buffer() + cache->load_size()))) {
 800     return true;
 801   }
 802   return false;
 803 }
 804 
 805 static void copy_bytes(const char* from, address to, uint size) {
 806   assert((int)size > 0, "sanity");
 807   memcpy(to, from, size);
 808   log_trace(aot, codecache)("Copied %d bytes from " INTPTR_FORMAT " to " INTPTR_FORMAT, size, p2i(from), p2i(to));
 809 }
 810 
 811 AOTCodeReader::AOTCodeReader(AOTCodeCache* cache, AOTCodeEntry* entry, CompileTask* task) {
 812   _cache = cache;
 813   _entry = entry;
 814   _load_buffer = cache->cache_buffer();
 815   _read_position = 0;
 816   if (task != nullptr) {
 817     _compile_id = task->compile_id();
 818     _comp_level = task->comp_level();
 819     _preload    = task->preload();
 820   } else {
 821     _compile_id = 0;
 822     _comp_level = 0;
 823     _preload    = false;
 824   }
 825   _lookup_failed = false;
 826 }
 827 
 828 void AOTCodeReader::set_read_position(uint pos) {
 829   if (pos == _read_position) {
 830     return;
 831   }
 832   assert(pos < _cache->load_size(), "offset:%d >= file size:%d", pos, _cache->load_size());
 833   _read_position = pos;
 834 }
 835 
 836 bool AOTCodeCache::set_write_position(uint pos) {
 837   if (pos == _write_position) {
 838     return true;
 839   }
 840   if (_store_size < _write_position) {
 841     _store_size = _write_position; // Adjust during write
 842   }
 843   assert(pos < _store_size, "offset:%d >= file size:%d", pos, _store_size);
 844   _write_position = pos;
 845   return true;
 846 }
 847 
 848 static char align_buffer[256] = { 0 };
 849 
 850 bool AOTCodeCache::align_write() {
 851   // We are not executing code from cache - we copy it by bytes first.
 852   // No need for big alignment (or at all).
 853   uint padding = DATA_ALIGNMENT - (_write_position & (DATA_ALIGNMENT - 1));
 854   if (padding == DATA_ALIGNMENT) {
 855     return true;
 856   }
 857   uint n = write_bytes((const void*)&align_buffer, padding);
 858   if (n != padding) {
 859     return false;
 860   }
 861   log_trace(aot, codecache)("Adjust write alignment in AOT Code Cache");
 862   return true;
 863 }
 864 
 865 // Check to see if AOT code cache has required space to store "nbytes" of data
 866 address AOTCodeCache::reserve_bytes(uint nbytes) {
 867   assert(for_dump(), "Code Cache file is not created");
 868   uint new_position = _write_position + nbytes;
 869   if (new_position >= (uint)((char*)_store_entries - _store_buffer)) {
 870     log_warning(aot,codecache)("Failed to ensure %d bytes at offset %d in AOT Code Cache. Increase AOTCodeMaxSize.",
 871                                nbytes, _write_position);
 872     set_failed();
 873     report_store_failure();
 874     return nullptr;
 875   }
 876   address buffer = (address)(_store_buffer + _write_position);
 877   log_trace(aot, codecache)("Reserved %d bytes at offset %d in AOT Code Cache", nbytes, _write_position);
 878   _write_position += nbytes;
 879   if (_store_size < _write_position) {
 880     _store_size = _write_position;
 881   }
 882   return buffer;
 883 }
 884 
 885 uint AOTCodeCache::write_bytes(const void* buffer, uint nbytes) {
 886   assert(for_dump(), "Code Cache file is not created");
 887   if (nbytes == 0) {
 888     return 0;
 889   }
 890   uint new_position = _write_position + nbytes;
 891   if (new_position >= (uint)((char*)_store_entries - _store_buffer)) {
 892     log_warning(aot, codecache)("Failed to write %d bytes at offset %d to AOT Code Cache. Increase AOTCodeMaxSize.",
 893                                 nbytes, _write_position);
 894     set_failed();
 895     report_store_failure();
 896     return 0;
 897   }
 898   copy_bytes((const char* )buffer, (address)(_store_buffer + _write_position), nbytes);
 899   log_trace(aot, codecache)("Wrote %d bytes at offset %d to AOT Code Cache", nbytes, _write_position);
 900   _write_position += nbytes;
 901   if (_store_size < _write_position) {
 902     _store_size = _write_position;
 903   }
 904   return nbytes;
 905 }
 906 
 907 AOTCodeEntry* AOTCodeCache::find_code_entry(const methodHandle& method, uint comp_level) {
 908   assert(is_using_code(), "AOT code caching should be enabled");
 909   switch (comp_level) {
 910     case CompLevel_simple:
 911       if ((DisableCachedCode & (1 << 0)) != 0) {
 912         return nullptr;
 913       }
 914       break;
 915     case CompLevel_limited_profile:
 916       if ((DisableCachedCode & (1 << 1)) != 0) {
 917         return nullptr;
 918       }
 919       break;
 920     case CompLevel_full_optimization:
 921       if ((DisableCachedCode & (1 << 2)) != 0) {
 922         return nullptr;
 923       }
 924       break;
 925 
 926     default: return nullptr; // Level 1, 2, and 4 only
 927   }
 928   TraceTime t1("Total time to find AOT code", &_t_totalFind, enable_timers(), false);
 929   if (is_on() && _cache->cache_buffer() != nullptr) {
 930     ResourceMark rm;
 931     const char* target_name = method->name_and_sig_as_C_string();
 932     uint hash = java_lang_String::hash_code((const jbyte*)target_name, (int)strlen(target_name));
 933     AOTCodeEntry* entry = _cache->find_entry(AOTCodeEntry::Code, hash, comp_level);
 934     if (entry == nullptr) {
 935       log_info(aot, codecache, nmethod)("Missing entry for '%s' (comp_level %d, hash: " UINT32_FORMAT_X_0 ")", target_name, (uint)comp_level, hash);
 936 #ifdef ASSERT
 937     } else {
 938       uint name_offset = entry->offset() + entry->name_offset();
 939       uint name_size   = entry->name_size(); // Includes '/0'
 940       const char* name = _cache->cache_buffer() + name_offset;
 941       if (strncmp(target_name, name, name_size) != 0) {
 942         assert(false, "AOTCodeCache: saved nmethod's name '%s' is different from '%s', hash: " UINT32_FORMAT_X_0, name, target_name, hash);
 943       }
 944 #endif
 945     }
 946 
 947     DirectiveSet* directives = DirectivesStack::getMatchingDirective(method, nullptr);
 948     if (directives->IgnorePrecompiledOption) {
 949       LogStreamHandle(Info, aot, codecache, compilation) log;
 950       if (log.is_enabled()) {
 951         log.print("Ignore cached code entry on level %d for ", comp_level);
 952         method->print_value_on(&log);
 953       }
 954       return nullptr;
 955     }
 956 
 957     return entry;
 958   }
 959   return nullptr;
 960 }
 961 
 962 void* AOTCodeEntry::operator new(size_t x, AOTCodeCache* cache) {
 963   return (void*)(cache->add_entry());
 964 }
 965 
 966 static bool check_entry(AOTCodeEntry::Kind kind, uint id, uint comp_level, AOTCodeEntry* entry) {
 967   if (entry->kind() == kind) {
 968     assert(entry->id() == id, "sanity");
 969     if (kind != AOTCodeEntry::Code || (!entry->not_entrant() && !entry->has_clinit_barriers() &&
 970                                   (entry->comp_level() == comp_level))) {
 971       return true; // Found
 972     }
 973   }
 974   return false;
 975 }
 976 
 977 AOTCodeEntry* AOTCodeCache::find_entry(AOTCodeEntry::Kind kind, uint id, uint comp_level) {
 978   assert(_for_use, "sanity");
 979   uint count = _load_header->entries_count();
 980   if (_load_entries == nullptr) {
 981     // Read it
 982     _search_entries = (uint*)addr(_load_header->entries_offset()); // [id, index]
 983     _load_entries = (AOTCodeEntry*)(_search_entries + 2 * count);
 984     log_debug(aot, codecache, init)("Read %d entries table at offset %d from AOT Code Cache", count, _load_header->entries_offset());
 985   }
 986   // Binary search
 987   int l = 0;
 988   int h = count - 1;
 989   while (l <= h) {
 990     int mid = (l + h) >> 1;
 991     int ix = mid * 2;
 992     uint is = _search_entries[ix];
 993     if (is == id) {
 994       int index = _search_entries[ix + 1];
 995       AOTCodeEntry* entry = &(_load_entries[index]);
 996       if (check_entry(kind, id, comp_level, entry)) {
 997         return entry; // Found
 998       }
 999       // Leaner search around
1000       for (int i = mid - 1; i >= l; i--) { // search back
1001         ix = i * 2;
1002         is = _search_entries[ix];
1003         if (is != id) {
1004           break;
1005         }
1006         index = _search_entries[ix + 1];
1007         AOTCodeEntry* entry = &(_load_entries[index]);
1008         if (check_entry(kind, id, comp_level, entry)) {
1009           return entry; // Found
1010         }
1011       }
1012       for (int i = mid + 1; i <= h; i++) { // search forward
1013         ix = i * 2;
1014         is = _search_entries[ix];
1015         if (is != id) {
1016           break;
1017         }
1018         index = _search_entries[ix + 1];
1019         AOTCodeEntry* entry = &(_load_entries[index]);
1020         if (check_entry(kind, id, comp_level, entry)) {
1021           return entry; // Found
1022         }
1023       }
1024       break; // No match found
1025     } else if (is < id) {
1026       l = mid + 1;
1027     } else {
1028       h = mid - 1;
1029     }
1030   }
1031   return nullptr;
1032 }
1033 
1034 void AOTCodeCache::invalidate_entry(AOTCodeEntry* entry) {
1035   assert(entry!= nullptr, "all entries should be read already");
1036   if (entry->not_entrant()) {
1037     return; // Someone invalidated it already
1038   }
1039 #ifdef ASSERT
1040   bool found = false;
1041   if (_for_use) {
1042     uint count = _load_header->entries_count();
1043     uint i = 0;
1044     for(; i < count; i++) {
1045       if (entry == &(_load_entries[i])) {
1046         break;
1047       }
1048     }
1049     found = (i < count);
1050   }
1051   if (!found && _for_dump) {
1052     uint count = _store_entries_cnt;
1053     uint i = 0;
1054     for(; i < count; i++) {
1055       if (entry == &(_store_entries[i])) {
1056         break;
1057       }
1058     }
1059     found = (i < count);
1060   }
1061   assert(found, "entry should exist");
1062 #endif
1063   entry->set_not_entrant();
1064   {
1065     uint name_offset = entry->offset() + entry->name_offset();
1066     const char* name;
1067     if (AOTCodeCache::is_loaded(entry)) {
1068       name = _load_buffer + name_offset;
1069     } else {
1070       name = _store_buffer + name_offset;
1071     }
1072     uint level   = entry->comp_level();
1073     uint comp_id = entry->comp_id();
1074     bool clinit_brs = entry->has_clinit_barriers();
1075     log_info(aot, codecache, nmethod)("Invalidated entry for '%s' (comp_id %d, comp_level %d, hash: " UINT32_FORMAT_X_0 "%s)",
1076                                       name, comp_id, level, entry->id(), (clinit_brs ? ", has clinit barriers" : ""));
1077   }
1078   if (entry->next() != nullptr) {
1079     entry = entry->next();
1080     assert(entry->has_clinit_barriers(), "expecting only such entries here");
1081     invalidate_entry(entry);
1082   }
1083 }
1084 
1085 void AOTCodeEntry::update_method_for_writing() {
1086   if (_method != nullptr) {
1087     _method_offset = AOTCacheAccess::delta_from_base_address((address)_method);
1088     _method = nullptr;
1089   }
1090 }
1091 
1092 static int uint_cmp(const void *i, const void *j) {
1093   uint a = *(uint *)i;
1094   uint b = *(uint *)j;
1095   return a > b ? 1 : a < b ? -1 : 0;
1096 }
1097 
1098 bool AOTCodeCache::finish_write() {
1099   if (!align_write()) {
1100     return false;
1101   }
1102   uint strings_offset = _write_position;
1103   int strings_count = store_strings();
1104   if (strings_count < 0) {
1105     return false;
1106   }
1107   if (!align_write()) {
1108     return false;
1109   }
1110   uint strings_size = _write_position - strings_offset;
1111 
1112   uint entries_count = 0; // Number of entrant (useful) code entries
1113   uint entries_offset = _write_position;
1114 
1115   uint store_count = _store_entries_cnt;
1116   if (store_count > 0) {
1117     _aot_code_directory = CachedCodeDirectory::create();
1118     assert(_aot_code_directory != nullptr, "Sanity check");
1119 
1120     uint header_size = (uint)align_up(sizeof(AOTCodeCache::Header),  DATA_ALIGNMENT);
1121     uint load_count = (_load_header != nullptr) ? _load_header->entries_count() : 0;
1122     uint code_count = store_count + load_count;
1123     uint search_count = code_count * 2;
1124     uint search_size = search_count * sizeof(uint);
1125     uint entries_size = (uint)align_up(code_count * sizeof(AOTCodeEntry), DATA_ALIGNMENT); // In bytes
1126     uint preload_entries_cnt = 0;
1127     uint* preload_entries = NEW_C_HEAP_ARRAY(uint, code_count, mtCode);
1128     uint preload_entries_size = code_count * sizeof(uint);
1129     // _write_position should include code and strings
1130     uint code_alignment = code_count * DATA_ALIGNMENT; // We align_up code size when storing it.
1131     uint total_size = _write_position + _load_size + header_size +
1132                      code_alignment + search_size + preload_entries_size + entries_size;
1133     assert(total_size < max_aot_code_size(), "AOT Code size (" UINT32_FORMAT " bytes) is greater than AOTCodeMaxSize(" UINT32_FORMAT " bytes).", total_size, max_aot_code_size());
1134 
1135 
1136     // Create ordered search table for entries [id, index];
1137     uint* search = NEW_C_HEAP_ARRAY(uint, search_count, mtCode);
1138     // Allocate in AOT Cache buffer
1139     char* buffer = (char *)AOTCacheAccess::allocate_aot_code_region(total_size + DATA_ALIGNMENT);
1140     char* start = align_up(buffer, DATA_ALIGNMENT);
1141     char* current = start + header_size; // Skip header
1142 
1143     AOTCodeEntry* entries_address = _store_entries; // Pointer to latest entry
1144     uint adapters_count = 0;
1145     uint shared_blobs_count = 0;
1146     uint C1_blobs_count = 0;
1147     uint C2_blobs_count = 0;
1148     uint stubs_count = 0;
1149     uint nmethods_count = 0;
1150     uint max_size = 0;
1151     // Add old entries first
1152     if (_for_use && (_load_header != nullptr)) {
1153       for(uint i = 0; i < load_count; i++) {
1154         AOTCodeEntry* entry = &(_load_entries[i]);
1155         if (entry->load_fail()) {
1156           continue;
1157         }
1158         if (entry->not_entrant()) {
1159           log_info(aot, codecache, exit)("Not entrant load entry id: %d, hash: " UINT32_FORMAT_X_0, i, entry->id());
1160           if (entry->for_preload()) {
1161             // Skip not entrant preload code:
1162             // we can't pre-load code which may have failing dependencies.
1163             continue;
1164           }
1165           entry->set_entrant(); // Reset
1166         } else if (entry->for_preload() && entry->method() != nullptr) {
1167           // record entrant first version code for pre-loading
1168           preload_entries[preload_entries_cnt++] = entries_count;
1169         }
1170         {
1171           uint size = align_up(entry->size(), DATA_ALIGNMENT);
1172           if (size > max_size) {
1173             max_size = size;
1174           }
1175           copy_bytes((_load_buffer + entry->offset()), (address)current, size);
1176           entry->set_offset(current - start); // New offset
1177           current += size;
1178           uint n = write_bytes(entry, sizeof(AOTCodeEntry));
1179           if (n != sizeof(AOTCodeEntry)) {
1180             FREE_C_HEAP_ARRAY(uint, search);
1181             return false;
1182           }
1183           search[entries_count*2 + 0] = entry->id();
1184           search[entries_count*2 + 1] = entries_count;
1185           entries_count++;
1186           AOTCodeEntry::Kind kind = entry->kind();
1187           if (kind == AOTCodeEntry::Adapter) {
1188             adapters_count++;
1189           } else if (kind == AOTCodeEntry::SharedBlob) {
1190             shared_blobs_count++;
1191           } else if (kind == AOTCodeEntry::C1Blob) {
1192             C1_blobs_count++;
1193           } else if (kind == AOTCodeEntry::C2Blob) {
1194             C2_blobs_count++;
1195           } else if (kind == AOTCodeEntry::Stub) {
1196             stubs_count++;
1197           } else {
1198             assert(kind == AOTCodeEntry::Code, "sanity");
1199             nmethods_count++;
1200           }
1201         }
1202       }
1203     }
1204     // AOTCodeEntry entries were allocated in reverse in store buffer.
1205     // Process them in reverse order to cache first code first.
1206     for (int i = store_count - 1; i >= 0; i--) {
1207       AOTCodeEntry* entry = &entries_address[i];
1208       if (entry->load_fail()) {
1209         continue;
1210       }
1211       if (entry->not_entrant()) {
1212         log_info(aot, codecache, exit)("Not entrant new entry comp_id: %d, comp_level: %d, hash: " UINT32_FORMAT_X_0 "%s",
1213                                        entry->comp_id(), entry->comp_level(), entry->id(), (entry->has_clinit_barriers() ? ", has clinit barriers" : ""));
1214         if (entry->for_preload()) {
1215           // Skip not entrant preload code:
1216           // we can't pre-load code which may have failing dependencies.
1217           continue;
1218         }
1219         entry->set_entrant(); // Reset
1220       } else if (entry->for_preload() && entry->method() != nullptr) {
1221         // record entrant first version code for pre-loading
1222         preload_entries[preload_entries_cnt++] = entries_count;
1223       }
1224       {
1225         entry->set_next(nullptr); // clear pointers before storing data
1226         uint size = align_up(entry->size(), DATA_ALIGNMENT);
1227         if (size > max_size) {
1228           max_size = size;
1229         }
1230         copy_bytes((_store_buffer + entry->offset()), (address)current, size);
1231         entry->set_offset(current - start); // New offset
1232         entry->update_method_for_writing();
1233         current += size;
1234         uint n = write_bytes(entry, sizeof(AOTCodeEntry));
1235         if (n != sizeof(AOTCodeEntry)) {
1236           FREE_C_HEAP_ARRAY(uint, search);
1237           return false;
1238         }
1239         search[entries_count*2 + 0] = entry->id();
1240         search[entries_count*2 + 1] = entries_count;
1241         entries_count++;
1242         AOTCodeEntry::Kind kind = entry->kind();
1243         if (kind == AOTCodeEntry::Adapter) {
1244           adapters_count++;
1245         } else if (kind == AOTCodeEntry::SharedBlob) {
1246           shared_blobs_count++;
1247         } else if (kind == AOTCodeEntry::C1Blob) {
1248           C1_blobs_count++;
1249         } else if (kind == AOTCodeEntry::C2Blob) {
1250           C2_blobs_count++;
1251         } else if (kind == AOTCodeEntry::Stub) {
1252           stubs_count++;
1253         } else {
1254           assert(kind == AOTCodeEntry::Code, "sanity");
1255           nmethods_count++;
1256         }
1257       }
1258     }
1259 
1260     if (entries_count == 0) {
1261       log_info(aot, codecache, exit)("AOT Code Cache was not created: no entires");
1262       FREE_C_HEAP_ARRAY(uint, search);
1263       return true; // Nothing to write
1264     }
1265     assert(entries_count <= (store_count + load_count), "%d > (%d + %d)", entries_count, store_count, load_count);
1266     // Write strings
1267     if (strings_count > 0) {
1268       copy_bytes((_store_buffer + strings_offset), (address)current, strings_size);
1269       strings_offset = (current - start); // New offset
1270       current += strings_size;
1271     }
1272     uint preload_entries_offset = (current - start);
1273     preload_entries_size = preload_entries_cnt * sizeof(uint);
1274     if (preload_entries_size > 0) {
1275       copy_bytes((const char*)preload_entries, (address)current, preload_entries_size);
1276       current += preload_entries_size;
1277       log_info(aot, codecache, exit)("Wrote %d preload entries to AOT Code Cache", preload_entries_cnt);
1278     }
1279     if (preload_entries != nullptr) {
1280       FREE_C_HEAP_ARRAY(uint, preload_entries);
1281     }
1282 
1283     uint new_entries_offset = (current - start); // New offset
1284     // Sort and store search table
1285     qsort(search, entries_count, 2*sizeof(uint), uint_cmp);
1286     search_size = 2 * entries_count * sizeof(uint);
1287     copy_bytes((const char*)search, (address)current, search_size);
1288     FREE_C_HEAP_ARRAY(uint, search);
1289     current += search_size;
1290 
1291     // Write entries
1292     entries_size = entries_count * sizeof(AOTCodeEntry); // New size
1293     copy_bytes((_store_buffer + entries_offset), (address)current, entries_size);
1294     current += entries_size;
1295 
1296     log_stats_on_exit();
1297 
1298     uint size = (current - start);
1299     assert(size <= total_size, "%d > %d", size , total_size);
1300     uint blobs_count = shared_blobs_count + C1_blobs_count + C2_blobs_count;
1301     assert(nmethods_count == (entries_count - (stubs_count + blobs_count + adapters_count)), "sanity");
1302     log_debug(aot, codecache, exit)("  Adapters: total=%u", adapters_count);
1303     log_debug(aot, codecache, exit)("  Shared Blobs: total=%u", shared_blobs_count);
1304     log_debug(aot, codecache, exit)("  C1 Blobs: total=%u", C1_blobs_count);
1305     log_debug(aot, codecache, exit)("  C2 Blobs: total=%u", C2_blobs_count);
1306     log_debug(aot, codecache, exit)("  Stubs:    total=%u", stubs_count);
1307     log_debug(aot, codecache, exit)("  Nmethods: total=%u", nmethods_count);
1308     log_debug(aot, codecache, exit)("  AOT code cache size: %u bytes, max entry's size: %u bytes", size, max_size);
1309 
1310     // Finalize header
1311     AOTCodeCache::Header* header = (AOTCodeCache::Header*)start;
1312     header->init(size, (uint)strings_count, strings_offset,
1313                  entries_count, new_entries_offset,
1314                  preload_entries_cnt, preload_entries_offset,
1315                  adapters_count, shared_blobs_count,
1316                  C1_blobs_count, C2_blobs_count, stubs_count);
1317 
1318     log_info(aot, codecache, exit)("Wrote %d AOT code entries to AOT Code Cache", entries_count);
1319 
1320     _aot_code_directory->set_aot_code_data(size, start);
1321   }
1322   return true;
1323 }
1324 
1325 //------------------Store/Load AOT code ----------------------
1326 
1327 bool AOTCodeCache::store_code_blob(CodeBlob& blob, AOTCodeEntry::Kind entry_kind, uint id, const char* name, int entry_offset_count, int* entry_offsets) {
1328   AOTCodeCache* cache = open_for_dump();
1329   if (cache == nullptr) {
1330     return false;
1331   }
1332   assert(AOTCodeEntry::is_valid_entry_kind(entry_kind), "invalid entry_kind %d", entry_kind);
1333 
1334   if (AOTCodeEntry::is_adapter(entry_kind) && !is_dumping_adapter()) {
1335     return false;
1336   }
1337   if (AOTCodeEntry::is_blob(entry_kind) && !is_dumping_stub()) {
1338     return false;
1339   }
1340   log_debug(aot, codecache, stubs)("Writing blob '%s' (id=%u, kind=%s) to AOT Code Cache", name, id, aot_code_entry_kind_name[entry_kind]);
1341 
1342 #ifdef ASSERT
1343   LogStreamHandle(Trace, aot, codecache, stubs) log;
1344   if (log.is_enabled()) {
1345     FlagSetting fs(PrintRelocations, true);
1346     blob.print_on(&log);
1347   }
1348 #endif
1349   // we need to take a lock to prevent race between compiler threads generating AOT code
1350   // and the main thread generating adapter
1351   MutexLocker ml(Compile_lock);
1352   if (!is_on()) {
1353     return false; // AOT code cache was already dumped and closed.
1354   }
1355   if (!cache->align_write()) {
1356     return false;
1357   }
1358   uint entry_position = cache->_write_position;
1359 
1360   // Write name
1361   uint name_offset = cache->_write_position - entry_position;
1362   uint name_size = (uint)strlen(name) + 1; // Includes '/0'
1363   uint n = cache->write_bytes(name, name_size);
1364   if (n != name_size) {
1365     return false;
1366   }
1367 
1368   // Write CodeBlob
1369   if (!cache->align_write()) {
1370     return false;
1371   }
1372   uint blob_offset = cache->_write_position - entry_position;
1373   address archive_buffer = cache->reserve_bytes(blob.size());
1374   if (archive_buffer == nullptr) {
1375     return false;
1376   }
1377   CodeBlob::archive_blob(&blob, archive_buffer);
1378 
1379   uint reloc_data_size = blob.relocation_size();
1380   n = cache->write_bytes((address)blob.relocation_begin(), reloc_data_size);
1381   if (n != reloc_data_size) {
1382     return false;
1383   }
1384 
1385   bool has_oop_maps = false;
1386   if (blob.oop_maps() != nullptr) {
1387     if (!cache->write_oop_map_set(blob)) {
1388       return false;
1389     }
1390     has_oop_maps = true;
1391   }
1392 
1393 #ifndef PRODUCT
1394   // Write asm remarks
1395   if (!cache->write_asm_remarks(blob.asm_remarks(), /* use_string_table */ true)) {
1396     return false;
1397   }
1398   if (!cache->write_dbg_strings(blob.dbg_strings(), /* use_string_table */ true)) {
1399     return false;
1400   }
1401 #endif /* PRODUCT */
1402 
1403   if (!cache->write_relocations(blob)) {
1404     if (!cache->failed()) {
1405       // We may miss an address in AOT table - skip this code blob.
1406       cache->set_write_position(entry_position);
1407     }
1408     return false;
1409   }
1410 
1411   // Write entries offsets
1412   n = cache->write_bytes(&entry_offset_count, sizeof(int));
1413   if (n != sizeof(int)) {
1414     return false;
1415   }
1416   for (int i = 0; i < entry_offset_count; i++) {
1417     uint32_t off = (uint32_t)entry_offsets[i];
1418     n = cache->write_bytes(&off, sizeof(uint32_t));
1419     if (n != sizeof(uint32_t)) {
1420       return false;
1421     }
1422   }
1423   uint entry_size = cache->_write_position - entry_position;
1424   AOTCodeEntry* entry = new(cache) AOTCodeEntry(entry_kind, encode_id(entry_kind, id),
1425                                                 entry_position, entry_size, name_offset, name_size,
1426                                                 blob_offset, has_oop_maps, blob.content_begin());
1427   log_debug(aot, codecache, stubs)("Wrote code blob '%s' (id=%u, kind=%s) to AOT Code Cache", name, id, aot_code_entry_kind_name[entry_kind]);
1428   return true;
1429 }
1430 
1431 CodeBlob* AOTCodeCache::load_code_blob(AOTCodeEntry::Kind entry_kind, uint id, const char* name, int entry_offset_count, int* entry_offsets) {
1432   AOTCodeCache* cache = open_for_use();
1433   if (cache == nullptr) {
1434     return nullptr;
1435   }
1436   assert(AOTCodeEntry::is_valid_entry_kind(entry_kind), "invalid entry_kind %d", entry_kind);
1437 
1438   if (AOTCodeEntry::is_adapter(entry_kind) && !is_using_adapter()) {
1439     return nullptr;
1440   }
1441   if (AOTCodeEntry::is_blob(entry_kind) && !is_using_stub()) {
1442     return nullptr;
1443   }
1444   log_debug(aot, codecache, stubs)("Reading blob '%s' (id=%u, kind=%s) from AOT Code Cache", name, id, aot_code_entry_kind_name[entry_kind]);
1445 
1446   AOTCodeEntry* entry = cache->find_entry(entry_kind, encode_id(entry_kind, id));
1447   if (entry == nullptr) {
1448     return nullptr;
1449   }
1450   AOTCodeReader reader(cache, entry, nullptr);
1451   CodeBlob* blob = reader.compile_code_blob(name, entry_offset_count, entry_offsets);
1452 
1453   log_debug(aot, codecache, stubs)("%sRead blob '%s' (id=%u, kind=%s) from AOT Code Cache",
1454                                    (blob == nullptr? "Failed to " : ""), name, id, aot_code_entry_kind_name[entry_kind]);
1455   return blob;
1456 }
1457 
1458 CodeBlob* AOTCodeReader::compile_code_blob(const char* name, int entry_offset_count, int* entry_offsets) {
1459   uint entry_position = _entry->offset();
1460 
1461   // Read name
1462   uint name_offset = entry_position + _entry->name_offset();
1463   uint name_size = _entry->name_size(); // Includes '/0'
1464   const char* stored_name = addr(name_offset);
1465 
1466   if (strncmp(stored_name, name, (name_size - 1)) != 0) {
1467     log_warning(aot, codecache, stubs)("Saved blob's name '%s' is different from the expected name '%s'",
1468                                        stored_name, name);
1469     set_lookup_failed(); // Skip this blob
1470     return nullptr;
1471   }
1472 
1473   // Read archived code blob
1474   uint offset = entry_position + _entry->code_offset();
1475   CodeBlob* archived_blob = (CodeBlob*)addr(offset);
1476   offset += archived_blob->size();
1477 
1478   address reloc_data = (address)addr(offset);
1479   offset += archived_blob->relocation_size();
1480   set_read_position(offset);
1481 
1482   ImmutableOopMapSet* oop_maps = nullptr;
1483   if (_entry->has_oop_maps()) {
1484     oop_maps = read_oop_map_set();
1485   }
1486 
1487   CodeBlob* code_blob = CodeBlob::create(archived_blob,
1488                                          stored_name,
1489                                          reloc_data,
1490                                          oop_maps
1491                                         );
1492   if (code_blob == nullptr) { // no space left in CodeCache
1493     return nullptr;
1494   }
1495 
1496 #ifndef PRODUCT
1497   code_blob->asm_remarks().init();
1498   read_asm_remarks(code_blob->asm_remarks(), /* use_string_table */ true);
1499   code_blob->dbg_strings().init();
1500   read_dbg_strings(code_blob->dbg_strings(), /* use_string_table */ true);
1501 #endif // PRODUCT
1502 
1503   fix_relocations(code_blob);
1504 
1505   // Read entries offsets
1506   offset = read_position();
1507   int stored_count = *(int*)addr(offset);
1508   assert(stored_count == entry_offset_count, "entry offset count mismatch, count in AOT code cache=%d, expected=%d", stored_count, entry_offset_count);
1509   offset += sizeof(int);
1510   set_read_position(offset);
1511   for (int i = 0; i < stored_count; i++) {
1512     uint32_t off = *(uint32_t*)addr(offset);
1513     offset += sizeof(uint32_t);
1514     const char* entry_name = (_entry->kind() == AOTCodeEntry::Adapter) ? AdapterHandlerEntry::entry_name(i) : "";
1515     log_trace(aot, codecache, stubs)("Reading adapter '%s:%s' (0x%x) offset: 0x%x from AOT Code Cache",
1516                                       stored_name, entry_name, _entry->id(), off);
1517     entry_offsets[i] = off;
1518   }
1519 
1520 #ifdef ASSERT
1521   LogStreamHandle(Trace, aot, codecache, stubs) log;
1522   if (log.is_enabled()) {
1523     FlagSetting fs(PrintRelocations, true);
1524     code_blob->print_on(&log);
1525   }
1526 #endif
1527   return code_blob;
1528 }
1529 
1530 bool AOTCodeCache::store_stub(StubCodeGenerator* cgen, vmIntrinsicID id, const char* name, address start) {
1531   if (!is_dumping_stub()) {
1532     return false;
1533   }
1534   AOTCodeCache* cache = open_for_dump();
1535   if (cache == nullptr) {
1536     return false;
1537   }
1538   log_info(aot, codecache, stubs)("Writing stub '%s' id:%d to AOT Code Cache", name, (int)id);
1539   if (!cache->align_write()) {
1540     return false;
1541   }
1542 #ifdef ASSERT
1543   CodeSection* cs = cgen->assembler()->code_section();
1544   if (cs->has_locs()) {
1545     uint reloc_count = cs->locs_count();
1546     tty->print_cr("======== write stubs code section relocations [%d]:", reloc_count);
1547     // Collect additional data
1548     RelocIterator iter(cs);
1549     while (iter.next()) {
1550       switch (iter.type()) {
1551         case relocInfo::none:
1552           break;
1553         default: {
1554           iter.print_current_on(tty);
1555           fatal("stub's relocation %d unimplemented", (int)iter.type());
1556           break;
1557         }
1558       }
1559     }
1560   }
1561 #endif
1562   uint entry_position = cache->_write_position;
1563 
1564   // Write code
1565   uint code_offset = 0;
1566   uint code_size = cgen->assembler()->pc() - start;
1567   uint n = cache->write_bytes(start, code_size);
1568   if (n != code_size) {
1569     return false;
1570   }
1571   // Write name
1572   uint name_offset = cache->_write_position - entry_position;
1573   uint name_size = (uint)strlen(name) + 1; // Includes '/0'
1574   n = cache->write_bytes(name, name_size);
1575   if (n != name_size) {
1576     return false;
1577   }
1578   uint entry_size = cache->_write_position - entry_position;
1579   AOTCodeEntry* entry = new(cache) AOTCodeEntry(entry_position, entry_size, name_offset, name_size,
1580                                                 code_offset, code_size,
1581                                                 AOTCodeEntry::Stub, (uint32_t)id);
1582   log_info(aot, codecache, stubs)("Wrote stub '%s' id:%d to AOT Code Cache", name, (int)id);
1583   return true;
1584 }
1585 
1586 bool AOTCodeCache::load_stub(StubCodeGenerator* cgen, vmIntrinsicID id, const char* name, address start) {
1587   if (!is_using_stub()) {
1588     return false;
1589   }
1590   assert(start == cgen->assembler()->pc(), "wrong buffer");
1591   AOTCodeCache* cache = open_for_use();
1592   if (cache == nullptr) {
1593     return false;
1594   }
1595   AOTCodeEntry* entry = cache->find_entry(AOTCodeEntry::Stub, (uint)id);
1596   if (entry == nullptr) {
1597     return false;
1598   }
1599   uint entry_position = entry->offset();
1600   // Read name
1601   uint name_offset = entry->name_offset() + entry_position;
1602   uint name_size   = entry->name_size(); // Includes '/0'
1603   const char* saved_name = cache->addr(name_offset);
1604   if (strncmp(name, saved_name, (name_size - 1)) != 0) {
1605     log_warning(aot, codecache)("Saved stub's name '%s' is different from '%s' for id:%d", saved_name, name, (int)id);
1606     cache->set_failed();
1607     report_load_failure();
1608     return false;
1609   }
1610   log_info(aot, codecache, stubs)("Reading stub '%s' id:%d from AOT Code Cache", name, (int)id);
1611   // Read code
1612   uint code_offset = entry->code_offset() + entry_position;
1613   uint code_size   = entry->code_size();
1614   copy_bytes(cache->addr(code_offset), start, code_size);
1615   cgen->assembler()->code_section()->set_end(start + code_size);
1616   log_info(aot, codecache, stubs)("Read stub '%s' id:%d from AOT Code Cache", name, (int)id);
1617   return true;
1618 }
1619 
1620 AOTCodeEntry* AOTCodeCache::store_nmethod(nmethod* nm, AbstractCompiler* compiler, bool for_preload) {
1621   if (!is_dumping_code()) {
1622     return nullptr;
1623   }
1624   if (!CDSConfig::is_dumping_aot_code()) {
1625     return nullptr; // The metadata and heap in the CDS image haven't been finalized yet.
1626   }
1627   AOTCodeCache* cache = open_for_dump();
1628   if (cache == nullptr) {
1629     return nullptr; // Cache file is closed
1630   }
1631   if (nm->is_osr_method()) {
1632     return nullptr; // No OSR
1633   }
1634   if (!compiler->is_c1() && !compiler->is_c2()) {
1635     // Only c1 and c2 compilers
1636     return nullptr;
1637   }
1638   int comp_level = nm->comp_level();
1639   if (comp_level == CompLevel_full_profile) {
1640     // Do not cache C1 compiles with full profile i.e. tier3
1641     return nullptr;
1642   }
1643   assert(comp_level == CompLevel_simple || comp_level == CompLevel_limited_profile || comp_level == CompLevel_full_optimization, "must be");
1644 
1645   TraceTime t1("Total time to store AOT code", &_t_totalStore, enable_timers(), false);
1646   AOTCodeEntry* entry = nullptr;
1647   entry = cache->write_nmethod(nm, for_preload);
1648   if (entry == nullptr) {
1649     log_info(aot, codecache, nmethod)("%d (L%d): nmethod store attempt failed", nm->compile_id(), comp_level);
1650   }
1651   return entry;
1652 }
1653 
1654 AOTCodeEntry* AOTCodeCache::write_nmethod(nmethod* nm, bool for_preload) {
1655   AOTCodeCache* cache = open_for_dump();
1656   assert(cache != nullptr, "sanity check");
1657   assert(!nm->has_clinit_barriers() || (ClassInitBarrierMode > 0), "sanity");
1658   uint comp_id = nm->compile_id();
1659   uint comp_level = nm->comp_level();
1660   Method* method = nm->method();
1661   bool method_in_cds = MetaspaceShared::is_in_shared_metaspace((address)method);
1662   InstanceKlass* holder = method->method_holder();
1663   bool klass_in_cds = holder->is_shared() && !holder->defined_by_other_loaders();
1664   bool builtin_loader = holder->class_loader_data()->is_builtin_class_loader_data();
1665   if (!builtin_loader) {
1666     ResourceMark rm;
1667     log_info(aot, codecache, nmethod)("%d (L%d): Skip method '%s' loaded by custom class loader %s", comp_id, (int)comp_level, method->name_and_sig_as_C_string(), holder->class_loader_data()->loader_name());
1668     return nullptr;
1669   }
1670   if (for_preload && !(method_in_cds && klass_in_cds)) {
1671     ResourceMark rm;
1672     log_info(aot, codecache, nmethod)("%d (L%d): Skip method '%s' for preload: not in CDS", comp_id, (int)comp_level, method->name_and_sig_as_C_string());
1673     return nullptr;
1674   }
1675   assert(!for_preload || method_in_cds, "sanity");
1676   _for_preload = for_preload;
1677   _has_clinit_barriers = nm->has_clinit_barriers();
1678 
1679   if (!align_write()) {
1680     return nullptr;
1681   }
1682 
1683   uint entry_position = _write_position;
1684 
1685   // Write name
1686   uint name_offset = 0;
1687   uint name_size   = 0;
1688   uint hash = 0;
1689   uint n;
1690   {
1691     ResourceMark rm;
1692     const char* name = method->name_and_sig_as_C_string();
1693     log_info(aot, codecache, nmethod)("%d (L%d): Writing nmethod '%s' (comp level: %d, %s) to AOT Code Cache",
1694                                       comp_id, (int)comp_level, name, comp_level,
1695                                       (nm->has_clinit_barriers() ? ", has clinit barriers" : ""));
1696 
1697     LogStreamHandle(Info, aot, codecache, loader) log;
1698     if (log.is_enabled()) {
1699       oop loader = holder->class_loader();
1700       oop domain = holder->protection_domain();
1701       log.print("Holder: ");
1702       holder->print_value_on(&log);
1703       log.print(" loader: ");
1704       if (loader == nullptr) {
1705         log.print("nullptr");
1706       } else {
1707         loader->print_value_on(&log);
1708       }
1709       log.print(" domain: ");
1710       if (domain == nullptr) {
1711         log.print("nullptr");
1712       } else {
1713         domain->print_value_on(&log);
1714       }
1715       log.cr();
1716     }
1717     name_offset = _write_position  - entry_position;
1718     name_size   = (uint)strlen(name) + 1; // Includes '/0'
1719     n = write_bytes(name, name_size);
1720     if (n != name_size) {
1721       return nullptr;
1722     }
1723     hash = java_lang_String::hash_code((const jbyte*)name, (int)strlen(name));
1724   }
1725 
1726   // Write CodeBlob
1727   if (!cache->align_write()) {
1728     return nullptr;
1729   }
1730   uint blob_offset = cache->_write_position - entry_position;
1731   address archive_buffer = cache->reserve_bytes(nm->size());
1732   if (archive_buffer == nullptr) {
1733     return nullptr;
1734   }
1735   CodeBlob::archive_blob(nm, archive_buffer);
1736 
1737   uint reloc_data_size = nm->relocation_size();
1738   n = write_bytes((address)nm->relocation_begin(), reloc_data_size);
1739   if (n != reloc_data_size) {
1740     return nullptr;
1741   }
1742 
1743   // Write oops and metadata present in the nmethod's data region
1744   if (!write_oops(nm)) {
1745     if (lookup_failed() && !failed()) {
1746       // Skip this method and reposition file
1747       set_write_position(entry_position);
1748     }
1749     return nullptr;
1750   }
1751   if (!write_metadata(nm)) {
1752     if (lookup_failed() && !failed()) {
1753       // Skip this method and reposition file
1754       set_write_position(entry_position);
1755     }
1756     return nullptr;
1757   }
1758 
1759   bool has_oop_maps = false;
1760   if (nm->oop_maps() != nullptr) {
1761     if (!cache->write_oop_map_set(*nm)) {
1762       return nullptr;
1763     }
1764     has_oop_maps = true;
1765   }
1766 
1767   uint immutable_data_size = nm->immutable_data_size();
1768   n = write_bytes(nm->immutable_data_begin(), immutable_data_size);
1769   if (n != immutable_data_size) {
1770     return nullptr;
1771   }
1772 
1773   JavaThread* thread = JavaThread::current();
1774   HandleMark hm(thread);
1775   GrowableArray<Handle> oop_list;
1776   GrowableArray<Metadata*> metadata_list;
1777 
1778   nm->create_reloc_immediates_list(thread, oop_list, metadata_list);
1779   if (!write_nmethod_reloc_immediates(oop_list, metadata_list)) {
1780     if (lookup_failed() && !failed()) {
1781       // Skip this method and reposition file
1782       set_write_position(entry_position);
1783     }
1784     return nullptr;
1785   }
1786 
1787   if (!write_relocations(*nm, &oop_list, &metadata_list)) {
1788     return nullptr;
1789   }
1790 
1791 #ifndef PRODUCT
1792   if (!cache->write_asm_remarks(nm->asm_remarks(), /* use_string_table */ false)) {
1793     return nullptr;
1794   }
1795   if (!cache->write_dbg_strings(nm->dbg_strings(), /* use_string_table */ false)) {
1796     return nullptr;
1797   }
1798 #endif /* PRODUCT */
1799 
1800   uint entry_size = _write_position - entry_position;
1801   AOTCodeEntry* entry = new (this) AOTCodeEntry(AOTCodeEntry::Code, hash,
1802                                                 entry_position, entry_size,
1803                                                 name_offset, name_size,
1804                                                 blob_offset, has_oop_maps,
1805                                                 nm->content_begin(), comp_level, comp_id,
1806                                                 nm->has_clinit_barriers(), for_preload);
1807   if (method_in_cds) {
1808     entry->set_method(method);
1809   }
1810 #ifdef ASSERT
1811   if (nm->has_clinit_barriers() || for_preload) {
1812     assert(for_preload, "sanity");
1813     assert(entry->method() != nullptr, "sanity");
1814   }
1815 #endif
1816   {
1817     ResourceMark rm;
1818     const char* name = nm->method()->name_and_sig_as_C_string();
1819     log_info(aot, codecache, nmethod)("%d (L%d): Wrote nmethod '%s'%s to AOT Code Cache",
1820                            comp_id, (int)comp_level, name, (for_preload ? " (for preload)" : ""));
1821   }
1822   if (VerifyCachedCode) {
1823     return nullptr;
1824   }
1825   return entry;
1826 }
1827 
1828 bool AOTCodeCache::load_nmethod(ciEnv* env, ciMethod* target, int entry_bci, AbstractCompiler* compiler, CompLevel comp_level) {
1829   if (!is_using_code()) {
1830     return false;
1831   }
1832   AOTCodeCache* cache = open_for_use();
1833   if (cache == nullptr) {
1834     return false;
1835   }
1836   assert(entry_bci == InvocationEntryBci, "unexpected entry_bci=%d", entry_bci);
1837   TraceTime t1("Total time to load AOT code", &_t_totalLoad, enable_timers(), false);
1838   CompileTask* task = env->task();
1839   task->mark_aot_load_start(os::elapsed_counter());
1840   AOTCodeEntry* entry = task->aot_code_entry();
1841   bool preload = task->preload();
1842   assert(entry != nullptr, "sanity");
1843   if (log_is_enabled(Info, aot, codecache, nmethod)) {
1844     VM_ENTRY_MARK;
1845     ResourceMark rm;
1846     methodHandle method(THREAD, target->get_Method());
1847     const char* target_name = method->name_and_sig_as_C_string();
1848     uint hash = java_lang_String::hash_code((const jbyte*)target_name, (int)strlen(target_name));
1849     bool clinit_brs = entry->has_clinit_barriers();
1850     log_info(aot, codecache, nmethod)("%d (L%d): %s nmethod '%s' (hash: " UINT32_FORMAT_X_0 "%s)",
1851                                       task->compile_id(), task->comp_level(), (preload ? "Preloading" : "Reading"),
1852                                       target_name, hash, (clinit_brs ? ", has clinit barriers" : ""));
1853   }
1854   ReadingMark rdmk;
1855   if (rdmk.failed()) {
1856     // Cache is closed, cannot touch anything.
1857     return false;
1858   }
1859 
1860   AOTCodeReader reader(cache, entry, task);
1861   bool success = reader.compile_nmethod(env, target, compiler);
1862   if (success) {
1863     task->set_num_inlined_bytecodes(entry->num_inlined_bytecodes());
1864   } else {
1865     entry->set_load_fail();
1866   }
1867   task->mark_aot_load_finish(os::elapsed_counter());
1868   return success;
1869 }
1870 
1871 bool AOTCodeReader::compile_nmethod(ciEnv* env, ciMethod* target, AbstractCompiler* compiler) {
1872   CompileTask* task = env->task();
1873   AOTCodeEntry* aot_code_entry = (AOTCodeEntry*)_entry;
1874   nmethod* nm = nullptr;
1875 
1876   uint entry_position = aot_code_entry->offset();
1877   uint archived_nm_offset = entry_position + aot_code_entry->code_offset();
1878   nmethod* archived_nm = (nmethod*)addr(archived_nm_offset);
1879   set_read_position(archived_nm_offset + archived_nm->size());
1880 
1881   OopRecorder* oop_recorder = new OopRecorder(env->arena());
1882   env->set_oop_recorder(oop_recorder);
1883 
1884   uint offset;
1885 
1886   offset = read_position();
1887   address reloc_data = (address)addr(offset);
1888   offset += archived_nm->relocation_size();
1889   set_read_position(offset);
1890 
1891   // Read oops and metadata
1892   VM_ENTRY_MARK
1893   GrowableArray<Handle> oop_list;
1894   GrowableArray<Metadata*> metadata_list;
1895 
1896   if (!read_oop_metadata_list(THREAD, target, oop_list, metadata_list, oop_recorder)) {
1897    return false;
1898   }
1899 
1900   ImmutableOopMapSet* oopmaps = read_oop_map_set();
1901 
1902   offset = read_position();
1903   address immutable_data = (address)addr(offset);
1904   offset += archived_nm->immutable_data_size();
1905   set_read_position(offset);
1906 
1907   GrowableArray<Handle> reloc_immediate_oop_list;
1908   GrowableArray<Metadata*> reloc_immediate_metadata_list;
1909   if (!read_oop_metadata_list(THREAD, target, reloc_immediate_oop_list, reloc_immediate_metadata_list, nullptr)) {
1910    return false;
1911   }
1912 
1913   // Read Dependencies (compressed already)
1914   Dependencies* dependencies = new Dependencies(env);
1915   dependencies->set_content(immutable_data, archived_nm->dependencies_size());
1916   env->set_dependencies(dependencies);
1917 
1918   const char* name = addr(entry_position + aot_code_entry->name_offset());
1919 
1920   if (VerifyCachedCode) {
1921     return false;
1922   }
1923 
1924   TraceTime t1("Total time to register AOT nmethod", &_t_totalRegister, enable_timers(), false);
1925   nm = env->register_aot_method(THREAD,
1926                                 target,
1927                                 compiler,
1928                                 archived_nm,
1929                                 reloc_data,
1930                                 oop_list,
1931                                 metadata_list,
1932                                 oopmaps,
1933                                 immutable_data,
1934                                 reloc_immediate_oop_list,
1935                                 reloc_immediate_metadata_list,
1936                                 this);
1937   bool success = task->is_success();
1938   if (success) {
1939     aot_code_entry->set_loaded();
1940     log_info(aot, codecache, nmethod)("%d (L%d): Read nmethod '%s' from AOT Code Cache", compile_id(), comp_level(), name);
1941 #ifdef ASSERT
1942     LogStreamHandle(Debug, aot, codecache, nmethod) log;
1943     if (log.is_enabled()) {
1944       FlagSetting fs(PrintRelocations, true);
1945       nm->print_on(&log);
1946       nm->decode2(&log);
1947     }
1948 #endif
1949   }
1950 
1951   return success;
1952 }
1953 
1954 bool skip_preload(methodHandle mh) {
1955   if (!mh->method_holder()->is_loaded()) {
1956     return true;
1957   }
1958   DirectiveSet* directives = DirectivesStack::getMatchingDirective(mh, nullptr);
1959   if (directives->DontPreloadOption) {
1960     LogStreamHandle(Info, aot, codecache, init) log;
1961     if (log.is_enabled()) {
1962       log.print("Exclude preloading code for ");
1963       mh->print_value_on(&log);
1964     }
1965     return true;
1966   }
1967   return false;
1968 }
1969 
1970 bool AOTCodeCache::gen_preload_code(ciMethod* m, int entry_bci) {
1971   VM_ENTRY_MARK;
1972   return (entry_bci == InvocationEntryBci) && is_dumping_code() && (ClassInitBarrierMode > 0) &&
1973          AOTCacheAccess::can_generate_aot_code(m->get_Method());
1974 }
1975 
1976 void AOTCodeCache::preload_code(JavaThread* thread) {
1977   if (!is_using_code()) {
1978     return;
1979   }
1980   if ((DisableCachedCode & (1 << 3)) != 0) {
1981     return; // no preloaded code (level 5);
1982   }
1983   _cache->preload_startup_code(thread);
1984 }
1985 
1986 void AOTCodeCache::preload_startup_code(TRAPS) {
1987   if (CompilationPolicy::compiler_count(CompLevel_full_optimization) == 0) {
1988     // Since we reuse the CompilerBroker API to install cached code, we're required to have a JIT compiler for the
1989     // level we want (that is CompLevel_full_optimization).
1990     return;
1991   }
1992   assert(_for_use, "sanity");
1993   uint count = _load_header->entries_count();
1994   if (_load_entries == nullptr) {
1995     // Read it
1996     _search_entries = (uint*)addr(_load_header->entries_offset()); // [id, index]
1997     _load_entries = (AOTCodeEntry*)(_search_entries + 2 * count);
1998     log_info(aot, codecache, init)("Read %d entries table at offset %d from AOT Code Cache", count, _load_header->entries_offset());
1999   }
2000   uint preload_entries_count = _load_header->preload_entries_count();
2001   if (preload_entries_count > 0) {
2002     uint* entries_index = (uint*)addr(_load_header->preload_entries_offset());
2003     log_info(aot, codecache, init)("Load %d preload entries from AOT Code Cache", preload_entries_count);
2004     uint count = MIN2(preload_entries_count, SCLoadStop);
2005     for (uint i = SCLoadStart; i < count; i++) {
2006       uint index = entries_index[i];
2007       AOTCodeEntry* entry = &(_load_entries[index]);
2008       if (entry->not_entrant()) {
2009         continue;
2010       }
2011       Method* m = AOTCacheAccess::convert_offset_to_method(entry->method_offset());
2012       entry->set_method(m);
2013       methodHandle mh(THREAD, entry->method());
2014       assert((mh.not_null() && MetaspaceShared::is_in_shared_metaspace((address)mh())), "sanity");
2015       if (skip_preload(mh)) {
2016         continue; // Exclude preloading for this method
2017       }
2018       assert(mh->method_holder()->is_loaded(), "");
2019       if (!mh->method_holder()->is_linked()) {
2020         assert(!HAS_PENDING_EXCEPTION, "");
2021         mh->method_holder()->link_class(THREAD);
2022         if (HAS_PENDING_EXCEPTION) {
2023           LogStreamHandle(Info, aot, codecache) log;
2024           if (log.is_enabled()) {
2025             ResourceMark rm;
2026             log.print("Linkage failed for %s: ", mh->method_holder()->external_name());
2027             THREAD->pending_exception()->print_value_on(&log);
2028             if (log_is_enabled(Debug, aot, codecache)) {
2029               THREAD->pending_exception()->print_on(&log);
2030             }
2031           }
2032           CLEAR_PENDING_EXCEPTION;
2033         }
2034       }
2035       if (mh->aot_code_entry() != nullptr) {
2036         // Second C2 compilation of the same method could happen for
2037         // different reasons without marking first entry as not entrant.
2038         continue; // Keep old entry to avoid issues
2039       }
2040       mh->set_aot_code_entry(entry);
2041       CompileBroker::compile_method(mh, InvocationEntryBci, CompLevel_full_optimization, 0, false, CompileTask::Reason_Preload, CHECK);
2042     }
2043   }
2044 }
2045 
2046 // ------------ process code and data --------------
2047 
2048 // Can't use -1. It is valid value for jump to iteself destination
2049 // used by static call stub: see NativeJump::jump_destination().
2050 #define BAD_ADDRESS_ID -2
2051 
2052 bool AOTCodeCache::write_relocations(CodeBlob& code_blob, GrowableArray<Handle>* oop_list, GrowableArray<Metadata*>* metadata_list) {
2053   GrowableArray<uint> reloc_data;
2054   RelocIterator iter(&code_blob);
2055   LogStreamHandle(Trace, aot, codecache, reloc) log;
2056   while (iter.next()) {
2057     int idx = reloc_data.append(0); // default value
2058     switch (iter.type()) {
2059       case relocInfo::none:
2060       break;
2061       case relocInfo::oop_type: {
2062         oop_Relocation* r = (oop_Relocation*)iter.reloc();
2063         if (r->oop_is_immediate()) {
2064           assert(oop_list != nullptr, "sanity check");
2065           // store index of oop in the reloc immediate oop list
2066           Handle h(JavaThread::current(), r->oop_value());
2067           int oop_idx = oop_list->find(h);
2068           assert(oop_idx != -1, "sanity check");
2069           reloc_data.at_put(idx, (uint)oop_idx);
2070         }
2071         break;
2072       }
2073       case relocInfo::metadata_type: {
2074         metadata_Relocation* r = (metadata_Relocation*)iter.reloc();
2075         if (r->metadata_is_immediate()) {
2076           assert(metadata_list != nullptr, "sanity check");
2077           // store index of metadata in the reloc immediate metadata list
2078           int metadata_idx = metadata_list->find(r->metadata_value());
2079           assert(metadata_idx != -1, "sanity check");
2080           reloc_data.at_put(idx, (uint)metadata_idx);
2081         }
2082         break;
2083       }
2084       case relocInfo::virtual_call_type:  // Fall through. They all call resolve_*_call blobs.
2085       case relocInfo::opt_virtual_call_type:
2086       case relocInfo::static_call_type: {
2087         CallRelocation* r = (CallRelocation*)iter.reloc();
2088         address dest = r->destination();
2089         if (dest == r->addr()) { // possible call via trampoline on Aarch64
2090           dest = (address)-1;    // do nothing in this case when loading this relocation
2091         }
2092         int id = _table->id_for_address(dest, iter, &code_blob);
2093         if (id == BAD_ADDRESS_ID) {
2094           return false;
2095         }
2096         reloc_data.at_put(idx, id);
2097         break;
2098       }
2099       case relocInfo::trampoline_stub_type: {
2100         address dest = ((trampoline_stub_Relocation*)iter.reloc())->destination();
2101         int id = _table->id_for_address(dest, iter, &code_blob);
2102         if (id == BAD_ADDRESS_ID) {
2103           return false;
2104         }
2105         reloc_data.at_put(idx, id);
2106         break;
2107       }
2108       case relocInfo::static_stub_type:
2109         break;
2110       case relocInfo::runtime_call_type: {
2111         // Record offset of runtime destination
2112         CallRelocation* r = (CallRelocation*)iter.reloc();
2113         address dest = r->destination();
2114         if (dest == r->addr()) { // possible call via trampoline on Aarch64
2115           dest = (address)-1;    // do nothing in this case when loading this relocation
2116         }
2117         int id = _table->id_for_address(dest, iter, &code_blob);
2118         if (id == BAD_ADDRESS_ID) {
2119           return false;
2120         }
2121         reloc_data.at_put(idx, id);
2122         break;
2123       }
2124       case relocInfo::runtime_call_w_cp_type:
2125         log_debug(aot, codecache, reloc)("runtime_call_w_cp_type relocation is not implemented");
2126         return false;
2127       case relocInfo::external_word_type: {
2128         // Record offset of runtime target
2129         address target = ((external_word_Relocation*)iter.reloc())->target();
2130         int id = _table->id_for_address(target, iter, &code_blob);
2131         if (id == BAD_ADDRESS_ID) {
2132           return false;
2133         }
2134         reloc_data.at_put(idx, id);
2135         break;
2136       }
2137       case relocInfo::internal_word_type:
2138         break;
2139       case relocInfo::section_word_type:
2140         break;
2141       case relocInfo::poll_type:
2142         break;
2143       case relocInfo::poll_return_type:
2144         break;
2145       case relocInfo::post_call_nop_type:
2146         break;
2147       case relocInfo::entry_guard_type:
2148         break;
2149       default:
2150         log_debug(aot, codecache, reloc)("relocation %d unimplemented", (int)iter.type());
2151         return false;
2152         break;
2153     }
2154     if (log.is_enabled()) {
2155       iter.print_current_on(&log);
2156     }
2157   }
2158 
2159   // Write additional relocation data: uint per relocation
2160   // Write the count first
2161   int count = reloc_data.length();
2162   write_bytes(&count, sizeof(int));
2163   for (GrowableArrayIterator<uint> iter = reloc_data.begin();
2164        iter != reloc_data.end(); ++iter) {
2165     uint value = *iter;
2166     int n = write_bytes(&value, sizeof(uint));
2167     if (n != sizeof(uint)) {
2168       return false;
2169     }
2170   }
2171   return true;
2172 }
2173 
2174 void AOTCodeReader::fix_relocations(CodeBlob* code_blob, GrowableArray<Handle>* oop_list, GrowableArray<Metadata*>* metadata_list) {
2175   LogStreamHandle(Trace, aot, reloc) log;
2176   uint offset = read_position();
2177   int count = *(int*)addr(offset);
2178   offset += sizeof(int);
2179   if (log.is_enabled()) {
2180     log.print_cr("======== extra relocations count=%d", count);
2181   }
2182   uint* reloc_data = (uint*)addr(offset);
2183   offset += (count * sizeof(uint));
2184   set_read_position(offset);
2185 
2186   RelocIterator iter(code_blob);
2187   int j = 0;
2188   while (iter.next()) {
2189     switch (iter.type()) {
2190       case relocInfo::none:
2191         break;
2192       case relocInfo::oop_type: {
2193         assert(code_blob->is_nmethod(), "sanity check");
2194         oop_Relocation* r = (oop_Relocation*)iter.reloc();
2195         if (r->oop_is_immediate()) {
2196           assert(oop_list != nullptr, "sanity check");
2197           Handle h = oop_list->at(reloc_data[j]);
2198           r->set_value(cast_from_oop<address>(h()));
2199         } else {
2200           r->fix_oop_relocation();
2201         }
2202         break;
2203       }
2204       case relocInfo::metadata_type: {
2205         assert(code_blob->is_nmethod(), "sanity check");
2206         metadata_Relocation* r = (metadata_Relocation*)iter.reloc();
2207         Metadata* m;
2208         if (r->metadata_is_immediate()) {
2209           assert(metadata_list != nullptr, "sanity check");
2210           m = metadata_list->at(reloc_data[j]);
2211         } else {
2212           // Get already updated value from nmethod.
2213           int index = r->metadata_index();
2214           m = code_blob->as_nmethod()->metadata_at(index);
2215         }
2216         r->set_value((address)m);
2217         break;
2218       }
2219       case relocInfo::virtual_call_type:   // Fall through. They all call resolve_*_call blobs.
2220       case relocInfo::opt_virtual_call_type:
2221       case relocInfo::static_call_type: {
2222         address dest = _cache->address_for_id(reloc_data[j]);
2223         if (dest != (address)-1) {
2224           ((CallRelocation*)iter.reloc())->set_destination(dest);
2225         }
2226         break;
2227       }
2228       case relocInfo::trampoline_stub_type: {
2229         address dest = _cache->address_for_id(reloc_data[j]);
2230         if (dest != (address)-1) {
2231           ((trampoline_stub_Relocation*)iter.reloc())->set_destination(dest);
2232         }
2233         break;
2234       }
2235       case relocInfo::static_stub_type:
2236         break;
2237       case relocInfo::runtime_call_type: {
2238         address dest = _cache->address_for_id(reloc_data[j]);
2239         if (dest != (address)-1) {
2240           ((CallRelocation*)iter.reloc())->set_destination(dest);
2241         }
2242         break;
2243       }
2244       case relocInfo::runtime_call_w_cp_type:
2245         // this relocation should not be in cache (see write_relocations)
2246         assert(false, "runtime_call_w_cp_type relocation is not implemented");
2247         break;
2248       case relocInfo::external_word_type: {
2249         address target = _cache->address_for_id(reloc_data[j]);
2250         // Add external address to global table
2251         int index = ExternalsRecorder::find_index(target);
2252         // Update index in relocation
2253         Relocation::add_jint(iter.data(), index);
2254         external_word_Relocation* reloc = (external_word_Relocation*)iter.reloc();
2255         assert(reloc->target() == target, "sanity");
2256         reloc->set_value(target); // Patch address in the code
2257         break;
2258       }
2259       case relocInfo::internal_word_type: {
2260         internal_word_Relocation* r = (internal_word_Relocation*)iter.reloc();
2261         r->fix_relocation_after_aot_load(aot_code_entry()->dumptime_content_start_addr(), code_blob->content_begin());
2262         break;
2263       }
2264       case relocInfo::section_word_type: {
2265         section_word_Relocation* r = (section_word_Relocation*)iter.reloc();
2266         r->fix_relocation_after_aot_load(aot_code_entry()->dumptime_content_start_addr(), code_blob->content_begin());
2267         break;
2268       }
2269       case relocInfo::poll_type:
2270         break;
2271       case relocInfo::poll_return_type:
2272         break;
2273       case relocInfo::post_call_nop_type:
2274         break;
2275       case relocInfo::entry_guard_type:
2276         break;
2277       default:
2278         assert(false,"relocation %d unimplemented", (int)iter.type());
2279         break;
2280     }
2281     if (log.is_enabled()) {
2282       iter.print_current_on(&log);
2283     }
2284     j++;
2285   }
2286   assert(j == count, "sanity");
2287 }
2288 
2289 bool AOTCodeCache::write_nmethod_reloc_immediates(GrowableArray<Handle>& oop_list, GrowableArray<Metadata*>& metadata_list) {
2290   int count = oop_list.length();
2291   if (!write_bytes(&count, sizeof(int))) {
2292     return false;
2293   }
2294   for (GrowableArrayIterator<Handle> iter = oop_list.begin();
2295        iter != oop_list.end(); ++iter) {
2296     Handle h = *iter;
2297     if (!write_oop(h())) {
2298       return false;
2299     }
2300   }
2301 
2302   count = metadata_list.length();
2303   if (!write_bytes(&count, sizeof(int))) {
2304     return false;
2305   }
2306   for (GrowableArrayIterator<Metadata*> iter = metadata_list.begin();
2307        iter != metadata_list.end(); ++iter) {
2308     Metadata* m = *iter;
2309     if (!write_metadata(m)) {
2310       return false;
2311     }
2312   }
2313   return true;
2314 }
2315 
2316 bool AOTCodeCache::write_metadata(nmethod* nm) {
2317   int count = nm->metadata_count()-1;
2318   if (!write_bytes(&count, sizeof(int))) {
2319     return false;
2320   }
2321   for (Metadata** p = nm->metadata_begin(); p < nm->metadata_end(); p++) {
2322     if (!write_metadata(*p)) {
2323       return false;
2324     }
2325   }
2326   return true;
2327 }
2328 
2329 bool AOTCodeCache::write_metadata(Metadata* m) {
2330   uint n = 0;
2331   if (m == nullptr) {
2332     DataKind kind = DataKind::Null;
2333     n = write_bytes(&kind, sizeof(int));
2334     if (n != sizeof(int)) {
2335       return false;
2336     }
2337   } else if (m == (Metadata*)Universe::non_oop_word()) {
2338     DataKind kind = DataKind::No_Data;
2339     n = write_bytes(&kind, sizeof(int));
2340     if (n != sizeof(int)) {
2341       return false;
2342     }
2343   } else if (m->is_klass()) {
2344     if (!write_klass((Klass*)m)) {
2345       return false;
2346     }
2347   } else if (m->is_method()) {
2348     if (!write_method((Method*)m)) {
2349       return false;
2350     }
2351   } else if (m->is_methodCounters()) {
2352     DataKind kind = DataKind::MethodCnts;
2353     n = write_bytes(&kind, sizeof(int));
2354     if (n != sizeof(int)) {
2355       return false;
2356     }
2357     if (!write_method(((MethodCounters*)m)->method())) {
2358       return false;
2359     }
2360     log_debug(aot, codecache, metadata)("%d (L%d): Write MethodCounters : " INTPTR_FORMAT, compile_id(), comp_level(), p2i(m));
2361   } else { // Not supported
2362     fatal("metadata : " INTPTR_FORMAT " unimplemented", p2i(m));
2363     return false;
2364   }
2365   return true;
2366 }
2367 
2368 Metadata* AOTCodeReader::read_metadata(const methodHandle& comp_method) {
2369   uint code_offset = read_position();
2370   Metadata* m = nullptr;
2371   DataKind kind = *(DataKind*)addr(code_offset);
2372   code_offset += sizeof(DataKind);
2373   set_read_position(code_offset);
2374   if (kind == DataKind::Null) {
2375     m = (Metadata*)nullptr;
2376   } else if (kind == DataKind::No_Data) {
2377     m = (Metadata*)Universe::non_oop_word();
2378   } else if (kind == DataKind::Klass) {
2379     m = (Metadata*)read_klass(comp_method);
2380   } else if (kind == DataKind::Method) {
2381     m = (Metadata*)read_method(comp_method);
2382   } else if (kind == DataKind::MethodCnts) {
2383     kind = *(DataKind*)addr(code_offset);
2384     code_offset += sizeof(DataKind);
2385     set_read_position(code_offset);
2386     m = (Metadata*)read_method(comp_method);
2387     if (m != nullptr) {
2388       Method* method = (Method*)m;
2389       m = method->get_method_counters(Thread::current());
2390       if (m == nullptr) {
2391         set_lookup_failed();
2392         log_debug(aot, codecache, metadata)("%d (L%d): Failed to get MethodCounters", compile_id(), comp_level());
2393       } else {
2394         log_debug(aot, codecache, metadata)("%d (L%d): Read MethodCounters : " INTPTR_FORMAT, compile_id(), comp_level(), p2i(m));
2395       }
2396     }
2397   } else {
2398     set_lookup_failed();
2399     log_debug(aot, codecache, metadata)("%d (L%d): Unknown metadata's kind: %d", compile_id(), comp_level(), (int)kind);
2400   }
2401   return m;
2402 }
2403 
2404 bool AOTCodeCache::write_method(Method* method) {
2405   ResourceMark rm; // To method's name printing
2406   if (AOTCacheAccess::can_generate_aot_code(method)) {
2407     DataKind kind = DataKind::Method;
2408     uint n = write_bytes(&kind, sizeof(int));
2409     if (n != sizeof(int)) {
2410       return false;
2411     }
2412     uint method_offset = AOTCacheAccess::delta_from_base_address((address)method);
2413     n = write_bytes(&method_offset, sizeof(uint));
2414     if (n != sizeof(uint)) {
2415       return false;
2416     }
2417     log_debug(aot, codecache, metadata)("%d (L%d): Wrote method: %s @ 0x%08x",
2418              compile_id(), comp_level(), method->name_and_sig_as_C_string(), method_offset);
2419     return true;
2420   }
2421   log_debug(aot, codecache, metadata)("%d (L%d): Method is not archived: %s",
2422               compile_id(), comp_level(), method->name_and_sig_as_C_string());
2423   set_lookup_failed();
2424   return false;
2425 }
2426 
2427 Method* AOTCodeReader::read_method(const methodHandle& comp_method) {
2428   uint code_offset = read_position();
2429   uint method_offset = *(uint*)addr(code_offset);
2430   code_offset += sizeof(uint);
2431   set_read_position(code_offset);
2432   Method* m = AOTCacheAccess::convert_offset_to_method(method_offset);
2433   if (!MetaspaceShared::is_in_shared_metaspace((address)m)) {
2434     // Something changed in CDS
2435     set_lookup_failed();
2436     log_debug(aot, codecache, metadata)("Lookup failed for shared method: " INTPTR_FORMAT " is not in CDS ", p2i((address)m));
2437     return nullptr;
2438   }
2439   assert(m->is_method(), "sanity");
2440   ResourceMark rm;
2441   Klass* k = m->method_holder();
2442   if (!k->is_instance_klass()) {
2443     set_lookup_failed();
2444     log_debug(aot, codecache, metadata)("%d '%s' (L%d): Lookup failed for holder %s: not instance klass",
2445                   compile_id(), comp_method->name_and_sig_as_C_string(), comp_level(), k->external_name());
2446     return nullptr;
2447   } else if (!MetaspaceShared::is_in_shared_metaspace((address)k)) {
2448     set_lookup_failed();
2449     log_debug(aot, codecache, metadata)("%d '%s' (L%d): Lookup failed for holder %s: not in CDS",
2450                   compile_id(), comp_method->name_and_sig_as_C_string(), comp_level(), k->external_name());
2451     return nullptr;
2452   } else if (!InstanceKlass::cast(k)->is_loaded()) {
2453     set_lookup_failed();
2454     log_debug(aot, codecache, metadata)("%d '%s' (L%d): Lookup failed for holder %s: not loaded",
2455                   compile_id(), comp_method->name_and_sig_as_C_string(), comp_level(), k->external_name());
2456     return nullptr;
2457   } else if (!InstanceKlass::cast(k)->is_linked()) {
2458     set_lookup_failed();
2459     log_debug(aot, codecache, metadata)("%d '%s' (L%d): Lookup failed for holder %s: not linked%s",
2460                   compile_id(), comp_method->name_and_sig_as_C_string(), comp_level(), k->external_name(), (_preload ? " for code preload" : ""));
2461     return nullptr;
2462   }
2463   log_debug(aot, codecache, metadata)("%d (L%d): Shared method lookup: %s",
2464                 compile_id(), comp_level(), m->name_and_sig_as_C_string());
2465   return m;
2466 }
2467 
2468 bool AOTCodeCache::write_klass(Klass* klass) {
2469   uint array_dim = 0;
2470   if (klass->is_objArray_klass()) {
2471     array_dim = ObjArrayKlass::cast(klass)->dimension();
2472     klass     = ObjArrayKlass::cast(klass)->bottom_klass(); // overwrites klass
2473   }
2474   uint init_state = 0;
2475   bool can_write = true;
2476   if (klass->is_instance_klass()) {
2477     InstanceKlass* ik = InstanceKlass::cast(klass);
2478     init_state = (ik->is_initialized() ? 1 : 0);
2479     can_write = AOTCacheAccess::can_generate_aot_code_for(ik);
2480   } else {
2481     can_write = AOTCacheAccess::can_generate_aot_code(klass);
2482   }
2483   ResourceMark rm;
2484   uint state = (array_dim << 1) | (init_state & 1);
2485   if (can_write) {
2486     DataKind kind = DataKind::Klass;
2487     uint n = write_bytes(&kind, sizeof(int));
2488     if (n != sizeof(int)) {
2489       return false;
2490     }
2491     // Record state of instance klass initialization and array dimentions.
2492     n = write_bytes(&state, sizeof(int));
2493     if (n != sizeof(int)) {
2494       return false;
2495     }
2496     uint klass_offset = AOTCacheAccess::delta_from_base_address((address)klass);
2497     n = write_bytes(&klass_offset, sizeof(uint));
2498     if (n != sizeof(uint)) {
2499       return false;
2500     }
2501     log_debug(aot, codecache, metadata)("%d (L%d): Registered klass: %s%s%s @ 0x%08x",
2502              compile_id(), comp_level(), klass->external_name(),
2503              (!klass->is_instance_klass() ? "" : (init_state == 1 ? " (initialized)" : " (not-initialized)")),
2504              (array_dim > 0 ? " (object array)" : ""), klass_offset);
2505     return true;
2506   }
2507   log_debug(aot, codecache, metadata)("%d (L%d): Klassis not archived: %s%s%s",
2508               compile_id(), comp_level(), klass->external_name(),
2509               (!klass->is_instance_klass() ? "" : (init_state == 1 ? " (initialized)" : " (not-initialized)")),
2510               (array_dim > 0 ? " (object array)" : ""));
2511   set_lookup_failed();
2512   return false;
2513 }
2514 
2515 Klass* AOTCodeReader::read_klass(const methodHandle& comp_method) {
2516   uint code_offset = read_position();
2517   uint state = *(uint*)addr(code_offset);
2518   uint init_state = (state  & 1);
2519   uint array_dim  = (state >> 1);
2520   code_offset += sizeof(int);
2521   uint klass_offset = *(uint*)addr(code_offset);
2522   code_offset += sizeof(uint);
2523   set_read_position(code_offset);
2524   Klass* k = AOTCacheAccess::convert_offset_to_klass(klass_offset);
2525   if (!MetaspaceShared::is_in_shared_metaspace((address)k)) {
2526     // Something changed in CDS
2527     set_lookup_failed();
2528     log_debug(aot, codecache, metadata)("Lookup failed for shared klass: " INTPTR_FORMAT " is not in CDS ", p2i((address)k));
2529     return nullptr;
2530   }
2531   assert(k->is_klass(), "sanity");
2532   ResourceMark rm;
2533   if (k->is_instance_klass() && !InstanceKlass::cast(k)->is_loaded()) {
2534     set_lookup_failed();
2535     log_debug(aot, codecache, metadata)("%d '%s' (L%d): Lookup failed for klass %s: not loaded",
2536                      compile_id(), comp_method->name_and_sig_as_C_string(), comp_level(), k->external_name());
2537     return nullptr;
2538   } else
2539   // Allow not initialized klass which was uninitialized during code caching or for preload
2540   if (k->is_instance_klass() && !InstanceKlass::cast(k)->is_initialized() && (init_state == 1) && !_preload) {
2541     set_lookup_failed();
2542     log_debug(aot, codecache, metadata)("%d '%s' (L%d): Lookup failed for klass %s: not initialized",
2543                      compile_id(), comp_method->name_and_sig_as_C_string(), comp_level(), k->external_name());
2544     return nullptr;
2545   }
2546   if (array_dim > 0) {
2547     assert(k->is_instance_klass() || k->is_typeArray_klass(), "sanity check");
2548     Klass* ak = k->array_klass_or_null(array_dim);
2549     // FIXME: what would it take to create an array class on the fly?
2550 //    Klass* ak = k->array_klass(dim, JavaThread::current());
2551 //    guarantee(JavaThread::current()->pending_exception() == nullptr, "");
2552     if (ak == nullptr) {
2553       set_lookup_failed();
2554       log_debug(aot, codecache, metadata)("%d (L%d): %d-dimension array klass lookup failed: %s",
2555                        compile_id(), comp_level(), array_dim, k->external_name());
2556     }
2557     log_debug(aot, codecache, metadata)("%d (L%d): Klass lookup: %s (object array)", compile_id(), comp_level(), k->external_name());
2558     return ak;
2559   } else {
2560     log_debug(aot, codecache, metadata)("%d (L%d): Shared klass lookup: %s",
2561                   compile_id(), comp_level(), k->external_name());
2562     return k;
2563   }
2564 }
2565 
2566 bool AOTCodeCache::write_oop(jobject& jo) {
2567   oop obj = JNIHandles::resolve(jo);
2568   return write_oop(obj);
2569 }
2570 
2571 bool AOTCodeCache::write_oop(oop obj) {
2572   DataKind kind;
2573   uint n = 0;
2574   if (obj == nullptr) {
2575     kind = DataKind::Null;
2576     n = write_bytes(&kind, sizeof(int));
2577     if (n != sizeof(int)) {
2578       return false;
2579     }
2580   } else if (cast_from_oop<void *>(obj) == Universe::non_oop_word()) {
2581     kind = DataKind::No_Data;
2582     n = write_bytes(&kind, sizeof(int));
2583     if (n != sizeof(int)) {
2584       return false;
2585     }
2586   } else if (java_lang_Class::is_instance(obj)) {
2587     if (java_lang_Class::is_primitive(obj)) {
2588       int bt = (int)java_lang_Class::primitive_type(obj);
2589       kind = DataKind::Primitive;
2590       n = write_bytes(&kind, sizeof(int));
2591       if (n != sizeof(int)) {
2592         return false;
2593       }
2594       n = write_bytes(&bt, sizeof(int));
2595       if (n != sizeof(int)) {
2596         return false;
2597       }
2598       log_debug(aot, codecache, oops)("%d (L%d): Write primitive type klass: %s", compile_id(), comp_level(), type2name((BasicType)bt));
2599     } else {
2600       Klass* klass = java_lang_Class::as_Klass(obj);
2601       if (!write_klass(klass)) {
2602         return false;
2603       }
2604     }
2605   } else if (java_lang_String::is_instance(obj)) { // herere
2606     int k = AOTCacheAccess::get_archived_object_permanent_index(obj);  // k >= 0 means obj is a "permanent heap object"
2607     ResourceMark rm;
2608     size_t length_sz = 0;
2609     const char* string = java_lang_String::as_utf8_string(obj, length_sz);
2610     if (k >= 0) {
2611       kind = DataKind::String;
2612       n = write_bytes(&kind, sizeof(int));
2613       if (n != sizeof(int)) {
2614         return false;
2615       }
2616       n = write_bytes(&k, sizeof(int));
2617       if (n != sizeof(int)) {
2618         return false;
2619       }
2620       log_debug(aot, codecache, oops)("%d (L%d): Write String object: " PTR_FORMAT " : %s", compile_id(), comp_level(), p2i(obj), string);
2621       return true;
2622     }
2623     // Not archived String object - bailout
2624     set_lookup_failed();
2625     log_debug(aot, codecache, oops)("%d (L%d): Not archived String object: " PTR_FORMAT " : %s",
2626                                       compile_id(), comp_level(), p2i(obj), string);
2627     return false;
2628   } else if (java_lang_Module::is_instance(obj)) {
2629     fatal("Module object unimplemented");
2630   } else if (java_lang_ClassLoader::is_instance(obj)) {
2631     if (obj == SystemDictionary::java_system_loader()) {
2632       kind = DataKind::SysLoader;
2633       log_debug(aot, codecache, oops)("%d (L%d): Write ClassLoader: java_system_loader", compile_id(), comp_level());
2634     } else if (obj == SystemDictionary::java_platform_loader()) {
2635       kind = DataKind::PlaLoader;
2636       log_debug(aot, codecache, oops)("%d (L%d): Write ClassLoader: java_platform_loader", compile_id(), comp_level());
2637     } else {
2638       fatal("ClassLoader object unimplemented");
2639       return false;
2640     }
2641     n = write_bytes(&kind, sizeof(int));
2642     if (n != sizeof(int)) {
2643       return false;
2644     }
2645   } else { // herere
2646     int k = AOTCacheAccess::get_archived_object_permanent_index(obj);  // k >= 0 means obj is a "permanent heap object"
2647     if (k >= 0) {
2648       kind = DataKind::MH_Oop;
2649       n = write_bytes(&kind, sizeof(int));
2650       if (n != sizeof(int)) {
2651         return false;
2652       }
2653       n = write_bytes(&k, sizeof(int));
2654       if (n != sizeof(int)) {
2655         return false;
2656       }
2657       log_debug(aot, codecache, oops)("%d (L%d): Write MH object: " PTR_FORMAT " : %s",
2658                               compile_id(), comp_level(), p2i(obj), obj->klass()->external_name());
2659       return true;
2660     }
2661     // Not archived Java object - bailout
2662     set_lookup_failed();
2663     log_debug(aot, codecache, oops)("%d (L%d): Not archived Java object: " PTR_FORMAT " : %s",
2664                               compile_id(), comp_level(), p2i(obj), obj->klass()->external_name());
2665     return false;
2666   }
2667   return true;
2668 }
2669 
2670 oop AOTCodeReader::read_oop(JavaThread* thread, const methodHandle& comp_method) {
2671   uint code_offset = read_position();
2672   oop obj = nullptr;
2673   DataKind kind = *(DataKind*)addr(code_offset);
2674   code_offset += sizeof(DataKind);
2675   set_read_position(code_offset);
2676   if (kind == DataKind::Null) {
2677     return nullptr;
2678   } else if (kind == DataKind::No_Data) {
2679     return cast_to_oop(Universe::non_oop_word());
2680   } else if (kind == DataKind::Klass) {
2681     Klass* k = read_klass(comp_method);
2682     if (k == nullptr) {
2683       return nullptr;
2684     }
2685     obj = k->java_mirror();
2686     if (obj == nullptr) {
2687       set_lookup_failed();
2688       log_debug(aot, codecache, oops)("Lookup failed for java_mirror of klass %s", k->external_name());
2689       return nullptr;
2690     }
2691   } else if (kind == DataKind::Primitive) {
2692     code_offset = read_position();
2693     int t = *(int*)addr(code_offset);
2694     code_offset += sizeof(int);
2695     set_read_position(code_offset);
2696     BasicType bt = (BasicType)t;
2697     obj = java_lang_Class::primitive_mirror(bt);
2698     log_debug(aot, codecache, oops)("%d (L%d): Read primitive type klass: %s", compile_id(), comp_level(), type2name(bt));
2699   } else if (kind == DataKind::String) {
2700     code_offset = read_position();
2701     int k = *(int*)addr(code_offset);
2702     code_offset += sizeof(int);
2703     set_read_position(code_offset);
2704     obj = AOTCacheAccess::get_archived_object(k);
2705     if (obj == nullptr) {
2706       set_lookup_failed();
2707       log_debug(aot, codecache, oops)("Lookup failed for String object");
2708       return nullptr;
2709     }
2710     assert(java_lang_String::is_instance(obj), "must be string");
2711 
2712     ResourceMark rm;
2713     size_t length_sz = 0;
2714     const char* string = java_lang_String::as_utf8_string(obj, length_sz);
2715     log_debug(aot, codecache, oops)("%d (L%d): Read String object: %s", compile_id(), comp_level(), string);
2716   } else if (kind == DataKind::SysLoader) {
2717     obj = SystemDictionary::java_system_loader();
2718     log_debug(aot, codecache, oops)("%d (L%d): Read java_system_loader", compile_id(), comp_level());
2719   } else if (kind == DataKind::PlaLoader) {
2720     obj = SystemDictionary::java_platform_loader();
2721     log_debug(aot, codecache, oops)("%d (L%d): Read java_platform_loader", compile_id(), comp_level());
2722   } else if (kind == DataKind::MH_Oop) {
2723     code_offset = read_position();
2724     int k = *(int*)addr(code_offset);
2725     code_offset += sizeof(int);
2726     set_read_position(code_offset);
2727     obj = AOTCacheAccess::get_archived_object(k);
2728     if (obj == nullptr) {
2729       set_lookup_failed();
2730       log_debug(aot, codecache, oops)("Lookup failed for MH object");
2731       return nullptr;
2732     }
2733     log_debug(aot, codecache, oops)("%d (L%d): Read MH object: " PTR_FORMAT " : %s",
2734                               compile_id(), comp_level(), p2i(obj), obj->klass()->external_name());
2735   } else {
2736     set_lookup_failed();
2737     log_debug(aot, codecache, oops)("%d (L%d): Unknown oop's kind: %d",
2738                      compile_id(), comp_level(), (int)kind);
2739     return nullptr;
2740   }
2741   return obj;
2742 }
2743 
2744 bool AOTCodeReader::read_oop_metadata_list(JavaThread* thread, ciMethod* target, GrowableArray<Handle> &oop_list, GrowableArray<Metadata*> &metadata_list, OopRecorder* oop_recorder) {
2745   methodHandle comp_method(JavaThread::current(), target->get_Method());
2746   JavaThread* current = JavaThread::current();
2747   uint offset = read_position();
2748   int count = *(int *)addr(offset);
2749   offset += sizeof(int);
2750   set_read_position(offset);
2751   for (int i = 0; i < count; i++) {
2752     oop obj = read_oop(current, comp_method);
2753     if (lookup_failed()) {
2754       return false;
2755     }
2756     Handle h(thread, obj);
2757     oop_list.append(h);
2758     if (oop_recorder != nullptr) {
2759       jobject jo = JNIHandles::make_local(thread, obj);
2760       if (oop_recorder->is_real(jo)) {
2761         oop_recorder->find_index(jo);
2762       } else {
2763         oop_recorder->allocate_oop_index(jo);
2764       }
2765     }
2766     LogStreamHandle(Debug, aot, codecache, oops) log;
2767     if (log.is_enabled()) {
2768       log.print("%d: " INTPTR_FORMAT " ", i, p2i(obj));
2769       if (obj == Universe::non_oop_word()) {
2770         log.print("non-oop word");
2771       } else if (obj == nullptr) {
2772         log.print("nullptr-oop");
2773       } else {
2774         obj->print_value_on(&log);
2775       }
2776       log.cr();
2777     }
2778   }
2779 
2780   offset = read_position();
2781   count = *(int *)addr(offset);
2782   offset += sizeof(int);
2783   set_read_position(offset);
2784   for (int i = 0; i < count; i++) {
2785     Metadata* m = read_metadata(comp_method);
2786     if (lookup_failed()) {
2787       return false;
2788     }
2789     metadata_list.append(m);
2790     if (oop_recorder != nullptr) {
2791       if (oop_recorder->is_real(m)) {
2792         oop_recorder->find_index(m);
2793       } else {
2794         oop_recorder->allocate_metadata_index(m);
2795       }
2796     }
2797     LogTarget(Debug, aot, codecache, metadata) log;
2798     if (log.is_enabled()) {
2799       LogStream ls(log);
2800       ls.print("%d: " INTPTR_FORMAT " ", i, p2i(m));
2801       if (m == (Metadata*)Universe::non_oop_word()) {
2802         ls.print("non-metadata word");
2803       } else if (m == nullptr) {
2804         ls.print("nullptr-oop");
2805       } else {
2806         Metadata::print_value_on_maybe_null(&ls, m);
2807       }
2808       ls.cr();
2809     }
2810   }
2811   return true;
2812 }
2813 
2814 bool AOTCodeCache::write_oop_map_set(CodeBlob& cb) {
2815   ImmutableOopMapSet* oopmaps = cb.oop_maps();
2816   int oopmaps_size = oopmaps->nr_of_bytes();
2817   if (!write_bytes(&oopmaps_size, sizeof(int))) {
2818     return false;
2819   }
2820   uint n = write_bytes(oopmaps, oopmaps->nr_of_bytes());
2821   if (n != (uint)oopmaps->nr_of_bytes()) {
2822     return false;
2823   }
2824   return true;
2825 }
2826 
2827 ImmutableOopMapSet* AOTCodeReader::read_oop_map_set() {
2828   uint offset = read_position();
2829   int size = *(int *)addr(offset);
2830   offset += sizeof(int);
2831   ImmutableOopMapSet* oopmaps = (ImmutableOopMapSet *)addr(offset);
2832   offset += size;
2833   set_read_position(offset);
2834   return oopmaps;
2835 }
2836 
2837 bool AOTCodeCache::write_oops(nmethod* nm) {
2838   int count = nm->oops_count()-1;
2839   if (!write_bytes(&count, sizeof(int))) {
2840     return false;
2841   }
2842   for (oop* p = nm->oops_begin(); p < nm->oops_end(); p++) {
2843     if (!write_oop(*p)) {
2844       return false;
2845     }
2846   }
2847   return true;
2848 }
2849 
2850 #ifndef PRODUCT
2851 bool AOTCodeCache::write_asm_remarks(AsmRemarks& asm_remarks, bool use_string_table) {
2852   // Write asm remarks
2853   uint* count_ptr = (uint *)reserve_bytes(sizeof(uint));
2854   if (count_ptr == nullptr) {
2855     return false;
2856   }
2857   uint count = 0;
2858   bool result = asm_remarks.iterate([&] (uint offset, const char* str) -> bool {
2859     log_trace(aot, codecache, stubs)("asm remark offset=%d, str='%s'", offset, str);
2860     uint n = write_bytes(&offset, sizeof(uint));
2861     if (n != sizeof(uint)) {
2862       return false;
2863     }
2864     if (use_string_table) {
2865       const char* cstr = add_C_string(str);
2866       int id = _table->id_for_C_string((address)cstr);
2867       assert(id != -1, "asm remark string '%s' not found in AOTCodeAddressTable", str);
2868       n = write_bytes(&id, sizeof(int));
2869       if (n != sizeof(int)) {
2870         return false;
2871       }
2872     } else {
2873       n = write_bytes(str, (uint)strlen(str) + 1);
2874       if (n != strlen(str) + 1) {
2875         return false;
2876       }
2877     }
2878     count += 1;
2879     return true;
2880   });
2881   *count_ptr = count;
2882   return result;
2883 }
2884 
2885 void AOTCodeReader::read_asm_remarks(AsmRemarks& asm_remarks, bool use_string_table) {
2886   // Read asm remarks
2887   uint offset = read_position();
2888   uint count = *(uint *)addr(offset);
2889   offset += sizeof(uint);
2890   for (uint i = 0; i < count; i++) {
2891     uint remark_offset = *(uint *)addr(offset);
2892     offset += sizeof(uint);
2893     const char* remark = nullptr;
2894     if (use_string_table) {
2895       int remark_string_id = *(uint *)addr(offset);
2896       offset += sizeof(int);
2897       remark = (const char*)_cache->address_for_C_string(remark_string_id);
2898     } else {
2899       remark = (const char*)addr(offset);
2900       offset += (uint)strlen(remark)+1;
2901     }
2902     asm_remarks.insert(remark_offset, remark);
2903   }
2904   set_read_position(offset);
2905 }
2906 
2907 bool AOTCodeCache::write_dbg_strings(DbgStrings& dbg_strings, bool use_string_table) {
2908   // Write dbg strings
2909   uint* count_ptr = (uint *)reserve_bytes(sizeof(uint));
2910   if (count_ptr == nullptr) {
2911     return false;
2912   }
2913   uint count = 0;
2914   bool result = dbg_strings.iterate([&] (const char* str) -> bool {
2915     log_trace(aot, codecache, stubs)("dbg string=%s", str);
2916     if (use_string_table) {
2917       const char* cstr = add_C_string(str);
2918       int id = _table->id_for_C_string((address)cstr);
2919       assert(id != -1, "db string '%s' not found in AOTCodeAddressTable", str);
2920       uint n = write_bytes(&id, sizeof(int));
2921       if (n != sizeof(int)) {
2922         return false;
2923       }
2924     } else {
2925       uint n = write_bytes(str, (uint)strlen(str) + 1);
2926       if (n != strlen(str) + 1) {
2927         return false;
2928       }
2929     }
2930     count += 1;
2931     return true;
2932   });
2933   *count_ptr = count;
2934   return result;
2935 }
2936 
2937 void AOTCodeReader::read_dbg_strings(DbgStrings& dbg_strings, bool use_string_table) {
2938   // Read dbg strings
2939   uint offset = read_position();
2940   uint count = *(uint *)addr(offset);
2941   offset += sizeof(uint);
2942   for (uint i = 0; i < count; i++) {
2943     const char* str = nullptr;
2944     if (use_string_table) {
2945       int string_id = *(uint *)addr(offset);
2946       offset += sizeof(int);
2947       str = (const char*)_cache->address_for_C_string(string_id);
2948     } else {
2949       str = (const char*)addr(offset);
2950       offset += (uint)strlen(str)+1;
2951     }
2952     dbg_strings.insert(str);
2953   }
2954   set_read_position(offset);
2955 }
2956 #endif // PRODUCT
2957 
2958 //======================= AOTCodeAddressTable ===============
2959 
2960 // address table ids for generated routines, external addresses and C
2961 // string addresses are partitioned into positive integer ranges
2962 // defined by the following positive base and max values
2963 // i.e. [_extrs_base, _extrs_base + _extrs_max -1],
2964 //      [_stubs_base, _stubs_base + _stubs_max -1],
2965 //      ...
2966 //      [_c_str_base, _c_str_base + _c_str_max -1],
2967 #define _extrs_max 140
2968 #define _stubs_max 210
2969 #define _shared_blobs_max 25
2970 #define _C1_blobs_max 50
2971 #define _C2_blobs_max 25
2972 #define _blobs_max (_shared_blobs_max+_C1_blobs_max+_C2_blobs_max)
2973 #define _all_max (_extrs_max+_stubs_max+_blobs_max)
2974 
2975 #define _extrs_base 0
2976 #define _stubs_base (_extrs_base + _extrs_max)
2977 #define _shared_blobs_base (_stubs_base + _stubs_max)
2978 #define _C1_blobs_base (_shared_blobs_base + _shared_blobs_max)
2979 #define _C2_blobs_base (_C1_blobs_base + _C1_blobs_max)
2980 #define _blobs_end  (_shared_blobs_base + _blobs_max)
2981 #if (_C2_blobs_base >= _all_max)
2982 #error AOTCodeAddressTable ranges need adjusting
2983 #endif
2984 
2985 #define SET_ADDRESS(type, addr)                           \
2986   {                                                       \
2987     type##_addr[type##_length++] = (address) (addr);      \
2988     assert(type##_length <= type##_max, "increase size"); \
2989   }
2990 
2991 static bool initializing_extrs = false;
2992 
2993 void AOTCodeAddressTable::init_extrs() {
2994   if (_extrs_complete || initializing_extrs) return; // Done already
2995 
2996   assert(_blobs_end <= _all_max, "AOTCodeAddress table ranges need adjusting");
2997 
2998   initializing_extrs = true;
2999   _extrs_addr = NEW_C_HEAP_ARRAY(address, _extrs_max, mtCode);
3000 
3001   _extrs_length = 0;
3002 
3003   // Record addresses of VM runtime methods
3004   SET_ADDRESS(_extrs, SharedRuntime::fixup_callers_callsite);
3005   SET_ADDRESS(_extrs, SharedRuntime::handle_wrong_method);
3006   SET_ADDRESS(_extrs, SharedRuntime::handle_wrong_method_abstract);
3007   SET_ADDRESS(_extrs, SharedRuntime::handle_wrong_method_ic_miss);
3008 #if defined(AARCH64) && !defined(ZERO)
3009   SET_ADDRESS(_extrs, JavaThread::aarch64_get_thread_helper);
3010 #endif
3011   {
3012     // Required by Shared blobs
3013     SET_ADDRESS(_extrs, Deoptimization::fetch_unroll_info);
3014     SET_ADDRESS(_extrs, Deoptimization::unpack_frames);
3015     SET_ADDRESS(_extrs, SafepointSynchronize::handle_polling_page_exception);
3016     SET_ADDRESS(_extrs, SharedRuntime::resolve_opt_virtual_call_C);
3017     SET_ADDRESS(_extrs, SharedRuntime::resolve_virtual_call_C);
3018     SET_ADDRESS(_extrs, SharedRuntime::resolve_static_call_C);
3019     SET_ADDRESS(_extrs, SharedRuntime::throw_delayed_StackOverflowError);
3020     SET_ADDRESS(_extrs, SharedRuntime::throw_AbstractMethodError);
3021     SET_ADDRESS(_extrs, SharedRuntime::throw_IncompatibleClassChangeError);
3022     SET_ADDRESS(_extrs, SharedRuntime::throw_NullPointerException_at_call);
3023     SET_ADDRESS(_extrs, CompressedOops::base_addr());
3024     SET_ADDRESS(_extrs, CompressedKlassPointers::base_addr());
3025 
3026   }
3027 
3028 #ifdef COMPILER1
3029   {
3030     // Required by C1 blobs
3031     SET_ADDRESS(_extrs, static_cast<int (*)(oopDesc*)>(SharedRuntime::dtrace_object_alloc));
3032     SET_ADDRESS(_extrs, SharedRuntime::exception_handler_for_return_address);
3033     SET_ADDRESS(_extrs, SharedRuntime::register_finalizer);
3034     SET_ADDRESS(_extrs, Runtime1::is_instance_of);
3035     SET_ADDRESS(_extrs, Runtime1::exception_handler_for_pc);
3036     SET_ADDRESS(_extrs, Runtime1::check_abort_on_vm_exception);
3037     SET_ADDRESS(_extrs, Runtime1::new_instance);
3038     SET_ADDRESS(_extrs, Runtime1::counter_overflow);
3039     SET_ADDRESS(_extrs, Runtime1::new_type_array);
3040     SET_ADDRESS(_extrs, Runtime1::new_object_array);
3041     SET_ADDRESS(_extrs, Runtime1::new_multi_array);
3042     SET_ADDRESS(_extrs, Runtime1::throw_range_check_exception);
3043     SET_ADDRESS(_extrs, Runtime1::throw_index_exception);
3044     SET_ADDRESS(_extrs, Runtime1::throw_div0_exception);
3045     SET_ADDRESS(_extrs, Runtime1::throw_null_pointer_exception);
3046     SET_ADDRESS(_extrs, Runtime1::throw_array_store_exception);
3047     SET_ADDRESS(_extrs, Runtime1::throw_class_cast_exception);
3048     SET_ADDRESS(_extrs, Runtime1::throw_incompatible_class_change_error);
3049     SET_ADDRESS(_extrs, Runtime1::monitorenter);
3050     SET_ADDRESS(_extrs, Runtime1::monitorexit);
3051     SET_ADDRESS(_extrs, Runtime1::deoptimize);
3052     SET_ADDRESS(_extrs, Runtime1::access_field_patching);
3053     SET_ADDRESS(_extrs, Runtime1::move_klass_patching);
3054     SET_ADDRESS(_extrs, Runtime1::move_mirror_patching);
3055     SET_ADDRESS(_extrs, Runtime1::move_appendix_patching);
3056     SET_ADDRESS(_extrs, Runtime1::predicate_failed_trap);
3057     SET_ADDRESS(_extrs, Runtime1::unimplemented_entry);
3058     SET_ADDRESS(_extrs, Runtime1::trace_block_entry);
3059 #ifndef PRODUCT
3060     SET_ADDRESS(_extrs, os::breakpoint);
3061 #endif
3062   }
3063 #endif // COMPILER1
3064 
3065 #ifdef COMPILER2
3066   {
3067     // Required by C2 blobs
3068     SET_ADDRESS(_extrs, Deoptimization::uncommon_trap);
3069     SET_ADDRESS(_extrs, OptoRuntime::handle_exception_C);
3070     SET_ADDRESS(_extrs, OptoRuntime::new_instance_C);
3071     SET_ADDRESS(_extrs, OptoRuntime::new_array_C);
3072     SET_ADDRESS(_extrs, OptoRuntime::new_array_nozero_C);
3073     SET_ADDRESS(_extrs, OptoRuntime::multianewarray2_C);
3074     SET_ADDRESS(_extrs, OptoRuntime::multianewarray3_C);
3075     SET_ADDRESS(_extrs, OptoRuntime::multianewarray4_C);
3076     SET_ADDRESS(_extrs, OptoRuntime::multianewarray5_C);
3077     SET_ADDRESS(_extrs, OptoRuntime::multianewarrayN_C);
3078 #if INCLUDE_JVMTI
3079     SET_ADDRESS(_extrs, SharedRuntime::notify_jvmti_vthread_start);
3080     SET_ADDRESS(_extrs, SharedRuntime::notify_jvmti_vthread_end);
3081     SET_ADDRESS(_extrs, SharedRuntime::notify_jvmti_vthread_mount);
3082     SET_ADDRESS(_extrs, SharedRuntime::notify_jvmti_vthread_unmount);
3083 #endif
3084     SET_ADDRESS(_extrs, OptoRuntime::complete_monitor_locking_C);
3085     SET_ADDRESS(_extrs, OptoRuntime::monitor_notify_C);
3086     SET_ADDRESS(_extrs, OptoRuntime::monitor_notifyAll_C);
3087     SET_ADDRESS(_extrs, OptoRuntime::rethrow_C);
3088     SET_ADDRESS(_extrs, OptoRuntime::slow_arraycopy_C);
3089     SET_ADDRESS(_extrs, OptoRuntime::register_finalizer_C);
3090     SET_ADDRESS(_extrs, OptoRuntime::class_init_barrier_C);
3091   }
3092 #endif // COMPILER2
3093 
3094 #if INCLUDE_G1GC
3095   SET_ADDRESS(_extrs, G1BarrierSetRuntime::write_ref_field_post_entry);
3096   SET_ADDRESS(_extrs, G1BarrierSetRuntime::write_ref_field_pre_entry);
3097 #endif
3098 
3099 #if INCLUDE_SHENANDOAHGC
3100   SET_ADDRESS(_extrs, ShenandoahRuntime::arraycopy_barrier_oop);
3101   SET_ADDRESS(_extrs, ShenandoahRuntime::arraycopy_barrier_narrow_oop);
3102   SET_ADDRESS(_extrs, ShenandoahRuntime::write_ref_field_pre);
3103   SET_ADDRESS(_extrs, ShenandoahRuntime::clone_barrier);
3104   SET_ADDRESS(_extrs, ShenandoahRuntime::load_reference_barrier_strong);
3105   SET_ADDRESS(_extrs, ShenandoahRuntime::load_reference_barrier_strong_narrow);
3106   SET_ADDRESS(_extrs, ShenandoahRuntime::load_reference_barrier_weak);
3107   SET_ADDRESS(_extrs, ShenandoahRuntime::load_reference_barrier_weak_narrow);
3108   SET_ADDRESS(_extrs, ShenandoahRuntime::load_reference_barrier_phantom);
3109   SET_ADDRESS(_extrs, ShenandoahRuntime::load_reference_barrier_phantom_narrow);
3110 #endif
3111 
3112 #if INCLUDE_ZGC
3113   SET_ADDRESS(_extrs, ZBarrierSetRuntime::load_barrier_on_phantom_oop_field_preloaded_addr());
3114 #if defined(AMD64)
3115   SET_ADDRESS(_extrs, &ZPointerLoadShift);
3116 #endif
3117 #endif // INCLUDE_ZGC
3118 
3119   SET_ADDRESS(_extrs, SharedRuntime::log_jni_monitor_still_held);
3120   SET_ADDRESS(_extrs, SharedRuntime::rc_trace_method_entry);
3121   SET_ADDRESS(_extrs, SharedRuntime::reguard_yellow_pages);
3122   SET_ADDRESS(_extrs, SharedRuntime::dtrace_method_exit);
3123 
3124   SET_ADDRESS(_extrs, SharedRuntime::complete_monitor_unlocking_C);
3125   SET_ADDRESS(_extrs, SharedRuntime::enable_stack_reserved_zone);
3126 #if defined(AMD64) && !defined(ZERO)
3127   SET_ADDRESS(_extrs, SharedRuntime::montgomery_multiply);
3128   SET_ADDRESS(_extrs, SharedRuntime::montgomery_square);
3129 #endif // AMD64
3130   SET_ADDRESS(_extrs, SharedRuntime::d2f);
3131   SET_ADDRESS(_extrs, SharedRuntime::d2i);
3132   SET_ADDRESS(_extrs, SharedRuntime::d2l);
3133   SET_ADDRESS(_extrs, SharedRuntime::dcos);
3134   SET_ADDRESS(_extrs, SharedRuntime::dexp);
3135   SET_ADDRESS(_extrs, SharedRuntime::dlog);
3136   SET_ADDRESS(_extrs, SharedRuntime::dlog10);
3137   SET_ADDRESS(_extrs, SharedRuntime::dpow);
3138   SET_ADDRESS(_extrs, SharedRuntime::dsin);
3139   SET_ADDRESS(_extrs, SharedRuntime::dtan);
3140   SET_ADDRESS(_extrs, SharedRuntime::f2i);
3141   SET_ADDRESS(_extrs, SharedRuntime::f2l);
3142 #ifndef ZERO
3143   SET_ADDRESS(_extrs, SharedRuntime::drem);
3144   SET_ADDRESS(_extrs, SharedRuntime::frem);
3145 #endif
3146   SET_ADDRESS(_extrs, SharedRuntime::l2d);
3147   SET_ADDRESS(_extrs, SharedRuntime::l2f);
3148   SET_ADDRESS(_extrs, SharedRuntime::ldiv);
3149   SET_ADDRESS(_extrs, SharedRuntime::lmul);
3150   SET_ADDRESS(_extrs, SharedRuntime::lrem);
3151 #if INCLUDE_JVMTI
3152   SET_ADDRESS(_extrs, &JvmtiExport::_should_notify_object_alloc);
3153 #endif /* INCLUDE_JVMTI */
3154   BarrierSet* bs = BarrierSet::barrier_set();
3155   if (bs->is_a(BarrierSet::CardTableBarrierSet)) {
3156     SET_ADDRESS(_extrs, ci_card_table_address_as<address>());
3157   }
3158   SET_ADDRESS(_extrs, ThreadIdentifier::unsafe_offset());
3159   SET_ADDRESS(_extrs, Thread::current);
3160 
3161   SET_ADDRESS(_extrs, os::javaTimeMillis);
3162   SET_ADDRESS(_extrs, os::javaTimeNanos);
3163   // For JFR
3164   SET_ADDRESS(_extrs, os::elapsed_counter);
3165 
3166 #if INCLUDE_JVMTI
3167   SET_ADDRESS(_extrs, &JvmtiVTMSTransitionDisabler::_VTMS_notify_jvmti_events);
3168 #endif /* INCLUDE_JVMTI */
3169   SET_ADDRESS(_extrs, StubRoutines::crc_table_addr());
3170 #ifndef PRODUCT
3171   SET_ADDRESS(_extrs, &SharedRuntime::_partial_subtype_ctr);
3172   SET_ADDRESS(_extrs, JavaThread::verify_cross_modify_fence_failure);
3173 #endif
3174 
3175 #ifndef ZERO
3176 #if defined(AMD64) || defined(AARCH64) || defined(RISCV64)
3177   SET_ADDRESS(_extrs, MacroAssembler::debug64);
3178 #endif
3179 #if defined(AMD64)
3180   SET_ADDRESS(_extrs, StubRoutines::x86::arrays_hashcode_powers_of_31());
3181 #endif
3182 #endif // ZERO
3183 
3184 #ifdef COMPILER1
3185 #ifdef X86
3186   SET_ADDRESS(_extrs, LIR_Assembler::float_signmask_pool);
3187   SET_ADDRESS(_extrs, LIR_Assembler::double_signmask_pool);
3188   SET_ADDRESS(_extrs, LIR_Assembler::float_signflip_pool);
3189   SET_ADDRESS(_extrs, LIR_Assembler::double_signflip_pool);
3190 #endif
3191 #endif
3192 
3193   // addresses of fields in AOT runtime constants area
3194   address* p = AOTRuntimeConstants::field_addresses_list();
3195   while (*p != nullptr) {
3196     SET_ADDRESS(_extrs, *p++);
3197   }
3198 
3199   _extrs_complete = true;
3200   log_info(aot, codecache, init)("External addresses recorded");
3201 }
3202 
3203 static bool initializing_early_stubs = false;
3204 
3205 void AOTCodeAddressTable::init_early_stubs() {
3206   if (_complete || initializing_early_stubs) return; // Done already
3207   initializing_early_stubs = true;
3208   _stubs_addr = NEW_C_HEAP_ARRAY(address, _stubs_max, mtCode);
3209   _stubs_length = 0;
3210   SET_ADDRESS(_stubs, StubRoutines::forward_exception_entry());
3211 
3212   {
3213     // Required by C1 blobs
3214 #if defined(AMD64) && !defined(ZERO)
3215     SET_ADDRESS(_stubs, StubRoutines::x86::double_sign_flip());
3216     SET_ADDRESS(_stubs, StubRoutines::x86::d2l_fixup());
3217 #endif // AMD64
3218   }
3219 
3220   _early_stubs_complete = true;
3221   log_info(aot, codecache, init)("Early stubs recorded");
3222 }
3223 
3224 static bool initializing_shared_blobs = false;
3225 
3226 void AOTCodeAddressTable::init_shared_blobs() {
3227   if (_complete || initializing_shared_blobs) return; // Done already
3228   initializing_shared_blobs = true;
3229   address* blobs_addr = NEW_C_HEAP_ARRAY(address, _blobs_max, mtCode);
3230 
3231   // Divide _shared_blobs_addr array to chunks because they could be initialized in parrallel
3232   _shared_blobs_addr = blobs_addr;
3233   _C1_blobs_addr = _shared_blobs_addr + _shared_blobs_max;// C1 blobs addresses stored after shared blobs
3234   _C2_blobs_addr = _C1_blobs_addr + _C1_blobs_max; // C2 blobs addresses stored after C1 blobs
3235 
3236   _shared_blobs_length = 0;
3237   _C1_blobs_length = 0;
3238   _C2_blobs_length = 0;
3239 
3240   // clear the address table
3241   memset(blobs_addr, 0, sizeof(address)* _blobs_max);
3242 
3243   // Record addresses of generated code blobs
3244   SET_ADDRESS(_shared_blobs, SharedRuntime::get_handle_wrong_method_stub());
3245   SET_ADDRESS(_shared_blobs, SharedRuntime::get_ic_miss_stub());
3246   SET_ADDRESS(_shared_blobs, SharedRuntime::deopt_blob()->unpack());
3247   SET_ADDRESS(_shared_blobs, SharedRuntime::deopt_blob()->unpack_with_exception());
3248   SET_ADDRESS(_shared_blobs, SharedRuntime::deopt_blob()->unpack_with_reexecution());
3249   SET_ADDRESS(_shared_blobs, SharedRuntime::deopt_blob()->unpack_with_exception_in_tls());
3250   SET_ADDRESS(_shared_blobs, SharedRuntime::get_resolve_opt_virtual_call_stub());
3251   SET_ADDRESS(_shared_blobs, SharedRuntime::get_resolve_virtual_call_stub());
3252   SET_ADDRESS(_shared_blobs, SharedRuntime::get_resolve_static_call_stub());
3253   SET_ADDRESS(_shared_blobs, SharedRuntime::deopt_blob()->entry_point());
3254   SET_ADDRESS(_shared_blobs, SharedRuntime::polling_page_safepoint_handler_blob()->entry_point());
3255   SET_ADDRESS(_shared_blobs, SharedRuntime::polling_page_return_handler_blob()->entry_point());
3256 #ifdef COMPILER2
3257   // polling_page_vectors_safepoint_handler_blob can be nullptr if AVX feature is not present or is disabled
3258   if (SharedRuntime::polling_page_vectors_safepoint_handler_blob() != nullptr) {
3259     SET_ADDRESS(_shared_blobs, SharedRuntime::polling_page_vectors_safepoint_handler_blob()->entry_point());
3260   }
3261 #endif
3262 #if INCLUDE_JVMCI
3263   if (EnableJVMCI) {
3264     SET_ADDRESS(_shared_blobs, SharedRuntime::deopt_blob()->uncommon_trap());
3265     SET_ADDRESS(_shared_blobs, SharedRuntime::deopt_blob()->implicit_exception_uncommon_trap());
3266   }
3267 #endif
3268   SET_ADDRESS(_shared_blobs, SharedRuntime::throw_AbstractMethodError_entry());
3269   SET_ADDRESS(_shared_blobs, SharedRuntime::throw_IncompatibleClassChangeError_entry());
3270   SET_ADDRESS(_shared_blobs, SharedRuntime::throw_NullPointerException_at_call_entry());
3271   SET_ADDRESS(_shared_blobs, SharedRuntime::throw_StackOverflowError_entry());
3272   SET_ADDRESS(_shared_blobs, SharedRuntime::throw_delayed_StackOverflowError_entry());
3273 
3274   assert(_shared_blobs_length <= _shared_blobs_max, "increase _shared_blobs_max to %d", _shared_blobs_length);
3275   _shared_blobs_complete = true;
3276   log_info(aot, codecache, init)("All shared blobs recorded");
3277 }
3278 
3279 static bool initializing_stubs = false;
3280 void AOTCodeAddressTable::init_stubs() {
3281   if (_complete || initializing_stubs) return; // Done already
3282   assert(_early_stubs_complete, "early stubs whould be initialized");
3283   initializing_stubs = true;
3284 
3285   // Stubs
3286   SET_ADDRESS(_stubs, StubRoutines::method_entry_barrier());
3287   SET_ADDRESS(_stubs, StubRoutines::atomic_xchg_entry());
3288   SET_ADDRESS(_stubs, StubRoutines::atomic_cmpxchg_entry());
3289   SET_ADDRESS(_stubs, StubRoutines::atomic_cmpxchg_long_entry());
3290   SET_ADDRESS(_stubs, StubRoutines::atomic_add_entry());
3291   SET_ADDRESS(_stubs, StubRoutines::fence_entry());
3292 
3293   SET_ADDRESS(_stubs, StubRoutines::cont_thaw());
3294   SET_ADDRESS(_stubs, StubRoutines::cont_returnBarrier());
3295   SET_ADDRESS(_stubs, StubRoutines::cont_returnBarrierExc());
3296 
3297   JFR_ONLY(SET_ADDRESS(_stubs, SharedRuntime::jfr_write_checkpoint());)
3298 
3299   SET_ADDRESS(_stubs, StubRoutines::jbyte_arraycopy());
3300   SET_ADDRESS(_stubs, StubRoutines::jshort_arraycopy());
3301   SET_ADDRESS(_stubs, StubRoutines::jint_arraycopy());
3302   SET_ADDRESS(_stubs, StubRoutines::jlong_arraycopy());
3303   SET_ADDRESS(_stubs, StubRoutines::_oop_arraycopy);
3304   SET_ADDRESS(_stubs, StubRoutines::_oop_arraycopy_uninit);
3305 
3306   SET_ADDRESS(_stubs, StubRoutines::jbyte_disjoint_arraycopy());
3307   SET_ADDRESS(_stubs, StubRoutines::jshort_disjoint_arraycopy());
3308   SET_ADDRESS(_stubs, StubRoutines::jint_disjoint_arraycopy());
3309   SET_ADDRESS(_stubs, StubRoutines::jlong_disjoint_arraycopy());
3310   SET_ADDRESS(_stubs, StubRoutines::_oop_disjoint_arraycopy);
3311   SET_ADDRESS(_stubs, StubRoutines::_oop_disjoint_arraycopy_uninit);
3312 
3313   SET_ADDRESS(_stubs, StubRoutines::arrayof_jbyte_arraycopy());
3314   SET_ADDRESS(_stubs, StubRoutines::arrayof_jshort_arraycopy());
3315   SET_ADDRESS(_stubs, StubRoutines::arrayof_jint_arraycopy());
3316   SET_ADDRESS(_stubs, StubRoutines::arrayof_jlong_arraycopy());
3317   SET_ADDRESS(_stubs, StubRoutines::_arrayof_oop_arraycopy);
3318   SET_ADDRESS(_stubs, StubRoutines::_arrayof_oop_arraycopy_uninit);
3319 
3320   SET_ADDRESS(_stubs, StubRoutines::arrayof_jbyte_disjoint_arraycopy());
3321   SET_ADDRESS(_stubs, StubRoutines::arrayof_jshort_disjoint_arraycopy());
3322   SET_ADDRESS(_stubs, StubRoutines::arrayof_jint_disjoint_arraycopy());
3323   SET_ADDRESS(_stubs, StubRoutines::arrayof_jlong_disjoint_arraycopy());
3324   SET_ADDRESS(_stubs, StubRoutines::_arrayof_oop_disjoint_arraycopy);
3325   SET_ADDRESS(_stubs, StubRoutines::_arrayof_oop_disjoint_arraycopy_uninit);
3326 
3327   SET_ADDRESS(_stubs, StubRoutines::_checkcast_arraycopy);
3328   SET_ADDRESS(_stubs, StubRoutines::_checkcast_arraycopy_uninit);
3329 
3330   SET_ADDRESS(_stubs, StubRoutines::unsafe_arraycopy());
3331   SET_ADDRESS(_stubs, StubRoutines::generic_arraycopy());
3332 
3333   SET_ADDRESS(_stubs, StubRoutines::jbyte_fill());
3334   SET_ADDRESS(_stubs, StubRoutines::jshort_fill());
3335   SET_ADDRESS(_stubs, StubRoutines::jint_fill());
3336   SET_ADDRESS(_stubs, StubRoutines::arrayof_jbyte_fill());
3337   SET_ADDRESS(_stubs, StubRoutines::arrayof_jshort_fill());
3338   SET_ADDRESS(_stubs, StubRoutines::arrayof_jint_fill());
3339 
3340   SET_ADDRESS(_stubs, StubRoutines::data_cache_writeback());
3341   SET_ADDRESS(_stubs, StubRoutines::data_cache_writeback_sync());
3342 
3343   SET_ADDRESS(_stubs, StubRoutines::aescrypt_encryptBlock());
3344   SET_ADDRESS(_stubs, StubRoutines::aescrypt_decryptBlock());
3345   SET_ADDRESS(_stubs, StubRoutines::cipherBlockChaining_encryptAESCrypt());
3346   SET_ADDRESS(_stubs, StubRoutines::cipherBlockChaining_decryptAESCrypt());
3347   SET_ADDRESS(_stubs, StubRoutines::electronicCodeBook_encryptAESCrypt());
3348   SET_ADDRESS(_stubs, StubRoutines::electronicCodeBook_decryptAESCrypt());
3349   SET_ADDRESS(_stubs, StubRoutines::poly1305_processBlocks());
3350   SET_ADDRESS(_stubs, StubRoutines::counterMode_AESCrypt());
3351   SET_ADDRESS(_stubs, StubRoutines::ghash_processBlocks());
3352   SET_ADDRESS(_stubs, StubRoutines::chacha20Block());
3353   SET_ADDRESS(_stubs, StubRoutines::base64_encodeBlock());
3354   SET_ADDRESS(_stubs, StubRoutines::base64_decodeBlock());
3355   SET_ADDRESS(_stubs, StubRoutines::md5_implCompress());
3356   SET_ADDRESS(_stubs, StubRoutines::md5_implCompressMB());
3357   SET_ADDRESS(_stubs, StubRoutines::sha1_implCompress());
3358   SET_ADDRESS(_stubs, StubRoutines::sha1_implCompressMB());
3359   SET_ADDRESS(_stubs, StubRoutines::sha256_implCompress());
3360   SET_ADDRESS(_stubs, StubRoutines::sha256_implCompressMB());
3361   SET_ADDRESS(_stubs, StubRoutines::sha512_implCompress());
3362   SET_ADDRESS(_stubs, StubRoutines::sha512_implCompressMB());
3363   SET_ADDRESS(_stubs, StubRoutines::sha3_implCompress());
3364   SET_ADDRESS(_stubs, StubRoutines::sha3_implCompressMB());
3365   SET_ADDRESS(_stubs, StubRoutines::double_keccak());
3366   SET_ADDRESS(_stubs, StubRoutines::intpoly_assign());
3367   SET_ADDRESS(_stubs, StubRoutines::intpoly_montgomeryMult_P256());
3368   SET_ADDRESS(_stubs, StubRoutines::dilithiumAlmostNtt());
3369   SET_ADDRESS(_stubs, StubRoutines::dilithiumAlmostInverseNtt());
3370   SET_ADDRESS(_stubs, StubRoutines::dilithiumNttMult());
3371   SET_ADDRESS(_stubs, StubRoutines::dilithiumMontMulByConstant());
3372   SET_ADDRESS(_stubs, StubRoutines::dilithiumDecomposePoly());
3373 
3374   SET_ADDRESS(_stubs, StubRoutines::updateBytesCRC32());
3375 
3376   SET_ADDRESS(_stubs, StubRoutines::crc32c_table_addr());
3377   SET_ADDRESS(_stubs, StubRoutines::updateBytesCRC32C());
3378   SET_ADDRESS(_stubs, StubRoutines::updateBytesAdler32());
3379 
3380   SET_ADDRESS(_stubs, StubRoutines::multiplyToLen());
3381   SET_ADDRESS(_stubs, StubRoutines::squareToLen());
3382   SET_ADDRESS(_stubs, StubRoutines::mulAdd());
3383   SET_ADDRESS(_stubs, StubRoutines::montgomeryMultiply());
3384   SET_ADDRESS(_stubs, StubRoutines::montgomerySquare());
3385   SET_ADDRESS(_stubs, StubRoutines::bigIntegerRightShift());
3386   SET_ADDRESS(_stubs, StubRoutines::bigIntegerLeftShift());
3387   SET_ADDRESS(_stubs, StubRoutines::galoisCounterMode_AESCrypt());
3388 
3389   SET_ADDRESS(_stubs, StubRoutines::vectorizedMismatch());
3390 
3391   SET_ADDRESS(_stubs, StubRoutines::unsafe_setmemory());
3392 
3393   SET_ADDRESS(_stubs, StubRoutines::dexp());
3394   SET_ADDRESS(_stubs, StubRoutines::dlog());
3395   SET_ADDRESS(_stubs, StubRoutines::dlog10());
3396   SET_ADDRESS(_stubs, StubRoutines::dpow());
3397   SET_ADDRESS(_stubs, StubRoutines::dsin());
3398   SET_ADDRESS(_stubs, StubRoutines::dcos());
3399   SET_ADDRESS(_stubs, StubRoutines::dlibm_reduce_pi04l());
3400   SET_ADDRESS(_stubs, StubRoutines::dlibm_sin_cos_huge());
3401   SET_ADDRESS(_stubs, StubRoutines::dlibm_tan_cot_huge());
3402   SET_ADDRESS(_stubs, StubRoutines::dtan());
3403 
3404   SET_ADDRESS(_stubs, StubRoutines::f2hf_adr());
3405   SET_ADDRESS(_stubs, StubRoutines::hf2f_adr());
3406 
3407   for (int slot = 0; slot < Klass::SECONDARY_SUPERS_TABLE_SIZE; slot++) {
3408     SET_ADDRESS(_stubs, StubRoutines::lookup_secondary_supers_table_stub(slot));
3409   }
3410   SET_ADDRESS(_stubs, StubRoutines::lookup_secondary_supers_table_slow_path_stub());
3411 
3412 #if defined(AMD64) && !defined(ZERO)
3413   SET_ADDRESS(_stubs, StubRoutines::x86::d2i_fixup());
3414   SET_ADDRESS(_stubs, StubRoutines::x86::f2i_fixup());
3415   SET_ADDRESS(_stubs, StubRoutines::x86::f2l_fixup());
3416   SET_ADDRESS(_stubs, StubRoutines::x86::float_sign_mask());
3417   SET_ADDRESS(_stubs, StubRoutines::x86::float_sign_flip());
3418   SET_ADDRESS(_stubs, StubRoutines::x86::double_sign_mask());
3419   SET_ADDRESS(_stubs, StubRoutines::x86::vector_popcount_lut());
3420   SET_ADDRESS(_stubs, StubRoutines::x86::vector_float_sign_mask());
3421   SET_ADDRESS(_stubs, StubRoutines::x86::vector_float_sign_flip());
3422   SET_ADDRESS(_stubs, StubRoutines::x86::vector_double_sign_mask());
3423   SET_ADDRESS(_stubs, StubRoutines::x86::vector_double_sign_flip());
3424   SET_ADDRESS(_stubs, StubRoutines::x86::vector_reverse_byte_perm_mask_int());
3425   SET_ADDRESS(_stubs, StubRoutines::x86::vector_reverse_byte_perm_mask_short());
3426   SET_ADDRESS(_stubs, StubRoutines::x86::vector_reverse_byte_perm_mask_long());
3427   // The iota indices are ordered by type B/S/I/L/F/D, and the offset between two types is 64.
3428   // See C2_MacroAssembler::load_iota_indices().
3429   for (int i = 0; i < 6; i++) {
3430     SET_ADDRESS(_stubs, StubRoutines::x86::vector_iota_indices() + i * 64);
3431   }
3432 #endif
3433 #if defined(AARCH64) && !defined(ZERO)
3434   SET_ADDRESS(_stubs, StubRoutines::aarch64::zero_blocks());
3435   SET_ADDRESS(_stubs, StubRoutines::aarch64::count_positives());
3436   SET_ADDRESS(_stubs, StubRoutines::aarch64::count_positives_long());
3437   SET_ADDRESS(_stubs, StubRoutines::aarch64::large_array_equals());
3438   SET_ADDRESS(_stubs, StubRoutines::aarch64::compare_long_string_LL());
3439   SET_ADDRESS(_stubs, StubRoutines::aarch64::compare_long_string_UU());
3440   SET_ADDRESS(_stubs, StubRoutines::aarch64::compare_long_string_LU());
3441   SET_ADDRESS(_stubs, StubRoutines::aarch64::compare_long_string_UL());
3442   SET_ADDRESS(_stubs, StubRoutines::aarch64::string_indexof_linear_ul());
3443   SET_ADDRESS(_stubs, StubRoutines::aarch64::string_indexof_linear_ll());
3444   SET_ADDRESS(_stubs, StubRoutines::aarch64::string_indexof_linear_uu());
3445   SET_ADDRESS(_stubs, StubRoutines::aarch64::large_byte_array_inflate());
3446   SET_ADDRESS(_stubs, StubRoutines::aarch64::spin_wait());
3447 
3448   SET_ADDRESS(_stubs, StubRoutines::aarch64::large_arrays_hashcode(T_BOOLEAN));
3449   SET_ADDRESS(_stubs, StubRoutines::aarch64::large_arrays_hashcode(T_BYTE));
3450   SET_ADDRESS(_stubs, StubRoutines::aarch64::large_arrays_hashcode(T_SHORT));
3451   SET_ADDRESS(_stubs, StubRoutines::aarch64::large_arrays_hashcode(T_CHAR));
3452   SET_ADDRESS(_stubs, StubRoutines::aarch64::large_arrays_hashcode(T_INT));
3453 #endif
3454 
3455   _complete = true;
3456   log_info(aot, codecache, init)("Stubs recorded");
3457 }
3458 
3459 void AOTCodeAddressTable::init_early_c1() {
3460 #ifdef COMPILER1
3461   // Runtime1 Blobs
3462   for (int i = 0; i <= (int)C1StubId::forward_exception_id; i++) {
3463     C1StubId id = (C1StubId)i;
3464     if (Runtime1::blob_for(id) == nullptr) {
3465       log_info(aot, codecache, init)("C1 blob %s is missing", Runtime1::name_for(id));
3466       continue;
3467     }
3468     if (Runtime1::entry_for(id) == nullptr) {
3469       log_info(aot, codecache, init)("C1 blob %s is missing entry", Runtime1::name_for(id));
3470       continue;
3471     }
3472     address entry = Runtime1::entry_for(id);
3473     SET_ADDRESS(_C1_blobs, entry);
3474   }
3475 #endif // COMPILER1
3476   assert(_C1_blobs_length <= _C1_blobs_max, "increase _C1_blobs_max to %d", _C1_blobs_length);
3477   _early_c1_complete = true;
3478 }
3479 
3480 void AOTCodeAddressTable::init_c1() {
3481 #ifdef COMPILER1
3482   // Runtime1 Blobs
3483   assert(_early_c1_complete, "early C1 blobs should be initialized");
3484   for (int i = (int)C1StubId::forward_exception_id + 1; i < (int)(C1StubId::NUM_STUBIDS); i++) {
3485     C1StubId id = (C1StubId)i;
3486     if (Runtime1::blob_for(id) == nullptr) {
3487       log_info(aot, codecache, init)("C1 blob %s is missing", Runtime1::name_for(id));
3488       continue;
3489     }
3490     if (Runtime1::entry_for(id) == nullptr) {
3491       log_info(aot, codecache, init)("C1 blob %s is missing entry", Runtime1::name_for(id));
3492       continue;
3493     }
3494     address entry = Runtime1::entry_for(id);
3495     SET_ADDRESS(_C1_blobs, entry);
3496   }
3497 #if INCLUDE_G1GC
3498   if (UseG1GC) {
3499     G1BarrierSetC1* bs = (G1BarrierSetC1*)BarrierSet::barrier_set()->barrier_set_c1();
3500     address entry = bs->pre_barrier_c1_runtime_code_blob()->code_begin();
3501     SET_ADDRESS(_C1_blobs, entry);
3502     entry = bs->post_barrier_c1_runtime_code_blob()->code_begin();
3503     SET_ADDRESS(_C1_blobs, entry);
3504   }
3505 #endif // INCLUDE_G1GC
3506 #if INCLUDE_ZGC
3507   if (UseZGC) {
3508     ZBarrierSetC1* bs = (ZBarrierSetC1*)BarrierSet::barrier_set()->barrier_set_c1();
3509     SET_ADDRESS(_C1_blobs, bs->_load_barrier_on_oop_field_preloaded_runtime_stub);
3510     SET_ADDRESS(_C1_blobs, bs->_load_barrier_on_weak_oop_field_preloaded_runtime_stub);
3511     SET_ADDRESS(_C1_blobs, bs->_store_barrier_on_oop_field_with_healing);
3512     SET_ADDRESS(_C1_blobs, bs->_store_barrier_on_oop_field_without_healing);
3513   }
3514 #endif // INCLUDE_ZGC
3515 #if INCLUDE_SHENANDOAHGC
3516   if (UseShenandoahGC) {
3517     ShenandoahBarrierSetC1* bs = (ShenandoahBarrierSetC1*)BarrierSet::barrier_set()->barrier_set_c1();
3518     SET_ADDRESS(_C1_blobs, bs->pre_barrier_c1_runtime_code_blob()->code_begin());
3519     SET_ADDRESS(_C1_blobs, bs->load_reference_barrier_strong_rt_code_blob()->code_begin());
3520     SET_ADDRESS(_C1_blobs, bs->load_reference_barrier_strong_native_rt_code_blob()->code_begin());
3521     SET_ADDRESS(_C1_blobs, bs->load_reference_barrier_weak_rt_code_blob()->code_begin());
3522     SET_ADDRESS(_C1_blobs, bs->load_reference_barrier_phantom_rt_code_blob()->code_begin());
3523   }
3524 #endif // INCLUDE_SHENANDOAHGC
3525 #endif // COMPILER1
3526 
3527   assert(_C1_blobs_length <= _C1_blobs_max, "increase _C1_blobs_max to %d", _C1_blobs_length);
3528   _c1_complete = true;
3529   log_info(aot, codecache, init)("Runtime1 Blobs recorded");
3530 }
3531 
3532 void AOTCodeAddressTable::init_c2() {
3533 #ifdef COMPILER2
3534   // OptoRuntime Blobs
3535   SET_ADDRESS(_C2_blobs, OptoRuntime::uncommon_trap_blob()->entry_point());
3536   SET_ADDRESS(_C2_blobs, OptoRuntime::exception_blob()->entry_point());
3537   SET_ADDRESS(_C2_blobs, OptoRuntime::new_instance_Java());
3538   SET_ADDRESS(_C2_blobs, OptoRuntime::new_array_Java());
3539   SET_ADDRESS(_C2_blobs, OptoRuntime::new_array_nozero_Java());
3540   SET_ADDRESS(_C2_blobs, OptoRuntime::multianewarray2_Java());
3541   SET_ADDRESS(_C2_blobs, OptoRuntime::multianewarray3_Java());
3542   SET_ADDRESS(_C2_blobs, OptoRuntime::multianewarray4_Java());
3543   SET_ADDRESS(_C2_blobs, OptoRuntime::multianewarray5_Java());
3544   SET_ADDRESS(_C2_blobs, OptoRuntime::multianewarrayN_Java());
3545   SET_ADDRESS(_C2_blobs, OptoRuntime::vtable_must_compile_stub());
3546   SET_ADDRESS(_C2_blobs, OptoRuntime::complete_monitor_locking_Java());
3547   SET_ADDRESS(_C2_blobs, OptoRuntime::monitor_notify_Java());
3548   SET_ADDRESS(_C2_blobs, OptoRuntime::monitor_notifyAll_Java());
3549   SET_ADDRESS(_C2_blobs, OptoRuntime::rethrow_stub());
3550   SET_ADDRESS(_C2_blobs, OptoRuntime::slow_arraycopy_Java());
3551   SET_ADDRESS(_C2_blobs, OptoRuntime::register_finalizer_Java());
3552   SET_ADDRESS(_C2_blobs, OptoRuntime::class_init_barrier_Java());
3553 #if INCLUDE_JVMTI
3554   SET_ADDRESS(_C2_blobs, OptoRuntime::notify_jvmti_vthread_start());
3555   SET_ADDRESS(_C2_blobs, OptoRuntime::notify_jvmti_vthread_end());
3556   SET_ADDRESS(_C2_blobs, OptoRuntime::notify_jvmti_vthread_mount());
3557   SET_ADDRESS(_C2_blobs, OptoRuntime::notify_jvmti_vthread_unmount());
3558 #endif /* INCLUDE_JVMTI */
3559 #endif
3560 
3561   assert(_C2_blobs_length <= _C2_blobs_max, "increase _C2_blobs_max to %d", _C2_blobs_length);
3562   _c2_complete = true;
3563   log_info(aot, codecache, init)("OptoRuntime Blobs recorded");
3564 }
3565 #undef SET_ADDRESS
3566 
3567 AOTCodeAddressTable::~AOTCodeAddressTable() {
3568   if (_extrs_addr != nullptr) {
3569     FREE_C_HEAP_ARRAY(address, _extrs_addr);
3570   }
3571   if (_stubs_addr != nullptr) {
3572     FREE_C_HEAP_ARRAY(address, _stubs_addr);
3573   }
3574   if (_shared_blobs_addr != nullptr) {
3575     FREE_C_HEAP_ARRAY(address, _shared_blobs_addr);
3576   }
3577 }
3578 
3579 #ifdef PRODUCT
3580 #define MAX_STR_COUNT 200
3581 #else
3582 #define MAX_STR_COUNT 500
3583 #endif
3584 #define _c_str_max  MAX_STR_COUNT
3585 static const int _c_str_base = _all_max;
3586 
3587 static const char* _C_strings_in[MAX_STR_COUNT] = {nullptr}; // Incoming strings
3588 static const char* _C_strings[MAX_STR_COUNT]    = {nullptr}; // Our duplicates
3589 static int _C_strings_count = 0;
3590 static int _C_strings_s[MAX_STR_COUNT] = {0};
3591 static int _C_strings_id[MAX_STR_COUNT] = {0};
3592 static int _C_strings_used = 0;
3593 
3594 void AOTCodeCache::load_strings() {
3595   uint strings_count  = _load_header->strings_count();
3596   if (strings_count == 0) {
3597     return;
3598   }
3599   uint strings_offset = _load_header->strings_offset();
3600   uint* string_lengths = (uint*)addr(strings_offset);
3601   strings_offset += (strings_count * sizeof(uint));
3602   uint strings_size = _load_header->entries_offset() - strings_offset;
3603   // We have to keep cached strings longer than _cache buffer
3604   // because they are refernced from compiled code which may
3605   // still be executed on VM exit after _cache is freed.
3606   char* p = NEW_C_HEAP_ARRAY(char, strings_size+1, mtCode);
3607   memcpy(p, addr(strings_offset), strings_size);
3608   _C_strings_buf = p;
3609   assert(strings_count <= MAX_STR_COUNT, "sanity");
3610   for (uint i = 0; i < strings_count; i++) {
3611     _C_strings[i] = p;
3612     uint len = string_lengths[i];
3613     _C_strings_s[i] = i;
3614     _C_strings_id[i] = i;
3615     p += len;
3616   }
3617   assert((uint)(p - _C_strings_buf) <= strings_size, "(" INTPTR_FORMAT " - " INTPTR_FORMAT ") = %d > %d ", p2i(p), p2i(_C_strings_buf), (uint)(p - _C_strings_buf), strings_size);
3618   _C_strings_count = strings_count;
3619   _C_strings_used  = strings_count;
3620   log_debug(aot, codecache, init)("  Loaded %d C strings of total length %d at offset %d from AOT Code Cache", _C_strings_count, strings_size, strings_offset);
3621 }
3622 
3623 int AOTCodeCache::store_strings() {
3624   if (_C_strings_used > 0) {
3625     MutexLocker ml(AOTCodeCStrings_lock, Mutex::_no_safepoint_check_flag);
3626     uint offset = _write_position;
3627     uint length = 0;
3628     uint* lengths = (uint *)reserve_bytes(sizeof(uint) * _C_strings_used);
3629     if (lengths == nullptr) {
3630       return -1;
3631     }
3632     for (int i = 0; i < _C_strings_used; i++) {
3633       const char* str = _C_strings[_C_strings_s[i]];
3634       uint len = (uint)strlen(str) + 1;
3635       length += len;
3636       assert(len < 1000, "big string: %s", str);
3637       lengths[i] = len;
3638       uint n = write_bytes(str, len);
3639       if (n != len) {
3640         return -1;
3641       }
3642     }
3643     log_debug(aot, codecache, exit)("  Wrote %d C strings of total length %d at offset %d to AOT Code Cache",
3644                                    _C_strings_used, length, offset);
3645   }
3646   return _C_strings_used;
3647 }
3648 
3649 const char* AOTCodeCache::add_C_string(const char* str) {
3650   if (is_on_for_dump() && str != nullptr) {
3651     MutexLocker ml(AOTCodeCStrings_lock, Mutex::_no_safepoint_check_flag);
3652     AOTCodeAddressTable* table = addr_table();
3653     if (table != nullptr) {
3654       return table->add_C_string(str);
3655     }
3656   }
3657   return str;
3658 }
3659 
3660 const char* AOTCodeAddressTable::add_C_string(const char* str) {
3661   if (_extrs_complete) {
3662     // Check previous strings address
3663     for (int i = 0; i < _C_strings_count; i++) {
3664       if (_C_strings_in[i] == str) {
3665         return _C_strings[i]; // Found previous one - return our duplicate
3666       } else if (strcmp(_C_strings[i], str) == 0) {
3667         return _C_strings[i];
3668       }
3669     }
3670     // Add new one
3671     if (_C_strings_count < MAX_STR_COUNT) {
3672       // Passed in string can be freed and used space become inaccessible.
3673       // Keep original address but duplicate string for future compare.
3674       _C_strings_id[_C_strings_count] = -1; // Init
3675       _C_strings_in[_C_strings_count] = str;
3676       const char* dup = os::strdup(str);
3677       _C_strings[_C_strings_count++] = dup;
3678       log_trace(aot, codecache, stringtable)("add_C_string: [%d] " INTPTR_FORMAT " '%s'", _C_strings_count, p2i(dup), dup);
3679       return dup;
3680     } else {
3681       assert(false, "Number of C strings >= MAX_STR_COUNT");
3682     }
3683   }
3684   return str;
3685 }
3686 
3687 int AOTCodeAddressTable::id_for_C_string(address str) {
3688   if (str == nullptr) {
3689     return -1;
3690   }
3691   MutexLocker ml(AOTCodeCStrings_lock, Mutex::_no_safepoint_check_flag);
3692   for (int i = 0; i < _C_strings_count; i++) {
3693     if (_C_strings[i] == (const char*)str) { // found
3694       int id = _C_strings_id[i];
3695       if (id >= 0) {
3696         assert(id < _C_strings_used, "%d >= %d", id , _C_strings_used);
3697         return id; // Found recorded
3698       }
3699       // Not found in recorded, add new
3700       id = _C_strings_used++;
3701       _C_strings_s[id] = i;
3702       _C_strings_id[i] = id;
3703       return id;
3704     }
3705   }
3706   return -1;
3707 }
3708 
3709 address AOTCodeAddressTable::address_for_C_string(int idx) {
3710   assert(idx < _C_strings_count, "sanity");
3711   return (address)_C_strings[idx];
3712 }
3713 
3714 static int search_address(address addr, address* table, uint length) {
3715   for (int i = 0; i < (int)length; i++) {
3716     if (table[i] == addr) {
3717       return i;
3718     }
3719   }
3720   return BAD_ADDRESS_ID;
3721 }
3722 
3723 address AOTCodeAddressTable::address_for_id(int idx) {
3724   assert(_extrs_complete, "AOT Code Cache VM runtime addresses table is not complete");
3725   if (idx == -1) {
3726     return (address)-1;
3727   }
3728   uint id = (uint)idx;
3729   // special case for symbols based relative to os::init
3730   if (id > (_c_str_base + _c_str_max)) {
3731     return (address)os::init + idx;
3732   }
3733   if (idx < 0) {
3734     fatal("Incorrect id %d for AOT Code Cache addresses table", id);
3735     return nullptr;
3736   }
3737   // no need to compare unsigned id against 0
3738   if (/* id >= _extrs_base && */ id < _extrs_length) {
3739     return _extrs_addr[id - _extrs_base];
3740   }
3741   if (id >= _stubs_base && id < _stubs_base + _stubs_length) {
3742     return _stubs_addr[id - _stubs_base];
3743   }
3744   if (id >= _stubs_base && id < _stubs_base + _stubs_length) {
3745     return _stubs_addr[id - _stubs_base];
3746   }
3747   if (id >= _shared_blobs_base && id < _shared_blobs_base + _shared_blobs_length) {
3748     return _shared_blobs_addr[id - _shared_blobs_base];
3749   }
3750   if (id >= _C1_blobs_base && id < _C1_blobs_base + _C1_blobs_length) {
3751     return _C1_blobs_addr[id - _C1_blobs_base];
3752   }
3753   if (id >= _C1_blobs_base && id < _C1_blobs_base + _C1_blobs_length) {
3754     return _C1_blobs_addr[id - _C1_blobs_base];
3755   }
3756   if (id >= _C2_blobs_base && id < _C2_blobs_base + _C2_blobs_length) {
3757     return _C2_blobs_addr[id - _C2_blobs_base];
3758   }
3759   if (id >= _c_str_base && id < (_c_str_base + (uint)_C_strings_count)) {
3760     return address_for_C_string(id - _c_str_base);
3761   }
3762   fatal("Incorrect id %d for AOT Code Cache addresses table", id);
3763   return nullptr;
3764 }
3765 
3766 int AOTCodeAddressTable::id_for_address(address addr, RelocIterator reloc, CodeBlob* blob) {
3767   assert(_extrs_complete, "AOT Code Cache VM runtime addresses table is not complete");
3768   int id = -1;
3769   if (addr == (address)-1) { // Static call stub has jump to itself
3770     return id;
3771   }
3772   // Check card_table_base address first since it can point to any address
3773   BarrierSet* bs = BarrierSet::barrier_set();
3774   if (bs->is_a(BarrierSet::CardTableBarrierSet)) {
3775     if (addr == ci_card_table_address_as<address>()) {
3776       id = search_address(addr, _extrs_addr, _extrs_length);
3777       assert(id > 0 && _extrs_addr[id - _extrs_base] == addr, "sanity");
3778       return id;
3779     }
3780   }
3781 
3782   // Seach for C string
3783   id = id_for_C_string(addr);
3784   if (id >= 0) {
3785     return id + _c_str_base;
3786   }
3787   if (StubRoutines::contains(addr)) {
3788     // Search in stubs
3789     id = search_address(addr, _stubs_addr, _stubs_length);
3790     if (id == BAD_ADDRESS_ID) {
3791       StubCodeDesc* desc = StubCodeDesc::desc_for(addr);
3792       if (desc == nullptr) {
3793         desc = StubCodeDesc::desc_for(addr + frame::pc_return_offset);
3794       }
3795       const char* sub_name = (desc != nullptr) ? desc->name() : "<unknown>";
3796       assert(false, "Address " INTPTR_FORMAT " for Stub:%s is missing in AOT Code Cache addresses table", p2i(addr), sub_name);
3797     } else {
3798       return _stubs_base + id;
3799     }
3800   } else {
3801     CodeBlob* cb = CodeCache::find_blob(addr);
3802     if (cb != nullptr) {
3803       int id_base = _shared_blobs_base;
3804       // Search in code blobs
3805       id = search_address(addr, _shared_blobs_addr, _shared_blobs_length);
3806       if (id == BAD_ADDRESS_ID) {
3807         id_base = _C1_blobs_base;
3808         // search C1 blobs
3809         id = search_address(addr, _C1_blobs_addr, _C1_blobs_length);
3810       }
3811       if (id == BAD_ADDRESS_ID) {
3812         id_base = _C2_blobs_base;
3813         // search C2 blobs
3814         id = search_address(addr, _C2_blobs_addr, _C2_blobs_length);
3815       }
3816       if (id == BAD_ADDRESS_ID) {
3817         assert(false, "Address " INTPTR_FORMAT " for Blob:%s is missing in AOT Code Cache addresses table", p2i(addr), cb->name());
3818       } else {
3819         return id_base + id;
3820       }
3821     } else {
3822       // Search in runtime functions
3823       id = search_address(addr, _extrs_addr, _extrs_length);
3824       if (id == BAD_ADDRESS_ID) {
3825         ResourceMark rm;
3826         const int buflen = 1024;
3827         char* func_name = NEW_RESOURCE_ARRAY(char, buflen);
3828         int offset = 0;
3829         if (os::dll_address_to_function_name(addr, func_name, buflen, &offset)) {
3830           if (offset > 0) {
3831             // Could be address of C string
3832             uint dist = (uint)pointer_delta(addr, (address)os::init, 1);
3833             CompileTask* task = ciEnv::current()->task();
3834             uint compile_id = 0;
3835             uint comp_level =0;
3836             if (task != nullptr) { // this could be called from compiler runtime initialization (compiler blobs)
3837               compile_id = task->compile_id();
3838               comp_level = task->comp_level();
3839             }
3840             log_debug(aot, codecache)("%d (L%d): Address " INTPTR_FORMAT " (offset %d) for runtime target '%s' is missing in AOT Code Cache addresses table",
3841                           compile_id, comp_level, p2i(addr), dist, (const char*)addr);
3842             assert(dist > (uint)(_all_max + MAX_STR_COUNT), "change encoding of distance");
3843             return dist;
3844           }
3845           reloc.print_current_on(tty);
3846           blob->print_on(tty);
3847           blob->print_code_on(tty);
3848           assert(false, "Address " INTPTR_FORMAT " for runtime target '%s+%d' is missing in AOT Code Cache addresses table", p2i(addr), func_name, offset);
3849         } else {
3850           reloc.print_current_on(tty);
3851           blob->print_on(tty);
3852           blob->print_code_on(tty);
3853           os::find(addr, tty);
3854           assert(false, "Address " INTPTR_FORMAT " for <unknown>/('%s') is missing in AOT Code Cache addresses table", p2i(addr), (const char*)addr);
3855         }
3856       } else {
3857         return _extrs_base + id;
3858       }
3859     }
3860   }
3861   return id;
3862 }
3863 
3864 #undef _extrs_max
3865 #undef _stubs_max
3866 #undef _shared_blobs_max
3867 #undef _C1_blobs_max
3868 #undef _C2_blobs_max
3869 #undef _blobs_max
3870 #undef _extrs_base
3871 #undef _stubs_base
3872 #undef _shared_blobs_base
3873 #undef _C1_blobs_base
3874 #undef _C2_blobs_base
3875 #undef _blobs_end
3876 
3877 void AOTRuntimeConstants::initialize_from_runtime() {
3878   BarrierSet* bs = BarrierSet::barrier_set();
3879   if (bs->is_a(BarrierSet::CardTableBarrierSet)) {
3880     CardTableBarrierSet* ctbs = ((CardTableBarrierSet*)bs);
3881     _aot_runtime_constants._grain_shift = ctbs->grain_shift();
3882     _aot_runtime_constants._card_shift = ctbs->card_shift();
3883   }
3884 }
3885 
3886 AOTRuntimeConstants AOTRuntimeConstants::_aot_runtime_constants;
3887 
3888 address AOTRuntimeConstants::_field_addresses_list[] = {
3889   grain_shift_address(),
3890   card_shift_address(),
3891   nullptr
3892 };
3893 
3894 
3895 void AOTCodeCache::wait_for_no_nmethod_readers() {
3896   while (true) {
3897     int cur = Atomic::load(&_nmethod_readers);
3898     int upd = -(cur + 1);
3899     if (cur >= 0 && Atomic::cmpxchg(&_nmethod_readers, cur, upd) == cur) {
3900       // Success, no new readers should appear.
3901       break;
3902     }
3903   }
3904 
3905   // Now wait for all readers to leave.
3906   SpinYield w;
3907   while (Atomic::load(&_nmethod_readers) != -1) {
3908     w.wait();
3909   }
3910 }
3911 
3912 AOTCodeCache::ReadingMark::ReadingMark() {
3913   while (true) {
3914     int cur = Atomic::load(&_nmethod_readers);
3915     if (cur < 0) {
3916       // Cache is already closed, cannot proceed.
3917       _failed = true;
3918       return;
3919     }
3920     if (Atomic::cmpxchg(&_nmethod_readers, cur, cur + 1) == cur) {
3921       // Successfully recorded ourselves as entered.
3922       _failed = false;
3923       return;
3924     }
3925   }
3926 }
3927 
3928 AOTCodeCache::ReadingMark::~ReadingMark() {
3929   if (_failed) {
3930     return;
3931   }
3932   while (true) {
3933     int cur = Atomic::load(&_nmethod_readers);
3934     if (cur > 0) {
3935       // Cache is open, we are counting down towards 0.
3936       if (Atomic::cmpxchg(&_nmethod_readers, cur, cur - 1) == cur) {
3937         return;
3938       }
3939     } else {
3940       // Cache is closed, we are counting up towards -1.
3941       if (Atomic::cmpxchg(&_nmethod_readers, cur, cur + 1) == cur) {
3942         return;
3943       }
3944     }
3945   }
3946 }
3947 
3948 void AOTCodeCache::print_timers_on(outputStream* st) {
3949   if (is_using_code()) {
3950     st->print_cr ("    AOT Code Load Time:   %7.3f s", _t_totalLoad.seconds());
3951     st->print_cr ("      nmethod register:     %7.3f s", _t_totalRegister.seconds());
3952     st->print_cr ("      find cached code:     %7.3f s", _t_totalFind.seconds());
3953   }
3954   if (is_dumping_code()) {
3955     st->print_cr ("    AOT Code Store Time:  %7.3f s", _t_totalStore.seconds());
3956   }
3957 }
3958 
3959 AOTCodeStats AOTCodeStats::add_aot_code_stats(AOTCodeStats stats1, AOTCodeStats stats2) {
3960   AOTCodeStats result;
3961   for (int kind = AOTCodeEntry::None; kind < AOTCodeEntry::Kind_count; kind++) {
3962     result.ccstats._kind_cnt[kind] = stats1.entry_count(kind) + stats2.entry_count(kind);
3963   }
3964 
3965   for (int lvl = CompLevel_none; lvl < AOTCompLevel_count; lvl++) {
3966     result.ccstats._nmethod_cnt[lvl] = stats1.nmethod_count(lvl) + stats2.nmethod_count(lvl);
3967   }
3968   result.ccstats._clinit_barriers_cnt = stats1.clinit_barriers_count() + stats2.clinit_barriers_count();
3969   return result;
3970 }
3971 
3972 void AOTCodeCache::log_stats_on_exit() {
3973   LogStreamHandle(Debug, aot, codecache, exit) log;
3974   if (log.is_enabled()) {
3975     AOTCodeStats prev_stats;
3976     AOTCodeStats current_stats;
3977     AOTCodeStats total_stats;
3978     uint max_size = 0;
3979 
3980     uint load_count = (_load_header != nullptr) ? _load_header->entries_count() : 0;
3981 
3982     for (uint i = 0; i < load_count; i++) {
3983       prev_stats.collect_entry_stats(&_load_entries[i]);
3984       if (max_size < _load_entries[i].size()) {
3985         max_size = _load_entries[i].size();
3986       }
3987     }
3988     for (uint i = 0; i < _store_entries_cnt; i++) {
3989       current_stats.collect_entry_stats(&_store_entries[i]);
3990       if (max_size < _store_entries[i].size()) {
3991         max_size = _store_entries[i].size();
3992       }
3993     }
3994     total_stats = AOTCodeStats::add_aot_code_stats(prev_stats, current_stats);
3995 
3996     log.print_cr("Wrote %d AOTCodeEntry entries(%u max size) to AOT Code Cache",
3997                  total_stats.total_count(), max_size);
3998     for (uint kind = AOTCodeEntry::None; kind < AOTCodeEntry::Kind_count; kind++) {
3999       if (total_stats.entry_count(kind) > 0) {
4000         log.print_cr("  %s: total=%u(old=%u+new=%u)",
4001                      aot_code_entry_kind_name[kind], total_stats.entry_count(kind), prev_stats.entry_count(kind), current_stats.entry_count(kind));
4002         if (kind == AOTCodeEntry::Code) {
4003           for (uint lvl = CompLevel_none; lvl < AOTCompLevel_count; lvl++) {
4004             if (total_stats.nmethod_count(lvl) > 0) {
4005               log.print_cr("    Tier %d: total=%u(old=%u+new=%u)",
4006                            lvl, total_stats.nmethod_count(lvl), prev_stats.nmethod_count(lvl), current_stats.nmethod_count(lvl));
4007             }
4008           }
4009         }
4010       }
4011     }
4012     log.print_cr("Total=%u(old=%u+new=%u)", total_stats.total_count(), prev_stats.total_count(), current_stats.total_count());
4013   }
4014 }
4015 
4016 static void print_helper1(outputStream* st, const char* name, int count) {
4017   if (count > 0) {
4018     st->print(" %s=%d", name, count);
4019   }
4020 }
4021 
4022 void AOTCodeCache::print_statistics_on(outputStream* st) {
4023   AOTCodeCache* cache = open_for_use();
4024   if (cache != nullptr) {
4025     ReadingMark rdmk;
4026     if (rdmk.failed()) {
4027       // Cache is closed, cannot touch anything.
4028       return;
4029     }
4030 
4031     uint count = cache->_load_header->entries_count();
4032     uint* search_entries = (uint*)cache->addr(cache->_load_header->entries_offset()); // [id, index]
4033     AOTCodeEntry* load_entries = (AOTCodeEntry*)(search_entries + 2 * count);
4034 
4035     AOTCodeStats stats;
4036     for (uint i = 0; i < count; i++) {
4037       stats.collect_all_stats(&load_entries[i]);
4038     }
4039 
4040     for (uint kind = AOTCodeEntry::None; kind < AOTCodeEntry::Kind_count; kind++) {
4041       if (stats.entry_count(kind) > 0) {
4042         st->print("  %s:", aot_code_entry_kind_name[kind]);
4043         print_helper1(st, "total", stats.entry_count(kind));
4044         print_helper1(st, "loaded", stats.entry_loaded_count(kind));
4045         print_helper1(st, "invalidated", stats.entry_invalidated_count(kind));
4046         print_helper1(st, "failed", stats.entry_load_failed_count(kind));
4047         st->cr();
4048       }
4049       if (kind == AOTCodeEntry::Code) {
4050         for (uint lvl = CompLevel_none; lvl < AOTCompLevel_count; lvl++) {
4051           if (stats.nmethod_count(lvl) > 0) {
4052             st->print("    AOT Code T%d", lvl);
4053             print_helper1(st, "total", stats.nmethod_count(lvl));
4054             print_helper1(st, "loaded", stats.nmethod_loaded_count(lvl));
4055             print_helper1(st, "invalidated", stats.nmethod_invalidated_count(lvl));
4056             print_helper1(st, "failed", stats.nmethod_load_failed_count(lvl));
4057             if (lvl == AOTCompLevel_count-1) {
4058               print_helper1(st, "has_clinit_barriers", stats.clinit_barriers_count());
4059             }
4060             st->cr();
4061           }
4062         }
4063       }
4064     }
4065     LogStreamHandle(Debug, aot, codecache, init) log;
4066     if (log.is_enabled()) {
4067       AOTCodeCache::print_unused_entries_on(&log);
4068     }
4069     LogStreamHandle(Trace, aot, codecache) aot_info;
4070     // need a lock to traverse the code cache
4071     if (aot_info.is_enabled()) {
4072       MutexLocker locker(CodeCache_lock, Mutex::_no_safepoint_check_flag);
4073       NMethodIterator iter(NMethodIterator::all);
4074       while (iter.next()) {
4075         nmethod* nm = iter.method();
4076         if (nm->is_in_use() && !nm->is_native_method() && !nm->is_osr_method()) {
4077           aot_info.print("%5d:%c%c%c%d:", nm->compile_id(),
4078                          (nm->method()->is_shared() ? 'S' : ' '),
4079                          (nm->is_aot() ? 'A' : ' '),
4080                          (nm->preloaded() ? 'P' : ' '),
4081                          nm->comp_level());
4082           print_helper(nm, &aot_info);
4083           aot_info.print(": ");
4084           CompileTask::print(&aot_info, nm, nullptr, true /*short_form*/);
4085           LogStreamHandle(Trace, aot, codecache) aot_debug;
4086           if (aot_debug.is_enabled()) {
4087             MethodTrainingData* mtd = MethodTrainingData::find(methodHandle(Thread::current(), nm->method()));
4088             if (mtd != nullptr) {
4089               mtd->iterate_compiles([&](CompileTrainingData* ctd) {
4090                 aot_debug.print("     CTD: "); ctd->print_on(&aot_debug); aot_debug.cr();
4091               });
4092             }
4093           }
4094         }
4095       }
4096     }
4097   } else {
4098     st->print_cr("failed to map code cache");
4099   }
4100 }
4101 
4102 void AOTCodeEntry::print(outputStream* st) const {
4103   st->print_cr(" AOT Code Cache entry " INTPTR_FORMAT " [kind: %d, id: " UINT32_FORMAT_X_0 ", offset: %d, size: %d, comp_level: %d, comp_id: %d, %s%s%s%s]",
4104                p2i(this), (int)_kind, _id, _offset, _size, _comp_level, _comp_id,
4105                (_not_entrant? "not_entrant" : "entrant"),
4106                (_loaded ? ", loaded" : ""),
4107                (_has_clinit_barriers ? ", has_clinit_barriers" : ""),
4108                (_for_preload ? ", for_preload" : ""));
4109 }
4110 
4111 void AOTCodeCache::print_on(outputStream* st) {
4112   if (opened_cache != nullptr && opened_cache->for_use()) {
4113     ReadingMark rdmk;
4114     if (rdmk.failed()) {
4115       // Cache is closed, cannot touch anything.
4116       return;
4117     }
4118 
4119     st->print_cr("\nAOT Code Cache");
4120     uint count = opened_cache->_load_header->entries_count();
4121     uint* search_entries = (uint*)opened_cache->addr(opened_cache->_load_header->entries_offset()); // [id, index]
4122     AOTCodeEntry* load_entries = (AOTCodeEntry*)(search_entries + 2 * count);
4123 
4124     for (uint i = 0; i < count; i++) {
4125       int index = search_entries[2*i + 1];
4126       AOTCodeEntry* entry = &(load_entries[index]);
4127 
4128       uint entry_position = entry->offset();
4129       uint name_offset = entry->name_offset() + entry_position;
4130       const char* saved_name = opened_cache->addr(name_offset);
4131 
4132       st->print_cr("%4u: %10s idx:%4u Id:%u L%u size=%u '%s' %s%s%s%s",
4133                    i, aot_code_entry_kind_name[entry->kind()], index, entry->id(), entry->comp_level(),
4134                    entry->size(),  saved_name,
4135                    entry->has_clinit_barriers() ? " has_clinit_barriers" : "",
4136                    entry->for_preload()         ? " for_preload"         : "",
4137                    entry->is_loaded()           ? " loaded"              : "",
4138                    entry->not_entrant()         ? " not_entrant"         : "");
4139 
4140       st->print_raw("         ");
4141       AOTCodeReader reader(opened_cache, entry, nullptr);
4142       reader.print_on(st);
4143     }
4144   }
4145 }
4146 
4147 void AOTCodeCache::print_unused_entries_on(outputStream* st) {
4148   LogStreamHandle(Info, aot, codecache, init) info;
4149   if (info.is_enabled()) {
4150     AOTCodeCache::iterate([&](AOTCodeEntry* entry) {
4151       if (entry->is_code() && !entry->is_loaded()) {
4152         MethodTrainingData* mtd = MethodTrainingData::find(methodHandle(Thread::current(), entry->method()));
4153         if (mtd != nullptr) {
4154           if (mtd->has_holder()) {
4155             if (mtd->holder()->method_holder()->is_initialized()) {
4156               ResourceMark rm;
4157               mtd->iterate_compiles([&](CompileTrainingData* ctd) {
4158                 if ((uint)ctd->level() == entry->comp_level()) {
4159                   if (ctd->init_deps_left() == 0) {
4160                     nmethod* nm = mtd->holder()->code();
4161                     if (nm == nullptr) {
4162                       if (mtd->holder()->queued_for_compilation()) {
4163                         return; // scheduled for compilation
4164                       }
4165                     } else if ((uint)nm->comp_level() >= entry->comp_level()) {
4166                       return; // already online compiled and superseded by a more optimal method
4167                     }
4168                     info.print("AOT Code Cache entry not loaded: ");
4169                     ctd->print_on(&info);
4170                     info.cr();
4171                   }
4172                 }
4173               });
4174             } else {
4175               // not yet initialized
4176             }
4177           } else {
4178             info.print("AOT Code Cache entry doesn't have a holder: ");
4179             mtd->print_on(&info);
4180             info.cr();
4181           }
4182         }
4183       }
4184     });
4185   }
4186 }
4187 
4188 void AOTCodeReader::print_on(outputStream* st) {
4189   uint entry_position = _entry->offset();
4190   set_read_position(entry_position);
4191 
4192   // Read name
4193   uint name_offset = entry_position + _entry->name_offset();
4194   uint name_size = _entry->name_size(); // Includes '/0'
4195   const char* name = addr(name_offset);
4196 
4197   st->print_cr("  name: %s", name);
4198 }
4199