8332689: RISC-V: Use load instead of trampolines

Reviewed-by: fyang, mli, luhenry

Author: robehn

src/hotspot/cpu/riscv/c1_CodeStubs_riscv.cpp

@@ -318,7 +318,7 @@ void ArrayCopyStub::emit_code(LIR_Assembler* ce) {
   }
   Address resolve(SharedRuntime::get_resolve_static_call_stub(),
                   relocInfo::static_call_type);
-  address call = __ trampoline_call(resolve);
+  address call = __ reloc_call(resolve);
   if (call == nullptr) {
     ce->bailout("trampoline stub overflow");
     return;

src/hotspot/cpu/riscv/c1_LIRAssembler_riscv.cpp

@@ -1346,7 +1346,7 @@ void LIR_Assembler::align_call(LIR_Code code) {
 }
 
 void LIR_Assembler::call(LIR_OpJavaCall* op, relocInfo::relocType rtype) {
-  address call = __ trampoline_call(Address(op->addr(), rtype));
+  address call = __ reloc_call(Address(op->addr(), rtype));
   if (call == nullptr) {
     bailout("trampoline stub overflow");
     return;

src/hotspot/cpu/riscv/c1_LIRAssembler_riscv.hpp

@@ -69,15 +69,15 @@ friend class ArrayCopyStub;
   enum {
     // See emit_static_call_stub for detail
     // CompiledDirectCall::to_interp_stub_size() (14) + CompiledDirectCall::to_trampoline_stub_size() (1 + 3 + address)
-    _call_stub_size = 14 * NativeInstruction::instruction_size +
-                      (NativeInstruction::instruction_size + NativeCallTrampolineStub::instruction_size),
+    _call_stub_size = 14 * MacroAssembler::instruction_size +
+                      (MacroAssembler::instruction_size + MacroAssembler::NativeShortCall::trampoline_size),
     // See emit_exception_handler for detail
     // verify_not_null_oop + far_call + should_not_reach_here + invalidate_registers(DEBUG_ONLY)
     _exception_handler_size = DEBUG_ONLY(584) NOT_DEBUG(548), // or smaller
     // See emit_deopt_handler for detail
     // auipc (1) + far_jump (6 or 2)
-    _deopt_handler_size = 1 * NativeInstruction::instruction_size +
-                          6 * NativeInstruction::instruction_size // or smaller
+    _deopt_handler_size = 1 * MacroAssembler::instruction_size +
+                          6 * MacroAssembler::instruction_size // or smaller
   };
 
   void check_conflict(ciKlass* exact_klass, intptr_t current_klass, Register tmp,

src/hotspot/cpu/riscv/c2_MacroAssembler_riscv.cpp

@@ -1040,7 +1040,7 @@ void C2_MacroAssembler::string_indexof(Register haystack, Register needle,
     stub = RuntimeAddress(StubRoutines::riscv::string_indexof_linear_uu());
     assert(stub.target() != nullptr, "string_indexof_linear_uu stub has not been generated");
   }
-  address call = trampoline_call(stub);
+  address call = reloc_call(stub);
   if (call == nullptr) {
     DEBUG_ONLY(reset_labels(LINEARSEARCH, DONE, NOMATCH));
     ciEnv::current()->record_failure("CodeCache is full");
@@ -1478,7 +1478,7 @@ void C2_MacroAssembler::string_compare(Register str1, Register str2,
       ShouldNotReachHere();
   }
   assert(stub.target() != nullptr, "compare_long_string stub has not been generated");
-  address call = trampoline_call(stub);
+  address call = reloc_call(stub);
   if (call == nullptr) {
     DEBUG_ONLY(reset_labels(DONE, SHORT_LOOP, SHORT_STRING, SHORT_LAST, SHORT_LOOP_TAIL, SHORT_LAST2, SHORT_LAST_INIT, SHORT_LOOP_START));
     ciEnv::current()->record_failure("CodeCache is full");

src/hotspot/cpu/riscv/codeBuffer_riscv.cpp

@@ -50,17 +50,18 @@ static bool emit_shared_trampolines(CodeBuffer* cb, CodeBuffer::SharedTrampoline
   if (requests == nullptr) {
     return true;
   }
+  assert(UseTrampolines, "We are not using trampolines");
 
   MacroAssembler masm(cb);
 
   auto emit = [&](address dest, const CodeBuffer::Offsets &offsets) {
-    assert(cb->stubs()->remaining() >= MacroAssembler::max_trampoline_stub_size(), "pre-allocated trampolines");
+    assert(cb->stubs()->remaining() >= MacroAssembler::max_reloc_call_stub_size(), "pre-allocated trampolines");
     LinkedListIterator<int> it(offsets.head());
     int offset = *it.next();
     address stub = __ emit_trampoline_stub(offset, dest);
     assert(stub, "pre-allocated trampolines");
 
-    address reloc_pc = cb->stubs()->end() - NativeCallTrampolineStub::instruction_size;
+    address reloc_pc = cb->stubs()->end() - MacroAssembler::NativeShortCall::trampoline_size;
     while (!it.is_empty()) {
       offset = *it.next();
       address caller_pc = cb->insts()->start() + offset;
@@ -70,7 +71,7 @@ static bool emit_shared_trampolines(CodeBuffer* cb, CodeBuffer::SharedTrampoline
   };
 
   assert(requests->number_of_entries() >= 1, "at least one");
-  const int total_requested_size = MacroAssembler::max_trampoline_stub_size() * requests->number_of_entries();
+  const int total_requested_size = MacroAssembler::max_reloc_call_stub_size() * requests->number_of_entries();
   if (cb->stubs()->maybe_expand_to_ensure_remaining(total_requested_size) && cb->blob() == nullptr) {
     return false;
   }

src/hotspot/cpu/riscv/codeBuffer_riscv.hpp

@@ -33,7 +33,7 @@
 
 public:
   void flush_bundle(bool start_new_bundle) {}
-  static constexpr bool supports_shared_stubs() { return true; }
+  static bool supports_shared_stubs() { return UseTrampolines; }
 
   void share_trampoline_for(address dest, int caller_offset);
 

src/hotspot/cpu/riscv/compiledIC_riscv.cpp

@@ -69,10 +69,9 @@ int CompiledDirectCall::to_interp_stub_size() {
 }
 
 int CompiledDirectCall::to_trampoline_stub_size() {
-  // Somewhat pessimistically, we count 4 instructions here (although
-  // there are only 3) because we sometimes emit an alignment nop.
+  // We count instructions and an additional alignment nop.
   // Trampoline stubs are always word aligned.
-  return MacroAssembler::max_trampoline_stub_size();
+  return MacroAssembler::max_reloc_call_stub_size();
 }
 
 // Relocation entries for call stub, compiled java to interpreter.

src/hotspot/cpu/riscv/globals_riscv.hpp

@@ -120,6 +120,8 @@ define_pd_global(intx, InlineSmallCode,          1000);
   product(bool, UseZvkn, false, EXPERIMENTAL,                                    \
           "Use Zvkn group extension, Zvkned, Zvknhb, Zvkb, Zvkt")                \
   product(bool, UseRVVForBigIntegerShiftIntrinsics, true,                        \
-          "Use RVV instructions for left/right shift of BigInteger")
+          "Use RVV instructions for left/right shift of BigInteger")             \
+  product(bool, UseTrampolines, false, EXPERIMENTAL,                             \
+          "Far calls uses jal to trampoline.")
 
 #endif // CPU_RISCV_GLOBALS_RISCV_HPP

src/hotspot/cpu/riscv/jvmciCodeInstaller_riscv.cpp

@@ -39,7 +39,7 @@
 jint CodeInstaller::pd_next_offset(NativeInstruction* inst, jint pc_offset, JVMCI_TRAPS) {
   address pc = (address) inst;
   if (inst->is_call()) {
-    return pc_offset + NativeCall::instruction_size;
+    return pc_offset + NativeCall::byte_size();
   } else if (inst->is_jump()) {
     return pc_offset + NativeJump::instruction_size;
   } else if (inst->is_movptr1()) {

src/hotspot/cpu/riscv/macroAssembler_riscv.cpp

@@ -978,36 +978,23 @@ void MacroAssembler::li(Register Rd, int64_t imm) {
   }
 }
 
+void MacroAssembler::load_link_jump(const address source, Register temp) {
+  assert(temp != noreg && temp != x0, "expecting a register");
+  assert_cond(source != nullptr);
+  int64_t distance = source - pc();
+  assert(is_simm32(distance), "Must be");
+  auipc(temp, (int32_t)distance + 0x800);
+  ld(temp, Address(temp, ((int32_t)distance << 20) >> 20));
+  jalr(temp);
+}
+
 void MacroAssembler::jump_link(const address dest, Register temp) {
+  assert(UseTrampolines, "Must be");
   assert_cond(dest != nullptr);
   int64_t distance = dest - pc();
-  if (is_simm21(distance) && ((distance % 2) == 0)) {
-    Assembler::jal(x1, distance);
-  } else {
-    assert(temp != noreg && temp != x0, "expecting a register");
-    int32_t offset = 0;
-    la(temp, dest, offset);
-    jalr(temp, offset);
-  }
-}
-
-void MacroAssembler::jump_link(const Address &adr, Register temp) {
-  switch (adr.getMode()) {
-    case Address::literal: {
-      relocate(adr.rspec(), [&] {
-        jump_link(adr.target(), temp);
-      });
-      break;
-    }
-    case Address::base_plus_offset: {
-      int32_t offset = ((int32_t)adr.offset() << 20) >> 20;
-      la(temp, Address(adr.base(), adr.offset() - offset));
-      jalr(temp, offset);
-      break;
-    }
-    default:
-      ShouldNotReachHere();
-  }
+  assert(is_simm21(distance), "Must be");
+  assert((distance % 2) == 0, "Must be");
+  jal(x1, distance);
 }
 
 void MacroAssembler::j(const address dest, Register temp) {
@@ -3941,15 +3928,7 @@ bool MacroAssembler::lookup_secondary_supers_table(Register r_sub_klass,
   // The next slot to be inspected, by the stub we're about to call,
   // is secondary_supers[r_array_index]. Bits 0 and 1 in the bitmap
   // have been checked.
-  Address stub = RuntimeAddress(StubRoutines::lookup_secondary_supers_table_slow_path_stub());
-  if (stub_is_near) {
-    jump_link(stub, t0);
-  } else {
-    address call = trampoline_call(stub);
-    if (call == nullptr) {
-      return false; // trampoline allocation failed
-    }
-  }
+  rt_call(StubRoutines::lookup_secondary_supers_table_slow_path_stub());
 
   BLOCK_COMMENT("} lookup_secondary_supers_table");
 
@@ -4258,12 +4237,42 @@ address MacroAssembler::trampoline_call(Address entry) {
   return call_pc;
 }
 
+address MacroAssembler::load_and_call(Address entry) {
+  assert(entry.rspec().type() == relocInfo::runtime_call_type ||
+         entry.rspec().type() == relocInfo::opt_virtual_call_type ||
+         entry.rspec().type() == relocInfo::static_call_type ||
+         entry.rspec().type() == relocInfo::virtual_call_type, "wrong reloc type");
+
+  address target = entry.target();
+
+  if (!in_scratch_emit_size()) {
+    address stub = emit_address_stub(offset(), target);
+    if (stub == nullptr) {
+      postcond(pc() == badAddress);
+      return nullptr; // CodeCache is full
+    }
+  }
+
+  address call_pc = pc();
+#ifdef ASSERT
+  if (entry.rspec().type() != relocInfo::runtime_call_type) {
+    assert_alignment(call_pc);
+  }
+#endif
+  relocate(entry.rspec(), [&] {
+    load_link_jump(target);
+  });
+
+  postcond(pc() != badAddress);
+  return call_pc;
+}
+
 address MacroAssembler::ic_call(address entry, jint method_index) {
   RelocationHolder rh = virtual_call_Relocation::spec(pc(), method_index);
   IncompressibleRegion ir(this);  // relocations
   movptr(t1, (address)Universe::non_oop_word(), t0);
   assert_cond(entry != nullptr);
-  return trampoline_call(Address(entry, rh));
+  return reloc_call(Address(entry, rh));
 }
 
 int MacroAssembler::ic_check_size() {
@@ -4308,6 +4317,34 @@ int MacroAssembler::ic_check(int end_alignment) {
   return uep_offset;
 }
 
+address MacroAssembler::emit_address_stub(int insts_call_instruction_offset, address dest) {
+  address stub = start_a_stub(max_reloc_call_stub_size());
+  if (stub == nullptr) {
+    return nullptr;  // CodeBuffer::expand failed
+  }
+
+  // We are always 4-byte aligned here.
+  assert_alignment(pc());
+
+  // Make sure the address of destination 8-byte aligned.
+  align(wordSize, 0);
+
+  RelocationHolder rh = trampoline_stub_Relocation::spec(code()->insts()->start() +
+                                                         insts_call_instruction_offset);
+  const int stub_start_offset = offset();
+  relocate(rh, [&] {
+    assert(offset() - stub_start_offset == 0,
+           "%ld - %ld == %ld : should be", (long)offset(), (long)stub_start_offset, (long)0);
+    assert(offset() % wordSize == 0, "bad alignment");
+    emit_int64((int64_t)dest);
+  });
+
+  const address stub_start_addr = addr_at(stub_start_offset);
+  end_a_stub();
+
+  return stub_start_addr;
+}
+
 // Emit a trampoline stub for a call to a target which is too far away.
 //
 // code sequences:
@@ -4322,11 +4359,13 @@ int MacroAssembler::ic_check(int end_alignment) {
 address MacroAssembler::emit_trampoline_stub(int insts_call_instruction_offset,
                                              address dest) {
   // Max stub size: alignment nop, TrampolineStub.
-  address stub = start_a_stub(max_trampoline_stub_size());
+  address stub = start_a_stub(max_reloc_call_stub_size());
   if (stub == nullptr) {
     return nullptr;  // CodeBuffer::expand failed
   }
 
+  assert(UseTrampolines, "Must be using trampos.");
+
   // We are always 4-byte aligned here.
   assert_alignment(pc());
 
@@ -4335,7 +4374,7 @@ address MacroAssembler::emit_trampoline_stub(int insts_call_instruction_offset,
   // instructions code-section.
 
   // Make sure the address of destination 8-byte aligned after 3 instructions.
-  align(wordSize, MacroAssembler::trampoline_stub_data_offset);
+  align(wordSize, MacroAssembler::NativeShortCall::trampoline_data_offset);
 
   RelocationHolder rh = trampoline_stub_Relocation::spec(code()->insts()->start() +
                                                          insts_call_instruction_offset);
@@ -4348,23 +4387,25 @@ address MacroAssembler::emit_trampoline_stub(int insts_call_instruction_offset,
     ld(t0, target);  // auipc + ld
     jr(t0);          // jalr
     bind(target);
-    assert(offset() - stub_start_offset == MacroAssembler::trampoline_stub_data_offset,
+    assert(offset() - stub_start_offset == MacroAssembler::NativeShortCall::trampoline_data_offset,
            "should be");
     assert(offset() % wordSize == 0, "bad alignment");
     emit_int64((int64_t)dest);
   });
 
   const address stub_start_addr = addr_at(stub_start_offset);
 
-  assert(MacroAssembler::is_trampoline_stub_at(stub_start_addr), "doesn't look like a trampoline");
-
   end_a_stub();
+
   return stub_start_addr;
 }
 
-int MacroAssembler::max_trampoline_stub_size() {
+int MacroAssembler::max_reloc_call_stub_size() {
   // Max stub size: alignment nop, TrampolineStub.
-  return MacroAssembler::instruction_size + MacroAssembler::trampoline_stub_instruction_size;
+  if (UseTrampolines) {
+    return instruction_size + MacroAssembler::NativeShortCall::trampoline_size;
+  }
+  return instruction_size + wordSize;
 }
 
 int MacroAssembler::static_call_stub_size() {
@@ -5083,14 +5124,14 @@ address MacroAssembler::zero_words(Register ptr, Register cnt) {
     RuntimeAddress zero_blocks(StubRoutines::riscv::zero_blocks());
     assert(zero_blocks.target() != nullptr, "zero_blocks stub has not been generated");
     if (StubRoutines::riscv::complete()) {
-      address tpc = trampoline_call(zero_blocks);
+      address tpc = reloc_call(zero_blocks);
       if (tpc == nullptr) {
         DEBUG_ONLY(reset_labels(around));
         postcond(pc() == badAddress);
         return nullptr;
       }
     } else {
-      jump_link(zero_blocks, t0);
+      rt_call(zero_blocks.target());
     }
   }
   bind(around);