[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:51 PST 2026


llvmorg-github-actions[bot] wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-backend-loongarch

Author: hev (heiher)

<details>
<summary>Changes</summary>

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

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


3 Files Affected:

- (modified) llvm/lib/Target/LoongArch/LoongArchMergeBaseOffset.cpp (+49-46) 
- (modified) llvm/test/CodeGen/LoongArch/merge-base-offset-fold-large-offset.mir (+12-12) 
- (modified) llvm/test/CodeGen/LoongArch/merge-base-offset.ll (+18-18) 


``````````diff
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:

``````````

</details>


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


More information about the llvm-branch-commits mailing list