cds: archive unique exception instances

iwanowww · iwanowww · commit 7b4a856f434d · 2023-09-06T16:23:02.000-07:00
diff --git a/src/hotspot/share/cds/heapShared.cpp b/src/hotspot/share/cds/heapShared.cpp
@@ -161,6 +161,14 @@ GrowableArrayCHeap<oop, mtClassShared>* HeapShared::_trace = nullptr;
 GrowableArrayCHeap<const char*, mtClassShared>* HeapShared::_context = nullptr;
 OopHandle HeapShared::_roots;
 OopHandle HeapShared::_scratch_basic_type_mirrors[T_VOID+1];
+
+OopHandle HeapShared::_scratch_null_ptr_exception_instance;
+OopHandle HeapShared::_scratch_arithmetic_exception_instance;
+OopHandle HeapShared::_scratch_virtual_machine_error_instance;
+OopHandle HeapShared::_scratch_array_index_oob_exception_instance;
+OopHandle HeapShared::_scratch_array_store_exception_instance;
+OopHandle HeapShared::_scratch_class_cast_exception_instance;
+
 MetaspaceObjToOopHandleTable* HeapShared::_scratch_java_mirror_table = nullptr;
 MetaspaceObjToOopHandleTable* HeapShared::_scratch_references_table = nullptr;
 ClassLoaderData* HeapShared::_saved_java_platform_loader_data = nullptr;
@@ -465,6 +473,27 @@ void HeapShared::init_scratch_objects(TRAPS) {
   _scratch_references_table = new (mtClass)MetaspaceObjToOopHandleTable();
 }
 
+void HeapShared::init_scratch_exceptions(TRAPS) {
+  oop instance = nullptr;
+
+  instance = java_lang_Throwable::create_exception_instance(vmSymbols::java_lang_NullPointerException(), CHECK);
+  _scratch_null_ptr_exception_instance = OopHandle(Universe::vm_global(), instance);
+
+  instance = java_lang_Throwable::create_exception_instance(vmSymbols::java_lang_ArithmeticException(), CHECK);
+  _scratch_arithmetic_exception_instance = OopHandle(Universe::vm_global(), instance);
+
+  instance = java_lang_Throwable::create_exception_instance(vmSymbols::java_lang_VirtualMachineError(), CHECK);
+  _scratch_virtual_machine_error_instance = OopHandle(Universe::vm_global(), instance);
+
+  instance = java_lang_Throwable::create_exception_instance(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), CHECK);
+  _scratch_array_index_oob_exception_instance = OopHandle(Universe::vm_global(), instance);
+
+  instance = java_lang_Throwable::create_exception_instance(vmSymbols::java_lang_ArrayStoreException(), CHECK);
+  _scratch_array_store_exception_instance = OopHandle(Universe::vm_global(), instance);
+
+  instance = java_lang_Throwable::create_exception_instance(vmSymbols::java_lang_ClassCastException(), CHECK);
+  _scratch_class_cast_exception_instance = OopHandle(Universe::vm_global(), instance);
+}
 // Given java_mirror that represents a (primitive or reference) type T,
 // return the "scratch" version that represents the same type T.
 // Note that if java_mirror will be returned if it's already a
@@ -646,6 +675,45 @@ void HeapShared::archive_strings() {
   StringTable::set_shared_strings_array_index(append_root(shared_strings_array));
 }
 
