8366477: Refactor AOT-related flag bits in klass.hpp

src/hotspot/os/posix/vmError_posix.cpp

@@ -24,7 +24,7 @@
  */
 
 #include "cds/cdsConfig.hpp"
-#include "cds/metaspaceShared.hpp"
+#include "cds/aotMetaspace.hpp"
 #include "os_posix.hpp"
 #include "runtime/javaThread.hpp"
 #include "runtime/os.hpp"
@@ -117,7 +117,7 @@ void VMError::check_failing_cds_access(outputStream* st, const void* siginfo) {
     if (si->si_signo == SIGBUS || si->si_signo == SIGSEGV) {
       const void* const fault_addr = si->si_addr;
       if (fault_addr != nullptr) {
-        if (MetaspaceShared::is_in_shared_metaspace(fault_addr)) {
+        if (AOTMetaspace::in_aot_cache(fault_addr)) {
           st->print("Error accessing class data sharing archive. "
             "Mapped file inaccessible during execution, possible disk/network problem.");
         }

src/hotspot/os/windows/vmError_windows.cpp

@@ -23,7 +23,7 @@
  */
 
 #include "cds/cdsConfig.hpp"
-#include "cds/metaspaceShared.hpp"
+#include "cds/aotMetaspace.hpp"
 #include "runtime/arguments.hpp"
 #include "runtime/javaThread.hpp"
 #include "runtime/os.hpp"
@@ -51,7 +51,7 @@ void VMError::check_failing_cds_access(outputStream* st, const void* siginfo) {
         er->NumberParameters >= 2) {
       const void* const fault_addr = (const void*) er->ExceptionInformation[1];
       if (fault_addr != nullptr) {
-        if (MetaspaceShared::is_in_shared_metaspace(fault_addr)) {
+        if (AOTMetaspace::in_aot_cache(fault_addr)) {
           st->print("Error accessing class data sharing archive. "
             "Mapped file inaccessible during execution, possible disk/network problem.");
         }

src/hotspot/os_cpu/bsd_aarch64/javaThread_bsd_aarch64.cpp

@@ -24,7 +24,7 @@
  *
  */
 
-#include "cds/metaspaceShared.hpp"
+#include "cds/aotMetaspace.hpp"
 #include "runtime/frame.inline.hpp"
 #include "runtime/javaThread.hpp"
 

src/hotspot/share/cds/aotArtifactFinder.cpp

@@ -224,7 +224,7 @@ void AOTArtifactFinder::append_to_all_cached_classes(Klass* k) {
 }
 
 void AOTArtifactFinder::add_cached_instance_class(InstanceKlass* ik) {
-  if (CDSConfig::is_dumping_dynamic_archive() && ik->is_shared()) {
+  if (CDSConfig::is_dumping_dynamic_archive() && ik->in_aot_cache()) {
     // This class is already included in the base archive. No need to cache
     // it again in the dynamic archive.
     return;

src/hotspot/share/cds/aotCacheAccess.cpp

@@ -23,11 +23,11 @@
  */
 
 #include "cds/aotCacheAccess.hpp"
+#include "cds/aotMetaspace.hpp"
 #include "cds/archiveBuilder.hpp"
 #include "cds/cdsConfig.hpp"
 #include "cds/filemap.hpp"
 #include "cds/heapShared.hpp"
-#include "cds/metaspaceShared.hpp"
 #include "classfile/stringTable.hpp"
 #include "logging/log.hpp"
 #include "logging/logStream.hpp"
@@ -45,7 +45,7 @@ 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 mapinfo->region_at(AOTMetaspace::ac)->used_aligned();
 }
 
 bool AOTCacheAccess::map_aot_code_region(ReservedSpace rs) {

src/hotspot/share/cds/aotClassLinker.cpp

@@ -212,7 +212,7 @@ Array<InstanceKlass*>* AOTClassLinker::write_classes(oop class_loader, bool is_j
       continue;
     }
 
-    if (ik->is_shared() && CDSConfig::is_dumping_dynamic_archive()) {
+    if (ik->in_aot_cache() && CDSConfig::is_dumping_dynamic_archive()) {
       if (CDSConfig::is_using_aot_linked_classes()) {
         // This class was recorded as AOT-linked for the base archive,
         // so there's no need to do so again for the dynamic archive.

src/hotspot/share/cds/aotClassLocation.cpp

@@ -24,11 +24,11 @@
 
 #include "cds/aotClassLocation.hpp"
 #include "cds/aotLogging.hpp"
+#include "cds/aotMetaspace.hpp"
 #include "cds/archiveBuilder.hpp"
 #include "cds/cdsConfig.hpp"
 #include "cds/dynamicArchive.hpp"
 #include "cds/filemap.hpp"
-#include "cds/metaspaceShared.hpp"
 #include "cds/serializeClosure.hpp"
 #include "classfile/classLoader.hpp"
 #include "classfile/classLoaderData.hpp"
@@ -252,7 +252,7 @@ AOTClassLocation* AOTClassLocation::allocate(JavaThread* current, const char* pa
     type = FileType::NOT_EXIST;
   } else {
     aot_log_error(aot)("Unable to open file %s.", path);
-    MetaspaceShared::unrecoverable_loading_error();
+    AOTMetaspace::unrecoverable_loading_error();
   }
 
   ResourceMark rm(current);
@@ -1034,10 +1034,10 @@ bool AOTClassLocationConfig::validate(const char* cache_filename, bool has_aot_l
         vm_exit_during_initialization("Unable to use create AOT cache.", nullptr);
       } else {
         aot_log_error(aot)("%s%s", mismatch_msg, hint_msg);
-        MetaspaceShared::unrecoverable_loading_error();
+        AOTMetaspace::unrecoverable_loading_error();
       }
     } else {
-      MetaspaceShared::report_loading_error("%s%s", mismatch_msg, hint_msg);
+      AOTMetaspace::report_loading_error("%s%s", mismatch_msg, hint_msg);
     }
   }
   return success;

src/hotspot/share/cds/aotConstantPoolResolver.cpp

@@ -85,7 +85,7 @@ bool AOTConstantPoolResolver::is_class_resolution_deterministic(InstanceKlass* c
   if (resolved_class->is_instance_klass()) {
     InstanceKlass* ik = InstanceKlass::cast(resolved_class);
 
-    if (!ik->is_shared() && SystemDictionaryShared::is_excluded_class(ik)) {
+    if (!ik->in_aot_cache() && SystemDictionaryShared::is_excluded_class(ik)) {
       return false;
     }
 

src/hotspot/share/cds/aotLinkedClassBulkLoader.cpp

@@ -221,7 +221,7 @@ void AOTLinkedClassBulkLoader::load_classes_impl(AOTLinkedClassCategory class_ca
           log_error(aot)("Unable to resolve %s class from %s: %s", category_name, CDSConfig::type_of_archive_being_loaded(), ik->external_name());
           log_error(aot)("Expected: " INTPTR_FORMAT ", actual: " INTPTR_FORMAT, p2i(ik), p2i(actual));
           log_error(aot)("JVMTI class retransformation is not supported when archive was generated with -XX:+AOTClassLinking.");
-          MetaspaceShared::unrecoverable_loading_error();
+          AOTMetaspace::unrecoverable_loading_error();
         }
         assert(actual->is_loaded(), "must be");
       }
@@ -434,4 +434,4 @@ void AOTLinkedClassBulkLoader::replay_training_at_init_for_preloaded_classes(TRA
     replay_training_at_init(table->platform(), CHECK);
     replay_training_at_init(table->app(),      CHECK);
   }
-}
+}

src/hotspot/share/cds/aotMapLogger.cpp

@@ -218,8 +218,8 @@ void AOTMapLogger::dumptime_log_metaspace_region(const char* name, DumpRegion* r
 }
 
 void AOTMapLogger::runtime_log_metaspace_regions(FileMapInfo* mapinfo, GrowableArrayCHeap<ArchivedObjInfo, mtClass>* objs) {
-  FileMapRegion* rw = mapinfo->region_at(MetaspaceShared::rw);
-  FileMapRegion* ro = mapinfo->region_at(MetaspaceShared::ro);
+  FileMapRegion* rw = mapinfo->region_at(AOTMetaspace::rw);
+  FileMapRegion* ro = mapinfo->region_at(AOTMetaspace::ro);
 
   address rw_base = address(rw->mapped_base());
   address rw_end  = address(rw->mapped_end());
@@ -782,7 +782,7 @@ void AOTMapLogger::dumptime_log_heap_region(ArchiveHeapInfo* heap_info) {
 
 void AOTMapLogger::runtime_log_heap_region(FileMapInfo* mapinfo) {
   ResourceMark rm;
-  int heap_region_index = MetaspaceShared::hp;
+  int heap_region_index = AOTMetaspace::hp;
   FileMapRegion* r = mapinfo->region_at(heap_region_index);
   size_t alignment = ObjectAlignmentInBytes;