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

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


llvmbot wrote:


<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-backend-risc-v

@llvm/pr-subscribers-bolt

Author: wangjue (WangJee)

<details>
<summary>Changes</summary>



---
Full diff: https://github.com/llvm/llvm-project/pull/189297.diff


3 Files Affected:

- (modified) bolt/lib/Target/RISCV/RISCVMCPlusBuilder.cpp (+3-6) 
- (modified) bolt/runtime/instr.cpp (+6-12) 
- (modified) bolt/runtime/sys_riscv64.h (+66-98) 


``````````diff
diff --git a/bolt/lib/Target/RISCV/RISCVMCPlusBuilder.cpp b/bolt/lib/Target/RISCV/RISCVMCPlusBuilder.cpp
index 957768e5aaa29..2f0291f3c8175 100644
--- a/bolt/lib/Target/RISCV/RISCVMCPlusBuilder.cpp
+++ b/bolt/lib/Target/RISCV/RISCVMCPlusBuilder.cpp
@@ -553,15 +553,12 @@ class RISCVMCPlusBuilder : public MCPlusBuilder {
                .addReg(RegCnt);
   }
 
-  InstructionListType createRegCmpJE(MCPhysReg RegNo, MCPhysReg RegTmp,
-                                     const MCSymbol *Target,
+  InstructionListType createRegCmpJE(MCPhysReg RegNo, 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)
+                           .addReg(RISCV::X0)
                            .addExpr(MCSymbolRefExpr::create(Target, *Ctx)));
     return Insts;
   }
