src/hotspot/share/cds/aotCacheAccess.cpp

@@ -1,7 +1,7 @@
  /*
-  * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
+  * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.

@@ -34,22 +34,157 @@
  #include "memory/resourceArea.hpp"
  #include "memory/universe.hpp"
  #include "memory/virtualspace.hpp"
  #include "oops/instanceKlass.hpp"
  
+ size_t _aot_code_region_size = 0;
+ 
+ bool AOTCacheAccess::can_generate_aot_code(address addr) {
+   if (CDSConfig::is_dumping_final_static_archive()) {
+     return ArchiveBuilder::is_active() && ArchiveBuilder::current()->has_been_archived(addr);
+   } else {
+     // Old CDS+AOT workflow.
+     return MetaspaceShared::is_in_shared_metaspace(addr);
+   }
+ }
+ 
+ bool AOTCacheAccess::can_generate_aot_code(InstanceKlass* ik) {
+   if (CDSConfig::is_dumping_final_static_archive()) {
+     if (!ArchiveBuilder::is_active()) {
+       return false;
+     }
+     ArchiveBuilder* builder = ArchiveBuilder::current();
+     if (!builder->has_been_archived((address)ik)) {
+       return false;
+     }
+     InstanceKlass* buffered_ik = builder->get_buffered_addr(ik);
+     if (ik->is_shared_unregistered_class()) {
+       return false;
+     }
+     return true;
+   } else {
+     // Old CDS+AOT workflow.
+     return ik->is_shared() && !ik->is_shared_unregistered_class();
+   }
+ }
+ 
+ uint AOTCacheAccess::delta_from_shared_address_base(address addr) {
+   if (CDSConfig::is_dumping_final_static_archive()) {
+     assert(ArchiveBuilder::is_active(), "must be");
+     ArchiveBuilder* builder = ArchiveBuilder::current();
+     address requested_addr = builder->to_requested(builder->get_buffered_addr(addr));
+     return (uint)pointer_delta(requested_addr, (address)SharedBaseAddress, 1);
+   } else {
+     // Old CDS+AOT workflow.
+     return (uint)pointer_delta(addr, (address)SharedBaseAddress, 1);
+   }
+ }
+ 
+ Method* AOTCacheAccess::method_in_aot_code(Method* m) {
+   if (CDSConfig::is_dumping_final_static_archive()) {
+     assert(ArchiveBuilder::is_active(), "must be");
+     ArchiveBuilder* builder = ArchiveBuilder::current();
+     return builder->to_requested(builder->get_buffered_addr(m));
+   } else {
+     // Old CDS+AOT workflow.
+     return m;
+   }
+ }
+ 
+ #if INCLUDE_CDS_JAVA_HEAP
+ int AOTCacheAccess::get_archived_object_permanent_index(oop obj) {
+   return HeapShared::get_archived_object_permanent_index(obj);
+ }
+ 
+ oop AOTCacheAccess::get_archived_object(int permanent_index) {
+   oop o = HeapShared::get_archived_object(permanent_index);
+   assert(oopDesc::is_oop_or_null(o), "sanity");
+   return o;
+ }
+ 
+ static void test_cds_heap_access_api_for_object(oop obj) {
+   LogStreamHandle(Info, cds, jit) log;
+ 
+   obj->print_on(&log);
+   log.cr();
+ 
+   int n = AOTCacheAccess::get_archived_object_permanent_index(obj); // call this when AOTCodeCaching is on
+   if (n < 0) {
+     log.print_cr("*** This object is not in CDS archive");
+   } else {
+     log.print_cr("AOTCacheAccess::get_archived_object_permanent_index(s) = %d", n);
+     oop archived_obj = AOTCacheAccess::get_archived_object(n); // call this when AOTCodeCaching is on
+     if (archived_obj == obj || archived_obj == HeapShared::orig_to_scratch_object(obj)) {
+       log.print_cr("AOTCacheAccess::get_archived_object(%d) returns the same object, as expected", n);
+     } else {
+       log.print_cr("Error!!! AOTCacheAccess::get_archived_object(%d) returns an unexpected object", n);
+       if (archived_obj == nullptr) {
+         log.print_cr("--> null");
+       } else {
+         archived_obj->print_on(&log);
+         log.cr();
+       }
+     }
+   }
+ }
+ 
+ // TEMP: examples for using the AOTCacheAccess::get_archived_object_permanent_index() and AOTCacheAccess::get_archived_object()
+ // APIs for the AOT compiler.
+ 
+ void AOTCacheAccess::test_heap_access_api() {
+   ResourceMark rm;
+   const char* tests[] = {
+     "",
+     "null",
+     "NARROW",
+     "not in cds",
+     nullptr,
+   };
+ 
+   LogStreamHandle(Info, cds, jit) log;
+ 
+   int i;
+   for (i = 0; tests[i] != nullptr; i++) {
+     EXCEPTION_MARK;
+     log.print_cr("Test %d ======================================== \"%s\"", i, tests[i]);
+     oop s = StringTable::intern(tests[i], CHECK);
+     test_cds_heap_access_api_for_object(s);
+   }
+ 
+   log.print_cr("Test %d ======================================== Universe::null_ptr_exception_instance()", i);
+   test_cds_heap_access_api_for_object(Universe::null_ptr_exception_instance());
+ }
+ 
+ #endif // INCLUDE_CDS_JAVA_HEAP
+ 
  void* AOTCacheAccess::allocate_aot_code_region(size_t size) {
    assert(CDSConfig::is_dumping_final_static_archive(), "must be");
    return (void*)ArchiveBuilder::ac_region_alloc(size);
  }
  
  size_t AOTCacheAccess::get_aot_code_region_size() {
-   assert(CDSConfig::is_using_archive(), "must be");
-   FileMapInfo* mapinfo = FileMapInfo::current_info();
-   assert(mapinfo != nullptr, "must be");
-   return mapinfo->region_at(MetaspaceShared::ac)->used_aligned();
+   return _aot_code_region_size;
+ }
+ 
+ void AOTCacheAccess::set_aot_code_region_size(size_t sz) {
+   _aot_code_region_size = sz;
  }
  
  bool AOTCacheAccess::map_aot_code_region(ReservedSpace rs) {
    FileMapInfo* static_mapinfo = FileMapInfo::current_info();
    assert(UseSharedSpaces && static_mapinfo != nullptr, "must be");
    return static_mapinfo->map_aot_code_region(rs);
  }
+ 
+ bool AOTCacheAccess::is_aot_code_region_empty() {
+   assert(CDSConfig::is_dumping_final_static_archive(), "must be");
+   return ArchiveBuilder::current()->ac_region()->is_empty();
+ }
+ 
+ void AOTCacheAccess::set_pointer(address* ptr, address value) {
+   ArchiveBuilder* builder = ArchiveBuilder::current();
+   if (value != nullptr && !builder->is_in_buffer_space(value)) {
+     value = builder->get_buffered_addr(value);
+   }
+   *ptr = value;
+   ArchivePtrMarker::mark_pointer(ptr);
+ }