8322630: Remove ICStubs and related safepoints

src/hotspot/cpu/aarch64/aarch64.ad

@@ -2221,7 +2221,7 @@ void MachUEPNode::emit(CodeBuffer& cbuf, PhaseRegAlloc* ra_) const
 {
   // This is the unverified entry point.
   C2_MacroAssembler _masm(&cbuf);
-  __ ic_check(CodeEntryAlignment);
+  __ ic_check(InteriorEntryAlignment);
 }
 
 uint MachUEPNode::size(PhaseRegAlloc* ra_) const

src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp

@@ -1014,6 +1014,10 @@ int MacroAssembler::ic_check(int end_alignment) {
   Register tmp1 = rscratch1;
   Register tmp2 = r10;
 
+  // The UEP of a code blob ensures that the VEP is padded. However, the padding of the UEP is placed
+  // before the inline cache check, so we don't have to execute any nop instructions when dispatching
+  // through the UEP, yet we can ensure that the VEP is aligned appropriately. That's why we align
+  // before the inline cache check here, and not after
   align(end_alignment, offset() + ic_check_size());
 
   int uep_offset = offset();

src/hotspot/cpu/aarch64/sharedRuntime_aarch64.cpp

@@ -753,6 +753,9 @@ AdapterHandlerEntry* SharedRuntime::generate_i2c2i_adapters(MacroAssembler *masm
 
   {
     __ block_comment("c2i_unverified_entry {");
+    // Method might have been compiled since the call site was patched to
+    // interpreted; if that is the case treat it as a miss so we can get
+    // the call site corrected.
     __ ic_check(1 /* end_alignment */);
     __ ldr(rmethod, Address(data, CompiledICData::speculated_method_offset()));
 
@@ -1548,6 +1551,8 @@ nmethod* SharedRuntime::generate_native_wrapper(MacroAssembler* masm,
     __ clinit_barrier(rscratch2, rscratch1, &L_skip_barrier);
     __ far_jump(RuntimeAddress(SharedRuntime::get_handle_wrong_method_stub()));
 
+    // Verified entry point must be aligned
+
     __ bind(L_skip_barrier);
   }
 

src/hotspot/cpu/arm/arm.ad

@@ -877,7 +877,7 @@ void MachUEPNode::format( PhaseRegAlloc *ra_, outputStream *st ) const {
 
 void MachUEPNode::emit(CodeBuffer &cbuf, PhaseRegAlloc *ra_) const {
   C2_MacroAssembler _masm(&cbuf);
-  __ ic_check(CodeEntryAlignment);
+  __ ic_check(InteriorEntryAlignment);
 }
 
 uint MachUEPNode::size(PhaseRegAlloc *ra_) const {

src/hotspot/cpu/arm/macroAssembler_arm.cpp

@@ -1873,6 +1873,10 @@ int MacroAssembler::ic_check(int end_alignment) {
   Register tmp1 = R4;
   Register tmp2 = R5;
 
+  // The UEP of a code blob ensures that the VEP is padded. However, the padding of the UEP is placed
+  // before the inline cache check, so we don't have to execute any nop instructions when dispatching
+  // through the UEP, yet we can ensure that the VEP is aligned appropriately. That's why we align
+  // before the inline cache check here, and not after
   align(end_alignment, offset() + ic_check_size());
 
   int uep_offset = offset();
@@ -1886,4 +1890,4 @@ int MacroAssembler::ic_check(int end_alignment) {
   jump(SharedRuntime::get_ic_miss_stub(), relocInfo::runtime_call_type);
   bind(dont);
   return uep_offset;
-}
+}

src/hotspot/cpu/arm/sharedRuntime_arm.cpp

@@ -817,7 +817,8 @@ nmethod* SharedRuntime::generate_native_wrapper(MacroAssembler* masm,
 
   const Register receiver = R0; // see receiverOpr()
   __ verify_oop(receiver);
-  __ ic_check(1 /* end_alignment */);
+  // Inline cache check
+  __ ic_check(CodeEntryAlignment /* end_alignment */);
 
   int vep_offset = __ pc() - start;
 

src/hotspot/cpu/ppc/macroAssembler_ppc.cpp

@@ -1222,6 +1222,10 @@ int MacroAssembler::ic_check(int end_alignment) {
   Register tmp1 = R11_scratch1;
   Register tmp2 = R12_scratch2;
 
+  // The UEP of a code blob ensures that the VEP is padded. However, the padding of the UEP is placed
+  // before the inline cache check, so we don't have to execute any nop instructions when dispatching
+  // through the UEP, yet we can ensure that the VEP is aligned appropriately. That's why we align
+  // before the inline cache check here, and not after
   align(end_alignment, end_alignment, end_alignment - ic_check_size());
 
   int uep_offset = offset();

src/hotspot/cpu/riscv/macroAssembler_riscv.cpp

@@ -3559,6 +3559,10 @@ int MacroAssembler::ic_check(int end_alignment) {
   // Hence we can clobber it.
   Register tmp2 = t2;
 
+  // The UEP of a code blob ensures that the VEP is padded. However, the padding of the UEP is placed
+  // before the inline cache check, so we don't have to execute any nop instructions when dispatching
+  // through the UEP, yet we can ensure that the VEP is aligned appropriately. That's why we align
+  // before the inline cache check here, and not after
   align(end_alignment, ic_check_size());
   int uep_offset = offset();
 

src/hotspot/cpu/s390/macroAssembler_s390.cpp

@@ -2167,6 +2167,11 @@ int MacroAssembler::ic_check(int end_alignment) {
   Register R1_scratch  = Z_R1_scratch;
   Register R9_data     = Z_inline_cache;
   Label success, failure;
+
+  // The UEP of a code blob ensures that the VEP is padded. However, the padding of the UEP is placed
+  // before the inline cache check, so we don't have to execute any nop instructions when dispatching
+  // through the UEP, yet we can ensure that the VEP is aligned appropriately. That's why we align
+  // before the inline cache check here, and not after
   align(end_alignment, offset() + ic_check_size());
 
   int uep_offset = offset();

src/hotspot/cpu/x86/macroAssembler_x86.cpp

@@ -1358,6 +1358,10 @@ int MacroAssembler::ic_check(int end_alignment) {
   Register data = rax;
   Register temp = LP64_ONLY(rscratch1) NOT_LP64(rbx);
 
+  // The UEP of a code blob ensures that the VEP is padded. However, the padding of the UEP is placed
+  // before the inline cache check, so we don't have to execute any nop instructions when dispatching
+  // through the UEP, yet we can ensure that the VEP is aligned appropriately. That's why we align
+  // before the inline cache check here, and not after
   align(end_alignment, offset() + ic_check_size());
 
   int uep_offset = offset();

src/hotspot/cpu/x86/sharedRuntime_x86_32.cpp

@@ -1445,6 +1445,7 @@ nmethod* SharedRuntime::generate_native_wrapper(MacroAssembler* masm,
   Label exception_pending;
 
   __ verify_oop(receiver);
+  // verified entry must be aligned for code patching.
   __ ic_check(8 /* end_alignment */);
 
   int vep_offset = ((intptr_t)__ pc()) - start;

src/hotspot/cpu/x86/x86_64.ad

@@ -1484,7 +1484,7 @@ void MachUEPNode::format(PhaseRegAlloc* ra_, outputStream* st) const
 void MachUEPNode::emit(CodeBuffer& cbuf, PhaseRegAlloc* ra_) const
 {
   MacroAssembler masm(&cbuf);
-  masm.ic_check(CodeEntryAlignment);
+  masm.ic_check(InteriorEntryAlignment);
 }
 
 uint MachUEPNode::size(PhaseRegAlloc* ra_) const

src/hotspot/share/code/compiledMethod.cpp

@@ -433,27 +433,16 @@ static void clean_ic_if_metadata_is_dead(CompiledIC *ic) {
 }
 
 // Clean references to unloaded nmethods at addr from this one, which is not unloaded.
-static void clean_if_nmethod_is_unloaded(CompiledIC *ic, CompiledMethod* from,
+template <typename CallsiteT>
+static void clean_if_nmethod_is_unloaded(CallsiteT* callsite, CompiledMethod* from,
                                          bool clean_all) {
-  CodeBlob* cb = CodeCache::find_blob(ic->destination());
+  CodeBlob* cb = CodeCache::find_blob(callsite->destination());
   if (!cb->is_compiled()) {
     return;
   }
   CompiledMethod* cm = cb->as_compiled_method();
   if (clean_all || !cm->is_in_use() || cm->is_unloading() || cm->method()->code() != cm) {
-    ic->set_to_clean();
-  }
-}
-
-static void clean_if_nmethod_is_unloaded(CompiledDirectCall *cdc, CompiledMethod* from,
-                                         bool clean_all) {
-  CodeBlob* cb = CodeCache::find_blob(cdc->destination());
-  if (!cb->is_compiled()) {
-    return;
-  }
-  CompiledMethod* cm = cb->as_compiled_method();
-  if (clean_all || !cm->is_in_use() || cm->is_unloading() || cm->method()->code() != cm) {
-    cdc->set_to_clean();
+    callsite->set_to_clean();
   }
 }
 

src/hotspot/share/oops/oopsHierarchy.hpp

@@ -179,7 +179,6 @@ class   MethodData;
 //      class Metadata
 class   Method;
 class   ConstantPool;
-//      class CHeapObj
 
 // The klass hierarchy is separate from the oop hierarchy.
 

src/hotspot/share/opto/output.cpp

@@ -3413,6 +3413,9 @@ void PhaseOutput::install_code(ciMethod*         target,
       _code_offsets.set_value(CodeOffsets::OSR_Entry, _first_block_size);
     } else {
       if (!target->is_static()) {
+        // The UEP of an nmethod ensures that the VEP is padded. However, the padding of the UEP is placed
+        // before the inline cache check, so we don't have to execute any nop instructions when dispatching
+        // through the UEP, yet we can ensure that the VEP is aligned appropriately.
         _code_offsets.set_value(CodeOffsets::Entry, _first_block_size - MacroAssembler::ic_check_size());
       }
       _code_offsets.set_value(CodeOffsets::Verified_Entry, _first_block_size);

src/hotspot/share/runtime/sharedRuntime.cpp

@@ -1360,13 +1360,12 @@ methodHandle SharedRuntime::resolve_helper(bool is_virtual, bool is_optimized, T
   // we are done patching the code.
 
 
+  CompiledICLocker ml(caller_nm);
   if (is_virtual && !is_optimized) {
-    CompiledICLocker ml(caller_nm);
     CompiledIC* inline_cache = CompiledIC_before(caller_nm, caller_frame.pc());
     inline_cache->update(&call_info, receiver->klass());
   } else {
     // Callsite is a direct call - set it to the destination method
-    CompiledICLocker ml(caller_nm);
     CompiledDirectCall* callsite = CompiledDirectCall::before(caller_frame.pc());
     callsite->set(callee_method);
   }
@@ -1594,9 +1593,6 @@ methodHandle SharedRuntime::handle_ic_miss_helper(TRAPS) {
   JvmtiDynamicCodeEventCollector event_collector;
 
   // Update inline cache to megamorphic. Skip update if we are called from interpreted.
-  // Transitioning IC caches may require transition stubs. If we run out
-  // of transition stubs, we have to drop locks and perform a safepoint
-  // that refills them.
   RegisterMap reg_map(current,
                       RegisterMap::UpdateMap::skip,
                       RegisterMap::ProcessFrames::include,
@@ -1661,8 +1657,6 @@ methodHandle SharedRuntime::reresolve_call_site(TRAPS) {
     CompiledICLocker ml(caller_nm);
     address call_addr = caller_nm->call_instruction_address(pc);
 
-    // Check relocations for the matching call to 1) avoid false positives,
-    // and 2) determine the type.
     if (call_addr != nullptr) {
       // On x86 the logic for finding a call instruction is blindly checking for a call opcode 5
       // bytes back in the instruction stream so we must also check for reloc info.
@@ -1804,7 +1798,6 @@ JRT_LEAF(void, SharedRuntime::fixup_callers_callsite(Method* method, address cal
     return;
   }
 
-  assert(iter.has_current(), "must have a reloc at java call site");
   relocInfo::relocType type = iter.reloc()->type();
   if (type != relocInfo::static_call_type &&
       type != relocInfo::opt_virtual_call_type) {

src/hotspot/share/runtime/vmStructs.cpp

@@ -211,10 +211,6 @@
   nonstatic_field(ArrayKlass,                  _dimension,                                    int)                                   \
   volatile_nonstatic_field(ArrayKlass,         _higher_dimension,                             ObjArrayKlass*)                        \
   volatile_nonstatic_field(ArrayKlass,         _lower_dimension,                              ArrayKlass*)                           \
-  volatile_nonstatic_field(CompiledICData,     _speculated_method,                            Method*)                               \
-  volatile_nonstatic_field(CompiledICData,     _speculated_klass,                             uintptr_t)                             \
-  nonstatic_field(CompiledICData,              _itable_defc_klass,                            Klass*)                                \
-  nonstatic_field(CompiledICData,              _itable_refc_klass,                            Klass*)                                \
   nonstatic_field(ConstantPool,                _tags,                                         Array<u1>*)                            \
   nonstatic_field(ConstantPool,                _cache,                                        ConstantPoolCache*)                    \
   nonstatic_field(ConstantPool,                _pool_holder,                                  InstanceKlass*)                        \
@@ -1164,7 +1160,6 @@
   /* MetadataOopDesc hierarchy (NOTE: some missing) */                    \
   /**************************************************/                    \
                                                                           \
-  declare_toplevel_type(CompiledICData)                                   \
   declare_toplevel_type(MetaspaceObj)                                     \
     declare_type(Metadata, MetaspaceObj)                                  \
     declare_type(Klass, Metadata)                                         \