[llvm-branch-commits] [llvm] [LoongArch] Prefer ALSL + LD/ST over SLLI + LDX/STX when the address is materialized anyway (PR #238715)

via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Wed Nov 4 00:18:28 PST 2026


llvmorg-github-actions[bot] wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-backend-loongarch

Author: hev (heiher)

<details>
<summary>Changes</summary>

When (add Base, (shl Index, 1..4)) also has users other than the base address of loads/stores, the add is selected as ALSL anyway. Folding it into LDX/STX then needs a separate SLLI for the index, so use the ALSL result with a zero offset instead:

  alsl.d $a2, $a1, $a0, 3        alsl.d $a2, $a1, $a0, 3
  slli.d $a1, $a1, 3       =>    ld.d   $a3, $a2, 0
  ldx.d  $a3, $a0, $a1           ld.d   $a2, $a2, 8
  ld.d   $a2, $a2, 8

rustc-perf fmt-write-str on LA664: 3988.1M -> 3973.1M instructions (-0.38%).

Assisted-By: LLM

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


4 Files Affected:

- (modified) llvm/lib/Target/LoongArch/LoongArchISelDAGToDAG.cpp (+35) 
- (modified) llvm/lib/Target/LoongArch/LoongArchISelDAGToDAG.h (+1) 
- (modified) llvm/lib/Target/LoongArch/LoongArchInstrInfo.td (+7-2) 
- (modified) llvm/test/CodeGen/LoongArch/ldx-stx-alsl.ll (+19-25) 


``````````diff
diff --git a/llvm/lib/Target/LoongArch/LoongArchISelDAGToDAG.cpp b/llvm/lib/Target/LoongArch/LoongArchISelDAGToDAG.cpp
index 924f360a3ea4d..4d3ac98f24284 100644
--- a/llvm/lib/Target/LoongArch/LoongArchISelDAGToDAG.cpp
+++ b/llvm/lib/Target/LoongArch/LoongArchISelDAGToDAG.cpp
@@ -250,6 +250,41 @@ bool LoongArchDAGToDAGISel::SelectAddrConstant(SDValue Addr, SDValue &Base,
   return true;
 }
 
+// Return true if the address (add Base, Index) should be selected as a
+// register-register addressed access. If Index is a shift that ALSL can fold
+// and the address is materialized anyway, e.g. because it is also the base of
+// another access with an offset, accessing it with offset 0 avoids the extra
+// shift instruction for the index of LDX/STX:
+//
+//   alsl.d $a2, $a1, $a0, 4      alsl.d $a2, $a1, $a0, 4
+//   slli.d $a1, $a1, 4      =>   ld.d   $a0, $a2, 0
+//   ldx.d  $a0, $a0, $a1         ld.d   $a1, $a2, 8
+//   ld.d   $a1, $a2, 8
+bool LoongArchDAGToDAGISel::isRegRegAddrProfitable(SDNode *Add) const {
+  auto IsAlslShift = [](SDValue V) {
+    // The shift is needed anyway if it has other users.
+    if (V.getOpcode() != ISD::SHL || !V.hasOneUse())
+      return false;
+    auto *C = dyn_cast<ConstantSDNode>(V.getOperand(1));
+    return C && C->getZExtValue() >= 1 && C->getZExtValue() <= 4;
+  };
+  if (!IsAlslShift(Add->getOperand(0)) && !IsAlslShift(Add->getOperand(1)))
+    return true;
+
+  for (SDNode *User : Add->users()) {
+    if (auto *LD = dyn_cast<LoadSDNode>(User))
+      if (LD->getBasePtr().getNode() == Add && LD->isUnindexed())
+        continue;
+    if (auto *ST = dyn_cast<StoreSDNode>(User))
+      if (ST->getBasePtr().getNode() == Add &&
+          ST->getValue().getNode() != Add && ST->isUnindexed())
+        continue;
+    // The address is materialized for this user.
+    return false;
+  }
+  return true;
+}
+
 bool LoongArchDAGToDAGISel::selectNonFIBaseAddr(SDValue Addr, SDValue &Base) {
   // If this is FrameIndex, don't select it.
   if (isa<FrameIndexSDNode>(Addr))
diff --git a/llvm/lib/Target/LoongArch/LoongArchISelDAGToDAG.h b/llvm/lib/Target/LoongArch/LoongArchISelDAGToDAG.h
index ae56e6771bb22..56897959c83b6 100644
--- a/llvm/lib/Target/LoongArch/LoongArchISelDAGToDAG.h
+++ b/llvm/lib/Target/LoongArch/LoongArchISelDAGToDAG.h
@@ -45,6 +45,7 @@ class LoongArchDAGToDAGISel : public SelectionDAGISel {
   bool SelectBaseAddr(SDValue Addr, SDValue &Base);
   bool SelectAddrConstant(SDValue Addr, SDValue &Base, SDValue &Offset);
   bool selectNonFIBaseAddr(SDValue Addr, SDValue &Base);
+  bool isRegRegAddrProfitable(SDNode *Add) const;
   bool SelectAddrRegImm12(SDValue Addr, SDValue &Base, SDValue &Offset);
 
   bool selectShiftMask(SDValue N, unsigned ShiftWidth, SDValue &ShAmt);
diff --git a/llvm/lib/Target/LoongArch/LoongArchInstrInfo.td b/llvm/lib/Target/LoongArch/LoongArchInstrInfo.td
index 9363d5581dc94..f2f6eeac87312 100644
--- a/llvm/lib/Target/LoongArch/LoongArchInstrInfo.td
+++ b/llvm/lib/Target/LoongArch/LoongArchInstrInfo.td
@@ -2108,10 +2108,15 @@ defm : LdPat<zextloadi32, LD_WU, i64>;
 defm : LdPat<load, LD_D, i64>;
 } // Predicates = [IsLA64]
 
+// The address of a register-register-addressed load or store.
+def AddRegReg : PatFrag<(ops node:$A, node:$B), (add node:$A, node:$B), [{
+  return isRegRegAddrProfitable(N);
+}]>;
+
 // LA64 register-register-addressed loads
 let Predicates = [IsLA64] in {
 class RegRegLdPat<PatFrag LoadOp, LAInst Inst, ValueType vt>
-  : Pat<(vt (LoadOp (add NonFIBaseAddr:$rj, GPR:$rk))),
+  : Pat<(vt (LoadOp (AddRegReg NonFIBaseAddr:$rj, GPR:$rk))),
         (Inst NonFIBaseAddr:$rj, GPR:$rk)>;
 
 def : RegRegLdPat<extloadi8, LDX_B, i64>;
@@ -2162,7 +2167,7 @@ def : Pat<(store (i64 GPR:$rd), (AddLike BaseAddr:$rj, simm14_lsl2:$imm14)),
 let Predicates = [IsLA64] in {
 class RegRegStPat<PatFrag StoreOp, LAInst Inst, RegisterClass StTy,
                   ValueType vt>
-  : Pat<(StoreOp (vt StTy:$rd), (add NonFIBaseAddr:$rj, GPR:$rk)),
+  : Pat<(StoreOp (vt StTy:$rd), (AddRegReg NonFIBaseAddr:$rj, GPR:$rk)),
         (Inst StTy:$rd, NonFIBaseAddr:$rj, GPR:$rk)>;
 
 def : RegRegStPat<truncstorei8, STX_B, GPR, i64>;
diff --git a/llvm/test/CodeGen/LoongArch/ldx-stx-alsl.ll b/llvm/test/CodeGen/LoongArch/ldx-stx-alsl.ll
index 4b44815aa2d20..2e8c9faf945e8 100644
--- a/llvm/test/CodeGen/LoongArch/ldx-stx-alsl.ll
+++ b/llvm/test/CodeGen/LoongArch/ldx-stx-alsl.ll
@@ -7,11 +7,10 @@
 define i64 @load_two_fields(ptr %p, i64 %i) nounwind {
 ; CHECK-LABEL: load_two_fields:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    alsl.d $a2, $a1, $a0, 4
-; CHECK-NEXT:    slli.d $a1, $a1, 4
-; CHECK-NEXT:    ldx.d $a0, $a0, $a1
-; CHECK-NEXT:    ld.d $a1, $a2, 8
-; CHECK-NEXT:    add.d $a0, $a0, $a1
+; CHECK-NEXT:    alsl.d $a0, $a1, $a0, 4
+; CHECK-NEXT:    ld.d $a1, $a0, 0
+; CHECK-NEXT:    ld.d $a0, $a0, 8
+; CHECK-NEXT:    add.d $a0, $a1, $a0
 ; CHECK-NEXT:    ret
   %a = getelementptr inbounds { i64, i64 }, ptr %p, i64 %i, i32 0
   %b = getelementptr inbounds { i64, i64 }, ptr %p, i64 %i, i32 1
@@ -24,10 +23,9 @@ define i64 @load_two_fields(ptr %p, i64 %i) nounwind {
 define void @store_two_fields(ptr %p, i64 %i, i64 %x, i64 %y) nounwind {
 ; CHECK-LABEL: store_two_fields:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    alsl.d $a4, $a1, $a0, 4
-; CHECK-NEXT:    slli.d $a1, $a1, 4
-; CHECK-NEXT:    stx.d $a2, $a0, $a1
-; CHECK-NEXT:    st.d $a3, $a4, 8
+; CHECK-NEXT:    alsl.d $a0, $a1, $a0, 4
+; CHECK-NEXT:    st.d $a2, $a0, 0
+; CHECK-NEXT:    st.d $a3, $a0, 8
 ; CHECK-NEXT:    ret
   %a = getelementptr inbounds { i64, i64 }, ptr %p, i64 %i, i32 0
   %b = getelementptr inbounds { i64, i64 }, ptr %p, i64 %i, i32 1
@@ -39,11 +37,10 @@ define void @store_two_fields(ptr %p, i64 %i, i64 %x, i64 %y) nounwind {
 define i32 @load_two_fields_i32(ptr %p, i64 %i) nounwind {
 ; CHECK-LABEL: load_two_fields_i32:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    alsl.d $a2, $a1, $a0, 3
-; CHECK-NEXT:    slli.d $a1, $a1, 3
-; CHECK-NEXT:    ldx.w $a0, $a0, $a1
-; CHECK-NEXT:    ld.w $a1, $a2, 4
-; CHECK-NEXT:    add.w $a0, $a0, $a1
+; CHECK-NEXT:    alsl.d $a0, $a1, $a0, 3
+; CHECK-NEXT:    ld.w $a1, $a0, 0
+; CHECK-NEXT:    ld.w $a0, $a0, 4
+; CHECK-NEXT:    add.w $a0, $a1, $a0
 ; CHECK-NEXT:    ret
   %a = getelementptr inbounds { i32, i32 }, ptr %p, i64 %i, i32 0
   %b = getelementptr inbounds { i32, i32 }, ptr %p, i64 %i, i32 1
@@ -56,10 +53,9 @@ define i32 @load_two_fields_i32(ptr %p, i64 %i) nounwind {
 define double @load_two_fields_f64(ptr %p, i64 %i) nounwind {
 ; CHECK-LABEL: load_two_fields_f64:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    alsl.d $a2, $a1, $a0, 4
-; CHECK-NEXT:    slli.d $a1, $a1, 4
-; CHECK-NEXT:    fldx.d $fa0, $a0, $a1
-; CHECK-NEXT:    fld.d $fa1, $a2, 8
+; CHECK-NEXT:    alsl.d $a0, $a1, $a0, 4
+; CHECK-NEXT:    fld.d $fa0, $a0, 0
+; CHECK-NEXT:    fld.d $fa1, $a0, 8
 ; CHECK-NEXT:    fadd.d $fa0, $fa0, $fa1
 ; CHECK-NEXT:    ret
   %a = getelementptr inbounds { double, double }, ptr %p, i64 %i, i32 0
@@ -73,10 +69,9 @@ define double @load_two_fields_f64(ptr %p, i64 %i) nounwind {
 define <4 x i32> @load_two_elts_v4i32(ptr %p, i64 %i) nounwind {
 ; CHECK-LABEL: load_two_elts_v4i32:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    alsl.d $a2, $a1, $a0, 4
-; CHECK-NEXT:    slli.d $a1, $a1, 4
-; CHECK-NEXT:    vldx $vr0, $a0, $a1
-; CHECK-NEXT:    vld $vr1, $a2, 16
+; CHECK-NEXT:    alsl.d $a0, $a1, $a0, 4
+; CHECK-NEXT:    vld $vr0, $a0, 0
+; CHECK-NEXT:    vld $vr1, $a0, 16
 ; CHECK-NEXT:    vadd.w $vr0, $vr0, $vr1
 ; CHECK-NEXT:    ret
   %a = getelementptr inbounds <4 x i32>, ptr %p, i64 %i
@@ -91,10 +86,9 @@ define <4 x i32> @load_two_elts_v4i32(ptr %p, i64 %i) nounwind {
 define ptr @load_and_return_addr(ptr %p, i64 %i, ptr %q) nounwind {
 ; CHECK-LABEL: load_and_return_addr:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    slli.d $a3, $a1, 3
-; CHECK-NEXT:    ldx.d $a3, $a0, $a3
 ; CHECK-NEXT:    alsl.d $a0, $a1, $a0, 3
-; CHECK-NEXT:    st.d $a3, $a2, 0
+; CHECK-NEXT:    ld.d $a1, $a0, 0
+; CHECK-NEXT:    st.d $a1, $a2, 0
 ; CHECK-NEXT:    ret
   %a = getelementptr inbounds i64, ptr %p, i64 %i
   %x = load i64, ptr %a

``````````

</details>


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


More information about the llvm-branch-commits mailing list