8361449: RISC-V: Code cleanup for native call

Reviewed-by: fyang, fjiang

Author: DingliZhang

src/hotspot/cpu/riscv/nativeInst_riscv.cpp

@@ -60,13 +60,13 @@ class NativeFarCall: public NativeInstruction {
   address next_instruction_address() const  { return addr_at(return_address_offset); }
   address return_address() const            { return addr_at(return_address_offset); }
   address destination() const;
-  address reloc_destination(address orig_address);
+  address reloc_destination();
 
   void set_destination(address dest);
   void verify();
   void print();
 
-  bool set_destination_mt_safe(address dest, bool assert_lock = true);
+  bool set_destination_mt_safe(address dest);
   bool reloc_set_destination(address dest);
 
  private:
@@ -88,28 +88,30 @@ address NativeFarCall::destination() const {
   address destination = MacroAssembler::target_addr_for_insn(addr);
 
   CodeBlob* cb = CodeCache::find_blob(addr);
-  assert(cb && cb->is_nmethod(), "sanity");
+  assert(cb != nullptr && cb->is_nmethod(), "nmethod expected");
   nmethod *nm = (nmethod *)cb;
   assert(nm != nullptr, "Sanity");
   assert(nm->stub_contains(destination), "Sanity");
   assert(destination != nullptr, "Sanity");
   return stub_address_destination_at(destination);
 }
 
-address NativeFarCall::reloc_destination(address orig_address) {
+address NativeFarCall::reloc_destination() {
   address call_addr = instruction_address();
+  assert(NativeFarCall::is_at(call_addr), "unexpected code at call site");
 
   CodeBlob *code = CodeCache::find_blob(call_addr);
   assert(code != nullptr, "Could not find the containing code blob");
 
   address stub_addr = nullptr;
-  if (code != nullptr && code->is_nmethod()) {
-    stub_addr = trampoline_stub_Relocation::get_trampoline_for(call_addr, (nmethod*)code);
+  if (code->is_nmethod()) {
+    stub_addr = trampoline_stub_Relocation::get_trampoline_for(call_addr, code->as_nmethod());
   }
 
   if (stub_addr != nullptr) {
     stub_addr = MacroAssembler::target_addr_for_insn(call_addr);
   }
+
   return stub_addr;
 }
 
@@ -128,18 +130,13 @@ void NativeFarCall::print() {
   tty->print_cr(PTR_FORMAT ": auipc,ld,jalr x1, offset/reg, ", p2i(addr_at(0)));
 }
 
-bool NativeFarCall::set_destination_mt_safe(address dest, bool assert_lock) {
+bool NativeFarCall::set_destination_mt_safe(address dest) {
   assert(NativeFarCall::is_at(addr_at(0)), "unexpected code at call site");
-  assert(!assert_lock ||
-         (CodeCache_lock->is_locked() || SafepointSynchronize::is_at_safepoint()) ||
+  assert((CodeCache_lock->is_locked() || SafepointSynchronize::is_at_safepoint()) ||
          CompiledICLocker::is_safe(addr_at(0)),
          "concurrent code patching");
 
-  address call_addr = addr_at(0);
-  assert(NativeFarCall::is_at(call_addr), "unexpected code at call site");
-
   address stub_addr = stub_address();
-
   if (stub_addr != nullptr) {
     set_stub_address_destination_at(stub_addr, dest);
     return true;
@@ -156,10 +153,9 @@ bool NativeFarCall::reloc_set_destination(address dest) {
   assert(code != nullptr, "Could not find the containing code blob");
 
   address stub_addr = nullptr;
-  if (code != nullptr && code->is_nmethod()) {
-    stub_addr = trampoline_stub_Relocation::get_trampoline_for(call_addr, (nmethod*)code);
+  if (code->is_nmethod()) {
+    stub_addr = trampoline_stub_Relocation::get_trampoline_for(call_addr, code->as_nmethod());
   }
-
   if (stub_addr != nullptr) {
     MacroAssembler::pd_patch_instruction_size(call_addr, stub_addr);
   }
@@ -209,7 +205,7 @@ bool NativeFarCall::is_at(address addr) {
       (MacroAssembler::extract_rd(addr + instr_size)       == x6) &&
       (MacroAssembler::extract_rs1(addr + instr_size)      == x6) &&
       (MacroAssembler::extract_rs1(addr + 2 * instr_size)  == x6) &&
-      (MacroAssembler::extract_rd(addr + 2 * instr_size)  == x1)) {
+      (MacroAssembler::extract_rd(addr + 2 * instr_size)   == x1)) {
     return true;
   }
   return false;
@@ -238,8 +234,8 @@ address NativeCall::destination() const {
   return NativeFarCall::at(addr_at(0))->destination();
 }
 
-address NativeCall::reloc_destination(address orig_address) {
-  return NativeFarCall::at(addr_at(0))->reloc_destination(orig_address);
+address NativeCall::reloc_destination() {
+  return NativeFarCall::at(addr_at(0))->reloc_destination();
 }
 
 void NativeCall::set_destination(address dest) {
@@ -254,8 +250,8 @@ void NativeCall::print() {
   NativeFarCall::at(addr_at(0))->print();;
 }
 
-bool NativeCall::set_destination_mt_safe(address dest, bool assert_lock) {
-  return NativeFarCall::at(addr_at(0))->set_destination_mt_safe(dest, assert_lock);
+bool NativeCall::set_destination_mt_safe(address dest) {
+  return NativeFarCall::at(addr_at(0))->set_destination_mt_safe(dest);
 }
 
 bool NativeCall::reloc_set_destination(address dest) {

src/hotspot/cpu/riscv/nativeInst_riscv.hpp

@@ -134,14 +134,14 @@ class NativeCall: private NativeInstruction {
   address next_instruction_address() const;
   address return_address() const;
   address destination() const;
-  address reloc_destination(address orig_address);
+  address reloc_destination();
 
   void verify_alignment() {} // do nothing on riscv
   void verify();
   void print();
 
   void set_destination(address dest);
-  bool set_destination_mt_safe(address dest, bool assert_lock = true);
+  bool set_destination_mt_safe(address dest);
   bool reloc_set_destination(address dest);
 
   static bool is_at(address addr);

src/hotspot/cpu/riscv/relocInfo_riscv.cpp

@@ -72,13 +72,12 @@ void Relocation::pd_set_data_value(address x, bool verify_only) {
 }
 
 address Relocation::pd_call_destination(address orig_addr) {
-  assert(is_call(), "should be an address instruction here");
+  assert(is_call(), "should be a call here");
   if (NativeCall::is_at(addr())) {
-    return nativeCall_at(addr())->reloc_destination(orig_addr);
+    return nativeCall_at(addr())->reloc_destination();
   }
-  // Non call reloc
+
   if (orig_addr != nullptr) {
-    // the extracted address from the instructions in address orig_addr
     address new_addr = MacroAssembler::pd_call_destination(orig_addr);
     // If call is branch to self, don't try to relocate it, just leave it
     // as branch to self. This happens during code generation if the code
@@ -87,20 +86,19 @@ address Relocation::pd_call_destination(address orig_addr) {
     new_addr = (new_addr == orig_addr) ? addr() : new_addr;
     return new_addr;
   }
+
   return MacroAssembler::pd_call_destination(addr());
 }
 
 void Relocation::pd_set_call_destination(address x) {
-  assert(is_call(), "should be an address instruction here");
+  assert(is_call(), "should be a call here");
   if (NativeCall::is_at(addr())) {
-    NativeCall* nc = nativeCall_at(addr());
-    if (nc->reloc_set_destination(x)) {
-      return;
-    }
+    NativeCall* call = nativeCall_at(addr());
+    call->reloc_set_destination(x);
+  } else {
+    MacroAssembler::pd_patch_instruction_size(addr(), x);
+    assert(pd_call_destination(addr()) == x, "fail in reloc");
   }
-  MacroAssembler::pd_patch_instruction_size(addr(), x);
-  address pd_call = pd_call_destination(addr());
-  assert(pd_call == x, "fail in reloc");
 }
 
 address* Relocation::pd_address_in_code() {