[llvm-branch-commits] [llvm] [LoongArch] Compute exact offset value in foldLargeOffset() (PR #242943)

via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Sun Nov 15 18:50:17 PST 2026


https://github.com/heiher created https://github.com/llvm/llvm-project/pull/242943

foldLargeOffset() reconstructed the offset additively with a mask of the bits overwritten later, which is only valid for the canonical sequences produced by LoongArchMatInt where every instruction writes a disjoint bit field. Non-canonical chains reach the pass when part of the constant is materialized in another basic block, e.g. ORI on top of ORI, or ORI after SLLI.D, and the computed offset was wrong:

  ori 256; ori 1                 -> g+1         (expected g+257)
  lu12i.w+ori 0x678; ori 0xf     -> g+305418255 (expected g+305419903)
  ori 0xabc; slli.d 4; ori 0xf0  -> g+41200     (expected g+44016)

Collect the chain first, then evaluate it in program order with the exact semantics of each instruction. The existing restrictions (single non-debug use, no target flags, at most 4 instructions, LU32I.D/LU52I.D/SLLI.D only with the pcala64 sequence) are kept.

Assisted-By: LLM

>From 4a0a1f20614b1ffdcc2a810028d8ac4aa1d82751 Mon Sep 17 00:00:00 2001
From: WANG Rui <wangrui at loongson.cn>
Date: Mon, 16 Nov 2026 10:44:34 +0800
Subject: [PATCH] [LoongArch] Compute exact offset value in foldLargeOffset()

foldLargeOffset() reconstructed the offset additively with a mask of the
bits overwritten later, which is only valid for the canonical sequences
produced by LoongArchMatInt where every instruction writes a disjoint bit
field. Non-canonical chains reach the pass when part of the constant is
materialized in another basic block, e.g. ORI on top of ORI, or ORI after
SLLI.D, and the computed offset was wrong:

  ori 256; ori 1                 -> g+1         (expected g+257)
  lu12i.w+ori 0x678; ori 0xf     -> g+305418255 (expected g+305419903)
  ori 0xabc; slli.d 4; ori 0xf0  -> g+41200     (expected g+44016)

Collect the chain first, then evaluate it in program order with the exact
semantics of each instruction. The existing restrictions (single non-debug
use, no target flags, at most 4 instructions, LU32I.D/LU52I.D/SLLI.D only
with the pcala64 sequence) are kept.

Assisted-By: LLM
---
 .../LoongArch/LoongArchMergeBaseOffset.cpp    | 95 ++++++++++---------
 .../merge-base-offset-fold-large-offset.mir   | 24 ++---
 .../CodeGen/LoongArch/merge-base-offset.ll    | 36 +++----
 3 files changed, 79 insertions(+), 76 deletions(-)

diff --git a/llvm/lib/Target/LoongArch/LoongArchMergeBaseOffset.cpp b/llvm/lib/Target/LoongArch/LoongArchMergeBaseOffset.cpp
index 01d68dfb8f045..689ce73df9755 100644
--- a/llvm/lib/Target/LoongArch/LoongArchMergeBaseOffset.cpp
+++ b/llvm/lib/Target/LoongArch/LoongArchMergeBaseOffset.cpp
@@ -362,10 +362,8 @@ bool LoongArchMergeBaseOffsetOpt::foldLargeOffset(
   Register Rt = TailAdd.getOperand(2).getReg();
   Register Reg = Rs == GAReg ? Rt : Rs;
   SmallVector<MachineInstr *, 4> Instrs;
-  int64_t Offset = 0;
-  int64_t Mask = -1;
-  int Shift = 0;
 
+  // Walk backwards through the single-use chain that materializes the offset.
   // This can point to one of [ORI, LU12I.W, LU32I.D, LU52I.D, SLLI.D]:
   for (int I = 0; I < 4; I++) {
     // Handle Reg is R0.
@@ -384,71 +382,76 @@ bool LoongArchMergeBaseOffsetOpt::foldLargeOffset(
     default:
       // Can't fold if the instruction opcode is unexpected.
       return false;
-    case LoongArch::ORI: {
-      MachineOperand ImmOp = Curr->getOperand(2);
-      if (ImmOp.getTargetFlags() != LoongArchII::MO_None)
+    case LoongArch::ORI:
+      if (Curr->getOperand(2).getTargetFlags() != LoongArchII::MO_None)
         return false;
-      const int64_t Imm = ImmOp.getImm();
-      Offset += (static_cast<uint64_t>(Imm) << Shift) & Mask;
-      Mask &= ~(0x0000000000000FFFULL << Shift);
       Reg = Curr->getOperand(1).getReg();
-      Instrs.push_back(Curr);
       break;
-    }
-    case LoongArch::LU12I_W: {
-      MachineOperand ImmOp = Curr->getOperand(1);
-      if (ImmOp.getTargetFlags() != LoongArchII::MO_None)
+    case LoongArch::LU12I_W:
+      if (Curr->getOperand(1).getTargetFlags() != LoongArchII::MO_None)
         return false;
-      const int64_t Imm =
-          SignExtend64<32>(static_cast<uint64_t>(ImmOp.getImm()) << 12);
-      Offset += (static_cast<uint64_t>(Imm) << Shift) & Mask;
       Reg = LoongArch::R0;
-      Instrs.push_back(Curr);
       break;
-    }
-    case LoongArch::LU32I_D: {
-      MachineOperand ImmOp = Curr->getOperand(2);
-      if (ImmOp.getTargetFlags() != LoongArchII::MO_None || !Lo20)
+    case LoongArch::LU32I_D:
+      if (Curr->getOperand(2).getTargetFlags() != LoongArchII::MO_None || !Lo20)
         return false;
-      const int64_t Imm =
-          SignExtend64<52>(static_cast<uint64_t>(ImmOp.getImm()) << 32);
-      Offset += (static_cast<uint64_t>(Imm) << Shift) & Mask;
-      Mask &= ~(0xFFFFFFFF00000000ULL << Shift);
       Reg = Curr->getOperand(1).getReg();
-      Instrs.push_back(Curr);
       break;
-    }
-    case LoongArch::LU52I_D: {
-      MachineOperand ImmOp = Curr->getOperand(2);
-      if (ImmOp.getTargetFlags() != LoongArchII::MO_None || !Hi12)
+    case LoongArch::LU52I_D:
+      if (Curr->getOperand(2).getTargetFlags() != LoongArchII::MO_None || !Hi12)
         return false;
-      const int64_t Imm = static_cast<uint64_t>(ImmOp.getImm()) << 52;
-      Offset += (static_cast<uint64_t>(Imm) << Shift) & Mask;
-      Mask &= ~(0xFFF0000000000000ULL << Shift);
       Reg = Curr->getOperand(1).getReg();
-      Instrs.push_back(Curr);
       break;
-    }
-    case LoongArch::SLLI_D: {
-      MachineOperand ImmOp = Curr->getOperand(2);
-      if (ImmOp.getTargetFlags() != LoongArchII::MO_None || !(Lo20 && Hi12))
-        return false;
-      Shift += ImmOp.getImm();
-      if (Shift >= 64)
+    case LoongArch::SLLI_D:
+      if (Curr->getOperand(2).getTargetFlags() != LoongArchII::MO_None ||
+          !(Lo20 && Hi12))
         return false;
       Reg = Curr->getOperand(1).getReg();
-      Instrs.push_back(Curr);
       break;
     }
+    Instrs.push_back(Curr);
+  }
+
+  // Can't fold if the current register does not reach R0.
+  if (Reg != LoongArch::R0)
+    return false;
+
+  // Compute the offset by evaluating the chain in program order with the exact
+  // semantics of each instruction. The chain is not necessarily in the
+  // canonical form produced by LoongArchMatInt (e.g. when part of the constant
+  // is materialized in another basic block), so the instructions may write
+  // overlapping bits.
+  uint64_t Val = 0;
+  for (MachineInstr *MI : reverse(Instrs)) {
+    switch (MI->getOpcode()) {
+    default:
+      llvm_unreachable("Unexpected opcode");
+    case LoongArch::ORI:
+      Val |= static_cast<uint64_t>(MI->getOperand(2).getImm()) & 0xFFF;
+      break;
+    case LoongArch::LU12I_W:
+      Val = SignExtend64<32>(static_cast<uint64_t>(MI->getOperand(1).getImm())
+                             << 12);
+      break;
+    case LoongArch::LU32I_D:
+      Val = (Val & 0xFFFFFFFF) |
+            SignExtend64<52>(static_cast<uint64_t>(MI->getOperand(2).getImm())
+                             << 32);
+      break;
+    case LoongArch::LU52I_D:
+      Val = (Val & 0x000FFFFFFFFFFFFF) |
+            (static_cast<uint64_t>(MI->getOperand(2).getImm()) << 52);
+      break;
+    case LoongArch::SLLI_D:
+      Val <<= MI->getOperand(2).getImm() & 0x3F;
+      break;
     }
   }
+  int64_t Offset = Val;
 
   // Can't fold if the offset is not extracted.
   if (!Offset)
     return false;
-  // Can't fold if the current register does not reach R0.
-  if (Reg != LoongArch::R0)
-    return false;
 
   foldOffset(Hi20, Lo12, Lo20, Hi12, Last, TailAdd, Offset);
   LLVM_DEBUG(dbgs() << "  Offset Instrs:\n");
diff --git a/llvm/test/CodeGen/LoongArch/merge-base-offset-fold-large-offset.mir b/llvm/test/CodeGen/LoongArch/merge-base-offset-fold-large-offset.mir
index d4dddf54dd036..15b33b9996ee1 100644
--- a/llvm/test/CodeGen/LoongArch/merge-base-offset-fold-large-offset.mir
+++ b/llvm/test/CodeGen/LoongArch/merge-base-offset-fold-large-offset.mir
@@ -20,10 +20,10 @@ tracksRegLiveness: true
 body:             |
   bb.0:
     ; CHECK-LABEL: name: ori_ori
-    ; CHECK: [[PCALAU12I:%[0-9]+]]:gpr = PCALAU12I target-flags(loongarch-pcrel-hi) @g + 1
-    ; CHECK-NEXT: [[ADDI_D:%[0-9]+]]:gpr = ADDI_D $r0, target-flags(loongarch-pcrel-lo) @g + 1
-    ; CHECK-NEXT: [[LU32I_D:%[0-9]+]]:gpr = LU32I_D [[ADDI_D]], target-flags(loongarch-pcrel64-lo) @g + 1
-    ; CHECK-NEXT: [[LU52I_D:%[0-9]+]]:gpr = LU52I_D [[LU32I_D]], target-flags(loongarch-pcrel64-hi) @g + 1
+    ; CHECK: [[PCALAU12I:%[0-9]+]]:gpr = PCALAU12I target-flags(loongarch-pcrel-hi) @g + 257
+    ; CHECK-NEXT: [[ADDI_D:%[0-9]+]]:gpr = ADDI_D $r0, target-flags(loongarch-pcrel-lo) @g + 257
+    ; CHECK-NEXT: [[LU32I_D:%[0-9]+]]:gpr = LU32I_D [[ADDI_D]], target-flags(loongarch-pcrel64-lo) @g + 257
+    ; CHECK-NEXT: [[LU52I_D:%[0-9]+]]:gpr = LU52I_D [[LU32I_D]], target-flags(loongarch-pcrel64-hi) @g + 257
     ; CHECK-NEXT: [[ADD_D:%[0-9]+]]:gpr = ADD_D [[LU52I_D]], [[PCALAU12I]]
     ; CHECK-NEXT: $r4 = COPY [[ADD_D]]
     ; CHECK-NEXT: PseudoRET implicit $r4
@@ -44,10 +44,10 @@ tracksRegLiveness: true
 body:             |
   bb.0:
     ; CHECK-LABEL: name: ori_ori_overlap
-    ; CHECK: [[PCALAU12I:%[0-9]+]]:gpr = PCALAU12I target-flags(loongarch-pcrel-hi) @g + 305418255
-    ; CHECK-NEXT: [[ADDI_D:%[0-9]+]]:gpr = ADDI_D $r0, target-flags(loongarch-pcrel-lo) @g + 305418255
-    ; CHECK-NEXT: [[LU32I_D:%[0-9]+]]:gpr = LU32I_D [[ADDI_D]], target-flags(loongarch-pcrel64-lo) @g + 305418255
-    ; CHECK-NEXT: [[LU52I_D:%[0-9]+]]:gpr = LU52I_D [[LU32I_D]], target-flags(loongarch-pcrel64-hi) @g + 305418255
+    ; CHECK: [[PCALAU12I:%[0-9]+]]:gpr = PCALAU12I target-flags(loongarch-pcrel-hi) @g + 305419903
+    ; CHECK-NEXT: [[ADDI_D:%[0-9]+]]:gpr = ADDI_D $r0, target-flags(loongarch-pcrel-lo) @g + 305419903
+    ; CHECK-NEXT: [[LU32I_D:%[0-9]+]]:gpr = LU32I_D [[ADDI_D]], target-flags(loongarch-pcrel64-lo) @g + 305419903
+    ; CHECK-NEXT: [[LU52I_D:%[0-9]+]]:gpr = LU52I_D [[LU32I_D]], target-flags(loongarch-pcrel64-hi) @g + 305419903
     ; CHECK-NEXT: [[ADD_D:%[0-9]+]]:gpr = ADD_D [[LU52I_D]], [[PCALAU12I]]
     ; CHECK-NEXT: $r4 = COPY [[ADD_D]]
     ; CHECK-NEXT: PseudoRET implicit $r4
@@ -69,10 +69,10 @@ tracksRegLiveness: true
 body:             |
   bb.0:
     ; CHECK-LABEL: name: ori_slli_ori
-    ; CHECK: [[PCALAU12I:%[0-9]+]]:gpr = PCALAU12I target-flags(loongarch-pcrel-hi) @g + 41200
-    ; CHECK-NEXT: [[ADDI_D:%[0-9]+]]:gpr = ADDI_D $r0, target-flags(loongarch-pcrel-lo) @g + 41200
-    ; CHECK-NEXT: [[LU32I_D:%[0-9]+]]:gpr = LU32I_D [[ADDI_D]], target-flags(loongarch-pcrel64-lo) @g + 41200
-    ; CHECK-NEXT: [[LU52I_D:%[0-9]+]]:gpr = LU52I_D [[LU32I_D]], target-flags(loongarch-pcrel64-hi) @g + 41200
+    ; CHECK: [[PCALAU12I:%[0-9]+]]:gpr = PCALAU12I target-flags(loongarch-pcrel-hi) @g + 44016
+    ; CHECK-NEXT: [[ADDI_D:%[0-9]+]]:gpr = ADDI_D $r0, target-flags(loongarch-pcrel-lo) @g + 44016
+    ; CHECK-NEXT: [[LU32I_D:%[0-9]+]]:gpr = LU32I_D [[ADDI_D]], target-flags(loongarch-pcrel64-lo) @g + 44016
+    ; CHECK-NEXT: [[LU52I_D:%[0-9]+]]:gpr = LU52I_D [[LU32I_D]], target-flags(loongarch-pcrel64-hi) @g + 44016
     ; CHECK-NEXT: [[ADD_D:%[0-9]+]]:gpr = ADD_D [[LU52I_D]], [[PCALAU12I]]
     ; CHECK-NEXT: $r4 = COPY [[ADD_D]]
     ; CHECK-NEXT: PseudoRET implicit $r4
diff --git a/llvm/test/CodeGen/LoongArch/merge-base-offset.ll b/llvm/test/CodeGen/LoongArch/merge-base-offset.ll
index c53642916968c..9b25413042b0b 100644
--- a/llvm/test/CodeGen/LoongArch/merge-base-offset.ll
+++ b/llvm/test/CodeGen/LoongArch/merge-base-offset.ll
@@ -1300,22 +1300,22 @@ define dso_local ptr @load_addr_offset_ori_ori() nounwind {
 ; LA32-LABEL: load_addr_offset_ori_ori:
 ; LA32:       # %bb.0: # %entry
 ; LA32-NEXT:  .Lpcadd_hi44:
-; LA32-NEXT:    pcaddu12i $a0, %pcadd_hi20(g_a64+1)
+; LA32-NEXT:    pcaddu12i $a0, %pcadd_hi20(g_a64+257)
 ; LA32-NEXT:    addi.w $a0, $a0, %pcadd_lo12(.Lpcadd_hi44)
 ; LA32-NEXT:    ret
 ;
 ; LA64-LABEL: load_addr_offset_ori_ori:
 ; LA64:       # %bb.0: # %entry
-; LA64-NEXT:    pcalau12i $a0, %pc_hi20(g_a64+1)
-; LA64-NEXT:    addi.d $a0, $a0, %pc_lo12(g_a64+1)
+; LA64-NEXT:    pcalau12i $a0, %pc_hi20(g_a64+257)
+; LA64-NEXT:    addi.d $a0, $a0, %pc_lo12(g_a64+257)
 ; LA64-NEXT:    ret
 ;
 ; LA64-LARGE-LABEL: load_addr_offset_ori_ori:
 ; LA64-LARGE:       # %bb.0: # %entry
-; LA64-LARGE-NEXT:    pcalau12i $a0, %pc_hi20(g_a64+1)
-; LA64-LARGE-NEXT:    addi.d $a1, $zero, %pc_lo12(g_a64+1)
-; LA64-LARGE-NEXT:    lu32i.d $a1, %pc64_lo20(g_a64+1)
-; LA64-LARGE-NEXT:    lu52i.d $a1, $a1, %pc64_hi12(g_a64+1)
+; LA64-LARGE-NEXT:    pcalau12i $a0, %pc_hi20(g_a64+257)
+; LA64-LARGE-NEXT:    addi.d $a1, $zero, %pc_lo12(g_a64+257)
+; LA64-LARGE-NEXT:    lu32i.d $a1, %pc64_lo20(g_a64+257)
+; LA64-LARGE-NEXT:    lu52i.d $a1, $a1, %pc64_hi12(g_a64+257)
 ; LA64-LARGE-NEXT:    add.d $a0, $a1, $a0
 ; LA64-LARGE-NEXT:    ret
 entry:
@@ -1331,22 +1331,22 @@ define dso_local ptr @load_addr_offset_ori_ori_overlap() nounwind {
 ; LA32-LABEL: load_addr_offset_ori_ori_overlap:
 ; LA32:       # %bb.0: # %entry
 ; LA32-NEXT:  .Lpcadd_hi45:
-; LA32-NEXT:    pcaddu12i $a0, %pcadd_hi20(g_a64+305418255)
+; LA32-NEXT:    pcaddu12i $a0, %pcadd_hi20(g_a64+305419903)
 ; LA32-NEXT:    addi.w $a0, $a0, %pcadd_lo12(.Lpcadd_hi45)
 ; LA32-NEXT:    ret
 ;
 ; LA64-LABEL: load_addr_offset_ori_ori_overlap:
 ; LA64:       # %bb.0: # %entry
-; LA64-NEXT:    pcalau12i $a0, %pc_hi20(g_a64+305418255)
-; LA64-NEXT:    addi.d $a0, $a0, %pc_lo12(g_a64+305418255)
+; LA64-NEXT:    pcalau12i $a0, %pc_hi20(g_a64+305419903)
+; LA64-NEXT:    addi.d $a0, $a0, %pc_lo12(g_a64+305419903)
 ; LA64-NEXT:    ret
 ;
 ; LA64-LARGE-LABEL: load_addr_offset_ori_ori_overlap:
 ; LA64-LARGE:       # %bb.0: # %entry
-; LA64-LARGE-NEXT:    pcalau12i $a0, %pc_hi20(g_a64+305418255)
-; LA64-LARGE-NEXT:    addi.d $a1, $zero, %pc_lo12(g_a64+305418255)
-; LA64-LARGE-NEXT:    lu32i.d $a1, %pc64_lo20(g_a64+305418255)
-; LA64-LARGE-NEXT:    lu52i.d $a1, $a1, %pc64_hi12(g_a64+305418255)
+; LA64-LARGE-NEXT:    pcalau12i $a0, %pc_hi20(g_a64+305419903)
+; LA64-LARGE-NEXT:    addi.d $a1, $zero, %pc_lo12(g_a64+305419903)
+; LA64-LARGE-NEXT:    lu32i.d $a1, %pc64_lo20(g_a64+305419903)
+; LA64-LARGE-NEXT:    lu52i.d $a1, $a1, %pc64_hi12(g_a64+305419903)
 ; LA64-LARGE-NEXT:    add.d $a0, $a1, $a0
 ; LA64-LARGE-NEXT:    ret
 entry:
@@ -1382,10 +1382,10 @@ define dso_local ptr @load_addr_offset_ori_slli_ori() nounwind {
 ;
 ; LA64-LARGE-LABEL: load_addr_offset_ori_slli_ori:
 ; LA64-LARGE:       # %bb.0: # %entry
-; LA64-LARGE-NEXT:    pcalau12i $a0, %pc_hi20(g_a64+41200)
-; LA64-LARGE-NEXT:    addi.d $a1, $zero, %pc_lo12(g_a64+41200)
-; LA64-LARGE-NEXT:    lu32i.d $a1, %pc64_lo20(g_a64+41200)
-; LA64-LARGE-NEXT:    lu52i.d $a1, $a1, %pc64_hi12(g_a64+41200)
+; LA64-LARGE-NEXT:    pcalau12i $a0, %pc_hi20(g_a64+44016)
+; LA64-LARGE-NEXT:    addi.d $a1, $zero, %pc_lo12(g_a64+44016)
+; LA64-LARGE-NEXT:    lu32i.d $a1, %pc64_lo20(g_a64+44016)
+; LA64-LARGE-NEXT:    lu52i.d $a1, $a1, %pc64_hi12(g_a64+44016)
 ; LA64-LARGE-NEXT:    add.d $a0, $a1, $a0
 ; LA64-LARGE-NEXT:    ret
 entry:



More information about the llvm-branch-commits mailing list