[llvm] [BOLT] Delete unnecessary instructions (PR #189296)

via llvm-commits llvm-commits at lists.llvm.org
Sun Mar 29 19:56:43 PDT 2026


llvmbot wrote:


<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-bolt

@llvm/pr-subscribers-backend-risc-v

Author: wangjue (WangJee)

<details>
<summary>Changes</summary>



---

Patch is 45.91 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/189296.diff


11 Files Affected:

- (modified) bolt/CMakeLists.txt (+2-1) 
- (modified) bolt/lib/Core/Relocation.cpp (+4) 
- (modified) bolt/lib/Rewrite/RewriteInstance.cpp (+5-5) 
- (modified) bolt/lib/Target/RISCV/RISCVMCPlusBuilder.cpp (+378) 
- (modified) bolt/runtime/CMakeLists.txt (+10-4) 
- (modified) bolt/runtime/common.h (+3-1) 
- (modified) bolt/runtime/instr.cpp (+48) 
- (added) bolt/runtime/sys_riscv64.h (+460) 
- (added) bolt/test/runtime/RISCV/basic-instrumentation.s (+33) 
- (added) bolt/test/runtime/RISCV/instrumentation-ind-call.c (+39) 
- (added) bolt/test/runtime/RISCV/lit.local.cfg (+2) 


``````````diff
diff --git a/bolt/CMakeLists.txt b/bolt/CMakeLists.txt
index 73c3ab54722e9..52c796518ac05 100644
--- a/bolt/CMakeLists.txt
+++ b/bolt/CMakeLists.txt
@@ -82,7 +82,8 @@ endforeach()
 
 set(BOLT_ENABLE_RUNTIME_default OFF)
 if ((CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64"
-    OR CMAKE_SYSTEM_PROCESSOR MATCHES "^(arm64|aarch64)$")
+    OR CMAKE_SYSTEM_PROCESSOR MATCHES "^(arm64|aarch64)$"
+    OR CMAKE_SYSTEM_PROCESSOR STREQUAL "riscv64")
     AND (CMAKE_SYSTEM_NAME STREQUAL "Linux"
       OR CMAKE_SYSTEM_NAME STREQUAL "Darwin")
     AND (NOT CMAKE_CROSSCOMPILING))
