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


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

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

>From 67636515ef1bc1203295150176596b0408f54984 Mon Sep 17 00:00:00 2001
From: WANG Rui <wangrui at loongson.cn>
Date: Wed, 4 Nov 2026 10:46:19 +0800
Subject: [PATCH] [LoongArch] Prefer ALSL + LD/ST over SLLI + LDX/STX when the
 address is materialized anyway

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
---
 .../LoongArch/LoongArchISelDAGToDAG.cpp       | 35 +++++++++++++++
 .../Target/LoongArch/LoongArchISelDAGToDAG.h  |  1 +
 .../Target/LoongArch/LoongArchInstrInfo.td    |  9 +++-
 llvm/test/CodeGen/LoongArch/ldx-stx-alsl.ll   | 44 ++++++++-----------
 4 files changed, 62 insertions(+), 27 deletions(-)

diff --git a/llvm/lib/Target/LoongArch/LoongArchISelDAGToDAG.cpp b/llvm/lib/Target/LoongArch/LoongArchISelDAGToDAG.cpp
index 924f360a3ea4db..4d3ac98f24284f 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 ae56e6771bb229..56897959c83b60 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 9363d5581dc944..f2f6eeac873128 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 4b44815aa2d20d..2e8c9faf945e8b 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



More information about the llvm-branch-commits mailing list