+void HeapShared::archive_exception_instances() {
+  {
+    oop m = _scratch_null_ptr_exception_instance.resolve();
+    bool success = archive_reachable_objects_from(1, _default_subgraph_info, m /*Universe::null_ptr_exception_instance()*/);
+    assert(success, "sanity");
+    Universe::set_archived_null_ptr_exception_instance_index(append_root(m));
+  }
+  {
+    oop m = _scratch_arithmetic_exception_instance.resolve();
+    bool success = archive_reachable_objects_from(1, _default_subgraph_info, m /*Universe::arithmetic_exception_instance()*/);
+    assert(success, "sanity");
+    Universe::set_archived_arithmetic_exception_instance_index(append_root(m));
+  }
+  {
+    oop m = _scratch_virtual_machine_error_instance.resolve();
+    bool success = archive_reachable_objects_from(1, _default_subgraph_info, m /*Universe::virtual_machine_error_instance()*/);
+    assert(success, "sanity");
+    Universe::set_archived_virtual_machine_error_instance_index(append_root(m));
+  }
+  {
+    oop m = _scratch_array_index_oob_exception_instance.resolve();
+    bool success = archive_reachable_objects_from(1, _default_subgraph_info, m /*Universe::array_index_oob_exception_instance()*/);
+    assert(success, "sanity");
+    Universe::set_archived_array_index_oob_exception_instance_index(append_root(m));
+  }
+  {
+    oop m = _scratch_array_store_exception_instance.resolve();
+    bool success = archive_reachable_objects_from(1, _default_subgraph_info, m /*Universe::array_store_exception_instance()*/);
+    assert(success, "sanity");
+    Universe::set_archived_array_store_exception_instance_index(append_root(m));
+  }
+  {
+    oop m = _scratch_class_cast_exception_instance.resolve();
+    bool success = archive_reachable_objects_from(1, _default_subgraph_info, m /*Universe::class_cast_exception_instance()*/);
+    assert(success, "sanity");
+    Universe::set_archived_class_cast_exception_instance_index(append_root(m));
+  }
+}
+
 void HeapShared::mark_native_pointers(oop orig_obj) {
   if (java_lang_Class::is_instance(orig_obj)) {
     ArchiveHeapWriter::mark_native_pointer(orig_obj, java_lang_Class::klass_offset());
@@ -702,6 +770,7 @@ void HeapShared::copy_special_objects() {
   init_seen_objects_table();
   archive_java_mirrors();
   archive_strings();
+  archive_exception_instances();
   delete_seen_objects_table();
 }
 
diff --git a/src/hotspot/share/cds/heapShared.hpp b/src/hotspot/share/cds/heapShared.hpp
@@ -282,6 +282,13 @@ class HeapShared: AllStatic {
   static OopHandle _roots;
   static int _permobj_segments;
   static OopHandle _scratch_basic_type_mirrors[T_VOID+1];
+  static OopHandle _scratch_null_ptr_exception_instance;
+  static OopHandle _scratch_arithmetic_exception_instance;
+  static OopHandle _scratch_virtual_machine_error_instance;
+  static OopHandle _scratch_array_index_oob_exception_instance;
+  static OopHandle _scratch_array_store_exception_instance;
+  static OopHandle _scratch_class_cast_exception_instance;
+
   static MetaspaceObjToOopHandleTable* _scratch_java_mirror_table;
   static MetaspaceObjToOopHandleTable* _scratch_references_table;
 
@@ -346,6 +353,7 @@ class HeapShared: AllStatic {
   static bool can_mirror_be_used_in_subgraph(oop orig_java_mirror);
   static void archive_java_mirrors();
   static void archive_strings();
+  static void archive_exception_instances();
   static void exit_on_error();
  public:
   static void reset_archived_object_states(TRAPS);
@@ -409,6 +417,7 @@ class HeapShared: AllStatic {
   static objArrayOop scratch_resolved_references(ConstantPool* src);
   static void add_scratch_resolved_references(ConstantPool* src, objArrayOop dest) NOT_CDS_JAVA_HEAP_RETURN;
   static void init_scratch_objects(TRAPS) NOT_CDS_JAVA_HEAP_RETURN;
+  static void init_scratch_exceptions(TRAPS) NOT_CDS_JAVA_HEAP_RETURN;
   static void init_box_classes(TRAPS) NOT_CDS_JAVA_HEAP_RETURN;
   static void restore_loader_data() NOT_CDS_JAVA_HEAP_RETURN;
   static bool is_heap_region(int idx) {
diff --git a/src/hotspot/share/cds/metaspaceShared.cpp b/src/hotspot/share/cds/metaspaceShared.cpp
@@ -1521,6 +1521,7 @@ void MetaspaceShared::initialize_shared_spaces() {
   ArchiveHeapLoader::finish_initialization();
 
   CDS_JAVA_HEAP_ONLY(Universe::update_archived_basic_type_mirrors());
+  CDS_JAVA_HEAP_ONLY(Universe::update_exception_instances());
 
   // Close the mapinfo file
   static_mapinfo->close();
diff --git a/src/hotspot/share/ci/ciEnv.cpp b/src/hotspot/share/ci/ciEnv.cpp
@@ -372,29 +372,6 @@ void ciEnv::cache_dtrace_flags() {
   _dtrace_alloc_probes  = DTraceAllocProbes;
 }
 
-// ------------------------------------------------------------------
-// helper for lazy exception creation
-ciInstance* ciEnv::get_or_create_exception(jobject& handle, Symbol* name) {
-  VM_ENTRY_MARK;
-  if (handle == nullptr) {
-    // Cf. universe.cpp, creation of Universe::_null_ptr_exception_instance.
-    InstanceKlass* ik = SystemDictionary::find_instance_klass(THREAD, name, Handle(), Handle());
-    jobject objh = nullptr;
-    if (ik != nullptr) {
-      oop obj = ik->allocate_instance(THREAD);
-      if (!HAS_PENDING_EXCEPTION)
-        objh = JNIHandles::make_global(Handle(THREAD, obj));
-    }
-    if (HAS_PENDING_EXCEPTION) {
-      CLEAR_PENDING_EXCEPTION;
-    } else {
-      handle = objh;
-    }
-  }
-  oop obj = JNIHandles::resolve(handle);
-  return obj == nullptr? nullptr: get_object(obj)->as_instance();
-}
-
 ciInstanceKlass* ciEnv::get_box_klass_for_primitive_type(BasicType type) {
   switch (type) {
     case T_BOOLEAN: return Boolean_klass();
@@ -414,25 +391,22 @@ ciInstanceKlass* ciEnv::get_box_klass_for_primitive_type(BasicType type) {
 
 ciInstance* ciEnv::ArrayIndexOutOfBoundsException_instance() {
   if (_ArrayIndexOutOfBoundsException_instance == nullptr) {
-    _ArrayIndexOutOfBoundsException_instance
-          = get_or_create_exception(_ArrayIndexOutOfBoundsException_handle,
-          vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
+    VM_ENTRY_MARK;
+    _ArrayIndexOutOfBoundsException_instance = get_object(Universe::array_index_oob_exception_instance())->as_instance();
   }
   return _ArrayIndexOutOfBoundsException_instance;
 }
 ciInstance* ciEnv::ArrayStoreException_instance() {
   if (_ArrayStoreException_instance == nullptr) {
-    _ArrayStoreException_instance
-          = get_or_create_exception(_ArrayStoreException_handle,
-          vmSymbols::java_lang_ArrayStoreException());
+    VM_ENTRY_MARK;
+    _ArrayStoreException_instance = get_object(Universe::array_store_exception_instance())->as_instance();
   }
   return _ArrayStoreException_instance;
 }
 ciInstance* ciEnv::ClassCastException_instance() {
   if (_ClassCastException_instance == nullptr) {
-    _ClassCastException_instance
-          = get_or_create_exception(_ClassCastException_handle,
-          vmSymbols::java_lang_ClassCastException());
+    VM_ENTRY_MARK;
+    _ClassCastException_instance = get_object(Universe::class_cast_exception_instance())->as_instance();
   }
   return _ClassCastException_instance;
 }
diff --git a/src/hotspot/share/ci/ciEnv.hpp b/src/hotspot/share/ci/ciEnv.hpp
@@ -230,8 +230,6 @@ class ciEnv : StackObj {
 
   ciMethod* get_method_from_handle(Method* method);
 
-  ciInstance* get_or_create_exception(jobject& handle, Symbol* name);
-
   // Get a ciMethod representing either an unfound method or
   // a method with an unloaded holder.  Ensures uniqueness of
   // the result.
diff --git a/src/hotspot/share/classfile/javaClasses.cpp b/src/hotspot/share/classfile/javaClasses.cpp
@@ -2100,6 +2100,10 @@ void java_lang_Throwable::clear_stacktrace(oop throwable) {
   set_stacktrace(throwable, nullptr);
 }
 
+oop java_lang_Throwable::create_exception_instance(Symbol* class_name, TRAPS) {
+  Klass* k = SystemDictionary::resolve_or_fail(class_name, true, CHECK_NULL);
+  return InstanceKlass::cast(k)->allocate_instance(CHECK_NULL);
+}
 
 void java_lang_Throwable::print(oop throwable, outputStream* st) {
   ResourceMark rm;
diff --git a/src/hotspot/share/classfile/javaClasses.hpp b/src/hotspot/share/classfile/javaClasses.hpp
@@ -619,7 +619,9 @@ class java_lang_Throwable: AllStatic {
   // For recreating class initialization error exceptions.
   static Handle create_initialization_error(JavaThread* current, Handle throwable);
 
-  // Printing
+  static oop create_exception_instance(Symbol* class_name, TRAPS);
+
+    // Printing
   static void print(oop throwable, outputStream* st);
   static void print_stack_trace(Handle throwable, outputStream* st);
   static void java_printStackTrace(Handle throwable, TRAPS);
diff --git a/src/hotspot/share/memory/universe.cpp b/src/hotspot/share/memory/universe.cpp
@@ -93,6 +93,13 @@ Klass* Universe::_fillerArrayKlassObj                 = nullptr;
 OopHandle Universe::_basic_type_mirrors[T_VOID+1];
 #if INCLUDE_CDS_JAVA_HEAP
 int Universe::_archived_basic_type_mirror_indices[T_VOID+1];
+
+int Universe::_archived_null_ptr_exception_instance_index;
+int Universe::_archived_arithmetic_exception_instance_index;
+int Universe::_archived_virtual_machine_error_instance_index;
+int Universe::_archived_array_index_oob_exception_instance_index;
+int Universe::_archived_array_store_exception_instance_index;
+int Universe::_archived_class_cast_exception_instance_index;
 #endif
 
 OopHandle Universe::_main_thread_group;
@@ -129,6 +136,10 @@ OopHandle Universe::_null_ptr_exception_instance;
 OopHandle Universe::_arithmetic_exception_instance;
 OopHandle Universe::_virtual_machine_error_instance;
 
+OopHandle Universe::_array_index_oob_exception_instance;
+OopHandle Universe::_array_store_exception_instance;
+OopHandle Universe::_class_cast_exception_instance;
+
 OopHandle Universe::_reference_pending_list;
 
 Array<Klass*>* Universe::_the_array_interfaces_array = nullptr;
@@ -184,6 +195,10 @@ oop Universe::null_ptr_exception_instance()       { return _null_ptr_exception_i
 oop Universe::arithmetic_exception_instance()     { return _arithmetic_exception_instance.resolve(); }
 oop Universe::virtual_machine_error_instance()    { return _virtual_machine_error_instance.resolve(); }
 
+oop Universe::array_index_oob_exception_instance() { return _array_index_oob_exception_instance.resolve(); }
+oop Universe::array_store_exception_instance()     { return _array_store_exception_instance.resolve(); }
+oop Universe::class_cast_exception_instance()      { return _class_cast_exception_instance.resolve(); }
+
 oop Universe::the_null_sentinel()                 { return _the_null_sentinel.resolve(); }
 
 oop Universe::int_mirror()                        { return check_mirror(_basic_type_mirrors[T_INT].resolve()); }
@@ -257,6 +272,41 @@ void Universe::update_archived_basic_type_mirrors() {
     }
   }
 }
+
+void Universe::update_exception_instances() {
+  if (ArchiveHeapLoader::is_in_use()) {
+    if (_archived_null_ptr_exception_instance_index >= 0) {
+      oop mirror_oop = HeapShared::get_root(_archived_null_ptr_exception_instance_index);
+      assert(mirror_oop != nullptr, "must be");
+      _null_ptr_exception_instance = OopHandle(vm_global(), mirror_oop);
+    }
+    if (_archived_arithmetic_exception_instance_index >= 0) {
+      oop mirror_oop = HeapShared::get_root(_archived_arithmetic_exception_instance_index);
+      assert(mirror_oop != nullptr, "must be");
+      _arithmetic_exception_instance = OopHandle(vm_global(), mirror_oop);
+    }
+    if (_archived_virtual_machine_error_instance_index >= 0) {
+      oop mirror_oop = HeapShared::get_root(_archived_virtual_machine_error_instance_index);
+      assert(mirror_oop != nullptr, "must be");
+      _virtual_machine_error_instance = OopHandle(vm_global(), mirror_oop);
+    }
+    if (_archived_array_index_oob_exception_instance_index >= 0) {
+      oop mirror_oop = HeapShared::get_root(_archived_array_index_oob_exception_instance_index);
+      assert(mirror_oop != nullptr, "must be");
+      _array_index_oob_exception_instance = OopHandle(vm_global(), mirror_oop);
+    }
+    if (_archived_array_store_exception_instance_index >= 0) {
+      oop mirror_oop = HeapShared::get_root(_archived_array_store_exception_instance_index);
+      assert(mirror_oop != nullptr, "must be");
+      _array_store_exception_instance = OopHandle(vm_global(), mirror_oop);
+    }
+    if (_archived_class_cast_exception_instance_index >= 0) {
+      oop mirror_oop = HeapShared::get_root(_archived_class_cast_exception_instance_index);
+      assert(mirror_oop != nullptr, "must be");
+      _class_cast_exception_instance = OopHandle(vm_global(), mirror_oop);
+    }
+  }
+}
 #endif
 
 void Universe::serialize(SerializeClosure* f) {
@@ -268,6 +318,12 @@ void Universe::serialize(SerializeClosure* f) {
     // contents may need to be relocated. _basic_type_mirrors[i] will be
     // updated later in Universe::update_archived_basic_type_mirrors().
   }
+  f->do_int(&_archived_null_ptr_exception_instance_index);
+  f->do_int(&_archived_arithmetic_exception_instance_index);
+  f->do_int(&_archived_virtual_machine_error_instance_index);
+  f->do_int(&_archived_array_index_oob_exception_instance_index);
+  f->do_int(&_archived_array_store_exception_instance_index);
+  f->do_int(&_archived_class_cast_exception_instance_index);
 #endif
 
   f->do_ptr(&_fillerArrayKlassObj);
@@ -1011,29 +1067,50 @@ bool universe_post_init() {
     instance = java_lang_String::create_oop_from_str("Delayed StackOverflowError due to ReservedStackAccess annotated method", CHECK_false);
     Universe::_delayed_stack_overflow_error_message = OopHandle(Universe::vm_global(), instance);
   }
+  if (Universe::_null_ptr_exception_instance.is_empty()) {
+    instance = java_lang_Throwable::create_exception_instance(vmSymbols::java_lang_NullPointerException(), CHECK_false);
+    Universe::_null_ptr_exception_instance = OopHandle(Universe::vm_global(), instance);
+    Universe::_archived_null_ptr_exception_instance_index = -1;
+  }
+  if (Universe::_arithmetic_exception_instance.is_empty()) {
+    instance = java_lang_Throwable::create_exception_instance(vmSymbols::java_lang_ArithmeticException(), CHECK_false);
+    Universe::_arithmetic_exception_instance = OopHandle(Universe::vm_global(), instance);
+    Universe::_archived_arithmetic_exception_instance_index = -1;
+  }
+//#ifdef COMPILER1_OR_COMPILER2_PRESENT
+  if (Universe::_array_index_oob_exception_instance.is_empty()) {
+    instance = java_lang_Throwable::create_exception_instance(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), CHECK_false);
+    Universe::_array_index_oob_exception_instance = OopHandle(Universe::vm_global(), instance);
+    Universe::_archived_array_index_oob_exception_instance_index = -1;
+  }
+  if (Universe::_array_store_exception_instance.is_empty()) {
+    instance = java_lang_Throwable::create_exception_instance(vmSymbols::java_lang_ArrayStoreException(), CHECK_false);
+    Universe::_array_store_exception_instance = OopHandle(Universe::vm_global(), instance);
+    Universe::_archived_array_store_exception_instance_index = -1;
+  }
+  if (Universe::_class_cast_exception_instance.is_empty()) {
+    instance = java_lang_Throwable::create_exception_instance(vmSymbols::java_lang_ClassCastException(), CHECK_false);
+    Universe::_class_cast_exception_instance = OopHandle(Universe::vm_global(), instance);
+    Universe::_archived_class_cast_exception_instance_index = -1;
+  }
+//#endif // COMPILER1_OR_COMPILER2_PRESENT
 
-  // Setup preallocated NullPointerException
-  // (this is currently used for a cheap & dirty solution in compiler exception handling)
-  Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_NullPointerException(), true, CHECK_false);
-  instance = InstanceKlass::cast(k)->allocate_instance(CHECK_false);
-  Universe::_null_ptr_exception_instance = OopHandle(Universe::vm_global(), instance);
-
-  // Setup preallocated ArithmeticException
-  // (this is currently used for a cheap & dirty solution in compiler exception handling)
-  k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_ArithmeticException(), true, CHECK_false);
-  instance = InstanceKlass::cast(k)->allocate_instance(CHECK_false);
-  Universe::_arithmetic_exception_instance = OopHandle(Universe::vm_global(), instance);
+  if (DumpSharedSpaces) {
+    HeapShared::init_scratch_exceptions(CHECK_false);
+  }
 
   // Virtual Machine Error for when we get into a situation we can't resolve
-  k = vmClasses::VirtualMachineError_klass();
+  Klass* k = vmClasses::VirtualMachineError_klass();
   bool linked = InstanceKlass::cast(k)->link_class_or_fail(CHECK_false);
   if (!linked) {
      tty->print_cr("Unable to link/verify VirtualMachineError class");
      return false; // initialization failed
   }
-  instance = InstanceKlass::cast(k)->allocate_instance(CHECK_false);
-  Universe::_virtual_machine_error_instance = OopHandle(Universe::vm_global(), instance);
-
+  if (Universe::_virtual_machine_error_instance.is_empty()) {
+    instance = java_lang_Throwable::create_exception_instance(vmSymbols::java_lang_VirtualMachineError(), CHECK_false);
+    Universe::_virtual_machine_error_instance = OopHandle(Universe::vm_global(), instance);
+    Universe::_archived_virtual_machine_error_instance_index = -1;
+  }
   Handle msg = java_lang_String::create_from_str("/ by zero", CHECK_false);
   java_lang_Throwable::set_message(Universe::arithmetic_exception_instance(), msg());
 
diff --git a/src/hotspot/share/memory/universe.hpp b/src/hotspot/share/memory/universe.hpp

Original file line number	Diff line number	Diff line change
`@@ -2100,6 +2100,10 @@ void java_lang_Throwable::clear_stacktrace(oop throwable) {`
`2100`	`2100`	`set_stacktrace(throwable, nullptr);`
`2101`	`2101`	`}`
`2102`	`2102`
	`2103`	`+oop java_lang_Throwable::create_exception_instance(Symbol* class_name, TRAPS) {`
	`2104`	`+ Klass* k = SystemDictionary::resolve_or_fail(class_name, true, CHECK_NULL);`
	`2105`	`+ return InstanceKlass::cast(k)->allocate_instance(CHECK_NULL);`
	`2106`	`+}`
`2103`	`2107`
`2104`	`2108`	`void java_lang_Throwable::print(oop throwable, outputStream* st) {`
`2105`	`2109`	`ResourceMark rm;`