[AIEX] added full search for global combiners

Author: F-Stuckmann

llvm/lib/Target/AIE/AIEGlobalCombiner.cpp

@@ -211,6 +211,94 @@ std::vector<const GenericCombiner *> CombineCandidates::searchCombinerSet(
   // seed greedy solution
   auto BestSolution = getGreedySolution();
 
+  std::priority_queue<CombinerSolution> PQ;
+  // Add Start Position
+  PQ.emplace(NumCombiner);
+  LLVM_DEBUG(dbgs() << MBB->getName() << " - Initial Search Start "
+                    << BestSolution << "\n");
+
+  // The search algorithm finds the optimal combination of combiners to
+  // maximize gain.  It starts with a greedy solution and iteratively
+  // explores the solution space using a priority queue.
+  //
+  // The Index within the CombinerSolution represents the index of the next
+  // combiner in the Combiners vector to consider. The Index is updated when a
+  // new CombinerSolution is created and pushed onto the priority queue, either
+  // by including the current combiner (Index increments by 1) or skipping it
+  // (Index increments by 1). Including a combiner always guarantees that the
+  // applied combiners are conflict free.
+  //
+  // The search prunes branches that cannot surpass the current best solution,
+  // and prioritizes candidates based on their potential future gain. The
+  // algorithm considers both applying and skipping each combiner to find the
+  // best overall combination. The priority queue ensures that we explore
+  // promising solutions first. When popping an element of the priority queue,
+  // we also remove it from the queue, thereby guaranteeing we don't search the
+  // same solution root twice. The algorithm is exhaustive, limited only by the
+  // maximum number of iterations.
+  int Iteration = 0;
+  while (!PQ.empty() && Iteration < MaxSearchIterationCount) {
+    Iteration++;
+
+    // Get best Candidate to continue searching
+    const CombinerSolution Current = PQ.top();
+    PQ.pop();
+    LLVM_DEBUG(dbgs() << "Search " << Current
+                      << " MaxGain = " << Current.getMaxFutureGain() << "\n");
+
+    // Check if Current has finished the search
+    if (Current.getIndex() == Combiners.size()) {
+      if (Current.getGain() > BestSolution.getGain()) {
+        LLVM_DEBUG(dbgs() << "  [Search] Updated Optimal Combiner " << Current
+                          << "\n");
+        BestSolution = Current;
+      }
+      continue;
+    }
+
+    const GenericCombiner *Candidate = Combiners[Current.getIndex()];
+
+    // Check if search can be stopped for Current
+    const auto PotentialGain = getMaxPotentialGain(Current, Current.getIndex());
+    if (BestSolution.getGain() > PotentialGain) {
+      LLVM_DEBUG(
+          dbgs() << "  [Search] Cannot Surpass BestScore, skipping exploration "
+                 << *Candidate << " Candidate: " << Candidate->getGain()
+                 << " Overlap= "
+                 << Candidate->getOverlapGain(Current.getCombinersBitVector(),
+                                              Combiners)
+                 << " MaxGain = " << PotentialGain << "\n");
+      continue;
+    }
+
+    if (Current.hasConflict(Candidate)) {
+      LLVM_DEBUG(dbgs() << "  Conflict, adding Non-Conflict Variant "
+                        << *Candidate << "Candidate: " << Candidate->getGain()
+                        << "\n");
+    } else {
+      PQ.emplace(Current, Candidate, PotentialGain, Current.getIndex(),
+                 Combiners);
+      LLVM_DEBUG(dbgs() << "  Adding to Stack: " << *Candidate
+                        << "Candidate: " << Candidate->getGain()
+                        << " MaxGain = " << PotentialGain << "\n");
+    }
+
+    // Add a solution where no combiner is applied, if it could Surpass
+    // CurrentBest
+    const auto NoneMaxFutureGain =
+        getMaxPotentialGain(Current, Current.getIndex() + 1);
+    if (BestSolution.getGain() < NoneMaxFutureGain) {
+      LLVM_DEBUG(dbgs() << "  Adding to Stack: None MaxGain = "
+                        << NoneMaxFutureGain << "\n");
+      // Idx is not needed, since we do not apply any Combiner
+      PQ.emplace(Current, nullptr, NoneMaxFutureGain, /*Idx=*/-1, Combiners);
+    }
+  } // end while
+
+  LLVM_DEBUG(dbgs() << "Search Iterations: " << Iteration << "\n");
+  LLVM_DEBUG(dbgs() << "Search Result " << BestSolution.getGain() << "\n");
+
+  // Save best Candidate to FixedCombiners
   std::vector<const GenericCombiner *> Result;
   BitVector CombinerBitVec = BestSolution.getCombinersBitVector();
   for (int Idx = CombinerBitVec.find_first(); Idx != -1;

llvm/test/CodeGen/AIE/GlobalISel/legalize-dyn-stackalloc.ll

@@ -246,36 +246,37 @@ define  void @test_huge_stack(i32 noundef %n) #0 {
 ; AIE2-NEXT:    padda [p7], m0
 ; AIE2-NEXT:    movxm m0, #-40048
 ; AIE2-NEXT:    mov p0, p7
+; AIE2-NEXT:    mov p3, p7
 ; AIE2-NEXT:    mov p2, p7
 ; AIE2-NEXT:    mov p6, p7
+; AIE2-NEXT:    paddb [p3], #-32
 ; AIE2-NEXT:    paddb [p0], m0
-; AIE2-NEXT:    paddb [p6], #-32
-; AIE2-NEXT:    movxm m0, #-40032
 ; AIE2-NEXT:    st r0, [p0, #0]
 ; AIE2-NEXT:    lda r0, [p0, #0]
-; AIE2-NEXT:    paddb [p2], m0
+; AIE2-NEXT:    paddb [p2], #-24
+; AIE2-NEXT:    mov r16, p3
+; AIE2-NEXT:    st r1, [p2, #4]
 ; AIE2-NEXT:    mov p0, sp
-; AIE2-NEXT:    mov r16, p2
-; AIE2-NEXT:    st p0, [p6, #0]
-; AIE2-NEXT:    mov p0, p7
-; AIE2-NEXT:    paddb [p0], #-24
+; AIE2-NEXT:    st p0, [p3, #0]
+; AIE2-NEXT:    mov p0, p1
 ; AIE2-NEXT:    lshl r2, r0, r2
-; AIE2-NEXT:    st r0, [p0], #4
+; AIE2-NEXT:    st r0, [p2, #0]
 ; AIE2-NEXT:    add r2, r2, #31
-; AIE2-NEXT:    st r1, [p0, #0]
+; AIE2-NEXT:    and r2, r2, r3
 ; AIE2-NEXT:    jl #extern_call
-; AIE2-NEXT:    mov p0, p1 // Delay Slot 5
-; AIE2-NEXT:    and r2, r2, r3 // Delay Slot 4
-; AIE2-NEXT:    mov m0, r2 // Delay Slot 3
-; AIE2-NEXT:    paddb [p1], m0 // Delay Slot 2
+; AIE2-NEXT:    mov m0, r2 // Delay Slot 5
+; AIE2-NEXT:    paddb [p1], m0 // Delay Slot 4
+; AIE2-NEXT:    movxm m0, #-40032 // Delay Slot 3
+; AIE2-NEXT:    paddb [p6], m0 // Delay Slot 2
 ; AIE2-NEXT:    mov sp, p1 // Delay Slot 1
 ; AIE2-NEXT:    nopb ; nopa ; nops ; jl #extern_call; nopv
 ; AIE2-NEXT:    nopa ; nopx // Delay Slot 5
 ; AIE2-NEXT:    nop // Delay Slot 4
 ; AIE2-NEXT:    nop // Delay Slot 3
 ; AIE2-NEXT:    nop // Delay Slot 2
-; AIE2-NEXT:    mov p0, r16 // Delay Slot 1
-; AIE2-NEXT:    lda p0, [p6, #0]; nopx
+; AIE2-NEXT:    mov p0, p6 // Delay Slot 1
+; AIE2-NEXT:    nopb ; nopa ; nops ; nopx ; mov p0, r16; nopv
+; AIE2-NEXT:    lda p0, [p0, #0]; nopx
 ; AIE2-NEXT:    nop
 ; AIE2-NEXT:    nop
 ; AIE2-NEXT:    nop
@@ -329,18 +330,18 @@ define  void @test_huge_stack(i32 noundef %n) #0 {
 ; AIE2P-NEXT:    padda [p0], m0
 ; AIE2P-NEXT:    mova m0, #-32
 ; AIE2P-NEXT:    padda [p3], m0
+; AIE2P-NEXT:    mova m0, #-24
 ; AIE2P-NEXT:    st r0, [p0, #0]
 ; AIE2P-NEXT:    lda r0, [p0, #0]
-; AIE2P-NEXT:    mova m0, #-24
 ; AIE2P-NEXT:    mov p0, sp
 ; AIE2P-NEXT:    mov r8, p3
 ; AIE2P-NEXT:    padda [p2], m0
 ; AIE2P-NEXT:    st p0, [p3, #0]
 ; AIE2P-NEXT:    mov p0, p1
+; AIE2P-NEXT:    st r1, [p2, #4]
 ; AIE2P-NEXT:    lshl r2, r0, r2
-; AIE2P-NEXT:    st r0, [p2], #4
+; AIE2P-NEXT:    st r0, [p2, #0]
 ; AIE2P-NEXT:    add r2, r2, #63
-; AIE2P-NEXT:    st r1, [p2, #0]
 ; AIE2P-NEXT:    and r2, r2, r3
 ; AIE2P-NEXT:    jl #extern_call
 ; AIE2P-NEXT:    mov m0, r2 // Delay Slot 5

llvm/test/CodeGen/AIE/GlobalISel/postinc-with-clustering.mir

@@ -19,15 +19,15 @@ body:             |
     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $p0
     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(p0) = COPY $p1
     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s20) = G_CONSTANT i20 4
-    ; CHECK-NEXT: [[AIE_POSTINC_LOAD:%[0-9]+]]:_(s32), [[AIE_POSTINC_LOAD1:%[0-9]+]]:_(p0) = G_AIE_POSTINC_LOAD [[COPY]], [[C]](s20) :: (load (s32))
+    ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(s32) = G_LOAD [[COPY]](p0) :: (load (s32))
     ; CHECK-NEXT: [[C1:%[0-9]+]]:_(s20) = G_CONSTANT i20 8
-    ; CHECK-NEXT: [[AIE_POSTINC_STORE:%[0-9]+]]:_(p0) = G_AIE_POSTINC_STORE [[AIE_POSTINC_LOAD]](s32), [[COPY1]], [[C1]](s20) :: (store (s32))
-    ; CHECK-NEXT: [[C2:%[0-9]+]]:_(s20) = G_CONSTANT i20 8
-    ; CHECK-NEXT: [[AIE_POSTINC_LOAD2:%[0-9]+]]:_(s32), [[AIE_POSTINC_LOAD3:%[0-9]+]]:_(p0) = G_AIE_POSTINC_LOAD [[AIE_POSTINC_LOAD1]], [[C2]](s20) :: (load (s32))
+    ; CHECK-NEXT: [[AIE_POSTINC_STORE:%[0-9]+]]:_(p0) = G_AIE_POSTINC_STORE [[LOAD]](s32), [[COPY1]], [[C1]](s20) :: (store (s32))
+    ; CHECK-NEXT: [[C2:%[0-9]+]]:_(s20) = G_CONSTANT i20 12
+    ; CHECK-NEXT: [[AIE_OFFSET_LOAD:%[0-9]+]]:_(s32) = G_AIE_OFFSET_LOAD [[COPY]](p0), [[C]](s20) :: (load (s32))
+    ; CHECK-NEXT: G_STORE [[AIE_OFFSET_LOAD]](s32), [[AIE_POSTINC_STORE]](p0) :: (store (s32))
     ; CHECK-NEXT: [[C3:%[0-9]+]]:_(s20) = G_CONSTANT i20 8
-    ; CHECK-NEXT: [[AIE_POSTINC_STORE1:%[0-9]+]]:_(p0) = G_AIE_POSTINC_STORE [[AIE_POSTINC_LOAD2]](s32), [[AIE_POSTINC_STORE]], [[C3]](s20) :: (store (s32))
-    ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(s32) = G_LOAD [[AIE_POSTINC_LOAD3]](p0) :: (load (s32))
-    ; CHECK-NEXT: G_STORE [[LOAD]](s32), [[AIE_POSTINC_STORE1]](p0) :: (store (s32))
+    ; CHECK-NEXT: [[AIE_OFFSET_LOAD1:%[0-9]+]]:_(s32) = G_AIE_OFFSET_LOAD [[COPY]](p0), [[C2]](s20) :: (load (s32))
+    ; CHECK-NEXT: G_AIE_OFFSET_STORE [[AIE_OFFSET_LOAD1]](s32), [[AIE_POSTINC_STORE]](p0), [[C3]](s20) :: (store (s32))
     %0:_(p0) = COPY $p0
     %1:_(p0) = COPY $p1
     %2:_(s20) = G_CONSTANT i20 4
@@ -59,15 +59,15 @@ body:             |
     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $p0
     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(p0) = COPY $p1
     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s20) = G_CONSTANT i20 4
-    ; CHECK-NEXT: [[AIE_POSTINC_LOAD:%[0-9]+]]:_(s32), [[AIE_POSTINC_LOAD1:%[0-9]+]]:_(p0) = G_AIE_POSTINC_LOAD [[COPY]], [[C]](s20) :: (load (s32))
+    ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(s32) = G_LOAD [[COPY]](p0) :: (load (s32))
     ; CHECK-NEXT: [[C1:%[0-9]+]]:_(s20) = G_CONSTANT i20 8
-    ; CHECK-NEXT: [[AIE_POSTINC_STORE:%[0-9]+]]:_(p0) = G_AIE_POSTINC_STORE [[AIE_POSTINC_LOAD]](s32), [[COPY1]], [[C1]](s20) :: (store (s32))
-    ; CHECK-NEXT: [[C2:%[0-9]+]]:_(s20) = G_CONSTANT i20 8
-    ; CHECK-NEXT: [[AIE_POSTINC_LOAD2:%[0-9]+]]:_(s32), [[AIE_POSTINC_LOAD3:%[0-9]+]]:_(p0) = G_AIE_POSTINC_LOAD [[AIE_POSTINC_LOAD1]], [[C2]](s20) :: (load (s32))
+    ; CHECK-NEXT: [[AIE_POSTINC_STORE:%[0-9]+]]:_(p0) = G_AIE_POSTINC_STORE [[LOAD]](s32), [[COPY1]], [[C1]](s20) :: (store (s32))
+    ; CHECK-NEXT: [[C2:%[0-9]+]]:_(s20) = G_CONSTANT i20 12
+    ; CHECK-NEXT: [[AIE_OFFSET_LOAD:%[0-9]+]]:_(s32) = G_AIE_OFFSET_LOAD [[COPY]](p0), [[C]](s20) :: (load (s32))
+    ; CHECK-NEXT: G_STORE [[AIE_OFFSET_LOAD]](s32), [[AIE_POSTINC_STORE]](p0) :: (store (s32))
     ; CHECK-NEXT: [[C3:%[0-9]+]]:_(s20) = G_CONSTANT i20 8
-    ; CHECK-NEXT: [[AIE_POSTINC_STORE1:%[0-9]+]]:_(p0) = G_AIE_POSTINC_STORE [[AIE_POSTINC_LOAD2]](s32), [[AIE_POSTINC_STORE]], [[C3]](s20) :: (store (s32))
-    ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(s32) = G_LOAD [[AIE_POSTINC_LOAD3]](p0) :: (load (s32))
-    ; CHECK-NEXT: G_STORE [[LOAD]](s32), [[AIE_POSTINC_STORE1]](p0) :: (store (s32))
+    ; CHECK-NEXT: [[AIE_OFFSET_LOAD1:%[0-9]+]]:_(s32) = G_AIE_OFFSET_LOAD [[COPY]](p0), [[C2]](s20) :: (load (s32))
+    ; CHECK-NEXT: G_AIE_OFFSET_STORE [[AIE_OFFSET_LOAD1]](s32), [[AIE_POSTINC_STORE]](p0), [[C3]](s20) :: (store (s32))
     %0:_(p0) = COPY $p0
     %1:_(p0) = COPY $p1
     %2:_(s20) = G_CONSTANT i20 4
@@ -119,15 +119,15 @@ body:             |
     ; CHECK-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $p0
     ; CHECK-NEXT: [[COPY1:%[0-9]+]]:_(p0) = COPY $p1
     ; CHECK-NEXT: [[C:%[0-9]+]]:_(s20) = G_CONSTANT i20 4
-    ; CHECK-NEXT: [[AIE_POSTINC_LOAD:%[0-9]+]]:_(s32), [[AIE_POSTINC_LOAD1:%[0-9]+]]:_(p0) = G_AIE_POSTINC_LOAD [[COPY]], [[C]](s20) :: (load (s32))
+    ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(s32) = G_LOAD [[COPY]](p0) :: (load (s32))
     ; CHECK-NEXT: [[C1:%[0-9]+]]:_(s20) = G_CONSTANT i20 8
-    ; CHECK-NEXT: [[AIE_POSTINC_STORE:%[0-9]+]]:_(p0) = G_AIE_POSTINC_STORE [[AIE_POSTINC_LOAD]](s32), [[COPY1]], [[C1]](s20) :: (store (s32))
-    ; CHECK-NEXT: [[C2:%[0-9]+]]:_(s20) = G_CONSTANT i20 8
-    ; CHECK-NEXT: [[AIE_POSTINC_LOAD2:%[0-9]+]]:_(s32), [[AIE_POSTINC_LOAD3:%[0-9]+]]:_(p0) = G_AIE_POSTINC_LOAD [[AIE_POSTINC_LOAD1]], [[C2]](s20) :: (load (s32))
+    ; CHECK-NEXT: [[AIE_POSTINC_STORE:%[0-9]+]]:_(p0) = G_AIE_POSTINC_STORE [[LOAD]](s32), [[COPY1]], [[C1]](s20) :: (store (s32))
+    ; CHECK-NEXT: [[C2:%[0-9]+]]:_(s20) = G_CONSTANT i20 12
+    ; CHECK-NEXT: [[AIE_OFFSET_LOAD:%[0-9]+]]:_(s32) = G_AIE_OFFSET_LOAD [[COPY]](p0), [[C]](s20) :: (load (s32))
+    ; CHECK-NEXT: G_STORE [[AIE_OFFSET_LOAD]](s32), [[AIE_POSTINC_STORE]](p0) :: (store (s32))
     ; CHECK-NEXT: [[C3:%[0-9]+]]:_(s20) = G_CONSTANT i20 8
-    ; CHECK-NEXT: [[AIE_POSTINC_STORE1:%[0-9]+]]:_(p0) = G_AIE_POSTINC_STORE [[AIE_POSTINC_LOAD2]](s32), [[AIE_POSTINC_STORE]], [[C3]](s20) :: (store (s32))
-    ; CHECK-NEXT: [[LOAD:%[0-9]+]]:_(s32) = G_LOAD [[AIE_POSTINC_LOAD3]](p0) :: (load (s32))
-    ; CHECK-NEXT: G_STORE [[LOAD]](s32), [[AIE_POSTINC_STORE1]](p0) :: (store (s32))
+    ; CHECK-NEXT: [[AIE_OFFSET_LOAD1:%[0-9]+]]:_(s32) = G_AIE_OFFSET_LOAD [[COPY]](p0), [[C2]](s20) :: (load (s32))
+    ; CHECK-NEXT: G_AIE_OFFSET_STORE [[AIE_OFFSET_LOAD1]](s32), [[AIE_POSTINC_STORE]](p0), [[C3]](s20) :: (store (s32))
     %0:_(p0) = COPY $p0
     %1:_(p0) = COPY $p1
     %2:_(s20) = G_CONSTANT i20 4

llvm/test/CodeGen/AIE/aie2/GlobalISel/prologepilog-tail-call-opt.ll

@@ -40,8 +40,8 @@ define dso_local void @_Z5test2PPv(ptr nocapture readonly %args) local_unnamed_a
   ; CHECK: bb.0.entry:
   ; CHECK-NEXT:   liveins: $p0
   ; CHECK-NEXT: {{  $}}
-  ; CHECK-NEXT:   renamable $p1, renamable $p0 = LDA_dms_lda_pstm_nrm_imm killed renamable $p0, 4 :: (load (p0) from %ir.args, align 4)
-  ; CHECK-NEXT:   renamable $p0 = LDA_dms_lda_idx_imm killed renamable $p0, 0 :: (load (p0) from %ir.arrayidx1, align 4)
+  ; CHECK-NEXT:   renamable $p1 = LDA_dms_lda_idx_imm renamable $p0, 0 :: (load (p0) from %ir.args, align 4)
+  ; CHECK-NEXT:   renamable $p0 = LDA_dms_lda_idx_imm killed renamable $p0, 4 :: (load (p0) from %ir.arrayidx1, align 4)
   ; CHECK-NEXT:   renamable $r1 = LDA_dms_lda_idx_imm killed renamable $p1, 0 :: (load (s32) from %ir.0)
   ; CHECK-NEXT:   renamable $r2 = LDA_dms_lda_idx_imm killed renamable $p0, 0 :: (load (s32) from %ir.2)
   ; CHECK-NEXT:   PseudoJ_TCO_jump_imm @_Z4funcii, csr_aie2, implicit $r1, implicit $r2

llvm/test/CodeGen/AIE/aie2/conv2d_offset_test.ll

@@ -20,29 +20,31 @@ define dso_local noundef i32 @_Z3foov() #0 {
 ; CHECK-LABEL: _Z3foov:
 ; CHECK:         .p2align 4
 ; CHECK-NEXT:  // %bb.0: // %entry
-; CHECK-NEXT:    nopb ; nopa ; nops ; movxm p0, #(X+92); nopv
-; CHECK-NEXT:    mova dj0, #96
-; CHECK-NEXT:    lda.u8 r1, [p0, dj0]
-; CHECK-NEXT:    mova dj0, #-68
-; CHECK-NEXT:    lda r0, [p0, #8]
-; CHECK-NEXT:    lda r1, [p0, #0]
-; CHECK-NEXT:    lda.u16 r1, [p0, dj0]
-; CHECK-NEXT:    mova dj0, #-56
-; CHECK-NEXT:    lda.u8 r1, [p0, dj0]
+; CHECK-NEXT:    nop ; movxm p1, #(X+92)
+; CHECK-NEXT:    mova m0, #-164
+; CHECK-NEXT:    mov p0, p1
+; CHECK-NEXT:    paddb [p0], #8
+; CHECK-NEXT:    lda r0, [p0], #88
+; CHECK-NEXT:    lda.u8 r1, [p0], m0
+; CHECK-NEXT:    mova m0, #12
+; CHECK-NEXT:    lda r1, [p1, #0]
+; CHECK-NEXT:    lda.u16 r1, [p0], m0
+; CHECK-NEXT:    mova m0, #60
+; CHECK-NEXT:    lda.u8 r1, [p0], m0
 ; CHECK-NEXT:    nop
-; CHECK-NEXT:    lda r1, [p0, #4]
+; CHECK-NEXT:    lda r1, [p0], #76
 ; CHECK-NEXT:    add r0, r0, r1
 ; CHECK-NEXT:    add r0, r0, r1
 ; CHECK-NEXT:    nop
 ; CHECK-NEXT:    add r0, r0, r1
 ; CHECK-NEXT:    add r0, r0, r1
-; CHECK-NEXT:    lda r1, [p0, #80]
+; CHECK-NEXT:    lda r1, [p0], #12
 ; CHECK-NEXT:    add r0, r0, r1
-; CHECK-NEXT:    lda r1, [p0, #92]
-; CHECK-NEXT:    lda r1, [p0, #44]
-; CHECK-NEXT:    lda r1, [p0, #8]
-; CHECK-NEXT:    lda r1, [p0, #76]
-; CHECK-NEXT:    lda r1, [p0, #-60]
+; CHECK-NEXT:    lda r1, [p0], #-48
+; CHECK-NEXT:    lda r1, [p0], #32
+; CHECK-NEXT:    lda r1, [p1, #8]
+; CHECK-NEXT:    lda r1, [p0], #-136
+; CHECK-NEXT:    lda r1, [p0, #0]
 ; CHECK-NEXT:    add r0, r0, r1
 ; CHECK-NEXT:    ret lr
 ; CHECK-NEXT:    add r0, r0, r1 // Delay Slot 5