diff --git a/bolt/lib/Core/Relocation.cpp b/bolt/lib/Core/Relocation.cpp
index ff1681f823987..f099dfa46f3d4 100644
--- a/bolt/lib/Core/Relocation.cpp
+++ b/bolt/lib/Core/Relocation.cpp
@@ -123,6 +123,7 @@ static bool isSupportedRISCV(uint32_t Type) {
   case ELF::R_RISCV_LO12_S:
   case ELF::R_RISCV_64:
   case ELF::R_RISCV_TLS_GOT_HI20:
+  case ELF::R_RISCV_TLS_GD_HI20:
   case ELF::R_RISCV_TPREL_HI20:
   case ELF::R_RISCV_TPREL_ADD:
   case ELF::R_RISCV_TPREL_LO12_I:
@@ -236,6 +237,7 @@ static size_t getSizeForTypeRISCV(uint32_t Type) {
   case ELF::R_RISCV_64:
   case ELF::R_RISCV_GOT_HI20:
   case ELF::R_RISCV_TLS_GOT_HI20:
+  case ELF::R_RISCV_TLS_GD_HI20:
     // See extractValueRISCV for why this is necessary.
     return 8;
   }
@@ -491,6 +493,7 @@ static uint64_t extractValueRISCV(uint32_t Type, uint64_t Contents,
     return extractBImmRISCV(Contents);
   case ELF::R_RISCV_GOT_HI20:
   case ELF::R_RISCV_TLS_GOT_HI20:
+  case ELF::R_RISCV_TLS_GD_HI20:
     // We need to know the exact address of the GOT entry so we extract the
     // value from both the AUIPC and L[D|W]. We cannot rely on the symbol in the
     // relocation for this since it simply refers to the object that is stored
@@ -707,6 +710,7 @@ static bool isPCRelativeRISCV(uint32_t Type) {
   case ELF::R_RISCV_RVC_BRANCH:
   case ELF::R_RISCV_32_PCREL:
   case ELF::R_RISCV_TLS_GOT_HI20:
+  case ELF::R_RISCV_TLS_GD_HI20:
     return true;
   }
 }
diff --git a/bolt/lib/Rewrite/RewriteInstance.cpp b/bolt/lib/Rewrite/RewriteInstance.cpp
index a03df3de39e83..37dcfa868c211 100644
--- a/bolt/lib/Rewrite/RewriteInstance.cpp
+++ b/bolt/lib/Rewrite/RewriteInstance.cpp
@@ -2926,12 +2926,12 @@ void RewriteInstance::handleRelocation(const SectionRef &RelocatedSection,
 
     if (BinaryData *BD = BC->getBinaryDataContainingAddress(SymbolAddress)) {
       // Note: this assertion is trying to check sanity of BinaryData objects
-      // but AArch64 has inferred and incomplete object locations coming from
-      // GOT/TLS or any other non-trivial relocation (that requires creation
-      // of sections and whose symbol address is not really what should be
-      // encoded in the instruction). So we essentially disabled this check
+      // but AArch64 and RISCV has inferred and incomplete object locations
+      // coming from GOT/TLS or any other non-trivial relocation (that requires
+      // creation of sections and whose symbol address is not really what should
+      // be encoded in the instruction). So we essentially disabled this check
       // for AArch64 and live with bogus names for objects.
-      assert((IsAArch64 || IsSectionRelocation ||
+      assert((IsAArch64 || BC->isRISCV() || IsSectionRelocation ||
               BD->nameStartsWith(SymbolName) ||
               BD->nameStartsWith("PG" + SymbolName) ||
               (BD->nameStartsWith("ANONYMOUS") &&
diff --git a/bolt/lib/Target/RISCV/RISCVMCPlusBuilder.cpp b/bolt/lib/Target/RISCV/RISCVMCPlusBuilder.cpp
index 4320c679acd54..7852225f7ab9f 100644
--- a/bolt/lib/Target/RISCV/RISCVMCPlusBuilder.cpp
+++ b/bolt/lib/Target/RISCV/RISCVMCPlusBuilder.cpp
@@ -14,7 +14,9 @@
 #include "MCTargetDesc/RISCVMCTargetDesc.h"
 #include "bolt/Core/MCPlusBuilder.h"
 #include "llvm/BinaryFormat/ELF.h"
+#include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInst.h"
+#include "llvm/MC/MCInstBuilder.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/ErrorHandling.h"
 
@@ -72,6 +74,7 @@ class RISCVMCPlusBuilder : public MCPlusBuilder {
     case ELF::R_RISCV_LO12_I:
     case ELF::R_RISCV_LO12_S:
     case ELF::R_RISCV_TLS_GOT_HI20:
+    case ELF::R_RISCV_TLS_GD_HI20:
       return true;
     default:
       llvm_unreachable("Unexpected RISCV relocation type in code");
@@ -252,6 +255,11 @@ class RISCVMCPlusBuilder : public MCPlusBuilder {
     return createCall(RISCV::PseudoCALL, Inst, Target, Ctx);
   }
 
+  void createLongTailCall(InstructionListType &Seq, const MCSymbol *Target,
+                          MCContext *Ctx) override {
+    createShortJmp(Seq, Target, Ctx, /*IsTailCall*/ true);
+  }
+
   void createTailCall(MCInst &Inst, const MCSymbol *Target,
                       MCContext *Ctx) override {
     return createCall(RISCV::PseudoTAIL, Inst, Target, Ctx);
@@ -424,6 +432,7 @@ class RISCVMCPlusBuilder : public MCPlusBuilder {
       return Expr;
     case ELF::R_RISCV_GOT_HI20:
     case ELF::R_RISCV_TLS_GOT_HI20:
+    case ELF::R_RISCV_TLS_GD_HI20:
       // The GOT is reused so no need to create GOT relocations
     case ELF::R_RISCV_PCREL_HI20:
       return RISCVMCExpr::create(Expr, RISCVMCExpr::VK_PCREL_HI, Ctx);
@@ -483,6 +492,375 @@ class RISCVMCPlusBuilder : public MCPlusBuilder {
       return 2;
     return 4;
   }
+
+  void createStackPointerIncrement(
+      MCInst &Inst, int imm,
+      bool NoFlagsClobber = false /*unused for RISCV*/) const override {
+    Inst = MCInstBuilder(RISCV::ADDI)
+               .addReg(RISCV::X2)
+               .addReg(RISCV::X2)
+               .addImm(-imm);
+  }
+
+  void createStackPointerDecrement(
+      MCInst &Inst, int imm,
+      bool NoFlagsClobber = false /*unused for RISCV*/) const override {
+    Inst = MCInstBuilder(RISCV::ADDI)
+               .addReg(RISCV::X2)
+               .addReg(RISCV::X2)
+               .addImm(imm);
+  }
+
+  void loadReg(MCInst &Inst, MCPhysReg To, MCPhysReg From,
+               int64_t offset) const {
+    Inst = MCInstBuilder(RISCV::LD).addReg(To).addReg(From).addImm(offset);
+  }
+
+  void storeReg(MCInst &Inst, MCPhysReg From, MCPhysReg To,
+                int64_t offset) const {
+    Inst = MCInstBuilder(RISCV::SD).addReg(From).addReg(To).addImm(offset);
+  }
+
+  void spillRegs(InstructionListType &Insts,
+                 const SmallVector<unsigned> &Regs) const {
+    Insts.emplace_back();
+    createStackPointerIncrement(Insts.back(), Regs.size() * 8);
+
+    int64_t Offset = 0;
+    for (auto Reg : Regs) {
+      Insts.emplace_back();
+      storeReg(Insts.back(), Reg, RISCV::X2, Offset);
+      Offset += 8;
+    }
+  }
+
+  void reloadRegs(InstructionListType &Insts,
+                  const SmallVector<unsigned> &Regs) const {
+    int64_t Offset = 0;
+    for (auto Reg : Regs) {
+      Insts.emplace_back();
+      loadReg(Insts.back(), Reg, RISCV::X2, Offset);
+      Offset += 8;
+    }
+
+    Insts.emplace_back();
+    createStackPointerDecrement(Insts.back(), Regs.size() * 8);
+  }
+
+  void atomicAdd(MCInst &Inst, MCPhysReg RegAtomic, MCPhysReg RegTo,
+                 MCPhysReg RegCnt) const {
+    Inst = MCInstBuilder(RISCV::AMOADD_D)
+               .addReg(RegAtomic)
+               .addReg(RegTo)
+               .addReg(RegCnt);
+  }
+
+  InstructionListType createCmpRegJE(MCPhysReg RegNo, MCPhysReg RegTmp,
+                                  const MCSymbol *Target,
+                                  MCContext *Ctx) const {
+    InstructionListType Insts;
+    Insts.emplace_back(
+        MCInstBuilder(RISCV::SUB).addReg(RegTmp).addReg(RegNo).addReg(RegNo));
+    Insts.emplace_back(MCInstBuilder(RISCV::BEQ)
+                           .addReg(RegNo)
+                           .addReg(RegTmp)
+                           .addExpr(MCSymbolRefExpr::create(
+                               Target, MCSymbolRefExpr::VK_None, *Ctx)));
+    return Insts;
+  }
+
+  void createTrap(MCInst &Inst) const override {
+    Inst.clear();
+    Inst.setOpcode(RISCV::EBREAK);
+  }
+
+  void createShortJmp(InstructionListType &Seq, const MCSymbol *Target,
+                      MCContext *Ctx, bool IsTailCall) override {
+    // The sequence of instructions we create here is the following:
+    //  auipc   a5, hi20(Target)
+    //  addi    a5, a5, low12(Target)
+    //  jr x5 => jalr x0, x5, 0
+    MCPhysReg Reg = RISCV::X5;
+    InstructionListType Insts = materializeAddress(Target, Ctx, Reg);
+    Insts.emplace_back();
+    MCInst &Inst = Insts.back();
+    Inst.clear();
+    Inst = MCInstBuilder(RISCV::JALR).addReg(RISCV::X0).addReg(Reg).addImm(0);
+    if (IsTailCall)
+      setTailCall(Inst);
+    Seq.swap(Insts);
+  }
+
+  InstructionListType createGetter(MCContext *Ctx, const char *name) const {
+    InstructionListType Insts(4);
+    MCSymbol *Locs = Ctx->getOrCreateSymbol(name);
+    InstructionListType Addr = materializeAddress(Locs, Ctx, RISCV::X10);
+    std::copy(Addr.begin(), Addr.end(), Insts.begin());
+    loadReg(Insts[2], RISCV::X10, RISCV::X10, 0);
+    createReturn(Insts[3]);
+    return Insts;
+  }
+
+  InstructionListType createIncMemory(MCPhysReg RegTo, MCPhysReg RegCnt,
+                                      MCPhysReg RegAtomic) const {
+    InstructionListType Insts;
+    Insts.emplace_back();
+    Insts.back() =
+        MCInstBuilder(RISCV::ADDI).addReg(RegCnt).addReg(RegAtomic).addImm(1);
+    Insts.emplace_back();
+    atomicAdd(Insts.back(), RegAtomic, RegTo, RegCnt);
+    return Insts;
+  }
+
+  InstructionListType materializeAddress(const MCSymbol *Target, MCContext *Ctx,
+                                         MCPhysReg RegName,
+                                         int64_t Addend = 0) const override {
+    // Get the symbol address by auipc + addi
+    InstructionListType Insts(2);
+    MCSymbol *AuipcLabel = Ctx->createNamedTempSymbol("pcrel_hi");
+    Insts[0] = MCInstBuilder(RISCV::AUIPC).addReg(RegName).addImm(0);
+    setOperandToSymbolRef(Insts[0], /* OpNum */ 1, Target, Addend, Ctx,
+                          ELF::R_RISCV_PCREL_HI20);
+    setInstLabel(Insts[0], AuipcLabel);
+
+    Insts[1] =
+        MCInstBuilder(RISCV::ADDI).addReg(RegName).addReg(RegName).addImm(0);
+    setOperandToSymbolRef(Insts[1], /* OpNum */ 2, AuipcLabel, Addend, Ctx,
+                          ELF::R_RISCV_PCREL_LO12_I);
+    return Insts;
+  }
+
+  InstructionListType
+  createInstrIncMemory(const MCSymbol *Target, MCContext *Ctx, bool IsLeaf,
+                       unsigned CodePointerSize) const override {
+    // We need 2 scratch registers: one for the target address (x10), and one
+    // for the increment value (x11).
+    // addi sp, sp, -16
+    // sd x10, 0(sp)
+    // sd x11, 8(sp)
+    // la x10, target         # 1: auipc x10, %pcrel_hi(target)
+    //                        # addi x10, x10, %pcrel_lo(1b)
+    // li x11, 1              # addi x11, zero, 1
+    // amoadd.d zero, x10, x11
+    // ld x10, 0(sp)
+    // ld x11, 8(sp)
+    // addi sp, sp, 16
+
+    InstructionListType Insts;
+    spillRegs(Insts, {RISCV::X10, RISCV::X11});
+    InstructionListType Addr = materializeAddress(Target, Ctx, RISCV::X10);
+    Insts.insert(Insts.end(), Addr.begin(), Addr.end());
+    InstructionListType IncInsts =
+        createIncMemory(RISCV::X10, RISCV::X11, RISCV::X0);
+    Insts.insert(Insts.end(), IncInsts.begin(), IncInsts.end());
+    reloadRegs(Insts, {RISCV::X10, RISCV::X11});
+    return Insts;
+  }
+
+  void createDirectCall(MCInst &Inst, const MCSymbol *Target, MCContext *Ctx,
+                        bool IsTailCall) override {
+    Inst.setOpcode(RISCV::JAL);
+    Inst.clear();
+    if (IsTailCall) {
+      Inst.addOperand(MCOperand::createReg(RISCV::X0));
+      Inst.addOperand(MCOperand::createExpr(getTargetExprFor(
+          Inst, MCSymbolRefExpr::create(Target, MCSymbolRefExpr::VK_None, *Ctx),
+          *Ctx, 0)));
+      convertJmpToTailCall(Inst);
+    } else {
+      Inst.addOperand(MCOperand::createReg(RISCV::X1));
+      Inst.addOperand(MCOperand::createExpr(getTargetExprFor(
+          Inst, MCSymbolRefExpr::create(Target, MCSymbolRefExpr::VK_None, *Ctx),
+          *Ctx, 0)));
+    }
+  }
+
+  void createIndirectCallInst(MCInst &Inst, bool IsTailCall, MCPhysReg Reg,
+                              int64_t Disp) const {
+    Inst.clear();
+    Inst.setOpcode(RISCV::JALR);
+    Inst.clear();
+    if (IsTailCall) {
+      Inst.addOperand(MCOperand::createReg(RISCV::X0));
+      Inst.addOperand(MCOperand::createReg(Reg));
+      Inst.addOperand(MCOperand::createImm(Disp));
+    } else {
+      Inst.addOperand(MCOperand::createReg(RISCV::X1));
+      Inst.addOperand(MCOperand::createReg(Reg));
+      Inst.addOperand(MCOperand::createImm(Disp));
+    }
+  }
+
+  InstructionListType
+  createInstrumentedIndCallHandlerEntryBB(const MCSymbol *InstrTrampoline,
+                                          const MCSymbol *IndCallHandler,
+                                          MCContext *Ctx) override {
+    // Code sequence used to check whether InstrTampoline was initialized
+    // and call it if so, returns via IndCallHandler
+    //   sp      -16(sp)
+    //   sd      x10, 0(sp)
+    //   sd      x11, 0(sp)
+    //   la      x10, InstrTrampoline -> auipc + addi
+    //   ld      x10, [x10]
+    //   beq     x10, x11, IndCallHandler
+    //   sp      -16(sp)
+    //   sd      x1, 0(sp)
+    //   jalr    x1,x10,0
+    //   ld      x1, [sp], #16
+    //   sp      16(sp)
+    //   jal     x0, IndCallHandler
+
+    InstructionListType Insts;
+    spillRegs(Insts, {RISCV::X10, RISCV::X11});
+    InstructionListType Addr =
+        materializeAddress(InstrTrampoline, Ctx, RISCV::X10);
+    Insts.insert(Insts.end(), Addr.begin(), Addr.end());
+    Insts.emplace_back();
+    loadReg(Insts.back(), RISCV::X10, RISCV::X10, 0);
+    InstructionListType cmpJmp =
+        createCmpRegJE(RISCV::X10, RISCV::X11, IndCallHandler, Ctx);
+    Insts.insert(Insts.end(), cmpJmp.begin(), cmpJmp.end());
+    Insts.emplace_back();
+    createStackPointerIncrement(Insts.back(), 16);
+    Insts.emplace_back();
+    storeReg(Insts.back(), RISCV::X1, RISCV::X2, 0);
+    Insts.emplace_back();
+    createIndirectCallInst(Insts.back(), /*IsTailCall*/ false, RISCV::X10, 0);
+    Insts.emplace_back();
+    loadReg(Insts.back(), RISCV::X1, RISCV::X2, 0);
+    Insts.emplace_back();
+    createStackPointerDecrement(Insts.back(), 16);
+    Insts.emplace_back();
+    createDirectCall(Insts.back(), IndCallHandler, Ctx, /*IsTailCall*/ true);
+    return Insts;
+  }
+
+  InstructionListType createInstrumentedIndCallHandlerExitBB() const override {
+    InstructionListType Insts;
+    reloadRegs(Insts, {RISCV::X10, RISCV::X11});
+    Insts.emplace_back();
+    loadReg(Insts.back(), RISCV::X5, RISCV::X2, 0);
+    Insts.emplace_back();
+    createStackPointerDecrement(Insts.back(), 16);
+    reloadRegs(Insts, {RISCV::X10, RISCV::X11});
+    Insts.emplace_back();
+    createIndirectCallInst(Insts.back(), /*IsTailCall*/ true, RISCV::X5, 0);
+    return Insts;
+  }
+
+  InstructionListType
+  createInstrumentedIndTailCallHandlerExitBB() const override {
+    return createInstrumentedIndCallHandlerExitBB();
+  }
+
+  std::vector<MCInst> createSymbolTrampoline(const MCSymbol *TgtSym,
+                                             MCContext *Ctx) override {
+    std::vector<MCInst> Insts;
+    createShortJmp(Insts, TgtSym, Ctx, /*IsTailCall*/ true);
+    return Insts;
+  }
+
+  InstructionListType createNumCountersGetter(MCContext *Ctx) const override {
+    return createGetter(Ctx, "__bolt_num_counters");
+  }
+
+  InstructionListType
+  createInstrLocationsGetter(MCContext *Ctx) const override {
+    return createGetter(Ctx, "__bolt_instr_locations");
+  }
+
+  InstructionListType createInstrTablesGetter(MCContext *Ctx) const override {
+    return createGetter(Ctx, "__bolt_instr_tables");
+  }
+
+  InstructionListType createInstrNumFuncsGetter(MCContext *Ctx) const override {
+    return createGetter(Ctx, "__bolt_instr_num_funcs");
+  }
+
+  void convertIndirectCallToLoad(MCInst &Inst,
+                                 MCPhysReg Reg) override {
+    bool IsTailCall = isTailCall(Inst);
+    if (IsTailCall)
+      removeAnnotation(Inst, MCPlus::MCAnnotation::kTailCall);
+    Inst.setOpcode(RISCV::ADD);
+    Inst.insert(Inst.begin(), MCOperand::createReg(Reg));
+    Inst.insert(Inst.begin() + 1, MCOperand::createReg(RISCV::X0));
+    return;
+  }
+
+  InstructionListType createLoadImmediate(const MCPhysReg Dest,
+                                          uint64_t Imm) const override {
+    InstructionListType Insts;
+    // get IMM higher 32bit
+    Insts.emplace_back(
+        MCInstBuilder(RISCV::LUI).addReg(Dest).addImm((Imm >> 44) & 0xFFFFF));
+    Insts.emplace_back(MCInstBuilder(RISCV::LUI)
+                           .addReg(RISCV::X5)
+                           .addImm((Imm >> 32) & 0xFFF));
+    Insts.emplace_back(MCInstBuilder(RISCV::SRLI)
+                           .addReg(RISCV::X5)
+                           .addReg(RISCV::X5)
+                           .addImm(12));
+    Insts.emplace_back(
+        MCInstBuilder(RISCV::OR).addReg(Dest).addReg(Dest).addReg(RISCV::X5));
+    Insts.emplace_back(
+        MCInstBuilder(RISCV::SLLI).addReg(Dest).addReg(Dest).addImm(32));
+
+    // get IMM lower 32bit
+    Insts.emplace_back(MCInstBuilder(RISCV::LUI)
+                           .addReg(RISCV::X5)
+                           .addImm((Imm >> 12) & 0xFFFFF));
+    Insts.emplace_back(
+        MCInstBuilder(RISCV::LUI).addReg(RISCV::X6).addImm((Imm)&0xFFF));
+    Insts.emplace_back(MCInstBuilder(RISCV::SRLI)
+                           .addReg(RISCV::X6)
+                           .addReg(RISCV::X6)
+                           .addImm(12));
+    Insts.emplace_back(
+        MCInstBuilder(RISCV::OR).addReg(RISCV::X5).addReg(RISCV::X5).addReg(
+            RISCV::X6));
+
+    // get 64bit IMM
+    Insts.emplace_back(
+        MCInstBuilder(RISCV::OR).addReg(Dest).addReg(Dest).addReg(RISCV::X5));
+    return Insts;
+  }
+
+  InstructionListType createInstrumentedIndirectCall(MCInst &&CallInst,
+                                                     MCSymbol *HandlerFuncAddr,
+                                                     int CallSiteID,
+                                                     MCContext *Ctx) override {
+    // Code sequence used to enter indirect call instrumentation helper:
+    //   addi  sp, sp, -0x10
+    //   sd  a0, 0x0(sp)
+    //   sd  a1, 0x8(sp)
+    //   mov target x0  convertIndirectCallToLoad -> add a0, zero, target
+    //   mov x1 CallSiteID createLoadImmediate
+    //   addi  sp, sp, -0x10
+    //   sd  a0, 0x0(sp)
+    //   sd  a1, 0x8(sp)
+    //   la x0 *HandlerFuncAddr -> auipc + addi
+    //   jalr x0
+
+    InstructionListType Insts;
+    spillRegs(Insts, {RISCV::X10, RISCV::X11});
+    Insts.emplace_back(CallInst);
+    convertIndirectCallToLoad(Insts.back(), RISCV::X10);
+    InstructionListType LoadImm = createLoadImmediate(RISCV::X11, CallSiteID);
+    Insts.insert(Insts.end(), LoadImm.begin(), LoadImm.end());
+    spillRegs(Insts, {RISCV::X10, RISCV::X11});
+    InstructionListType Addr =
+        materializeAddress(HandlerFuncAddr, Ctx, RISCV::X5);
+    Insts.insert(Insts.end(), Addr.begin(), Addr.end());
+    Insts.emplace_back();
+    createIndirectCallInst(Insts.back(), isTailCall(CallInst), RISCV::X5, 0);
+
+    // // Carry over metadata including tail call marker if present.
+    stripAnnotations(Insts.back());
+    moveAnnotations(std::move(CallInst), Insts.back());
+
+    return Insts;
+  }
 };
 
 } // end anonymous namespace
diff --git a/bolt/runtime/CMakeLists.txt b/bolt/runtime/CMakeLists.txt
index 0deb69a27d435..87cc44812da11 100644
--- a/bolt/runtime/CMakeLists.txt
+++ b/bolt/runtime/CMakeLists.txt
@@ -35,15 +35,21 @@ set(BOLT_RT_FLAGS
   -fno-exceptions
   -fno-rtti
   -fno-stack-protector
-  -fPIC
-  -mgeneral-regs-only)
+  -fPIC)
 if (CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
-  set(BOLT_RT_FLAGS ${BOLT_RT_FLAGS} "-mno-sse")
+  set(BOLT_RT_FLAGS ${BOLT_RT_FLAGS} 
+    -mno-sse 
+    -mgeneral-regs-only)
+endif()
+if (CMAKE_SYSTEM_PROCESSOR MATCHES "riscv64")
+  set(BOLT_RT_FLAGS ${BOLT_RT_FLAGS})
 endif()
 if (CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
   check_cxx_compiler_flag("-mno-outline-atomics" CXX_SUPPORTS_OUTLINE_ATOMICS)
   if (CXX_SUPPORTS_OUTLINE_ATOMICS)
-    set(BOLT_RT_FLAGS ${BOLT_RT_FLAGS} "-mno-outline-atomics")
+    set(BOLT_RT_FLAGS ${BO...
[truncated]

``````````

</details>


https://github.com/llvm/llvm-project/pull/189296


More information about the llvm-commits mailing list