@@ -713,7 +710,7 @@ class RISCVMCPlusBuilder : public MCPlusBuilder {
     Insts.emplace_back();
     loadReg(Insts.back(), RISCV::X10, RISCV::X10, 0);
     InstructionListType cmpJmp =
-        createRegCmpJE(RISCV::X10, RISCV::X11, IndCallHandler, Ctx);
+        createRegCmpJE(RISCV::X10, IndCallHandler, Ctx);
     Insts.insert(Insts.end(), cmpJmp.begin(), cmpJmp.end());
     Insts.emplace_back();
     createStackPointerIncrement(Insts.back(), 16);
diff --git a/bolt/runtime/instr.cpp b/bolt/runtime/instr.cpp
index 08760c9ca8af1..c49567d4f6ac6 100644
--- a/bolt/runtime/instr.cpp
+++ b/bolt/runtime/instr.cpp
@@ -1727,10 +1727,8 @@ extern "C" __attribute((naked)) void __bolt_instr_indirect_call()
   // clang-format off
   __asm__ __volatile__(
                       SAVE_ALL
-                      "addi sp, sp, 288\n"
-                      "ld x10, 0(sp)\n"
-                      "ld x11, 8(sp)\n"
-                      "addi sp, sp, -288\n"
+                      "ld x10, 288(sp)\n"
+                      "ld x11, 296(sp)\n"
                       "jal x1, instrumentIndirectCall\n"
                       RESTORE_ALL
                       "ret\n"
@@ -1763,10 +1761,8 @@ extern "C" __attribute((naked)) void __bolt_instr_indirect_tailcall()
 #elif defined(__riscv)
   // clang-format off
   __asm__ __volatile__(SAVE_ALL
-                      "addi sp, sp, 288\n"
-                      "ld x10, 0(sp)\n"
-                      "ld x11, 8(sp)\n"
-                      "addi sp, sp, -288\n"
+                      "ld x10, 288(sp)\n"
+                      "ld x11, 296(sp)\n"
                       "jal x1, instrumentIndirectCall\n"
                       RESTORE_ALL
                       "ret\n"
@@ -1806,8 +1802,7 @@ extern "C" __attribute((naked)) void __bolt_instr_start()
                       RESTORE_ALL
                       "setup_symbol:\n"
                       "auipc x5, %%pcrel_hi(__bolt_start_trampoline)\n"
-                      "addi x5, x5, %%pcrel_lo(setup_symbol)\n"
-                      "jr x5\n"
+                      "jalr x0, %%pcrel_lo(setup_symbol)(x5)\n"
                       :::);
   // clang-format on
 #else
@@ -1838,8 +1833,7 @@ extern "C" void __bolt_instr_fini() {
                       SAVE_ALL
                       "fini_symbol:\n"
                       "auipc x5, %%pcrel_hi(__bolt_fini_trampoline)\n"
-                      "addi x5, x5, %%pcrel_lo(fini_symbol)\n"
-                      "jalr x1, 0(x5)\n"
+                      "jalr x1, %%pcrel_lo(fini_symbol)(x5)\n"
                       RESTORE_ALL
                       :::);
   // clang-format on
diff --git a/bolt/runtime/sys_riscv64.h b/bolt/runtime/sys_riscv64.h
index 442fa2e018494..74684ef8c90ed 100644
--- a/bolt/runtime/sys_riscv64.h
+++ b/bolt/runtime/sys_riscv64.h
@@ -2,105 +2,73 @@
 #define LLVM_TOOLS_LLVM_BOLT_SYS_RISCV
 
 // Save all registers while keeping 16B stack alignment
-#define SAVE_ALL                                                               \
-  "addi sp, sp, -16\n"                                                         \
-  "sd x0, 0(sp)\n"                                                             \
-  "sd x1, 8(sp)\n"                                                             \
-  "addi sp, sp, -16\n"                                                         \
-  "sd x2, 0(sp)\n"                                                             \
-  "sd x3, 8(sp)\n"                                                             \
-  "addi sp, sp, -16\n"                                                         \
-  "sd x4, 0(sp)\n"                                                             \
-  "sd x5, 8(sp)\n"                                                             \
-  "addi sp, sp, -16\n"                                                         \
-  "sd x6, 0(sp)\n"                                                             \
-  "sd x7, 8(sp)\n"                                                             \
-  "addi sp, sp, -16\n"                                                         \
-  "sd x8, 0(sp)\n"                                                             \
-  "sd x9, 8(sp)\n"                                                             \
-  "addi sp, sp, -16\n"                                                         \
-  "sd x10, 0(sp)\n"                                                            \
-  "sd x11, 8(sp)\n"                                                            \
-  "addi sp, sp, -16\n"                                                         \
-  "sd x12, 0(sp)\n"                                                            \
-  "sd x13, 8(sp)\n"                                                            \
-  "addi sp, sp, -16\n"                                                         \
-  "sd x14, 0(sp)\n"                                                            \
-  "sd x15, 8(sp)\n"                                                            \
-  "addi sp, sp, -16\n"                                                         \
-  "sd x16, 0(sp)\n"                                                            \
-  "sd x17, 8(sp)\n"                                                            \
-  "addi sp, sp, -16\n"                                                         \
-  "sd x18, 0(sp)\n"                                                            \
-  "sd x19, 8(sp)\n"                                                            \
-  "addi sp, sp, -16\n"                                                         \
-  "sd x20, 0(sp)\n"                                                            \
-  "sd x21, 8(sp)\n"                                                            \
-  "addi sp, sp, -16\n"                                                         \
-  "sd x22, 0(sp)\n"                                                            \
-  "sd x23, 8(sp)\n"                                                            \
-  "addi sp, sp, -16\n"                                                         \
-  "sd x24, 0(sp)\n"                                                            \
-  "sd x25, 8(sp)\n"                                                            \
-  "addi sp, sp, -16\n"                                                         \
-  "sd x26, 0(sp)\n"                                                            \
-  "sd x27, 8(sp)\n"                                                            \
-  "addi sp, sp, -16\n"                                                         \
-  "sd x28, 0(sp)\n"                                                            \
-  "sd x29, 8(sp)\n"                                                            \
-  "addi sp, sp, -16\n"                                                         \
-  "sd x30, 0(sp)\n"                                                            \
-  "sd x31, 8(sp)\n"
+#define SAVE_ALL                                                                 \
+  "addi sp, sp, -256\n"                                                          \
+  "sd x1, 0(sp)\n"                                                               \
+  "sd x2, 8(sp)\n"                                                               \
+  "sd x3, 16(sp)\n"                                                              \
+  "sd x4, 24(sp)\n"                                                              \
+  "sd x5, 32(sp)\n"                                                              \
+  "sd x6, 40(sp)\n"                                                              \
+  "sd x7, 48(sp)\n"                                                              \
+  "sd x8, 56(sp)\n"                                                              \
+  "sd x9, 64(sp)\n"                                                              \
+  "sd x10, 72(sp)\n"                                                             \
+  "sd x11, 80(sp)\n"                                                             \
+  "sd x12, 88(sp)\n"                                                             \
+  "sd x13, 96(sp)\n"                                                             \
+  "sd x14, 104(sp)\n"                                                            \
+  "sd x15, 112(sp)\n"                                                            \
+  "sd x16, 120(sp)\n"                                                            \
+  "sd x17, 128(sp)\n"                                                            \
+  "sd x18, 136(sp)\n"                                                            \
+  "sd x19, 144(sp)\n"                                                            \
+  "sd x20, 152(sp)\n"                                                            \
+  "sd x21, 160(sp)\n"                                                            \
+  "sd x22, 168(sp)\n"                                                            \
+  "sd x23, 176(sp)\n"                                                            \
+  "sd x24, 184(sp)\n"                                                            \
+  "sd x25, 192(sp)\n"                                                            \
+  "sd x26, 200(sp)\n"                                                            \
+  "sd x27, 208(sp)\n"                                                            \
+  "sd x28, 216(sp)\n"                                                            \
+  "sd x29, 224(sp)\n"                                                            \
+  "sd x30, 232(sp)\n"                                                            \
+  "sd x31, 240(sp)\n"
 // Mirrors SAVE_ALL
-#define RESTORE_ALL                                                            \
-  "ld  x30, 0(sp)\n"                                                           \
-  "ld  x31, 8(sp)\n"                                                           \
-  "addi sp, sp,  16\n"                                                         \
-  "ld  x28, 0(sp)\n"                                                           \
-  "ld  x29, 8(sp)\n"                                                           \
-  "addi sp, sp,  16\n"                                                         \
-  "ld  x26, 0(sp)\n"                                                           \
-  "ld  x27, 8(sp)\n"                                                           \
-  "addi sp, sp,  16\n"                                                         \
-  "ld  x24, 0(sp)\n"                                                           \
-  "ld  x25, 8(sp)\n"                                                           \
-  "addi sp, sp,  16\n"                                                         \
-  "ld  x22, 0(sp)\n"                                                           \
-  "ld  x23, 8(sp)\n"                                                           \
-  "addi sp, sp,  16\n"                                                         \
-  "ld  x20, 0(sp)\n"                                                           \
-  "ld  x21, 8(sp)\n"                                                           \
-  "addi sp, sp,  16\n"                                                         \
-  "ld  x18, 0(sp)\n"                                                           \
-  "ld  x19, 8(sp)\n"                                                           \
-  "addi sp, sp,  16\n"                                                         \
-  "ld  x16, 0(sp)\n"                                                           \
-  "ld  x17, 8(sp)\n"                                                           \
-  "addi sp, sp,  16\n"                                                         \
-  "ld  x14, 0(sp)\n"                                                           \
-  "ld  x15, 8(sp)\n"                                                           \
-  "addi sp, sp,  16\n"                                                         \
-  "ld  x12, 0(sp)\n"                                                           \
-  "ld  x13, 8(sp)\n"                                                           \
-  "addi sp, sp,  16\n"                                                         \
-  "ld  x10, 0(sp)\n"                                                           \
-  "ld  x11, 8(sp)\n"                                                           \
-  "addi sp, sp,  16\n"                                                         \
-  "ld  x8, 0(sp)\n"                                                            \
-  "ld  x9, 8(sp)\n"                                                            \
-  "addi sp, sp,  16\n"                                                         \
-  "ld  x6, 0(sp)\n"                                                            \
-  "ld  x7, 8(sp)\n"                                                            \
-  "addi sp, sp,  16\n"                                                         \
-  "ld  x4, 0(sp)\n"                                                            \
-  "ld  x5, 8(sp)\n"                                                            \
-  "addi sp, sp,  16\n"                                                         \
-  "ld  x2, 0(sp)\n"                                                            \
-  "ld  x3, 8(sp)\n"                                                            \
-  "addi sp, sp,  16\n"                                                         \
-  "ld  x0, 0(sp)\n"                                                            \
-  "ld  x1, 8(sp)\n"                                                            \
-  "addi sp, sp,  16\n"
+#define RESTORE_ALL                                                              \
+  "ld x1, 0(sp)\n"                                                               \
+  "ld x2, 8(sp)\n"                                                               \
+  "ld x3, 16(sp)\n"                                                              \
+  "ld x4, 24(sp)\n"                                                              \
+  "ld x5, 32(sp)\n"                                                              \
+  "ld x6, 40(sp)\n"                                                              \
+  "ld x7, 48(sp)\n"                                                              \
+  "ld x8, 56(sp)\n"                                                              \
+  "ld x9, 64(sp)\n"                                                              \
+  "ld x10, 72(sp)\n"                                                             \
+  "ld x11, 80(sp)\n"                                                             \
+  "ld x12, 88(sp)\n"                                                             \
+  "ld x13, 96(sp)\n"                                                             \
+  "ld x14, 104(sp)\n"                                                            \
+  "ld x15, 112(sp)\n"                                                            \
+  "ld x16, 120(sp)\n"                                                            \
+  "ld x17, 128(sp)\n"                                                            \
+  "ld x18, 136(sp)\n"                                                            \
+  "ld x19, 144(sp)\n"                                                            \
+  "ld x20, 152(sp)\n"                                                            \
+  "ld x21, 160(sp)\n"                                                            \
+  "ld x22, 168(sp)\n"                                                            \
+  "ld x23, 176(sp)\n"                                                            \
+  "ld x24, 184(sp)\n"                                                            \
+  "ld x25, 192(sp)\n"                                                            \
+  "ld x26, 200(sp)\n"                                                            \
+  "ld x27, 208(sp)\n"                                                            \
+  "ld x28, 216(sp)\n"                                                            \
+  "ld x29, 224(sp)\n"                                                            \
+  "ld x30, 232(sp)\n"                                                            \
+  "ld x31, 240(sp)\n"                                                            \
+  "addi sp, sp,  256\n"
 
 // Anonymous namespace covering everything but our library entry point
 namespace {

``````````

</details>


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


More information about the llvm-commits mailing list