[AArch64] Favor pre-increments and implement TTI::getPreferredAddressingMode

[SjoerdMeijer]

Summary

We are missing an opportunity to generate more efficient addressing modes, preindexed loads/stores, which avoids increments of pointers with separate add instructions. This implements target hook getPreferredAddressingMode for AArch64, which is queried in LoopStrengthReduce that can bring loops in a better form to generate pre-increments.

[samparker]

How about results from the LLVM test suite? This should benefit size and performance?

[dmgreen]

So far as we have used it, this option mean "aggressively optimizer for postincs". That is useful for MVE where not using postinc's in loops can have a significant effect on performance. AArch64 I'm less sure about, but it might make sense. The option tends to make loops use more registers, which might be OK on an architecture with a lot of registers.

Which improves one benchmark with 1.2%, and didn't show any changes in another which I also didn't expect to be impacted (just checking as a sanity check).

Does this mean you've ran 2 benchmarks? What does SPEC or the llvm test suite say?

[SjoerdMeijer]

Cheers guys, that's fair, will give the llvm test suite a try too.

[SjoerdMeijer]

I've ran CTMark and filter out the test that run very shortly with --filter-short and see the same trend, i.e. no regressions and some okay improvements:

Tests: 10
Short Running: 4 (filtered out)
Remaining: 6
Metric: exec_time
Program                                        before after  diff 
 test-suite :: CTMark/lencod/lencod.test         8.57   8.58  0.0%
 test-suite...Mark/mafft/pairlocalalign.test    56.49  56.46 -0.0%
 test-suite...TMark/7zip/7zip-benchmark.test    10.23  10.15 -0.7%
 test-suite...:: CTMark/sqlite3/sqlite3.test     3.93   3.90 -0.8%
 test-suite :: CTMark/Bullet/bullet.test        10.17  10.01 -1.6%
 test-suite :: CTMark/SPASS/SPASS.test          26.04  25.09 -3.7%
 Geomean difference                                          -1.1%
          before      after      diff
count  6.000000   6.000000   6.000000
mean   19.238417  19.031417 -0.011363
std    19.723614  19.679435  0.013708
min    3.933800   3.901200  -0.036644
25%    8.971825   8.934025  -0.013844
50%    10.198600  10.080500 -0.007888
75%    22.087150  21.352350 -0.002162
max    56.486600  56.464800  0.000327

[dmgreen]

How many runs was that? How much noise is there?

It's encouraging at least. Can you run SPEC too? Tamar has a good low-noise system. This isn't a small change to be taken lightly, even if the patch is small in number of lines changed.

[SjoerdMeijer]

Just curious if there's something in particular you are concerned about? I am just asking because then I can focus on that.

I have rerun experiment and instead of 5 runs I am comparing 10 runs by taking the minimum runtime of each of the runs in this way:

../test-suite/utils/compare.py --filter-short before.1.json before.2.json before.3.json before.4.json before.5.json before.6.json before.7.json before.8.json before.9.json before.10.json vs after.1.json after.2.json after.3.json after.4.json after.5.json after.6.json after.7.json after.8.json after.9.json after.10.json

This gives:

Tests: 10
Short Running: 4 (filtered out)
Remaining: 6
Metric: exec_time
Program                                        lhs    rhs    diff 
 test-suite...Mark/mafft/pairlocalalign.test    56.41  56.48  0.1%
 test-suite :: CTMark/Bullet/bullet.test         9.99   9.98 -0.0%
 test-suite :: CTMark/SPASS/SPASS.test          25.11  25.08 -0.1%
 test-suite :: CTMark/lencod/lencod.test         8.58   8.57 -0.2%
 test-suite...TMark/7zip/7zip-benchmark.test    10.16  10.11 -0.4%
 test-suite...:: CTMark/sqlite3/sqlite3.test     3.86   3.84 -0.5%
 Geomean difference                                          -0.2%
             lhs        rhs      diff
count  6.000000   6.000000   6.000000
mean   19.016133  19.009183 -0.001906
std    19.665927  19.699874  0.002340
min    3.858400   3.839700  -0.004847
25%    8.933775   8.919975  -0.003747
50%    10.071450  10.047500 -0.001556
75%    21.368850  21.336775 -0.000573
max    56.406300  56.476400  0.001243

[SjoerdMeijer]

Ah wait a minute, I am doing the last experiment again, just double checking if I haven't make mistake running them

[SjoerdMeijer]

Okay, so my last results basically shows the noise as I had forgotten to do a rebuild between the runs. Now results look less convincing....looking into it.

[fhahn]

In D89693#2342476, @SjoerdMeijer wrote:

Okay, so my last results basically shows the noise as I had forgotten to do a rebuild between the runs. Now results look less convincing....looking into it.

FWIW the CTmark subset runs for quite a short time on beefier cores, so it might be good to also do some SPEC runs.

[SjoerdMeijer]

Yep, cheers, hopefully SPEC is better and more conclusive. The 1.2% uplift in one benchmark was on baremetal aarch64, will check if I can run some more things on that too.

[SjoerdMeijer]

SPECInt numbers:

500.perlbench_r	-0.36%
502.gcc_r	 0.25%
505.mcf_r	-0.23%
520.omnetpp_r	-0.16%
523.xalancbmk_r	-0.48%
525.x264_r	 1.38%
531.deepsjeng_r	-0.20%
541.leela_r	-0.11%
548.exchange2_r	 0.01%
557.xz_r	-0.03%

These are runtime reduction in percentage, so negative is good, postive number is a regression.
Overall, a small win, does what I want, except that 525.x264 is a bit of a negative outlier that makes things less rosy, and needs looking into.
And also need to look what Sam has cooked up in D89894....

[dmgreen]

Those numbers don't look too bad, but like you say it's probably worth looking into what x264_r is doing, just to see what is going on. Sanne ran some other numbers from the burst compiler and they were about the same - some small improvements, a couple of small losses but overall OK. That gives us confidence that big out of order cores are not going to hate this.

The original tests were on an in-order core I believe? Which from the optimization guide looks like it should be sensible to use. And the option doesn't seem to be messing anything up especially.

Can you add a test for vector postincs, the kind of thing that you would get in a loop? I only see changes for scalars here.

llvm/test/CodeGen/AArch64/shrink-wrapping-vla.ll

89

How is this test changing? Just the initial operand for the add?

[SjoerdMeijer]

In D89693#2346568, @dmgreen wrote:

Those numbers don't look too bad, but like you say it's probably worth looking into what x264_r is doing, just to see what is going on. Sanne ran some other numbers from the burst compiler and they were about the same - some small improvements, a couple of small losses but overall OK. That gives us confidence that big out of order cores are not going to hate this.

The original tests were on an in-order core I believe? Which from the optimization guide looks like it should be sensible to use. And the option doesn't seem to be messing anything up especially.

I analysed x264 and couldn't find any concerning codegen changes in the top 6 hottest functions in the profile. Then, I did more runs and concluded I must have been looking at noise (again) as I don't see that 1.38% regression anymore. It is more like 0.5% if it happens. Overall, my conclusion is in line with yours: this change is neutral on bigger cores worst case, but probably a small gain, and indeed in my first experiment on an in-order core I see decent speed-ups. Intuitively this makes sense, because probably the bigger ooo cores can deal better with inefficient code, while the smaller ones are more sensitive for this and an optimisation has more effect. While looking at x264, I did observe this for some cases:

The option tends to make loops use more registers,

I saw some more registers being used in preheaders to setup pointers, but then didn't seem to affect the loop.

Can you add a test for vector postincs, the kind of thing that you would get in a loop? I only see changes for scalars here.

Cheers, will look at this now.

[SjoerdMeijer]

I wanted to abandon this change in favour of D89894. The reason is that D89894 works for unrolled loops, and this change doesn't. But D89894 doesn't really work when things haven't been unrolled, so I think there's actually value in having them both, and I will progress that.

This means shouldFavorPostInc() would need to make a decision if it is working on unrolled loops or not, but the current interface doesn't allow that:

/// \return True is LSR should make efforts to create/preserve post-inc
/// addressing mode expressions.
bool shouldFavorPostInc() const;
/// Return true if LSR should make efforts to generate indexed addressing
/// modes that operate across loop iterations.
bool shouldFavorBackedgeIndex(const Loop *L) const;

I will first make shouldFavorPostInc consistent with shouldFavorBackedgeIndex to accept Loop *L as an argument, so that we can look at its induction variable and step size.
After that interface change, I will then continue here to implement that.

[samparker]

Sounds good. How about unifying it to one call to get the type of preferred indexing: none, pre and post?

[SjoerdMeijer]

In D89693#2559369, @samparker wrote:

Sounds good. How about unifying it to one call to get the type of preferred indexing: none, pre and post?

That would be best, agreed, as it's quite incomprehensible at the moment what things are and how they interact.

I will see if I can first refactor this into 1 call.

[dmgreen]

Ideally LSR would account for the pre/postinc in its cost modelling and automatically pick the correct one. The shouldFavorPostInc would work on top of that to more consistently produce postinc in cases like MVE where they are so beneficial. But until that happens this sounds like a fine plan. And we can probably use the same thing to do something better under MVE, where not all loops are vector loops, after all.

If it is doing any real amount of processing on the loop, it will need to be calling shouldFavorPostInc less, caching the result somewhere for the loop.

[SjoerdMeijer]

This is now "rebased" on the changes that introduced getPreferredAddressingMode, see also the updated title/description of this change.

I have rerun numbers and not much has fundamentally changed: this is a good thing to do. The only new insight is that if we also start doing runtime loop unrolling, the picture change. In that case, preindexed addressing modes are better. But with getPreferredAddressingMode now in place, we can easily adapt to that (see also my comment in the implementation of getPreferredAddressingMode) when we start doing that, which is what we will be looking into next.

[fhahn]

llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp

1287

What if the loop has multiple induction phis and one of those has a large constant step or unknown step? Should we instead iterate over all phis and check all induction phis (using InductionDescriptor::isInductionPHI to identify them)?

[SjoerdMeijer]

llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp

1287

Yeah, I thought about that a bit. I don't think we are interested in all induction phis here. I think we are interested in what is called the PrimaryInduction in the loop vectoriser, i.e. the one that actually controls the loop. And this seems to match exactly with what getInductionVariable() promises to return, which is used by getInductionDescriptor. That's why this looked okay to me...

[fhahn]

llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp

1287

I am not sure I completely understand why the IV that controls the loop is special when it comes to picking the addressing mode for the loop? As : D97050 indicates, getInductionVariable is quite brittle and probably misses additional cases, so if we can avoid using it the code should be more robust.

If we have multiple IVs, would we not be interested if we can use post-increments for all of the ones that access memory? You could have a loop with 2 IVs, one to control the loop and one to access memory, like below. If we use the offset of the IV controlling the loop, post-index is profitable, but there won't be any accesses for that variable. (in this example, the inductions can probably be simplified to a single one, but it keeps things simple)

int I=0, J=0;

while (I != N) {
  Ptr[J] = 0;
  I++;
 J += 2000;
}

[SjoerdMeijer]

llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp

1287

Ah, okay, I misunderstood but understand your point now! So your suggestion is if we need a more fine-grained (precise) heuristic.

I would need to give this some more thoughts, but the current heuristic is based on the distinction between unrolled loops not not unrolled loops (which is why I use the primary IV) which is a simple heuristic that seems to work. In general, I think this is quite a difficult problem, given that there are a few addressing modes and potentially quite some inductions to analyse. This will come at a cost, and it's unclear at the point if it will improve results.

I have verified that the implementation in D89894 works (for runtime unrolled loops), but that indeed reveals an inefficiency (missed opportunity) in the load store optimiser as noted there, which means we can't use that yet for enabling pre-indexed accesses. But perhaps I can use that heuristic, which does a bit more analysis, to decide when *not* to generate pre-indexed but post-indexed accesses.

But this slightly improved heuristic in D89894 may still not be precise enough for your liking... I will try to experiment a little bit with that, but at the moment I tend to think that this is a step forward, and this could be improved when we find the need for that?

[SjoerdMeijer]

This abandons the idea of looking at the IV, and incorporates D89894 to look at the pointer uses.

[dmgreen]

llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp

1293

I'm not sure I understand this logic. Won't it detect many things that are not unrolled loops? Why does it start at 0?

I think it's worth added a few deliberate tests for the different cases this is trying to optimize. Some for simple loops, more complex unrolled loops and vectorized/interleaved loops. Showing how the codegen has changed now that we change this default option.

llvm/test/CodeGen/AArch64/vldn_shuffle.ll

2–4

I don't think we should be adding this to unrelated tests if we can help it. For tests like this that are testing something else, it's OK to just check the default.

Same for all the other tests. From what I can tell they seem the same or better?

[SjoerdMeijer]

Thanks for commenting Dave. I will have another go at this, and try to come up with a better analysis, at least one we understand.

[SjoerdMeijer]

This is changing our approach to preferring pre-indexed addressing modes, because:

• this what we want for runtime unrolled loops, which is what we want to address next,
• post indexed is currently better for some cases, but that's mainly cause because we miss an opportunity in the load/store optimiser. With that fixed, expectation is that pre-indexed gives the same or better perf than post-indexed.
• for what it is worth, pre-indexed is also the default for ARM,

And as a consequence of the above, this implementation becomes really straightforward, which is another benefit.
But again, we can't commit this yet, because it depends on changes in the load/store optimiser which we will address first.

[SjoerdMeijer]

This depends on D99272.

llvm/lib/Target/AArch64/AArch64TargetTransformInfo.h

bool isLegalToVectorizeReduction(RecurrenceDescriptor RdxDesc,
                                    ElementCount VF) const;
 
   int getArithmeticReductionCost(unsigned Opcode, VectorType *Ty,
                                  bool IsPairwiseForm,
                                  TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput);
 
   int getShuffleCost(TTI::ShuffleKind Kind, VectorType *Tp, int Index,
                      VectorType *SubTp);
+
+  TTI::AddressingModeKind getPreferredAddressingMode(const Loop *L,
+                                                     ScalarEvolution *SE) const;
+
   /// @}
 };
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_TARGET_AARCH64_AARCH64TARGETTRANSFORMINFO_H

llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp

 //===-- AArch64TargetTransformInfo.cpp - AArch64 specific TTI -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "AArch64TargetTransformInfo.h"
 #include "AArch64ExpandImm.h"
 #include "MCTargetDesc/AArch64AddressingModes.h"
+#include "llvm/Analysis/IVDescriptors.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/CodeGen/BasicTTIImpl.h"
 #include "llvm/CodeGen/CostTable.h"
 #include "llvm/CodeGen/TargetLowering.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/IntrinsicsAArch64.h"
 #include "llvm/IR/PatternMatch.h"
if (Kind == TTI::SK_Broadcast || Kind == TTI::SK_Transpose ||
     };
     std::pair<int, MVT> LT = TLI->getTypeLegalizationCost(DL, Tp);
     if (const auto *Entry = CostTableLookup(ShuffleTbl, Kind, LT.second))
       return LT.first * Entry->Cost;
   }
 
   return BaseT::getShuffleCost(Kind, Tp, Index, SubTp);
 }
+
+TTI::AddressingModeKind
+AArch64TTIImpl::getPreferredAddressingMode(const Loop *L,
+                                           ScalarEvolution *SE) const {
+  InductionDescriptor IndDesc;
+  if (!L->getInductionDescriptor(*SE, IndDesc))
+    return TTI::AMK_None;
+
+  ConstantInt *CI = IndDesc.getConstIntStepValue();
+  if (!CI)
+    return TTI::AMK_None;
+
+  // With runtime loop unrolling disabled, PostIndexed addressing modes give
+  // better results. This heuristic checks if the loop induction variable
+  // update is 16 or less, which means that vectorisation could have been
+  // applied (with a vectorisation factor of up to 16), but no further runtime
+  // unrolling, in which case the loop IV update would be bigger than 16.
+  if (CI->getZExtValue() <= 16)
+    return TTI::AMK_PostIndexed;
+
+  // TODO: With runtime loop unrolling enabled, PreIndexed addressing modes give
+  // better results. But we need to enable runtime unrolling first and then
+  // get some more data on this, so return AMK_None for now.
+  return TTI::AMK_None;
+}

llvm/test/CodeGen/AArch64/ragreedy-local-interval-cost.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc -mtriple=aarch64-arm-none-eabi < %s | FileCheck %s
 
 @A = external dso_local local_unnamed_addr global [8 x [8 x i64]], align 8
 @B = external dso_local local_unnamed_addr global [8 x [8 x i64]], align 8
 @C = external dso_local local_unnamed_addr global [8 x [8 x i64]], align 8
 
 define dso_local void @run_test() local_unnamed_addr #0 {
 ; CHECK-LABEL: run_test:
 ; CHECK:       // %bb.0: // %entry
-; CHECK-NEXT:    sub sp, sp, #80 // =80
-; CHECK-NEXT:    stp d15, d14, [sp, #16] // 16-byte Folded Spill
-; CHECK-NEXT:    stp d13, d12, [sp, #32] // 16-byte Folded Spill
-; CHECK-NEXT:    stp d11, d10, [sp, #48] // 16-byte Folded Spill
-; CHECK-NEXT:    stp d9, d8, [sp, #64] // 16-byte Folded Spill
-; CHECK-NEXT:    .cfi_def_cfa_offset 80
+; CHECK-NEXT:    stp d15, d14, [sp, #-64]! // 16-byte Folded Spill
+; CHECK-NEXT:    stp d13, d12, [sp, #16] // 16-byte Folded Spill
+; CHECK-NEXT:    stp d11, d10, [sp, #32] // 16-byte Folded Spill
+; CHECK-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
+; CHECK-NEXT:    .cfi_def_cfa_offset 64
 ; CHECK-NEXT:    .cfi_offset b8, -8
 ; CHECK-NEXT:    .cfi_offset b9, -16
 ; CHECK-NEXT:    .cfi_offset b10, -24
 ; CHECK-NEXT:    .cfi_offset b11, -32
 ; CHECK-NEXT:    .cfi_offset b12, -40
 ; CHECK-NEXT:    .cfi_offset b13, -48
 ; CHECK-NEXT:    .cfi_offset b14, -56
 ; CHECK-NEXT:    .cfi_offset b15, -64
+; CHECK-NEXT:    adrp x9, A+128
 ; CHECK-NEXT:    adrp x10, B+48
-; CHECK-NEXT:    adrp x11, A
 ; CHECK-NEXT:    mov x8, xzr
-; CHECK-NEXT:    mov x9, xzr
 ; CHECK-NEXT:    movi v0.2d, #0000000000000000
+; CHECK-NEXT:    add x9, x9, :lo12:A+128
 ; CHECK-NEXT:    add x10, x10, :lo12:B+48
-; CHECK-NEXT:    add x11, x11, :lo12:A
-; CHECK-NEXT:    str q0, [sp] // 16-byte Folded Spill
+; CHECK-NEXT:    mov w11, #8
 ; CHECK-NEXT:    // implicit-def: $q1
 ; CHECK-NEXT:    // implicit-def: $q2
 ; CHECK-NEXT:    // implicit-def: $q3
 ; CHECK-NEXT:    // implicit-def: $q4
 ; CHECK-NEXT:    // implicit-def: $q5
 ; CHECK-NEXT:    // implicit-def: $q6
 ; CHECK-NEXT:    // implicit-def: $q7
 ; CHECK-NEXT:    // implicit-def: $q16

 ; CHECK-NEXT:    // implicit-def: $q8
 ; CHECK-NEXT:    // implicit-def: $q9
 ; CHECK-NEXT:    // implicit-def: $q10
 ; CHECK-NEXT:    // implicit-def: $q11
 ; CHECK-NEXT:    // implicit-def: $q12
 ; CHECK-NEXT:    // implicit-def: $q13
 ; CHECK-NEXT:  .LBB0_1: // %for.cond1.preheader
 ; CHECK-NEXT:    // =>This Inner Loop Header: Depth=1
-; CHECK-NEXT:    mov x12, xzr
+; CHECK-NEXT:    mov x13, xzr
+; CHECK-NEXT:    ldr q14, [x13]
 ; CHECK-NEXT:    ldr q15, [x8]
-; CHECK-NEXT:    ldr q14, [x12]
-; CHECK-NEXT:    ldr q0, [x10], #64
-; CHECK-NEXT:    ldr x18, [x12]
-; CHECK-NEXT:    fmov x15, d15
-; CHECK-NEXT:    mov x14, v15.d[1]
-; CHECK-NEXT:    fmov x13, d14
-; CHECK-NEXT:    mul x1, x15, x18
-; CHECK-NEXT:    mov x16, v0.d[1]
-; CHECK-NEXT:    fmov x17, d0
-; CHECK-NEXT:    fmov d0, x1
-; CHECK-NEXT:    mul x1, x14, x18
+; CHECK-NEXT:    subs x11, x11, #1 // =1
 ; CHECK-NEXT:    mov x12, v14.d[1]
-; CHECK-NEXT:    ldr x0, [x8]
-; CHECK-NEXT:    mov v0.d[1], x1
-; CHECK-NEXT:    mul x1, x13, x18
-; CHECK-NEXT:    add v12.2d, v12.2d, v0.2d
-; CHECK-NEXT:    fmov d0, x1
-; CHECK-NEXT:    mul x1, x12, x18
-; CHECK-NEXT:    mov v0.d[1], x1
-; CHECK-NEXT:    mul x1, x17, x18
-; CHECK-NEXT:    add v13.2d, v13.2d, v0.2d
-; CHECK-NEXT:    add v11.2d, v11.2d, v0.2d
-; CHECK-NEXT:    fmov d0, x1
-; CHECK-NEXT:    mul x18, x16, x18
-; CHECK-NEXT:    ldr q14, [sp] // 16-byte Folded Reload
-; CHECK-NEXT:    mov v0.d[1], x18
-; CHECK-NEXT:    mul x18, x15, x0
-; CHECK-NEXT:    add x1, x11, x8
-; CHECK-NEXT:    add v10.2d, v10.2d, v0.2d
-; CHECK-NEXT:    fmov d0, x18
-; CHECK-NEXT:    mul x18, x14, x0
-; CHECK-NEXT:    ldr x1, [x1, #128]
-; CHECK-NEXT:    mov v0.d[1], x18
-; CHECK-NEXT:    mul x18, x13, x0
-; CHECK-NEXT:    add v8.2d, v8.2d, v0.2d
-; CHECK-NEXT:    add v25.2d, v25.2d, v0.2d
-; CHECK-NEXT:    add v22.2d, v22.2d, v0.2d
-; CHECK-NEXT:    add v18.2d, v18.2d, v0.2d
-; CHECK-NEXT:    add v6.2d, v6.2d, v0.2d
-; CHECK-NEXT:    add v14.2d, v14.2d, v0.2d
-; CHECK-NEXT:    fmov d0, x18
-; CHECK-NEXT:    mul x18, x12, x0
-; CHECK-NEXT:    mov v0.d[1], x18
-; CHECK-NEXT:    mul x18, x17, x0
-; CHECK-NEXT:    mul x0, x16, x0
-; CHECK-NEXT:    add v9.2d, v9.2d, v0.2d
-; CHECK-NEXT:    add v31.2d, v31.2d, v0.2d
-; CHECK-NEXT:    add v26.2d, v26.2d, v0.2d
-; CHECK-NEXT:    add v23.2d, v23.2d, v0.2d
-; CHECK-NEXT:    add v21.2d, v21.2d, v0.2d
-; CHECK-NEXT:    add v19.2d, v19.2d, v0.2d
-; CHECK-NEXT:    add v17.2d, v17.2d, v0.2d
-; CHECK-NEXT:    add v7.2d, v7.2d, v0.2d
-; CHECK-NEXT:    add v5.2d, v5.2d, v0.2d
-; CHECK-NEXT:    add v3.2d, v3.2d, v0.2d
-; CHECK-NEXT:    add v2.2d, v2.2d, v0.2d
-; CHECK-NEXT:    fmov d0, x18
-; CHECK-NEXT:    mul x15, x15, x1
-; CHECK-NEXT:    mov v0.d[1], x0
-; CHECK-NEXT:    mul x14, x14, x1
-; CHECK-NEXT:    add v30.2d, v30.2d, v0.2d
-; CHECK-NEXT:    add v24.2d, v24.2d, v0.2d
-; CHECK-NEXT:    add v20.2d, v20.2d, v0.2d
-; CHECK-NEXT:    add v16.2d, v16.2d, v0.2d
-; CHECK-NEXT:    add v4.2d, v4.2d, v0.2d
-; CHECK-NEXT:    add v1.2d, v1.2d, v0.2d
-; CHECK-NEXT:    fmov d0, x15
-; CHECK-NEXT:    mul x13, x13, x1
-; CHECK-NEXT:    mov v0.d[1], x14
-; CHECK-NEXT:    mul x12, x12, x1
-; CHECK-NEXT:    add v29.2d, v29.2d, v0.2d
-; CHECK-NEXT:    fmov d0, x13
-; CHECK-NEXT:    mul x17, x17, x1
-; CHECK-NEXT:    mov v0.d[1], x12
-; CHECK-NEXT:    mul x16, x16, x1
-; CHECK-NEXT:    add v28.2d, v28.2d, v0.2d
-; CHECK-NEXT:    fmov d0, x17
-; CHECK-NEXT:    mov v0.d[1], x16
-; CHECK-NEXT:    add x8, x8, #8 // =8
-; CHECK-NEXT:    add v27.2d, v27.2d, v0.2d
-; CHECK-NEXT:    cmp x8, #64 // =64
-; CHECK-NEXT:    add x9, x9, #1 // =1
-; CHECK-NEXT:    str q14, [sp] // 16-byte Folded Spill
+; CHECK-NEXT:    fmov x14, d14
+; CHECK-NEXT:    ldr q14, [x10], #64
+; CHECK-NEXT:    ldr x13, [x13]
+; CHECK-NEXT:    fmov x16, d15
+; CHECK-NEXT:    mov x15, v15.d[1]
+; CHECK-NEXT:    mov x1, v14.d[1]
+; CHECK-NEXT:    mul x0, x16, x13
+; CHECK-NEXT:    fmov x2, d14
+; CHECK-NEXT:    fmov d14, x0
+; CHECK-NEXT:    mul x0, x15, x13
+; CHECK-NEXT:    ldr x17, [x8], #1
+; CHECK-NEXT:    ldr x18, [x9], #8
+; CHECK-NEXT:    mov v14.d[1], x0
+; CHECK-NEXT:    mul x0, x14, x13
+; CHECK-NEXT:    add v12.2d, v12.2d, v14.2d
+; CHECK-NEXT:    fmov d14, x0
+; CHECK-NEXT:    mul x0, x12, x13
+; CHECK-NEXT:    mov v14.d[1], x0
+; CHECK-NEXT:    mul x0, x2, x13
+; CHECK-NEXT:    add v13.2d, v13.2d, v14.2d
+; CHECK-NEXT:    add v11.2d, v11.2d, v14.2d
+; CHECK-NEXT:    fmov d14, x0
+; CHECK-NEXT:    mul x13, x1, x13
+; CHECK-NEXT:    mov v14.d[1], x13
+; CHECK-NEXT:    mul x13, x16, x18
+; CHECK-NEXT:    add v10.2d, v10.2d, v14.2d
+; CHECK-NEXT:    fmov d14, x13
+; CHECK-NEXT:    mul x13, x15, x18
+; CHECK-NEXT:    mov v14.d[1], x13
+; CHECK-NEXT:    mul x13, x14, x17
+; CHECK-NEXT:    mul x14, x14, x18
+; CHECK-NEXT:    add v29.2d, v29.2d, v14.2d
+; CHECK-NEXT:    fmov d14, x14
+; CHECK-NEXT:    mul x14, x12, x18
+; CHECK-NEXT:    mov v14.d[1], x14
+; CHECK-NEXT:    mul x0, x2, x18
+; CHECK-NEXT:    mul x18, x1, x18
+; CHECK-NEXT:    add v28.2d, v28.2d, v14.2d
+; CHECK-NEXT:    fmov d14, x0
+; CHECK-NEXT:    mul x16, x16, x17
+; CHECK-NEXT:    mov v14.d[1], x18
+; CHECK-NEXT:    mul x15, x15, x17
+; CHECK-NEXT:    add v27.2d, v27.2d, v14.2d
+; CHECK-NEXT:    fmov d14, x16
+; CHECK-NEXT:    mov v14.d[1], x15
+; CHECK-NEXT:    mul x12, x12, x17
+; CHECK-NEXT:    add v8.2d, v8.2d, v14.2d
+; CHECK-NEXT:    add v25.2d, v25.2d, v14.2d
+; CHECK-NEXT:    add v22.2d, v22.2d, v14.2d
+; CHECK-NEXT:    add v18.2d, v18.2d, v14.2d
+; CHECK-NEXT:    add v6.2d, v6.2d, v14.2d
+; CHECK-NEXT:    add v0.2d, v0.2d, v14.2d
+; CHECK-NEXT:    fmov d14, x13
+; CHECK-NEXT:    mul x14, x2, x17
+; CHECK-NEXT:    mov v14.d[1], x12
+; CHECK-NEXT:    mul x13, x1, x17
+; CHECK-NEXT:    add v9.2d, v9.2d, v14.2d
+; CHECK-NEXT:    add v31.2d, v31.2d, v14.2d
+; CHECK-NEXT:    add v26.2d, v26.2d, v14.2d
+; CHECK-NEXT:    add v23.2d, v23.2d, v14.2d
+; CHECK-NEXT:    add v21.2d, v21.2d, v14.2d
+; CHECK-NEXT:    add v19.2d, v19.2d, v14.2d
+; CHECK-NEXT:    add v17.2d, v17.2d, v14.2d
+; CHECK-NEXT:    add v7.2d, v7.2d, v14.2d
+; CHECK-NEXT:    add v5.2d, v5.2d, v14.2d
+; CHECK-NEXT:    add v3.2d, v3.2d, v14.2d
+; CHECK-NEXT:    add v2.2d, v2.2d, v14.2d
+; CHECK-NEXT:    fmov d14, x14
+; CHECK-NEXT:    mov v14.d[1], x13
+; CHECK-NEXT:    add v30.2d, v30.2d, v14.2d
+; CHECK-NEXT:    add v24.2d, v24.2d, v14.2d
+; CHECK-NEXT:    add v20.2d, v20.2d, v14.2d
+; CHECK-NEXT:    add v16.2d, v16.2d, v14.2d
+; CHECK-NEXT:    add v4.2d, v4.2d, v14.2d
+; CHECK-NEXT:    add v1.2d, v1.2d, v14.2d
 ; CHECK-NEXT:    b.ne .LBB0_1
 ; CHECK-NEXT:  // %bb.2: // %for.cond.cleanup
 ; CHECK-NEXT:    adrp x8, C
 ; CHECK-NEXT:    add x8, x8, :lo12:C
-; CHECK-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 ; CHECK-NEXT:    stp q13, q12, [x8]
 ; CHECK-NEXT:    stp q11, q10, [x8, #32]
 ; CHECK-NEXT:    stp q9, q8, [x8, #64]
-; CHECK-NEXT:    ldp d9, d8, [sp, #64] // 16-byte Folded Reload
-; CHECK-NEXT:    ldp d11, d10, [sp, #48] // 16-byte Folded Reload
-; CHECK-NEXT:    ldp d13, d12, [sp, #32] // 16-byte Folded Reload
-; CHECK-NEXT:    ldp d15, d14, [sp, #16] // 16-byte Folded Reload
+; CHECK-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
+; CHECK-NEXT:    ldp d11, d10, [sp, #32] // 16-byte Folded Reload
+; CHECK-NEXT:    ldp d13, d12, [sp, #16] // 16-byte Folded Reload
 ; CHECK-NEXT:    stp q31, q30, [x8, #96]
 ; CHECK-NEXT:    stp q29, q28, [x8, #144]
 ; CHECK-NEXT:    stp q27, q26, [x8, #176]
 ; CHECK-NEXT:    str q25, [x8, #208]
 ; CHECK-NEXT:    stp q24, q23, [x8, #240]
 ; CHECK-NEXT:    stp q22, q21, [x8, #272]
 ; CHECK-NEXT:    stp q20, q19, [x8, #304]
 ; CHECK-NEXT:    stp q18, q17, [x8, #336]
 ; CHECK-NEXT:    stp q16, q7, [x8, #368]
 ; CHECK-NEXT:    stp q6, q5, [x8, #400]
 ; CHECK-NEXT:    stp q4, q3, [x8, #432]
 ; CHECK-NEXT:    stp q0, q2, [x8, #464]
 ; CHECK-NEXT:    str q1, [x8, #496]
-; CHECK-NEXT:    add sp, sp, #80 // =80
+; CHECK-NEXT:    ldp d15, d14, [sp], #64 // 16-byte Folded Reload
 ; CHECK-NEXT:    ret
 entry:
   br label %for.cond1.preheader
 
 for.cond1.preheader:                              ; preds = %for.cond1.preheader, %entry
   %0 = phi <2 x i64> [ undef, %entry ], [ %118, %for.cond1.preheader ]
   %1 = phi <2 x i64> [ undef, %entry ], [ %116, %for.cond1.preheader ]
   %2 = phi <2 x i64> [ zeroinitializer, %entry ], [ %114, %for.cond1.preheader ]

llvm/test/CodeGen/AArch64/shrink-wrapping-vla.ll

 ; Test shrink wrapping placement is correct with respect to calls to llvm.{stacksave,stackrestore}
 
 ; void f(int n, int x[]) {
 ;   if (n < 0)
 ;     return;
 ;
 ;  int a[n];
 ;
 ;  for (int i = 0; i < n; i++)
 ;    a[i] = x[n - i - 1];
 ;
 ;  for (int i = 0; i < n; i++)
 ;    x[i] = a[i] + 1;
 ; }
 ;
-; RUN: llc -mtriple aarch64-linux %s -o - | FileCheck %s
+; RUN: llc -mtriple aarch64-linux %s -lsr-preferred-addressing-mode=none -o - | FileCheck %s --check-prefix=CHECK
 
 define dso_local void @f(i32 %n, i32* nocapture %x) {
 entry:
   %cmp = icmp slt i32 %n, 0
   br i1 %cmp, label %return, label %if.end
 
 if.end:                                           ; preds = %entry
   %0 = zext i32 %n to i64

 ; CHECK-NEXT: mov x29, sp
 
 ; VLA allocation
 ; CHECK: add [[X1:x[0-9]+]], [[X1]], #15
 ; CHECK: mov [[X2:x[0-9]+]], sp
 ; CHECK: and [[X1]], [[X1]], #0x7fffffff0
 ; Saving the SP via llvm.stacksave()
 ; CHECK: mov [[SAVE:x[0-9]+]], sp
 ; CHECK: sub [[X2]], [[X2]], [[X1]]
 
 ; The next instruction comes from llvm.stackrestore()
 ; CHECK:      mov sp, [[SAVE]]
 ; Epilogue
 ; CHECK-NEXT: mov sp, x29
 ; CHECK-NEXT: ldp x29, x30, [sp], #16

llvm/test/CodeGen/AArch64/vldn_shuffle.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
-; RUN: llc < %s -mtriple=aarch64-none-eabif | FileCheck %s
+; RUN: llc < %s -mtriple=aarch64-none-eabif -lsr-preferred-addressing-mode=none | FileCheck %s --check-prefix=CHECK
+; RUN: llc < %s -mtriple=aarch64-none-eabif | FileCheck %s --check-prefix=POSTINDEXED
+; RUN: llc < %s -mtriple=aarch64-none-eabif -lsr-preferred-addressing-mode=postindexed | FileCheck %s --check-prefix=POSTINDEXED
 
 define void @vld2(float* nocapture readonly %pSrc, float* noalias nocapture %pDst, i32 %numSamples) {
 ; CHECK-LABEL: vld2:
 ; CHECK:       // %bb.0: // %entry
 ; CHECK-NEXT:    mov x8, xzr
 ; CHECK-NEXT:  .LBB0_1: // %vector.body
 ; CHECK-NEXT:    // =>This Inner Loop Header: Depth=1
 ; CHECK-NEXT:    ld2 { v0.4s, v1.4s }, [x0], #32
 ; CHECK-NEXT:    fmul v2.4s, v0.4s, v0.4s
 ; CHECK-NEXT:    fmla v2.4s, v1.4s, v1.4s
 ; CHECK-NEXT:    str q2, [x1, x8]
 ; CHECK-NEXT:    add x8, x8, #16 // =16
 ; CHECK-NEXT:    cmp x8, #1, lsl #12 // =4096
 ; CHECK-NEXT:    b.ne .LBB0_1
 ; CHECK-NEXT:  // %bb.2: // %while.end
 ; CHECK-NEXT:    ret
+;
+; POSTINDEXED-LABEL: vld2:
+; POSTINDEXED:       // %bb.0: // %entry
+; POSTINDEXED-NEXT:    mov w8, #1024
+; POSTINDEXED-NEXT:  .LBB0_1: // %vector.body
+; POSTINDEXED-NEXT:    // =>This Inner Loop Header: Depth=1
+; POSTINDEXED-NEXT:    ld2 { v0.4s, v1.4s }, [x0], #32
+; POSTINDEXED-NEXT:    subs x8, x8, #4 // =4
+; POSTINDEXED-NEXT:    fmul v2.4s, v0.4s, v0.4s
+; POSTINDEXED-NEXT:    fmla v2.4s, v1.4s, v1.4s
+; POSTINDEXED-NEXT:    str q2, [x1], #16
+; POSTINDEXED-NEXT:    b.ne .LBB0_1
+; POSTINDEXED-NEXT:  // %bb.2: // %while.end
+; POSTINDEXED-NEXT:    ret
 entry:
   br label %vector.body
 
 vector.body:                                      ; preds = %vector.body, %entry
   %index = phi i64 [ 0, %entry ], [ %index.next, %vector.body ]
   %0 = shl i64 %index, 1
   %next.gep = getelementptr float, float* %pSrc, i64 %0
   %next.gep19 = getelementptr float, float* %pDst, i64 %index

 ; CHECK-NEXT:    fmla v3.4s, v1.4s, v1.4s
 ; CHECK-NEXT:    fmla v3.4s, v2.4s, v2.4s
 ; CHECK-NEXT:    str q3, [x1, x8]
 ; CHECK-NEXT:    add x8, x8, #16 // =16
 ; CHECK-NEXT:    cmp x8, #1, lsl #12 // =4096
 ; CHECK-NEXT:    b.ne .LBB1_1
 ; CHECK-NEXT:  // %bb.2: // %while.end
 ; CHECK-NEXT:    ret
+;
+; POSTINDEXED-LABEL: vld3:
+; POSTINDEXED:       // %bb.0: // %entry
+; POSTINDEXED-NEXT:    mov w8, #1024
+; POSTINDEXED-NEXT:  .LBB1_1: // %vector.body
+; POSTINDEXED-NEXT:    // =>This Inner Loop Header: Depth=1
+; POSTINDEXED-NEXT:    ld3 { v0.4s, v1.4s, v2.4s }, [x0], #48
+; POSTINDEXED-NEXT:    subs x8, x8, #4 // =4
+; POSTINDEXED-NEXT:    fmul v3.4s, v0.4s, v0.4s
+; POSTINDEXED-NEXT:    fmla v3.4s, v1.4s, v1.4s
+; POSTINDEXED-NEXT:    fmla v3.4s, v2.4s, v2.4s
+; POSTINDEXED-NEXT:    str q3, [x1], #16
+; POSTINDEXED-NEXT:    b.ne .LBB1_1
+; POSTINDEXED-NEXT:  // %bb.2: // %while.end
+; POSTINDEXED-NEXT:    ret
 entry:
   br label %vector.body
 
 vector.body:                                      ; preds = %vector.body, %entry
   %index = phi i64 [ 0, %entry ], [ %index.next, %vector.body ]
   %0 = mul i64 %index, 3
   %next.gep = getelementptr float, float* %pSrc, i64 %0
   %next.gep23 = getelementptr float, float* %pDst, i64 %index

 ; CHECK-NEXT:    fmul v4.4s, v0.4s, v0.4s
 ; CHECK-NEXT:    fmla v4.4s, v1.4s, v1.4s
 ; CHECK-NEXT:    fmul v5.4s, v2.4s, v2.4s
 ; CHECK-NEXT:    fmla v5.4s, v3.4s, v3.4s
 ; CHECK-NEXT:    st2 { v4.4s, v5.4s }, [x9]
 ; CHECK-NEXT:    b.ne .LBB2_1
 ; CHECK-NEXT:  // %bb.2: // %while.end
 ; CHECK-NEXT:    ret
+;
+; POSTINDEXED-LABEL: vld4:
+; POSTINDEXED:       // %bb.0: // %entry
+; POSTINDEXED-NEXT:    mov w8, #1024
+; POSTINDEXED-NEXT:  .LBB2_1: // %vector.body
+; POSTINDEXED-NEXT:    // =>This Inner Loop Header: Depth=1
+; POSTINDEXED-NEXT:    ld4 { v0.4s, v1.4s, v2.4s, v3.4s }, [x0], #64
+; POSTINDEXED-NEXT:    subs x8, x8, #4 // =4
+; POSTINDEXED-NEXT:    fmul v4.4s, v0.4s, v0.4s
+; POSTINDEXED-NEXT:    fmla v4.4s, v1.4s, v1.4s
+; POSTINDEXED-NEXT:    fmul v5.4s, v2.4s, v2.4s
+; POSTINDEXED-NEXT:    fmla v5.4s, v3.4s, v3.4s
+; POSTINDEXED-NEXT:    st2 { v4.4s, v5.4s }, [x1], #32
+; POSTINDEXED-NEXT:    b.ne .LBB2_1
+; POSTINDEXED-NEXT:  // %bb.2: // %while.end
+; POSTINDEXED-NEXT:    ret
 entry:
   br label %vector.body
 
 vector.body:                                      ; preds = %vector.body, %entry
   %index = phi i64 [ 0, %entry ], [ %index.next, %vector.body ]
   %0 = shl i64 %index, 2
   %next.gep = getelementptr float, float* %pSrc, i64 %0
   %1 = shl i64 %index, 1

 ; CHECK-NEXT:    add x8, x8, #32 // =32
 ; CHECK-NEXT:    cmp x8, #2, lsl #12 // =8192
 ; CHECK-NEXT:    fmul v4.4s, v2.4s, v0.4s
 ; CHECK-NEXT:    fmla v4.4s, v1.4s, v3.4s
 ; CHECK-NEXT:    str q4, [x2], #16
 ; CHECK-NEXT:    b.ne .LBB3_1
 ; CHECK-NEXT:  // %bb.2: // %while.end
 ; CHECK-NEXT:    ret
+;
+; POSTINDEXED-LABEL: twosrc:
+; POSTINDEXED:       // %bb.0: // %entry
+; POSTINDEXED-NEXT:    mov w8, #1024
+; POSTINDEXED-NEXT:  .LBB3_1: // %vector.body
+; POSTINDEXED-NEXT:    // =>This Inner Loop Header: Depth=1
+; POSTINDEXED-NEXT:    ld2 { v0.4s, v1.4s }, [x0], #32
+; POSTINDEXED-NEXT:    ld2 { v2.4s, v3.4s }, [x1], #32
+; POSTINDEXED-NEXT:    subs x8, x8, #4 // =4
+; POSTINDEXED-NEXT:    fmul v4.4s, v2.4s, v0.4s
+; POSTINDEXED-NEXT:    fmla v4.4s, v1.4s, v3.4s
+; POSTINDEXED-NEXT:    str q4, [x2], #16
+; POSTINDEXED-NEXT:    b.ne .LBB3_1
+; POSTINDEXED-NEXT:  // %bb.2: // %while.end
+; POSTINDEXED-NEXT:    ret
 entry:
   br label %vector.body
 
 vector.body:                                      ; preds = %vector.body, %entry
   %index = phi i64 [ 0, %entry ], [ %index.next, %vector.body ]
   %0 = shl i64 %index, 1
   %next.gep = getelementptr float, float* %pSrc, i64 %0
   %1 = shl i64 %index, 1

llvm/test/Transforms/LoopStrengthReduce/AArch64/small-constant.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 
-; RUN: llc < %s -mtriple=aarch64-unknown-unknown | FileCheck %s
+; RUN: llc < %s -mtriple=aarch64-unknown-unknown | FileCheck %s --check-prefix=CHECK
+; RUN: llc < %s -mtriple=aarch64-unknown-unknown -lsr-preferred-addressing-mode=postindexed | FileCheck %s --check-prefix=POSTINDEXED
+; RUN: llc < %s -mtriple=aarch64-unknown-unknown -lsr-preferred-addressing-mode=preindexed | FileCheck %s --check-prefix=PREINDEXED
+; RUN: llc < %s -mtriple=aarch64-unknown-unknown -lsr-preferred-addressing-mode=none | FileCheck %s --check-prefix=AMKNONE
 
 ; Test LSR for giving small constants, which get re-associated as unfolded
 ; offset, a chance to get combined with loop-invariant registers (same as
 ; large constants which do not fit as add immediate operands). LSR
 ; favors here to bump the base pointer outside the loop.
 
 ; float test(float *arr, long long start, float threshold) {
 ;   for (long long i = start; i != 0; ++i) {
 ;     float x = arr[i + 7];
 ;     if (x > threshold)
 ;       return x;
 ;   }
 ;   return -7;
 ; }
 define float @test1(float* nocapture readonly %arr, i64 %start, float %threshold) {
 ; CHECK-LABEL: test1:
 ; CHECK:       // %bb.0: // %entry
 ; CHECK-NEXT:    cbz x1, .LBB0_4
 ; CHECK-NEXT:  // %bb.1: // %for.body.preheader
-; CHECK-NEXT:    add x8, x0, #28 // =28
+; CHECK-NEXT:    add x8, x0, x1, lsl #2
+; CHECK-NEXT:    add x8, x8, #28 // =28
 ; CHECK-NEXT:  .LBB0_2: // %for.body
 ; CHECK-NEXT:    // =>This Inner Loop Header: Depth=1
-; CHECK-NEXT:    ldr s1, [x8, x1, lsl #2]
+; CHECK-NEXT:    ldr s1, [x8]
 ; CHECK-NEXT:    fcmp s1, s0
 ; CHECK-NEXT:    b.gt .LBB0_5
 ; CHECK-NEXT:  // %bb.3: // %for.cond
 ; CHECK-NEXT:    // in Loop: Header=BB0_2 Depth=1
 ; CHECK-NEXT:    add x1, x1, #1 // =1
+; CHECK-NEXT:    add x8, x8, #4 // =4
 ; CHECK-NEXT:    cbnz x1, .LBB0_2
 ; CHECK-NEXT:  .LBB0_4:
 ; CHECK-NEXT:    fmov s0, #-7.00000000
 ; CHECK-NEXT:    ret
 ; CHECK-NEXT:  .LBB0_5: // %cleanup2
 ; CHECK-NEXT:    mov v0.16b, v1.16b
 ; CHECK-NEXT:    ret
+;
+; POSTINDEXED-LABEL: test1:
+; POSTINDEXED:       // %bb.0: // %entry
+; POSTINDEXED-NEXT:    cbz x1, .LBB0_4
+; POSTINDEXED-NEXT:  // %bb.1: // %for.body.preheader
+; POSTINDEXED-NEXT:    add x8, x0, x1, lsl #2
+; POSTINDEXED-NEXT:    add x8, x8, #28 // =28
+; POSTINDEXED-NEXT:  .LBB0_2: // %for.body
+; POSTINDEXED-NEXT:    // =>This Inner Loop Header: Depth=1
+; POSTINDEXED-NEXT:    ldr s1, [x8]
+; POSTINDEXED-NEXT:    fcmp s1, s0
+; POSTINDEXED-NEXT:    b.gt .LBB0_5
+; POSTINDEXED-NEXT:  // %bb.3: // %for.cond
+; POSTINDEXED-NEXT:    // in Loop: Header=BB0_2 Depth=1
+; POSTINDEXED-NEXT:    add x1, x1, #1 // =1
+; POSTINDEXED-NEXT:    add x8, x8, #4 // =4
+; POSTINDEXED-NEXT:    cbnz x1, .LBB0_2
+; POSTINDEXED-NEXT:  .LBB0_4:
+; POSTINDEXED-NEXT:    fmov s0, #-7.00000000
+; POSTINDEXED-NEXT:    ret
+; POSTINDEXED-NEXT:  .LBB0_5: // %cleanup2
+; POSTINDEXED-NEXT:    mov v0.16b, v1.16b
+; POSTINDEXED-NEXT:    ret
+;
+; PREINDEXED-LABEL: test1:
+; PREINDEXED:       // %bb.0: // %entry
+; PREINDEXED-NEXT:    cbz x1, .LBB0_4
+; PREINDEXED-NEXT:  // %bb.1: // %for.body.preheader
+; PREINDEXED-NEXT:    add x9, x0, x1, lsl #2
+; PREINDEXED-NEXT:    neg x8, x1
+; PREINDEXED-NEXT:    add x9, x9, #24 // =24
+; PREINDEXED-NEXT:  .LBB0_2: // %for.body
+; PREINDEXED-NEXT:    // =>This Inner Loop Header: Depth=1
+; PREINDEXED-NEXT:    ldr s1, [x9, #4]
+; PREINDEXED-NEXT:    fcmp s1, s0
+; PREINDEXED-NEXT:    b.gt .LBB0_5
+; PREINDEXED-NEXT:  // %bb.3: // %for.cond
+; PREINDEXED-NEXT:    // in Loop: Header=BB0_2 Depth=1
+; PREINDEXED-NEXT:    subs x8, x8, #1 // =1
+; PREINDEXED-NEXT:    add x9, x9, #4 // =4
+; PREINDEXED-NEXT:    b.ne .LBB0_2
+; PREINDEXED-NEXT:  .LBB0_4:
+; PREINDEXED-NEXT:    fmov s0, #-7.00000000
+; PREINDEXED-NEXT:    ret
+; PREINDEXED-NEXT:  .LBB0_5: // %cleanup2
+; PREINDEXED-NEXT:    mov v0.16b, v1.16b
+; PREINDEXED-NEXT:    ret
+;
+; AMKNONE-LABEL: test1:
+; AMKNONE:       // %bb.0: // %entry
+; AMKNONE-NEXT:    cbz x1, .LBB0_4
+; AMKNONE-NEXT:  // %bb.1: // %for.body.preheader
+; AMKNONE-NEXT:    add x8, x0, #28 // =28
+; AMKNONE-NEXT:  .LBB0_2: // %for.body
+; AMKNONE-NEXT:    // =>This Inner Loop Header: Depth=1
+; AMKNONE-NEXT:    ldr s1, [x8, x1, lsl #2]
+; AMKNONE-NEXT:    fcmp s1, s0
+; AMKNONE-NEXT:    b.gt .LBB0_5
+; AMKNONE-NEXT:  // %bb.3: // %for.cond
+; AMKNONE-NEXT:    // in Loop: Header=BB0_2 Depth=1
+; AMKNONE-NEXT:    add x1, x1, #1 // =1
+; AMKNONE-NEXT:    cbnz x1, .LBB0_2
+; AMKNONE-NEXT:  .LBB0_4:
+; AMKNONE-NEXT:    fmov s0, #-7.00000000
+; AMKNONE-NEXT:    ret
+; AMKNONE-NEXT:  .LBB0_5: // %cleanup2
+; AMKNONE-NEXT:    mov v0.16b, v1.16b
+; AMKNONE-NEXT:    ret
 entry:
   %cmp11 = icmp eq i64 %start, 0
   br i1 %cmp11, label %cleanup2, label %for.body
 
 for.cond:                                         ; preds = %for.body
   %cmp = icmp eq i64 %inc, 0
   br i1 %cmp, label %cleanup2, label %for.body
 

 
 ; Same as test1, except i has another use:
 ;     if (x > threshold) ---> if (x > threshold + i)
 define float @test2(float* nocapture readonly %arr, i64 %start, float %threshold) {
 ; CHECK-LABEL: test2:
 ; CHECK:       // %bb.0: // %entry
 ; CHECK-NEXT:    cbz x1, .LBB1_4
 ; CHECK-NEXT:  // %bb.1: // %for.body.preheader
-; CHECK-NEXT:    add x8, x0, #28 // =28
+; CHECK-NEXT:    add x8, x0, x1, lsl #2
+; CHECK-NEXT:    add x8, x8, #28 // =28
 ; CHECK-NEXT:  .LBB1_2: // %for.body
 ; CHECK-NEXT:    // =>This Inner Loop Header: Depth=1
-; CHECK-NEXT:    ldr s1, [x8, x1, lsl #2]
+; CHECK-NEXT:    ldr s1, [x8]
 ; CHECK-NEXT:    scvtf s2, x1
 ; CHECK-NEXT:    fadd s2, s2, s0
 ; CHECK-NEXT:    fcmp s1, s2
 ; CHECK-NEXT:    b.gt .LBB1_5
 ; CHECK-NEXT:  // %bb.3: // %for.cond
 ; CHECK-NEXT:    // in Loop: Header=BB1_2 Depth=1
 ; CHECK-NEXT:    add x1, x1, #1 // =1
+; CHECK-NEXT:    add x8, x8, #4 // =4
 ; CHECK-NEXT:    cbnz x1, .LBB1_2
 ; CHECK-NEXT:  .LBB1_4:
 ; CHECK-NEXT:    fmov s0, #-7.00000000
 ; CHECK-NEXT:    ret
 ; CHECK-NEXT:  .LBB1_5: // %cleanup4
 ; CHECK-NEXT:    mov v0.16b, v1.16b
 ; CHECK-NEXT:    ret
+;
+; POSTINDEXED-LABEL: test2:
+; POSTINDEXED:       // %bb.0: // %entry
+; POSTINDEXED-NEXT:    cbz x1, .LBB1_4
+; POSTINDEXED-NEXT:  // %bb.1: // %for.body.preheader
+; POSTINDEXED-NEXT:    add x8, x0, x1, lsl #2
+; POSTINDEXED-NEXT:    add x8, x8, #28 // =28
+; POSTINDEXED-NEXT:  .LBB1_2: // %for.body
+; POSTINDEXED-NEXT:    // =>This Inner Loop Header: Depth=1
+; POSTINDEXED-NEXT:    ldr s1, [x8]
+; POSTINDEXED-NEXT:    scvtf s2, x1
+; POSTINDEXED-NEXT:    fadd s2, s2, s0
+; POSTINDEXED-NEXT:    fcmp s1, s2
+; POSTINDEXED-NEXT:    b.gt .LBB1_5
+; POSTINDEXED-NEXT:  // %bb.3: // %for.cond
+; POSTINDEXED-NEXT:    // in Loop: Header=BB1_2 Depth=1
+; POSTINDEXED-NEXT:    add x1, x1, #1 // =1
+; POSTINDEXED-NEXT:    add x8, x8, #4 // =4
+; POSTINDEXED-NEXT:    cbnz x1, .LBB1_2
+; POSTINDEXED-NEXT:  .LBB1_4:
+; POSTINDEXED-NEXT:    fmov s0, #-7.00000000
+; POSTINDEXED-NEXT:    ret
+; POSTINDEXED-NEXT:  .LBB1_5: // %cleanup4
+; POSTINDEXED-NEXT:    mov v0.16b, v1.16b
+; POSTINDEXED-NEXT:    ret
+;
+; PREINDEXED-LABEL: test2:
+; PREINDEXED:       // %bb.0: // %entry
+; PREINDEXED-NEXT:    cbz x1, .LBB1_4
+; PREINDEXED-NEXT:  // %bb.1: // %for.body.preheader
+; PREINDEXED-NEXT:    add x8, x0, #28 // =28
+; PREINDEXED-NEXT:  .LBB1_2: // %for.body
+; PREINDEXED-NEXT:    // =>This Inner Loop Header: Depth=1
+; PREINDEXED-NEXT:    ldr s1, [x8, x1, lsl #2]
+; PREINDEXED-NEXT:    scvtf s2, x1
+; PREINDEXED-NEXT:    fadd s2, s2, s0
+; PREINDEXED-NEXT:    fcmp s1, s2
+; PREINDEXED-NEXT:    b.gt .LBB1_5
+; PREINDEXED-NEXT:  // %bb.3: // %for.cond
+; PREINDEXED-NEXT:    // in Loop: Header=BB1_2 Depth=1
+; PREINDEXED-NEXT:    add x1, x1, #1 // =1
+; PREINDEXED-NEXT:    cbnz x1, .LBB1_2
+; PREINDEXED-NEXT:  .LBB1_4:
+; PREINDEXED-NEXT:    fmov s0, #-7.00000000
+; PREINDEXED-NEXT:    ret
+; PREINDEXED-NEXT:  .LBB1_5: // %cleanup4
+; PREINDEXED-NEXT:    mov v0.16b, v1.16b
+; PREINDEXED-NEXT:    ret
+;
+; AMKNONE-LABEL: test2:
+; AMKNONE:       // %bb.0: // %entry
+; AMKNONE-NEXT:    cbz x1, .LBB1_4
+; AMKNONE-NEXT:  // %bb.1: // %for.body.preheader
+; AMKNONE-NEXT:    add x8, x0, #28 // =28
+; AMKNONE-NEXT:  .LBB1_2: // %for.body
+; AMKNONE-NEXT:    // =>This Inner Loop Header: Depth=1
+; AMKNONE-NEXT:    ldr s1, [x8, x1, lsl #2]
+; AMKNONE-NEXT:    scvtf s2, x1
+; AMKNONE-NEXT:    fadd s2, s2, s0
+; AMKNONE-NEXT:    fcmp s1, s2
+; AMKNONE-NEXT:    b.gt .LBB1_5
+; AMKNONE-NEXT:  // %bb.3: // %for.cond
+; AMKNONE-NEXT:    // in Loop: Header=BB1_2 Depth=1
+; AMKNONE-NEXT:    add x1, x1, #1 // =1
+; AMKNONE-NEXT:    cbnz x1, .LBB1_2
+; AMKNONE-NEXT:  .LBB1_4:
+; AMKNONE-NEXT:    fmov s0, #-7.00000000
+; AMKNONE-NEXT:    ret
+; AMKNONE-NEXT:  .LBB1_5: // %cleanup4
+; AMKNONE-NEXT:    mov v0.16b, v1.16b
+; AMKNONE-NEXT:    ret
 entry:
   %cmp14 = icmp eq i64 %start, 0
   br i1 %cmp14, label %cleanup4, label %for.body
 
 for.cond:                                         ; preds = %for.body
   %cmp = icmp eq i64 %inc, 0
   br i1 %cmp, label %cleanup4, label %for.body
 

llvm/test/Transforms/LoopStrengthReduce/AArch64/vscale-factor-out-constant.ll

-; RUN: opt -S -loop-reduce < %s | FileCheck %s
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt -S -loop-reduce < %s | FileCheck %s --check-prefix=CHECK
+; RUN: opt -S -loop-reduce -lsr-preferred-addressing-mode=none < %s | FileCheck %s --check-prefix=AMKNONE
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 target triple = "aarch64-unknown-linux-gnu"
 
 ; This test check SCEVExpander FactorOutConstant() is not crashing with blind cast 'Factor' to SCEVConstant.
 
-; CHECK-LABEL: test
 ; FIXME: Handle VectorType in SCEVExpander::expandAddToGEP.
 ; The generated IR is not ideal with base 'scalar_vector' cast to i8*, and do ugly getelementptr over casted base.
-; CHECK: uglygep
+;
 define void @test(i32* %a, i32 %v, i64 %n) {
+; CHECK-LABEL: @test(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[SCALAR_VECTOR:%.*]] = alloca <vscale x 4 x i32>, align 16
+; CHECK-NEXT:    [[NUM_ELM:%.*]] = call i64 @llvm.aarch64.sve.cntw(i32 31)
+; CHECK-NEXT:    [[SCALAR_COUNT:%.*]] = and i64 [[NUM_ELM]], -4
+; CHECK-NEXT:    br label [[LOOP_HEADER:%.*]]
+; CHECK:       exit:
+; CHECK-NEXT:    ret void
+; CHECK:       loop_header:
+; CHECK-NEXT:    [[INDVAR:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVAR_NEXT:%.*]], [[FOR_LOOP:%.*]] ]
+; CHECK-NEXT:    [[GEP_A_0:%.*]] = getelementptr i32, i32* [[A:%.*]], i64 0
+; CHECK-NEXT:    [[GEP_VEC_0:%.*]] = getelementptr inbounds <vscale x 4 x i32>, <vscale x 4 x i32>* [[SCALAR_VECTOR]], i64 0, i64 0
+; CHECK-NEXT:    br label [[SCALAR_LOOP:%.*]]
+; CHECK:       scalar_loop:
+; CHECK-NEXT:    [[LSR_IV:%.*]] = phi i64 [ [[LSR_IV_NEXT:%.*]], [[SCALAR_LOOP]] ], [ [[SCALAR_COUNT]], [[LOOP_HEADER]] ]
+; CHECK-NEXT:    [[GEP_VEC:%.*]] = phi i32* [ [[GEP_VEC_0]], [[LOOP_HEADER]] ], [ [[GEP_VEC_INC:%.*]], [[SCALAR_LOOP]] ]
+; CHECK-NEXT:    store i32 [[V:%.*]], i32* [[GEP_VEC]], align 4
+; CHECK-NEXT:    [[GEP_VEC_INC]] = getelementptr i32, i32* [[GEP_VEC]], i64 1
+; CHECK-NEXT:    [[LSR_IV_NEXT]] = add i64 [[LSR_IV]], -1
+; CHECK-NEXT:    [[SCALAR_EXIT:%.*]] = icmp eq i64 [[LSR_IV_NEXT]], 0
+; CHECK-NEXT:    br i1 [[SCALAR_EXIT]], label [[FOR_LOOP]], label [[SCALAR_LOOP]]
+; CHECK:       for_loop:
+; CHECK-NEXT:    [[VECTOR:%.*]] = load <vscale x 4 x i32>, <vscale x 4 x i32>* [[SCALAR_VECTOR]], align 16
+; CHECK-NEXT:    [[GEP_A:%.*]] = getelementptr i32, i32* [[GEP_A_0]], i64 [[INDVAR]]
+; CHECK-NEXT:    [[VECTOR_PTR:%.*]] = bitcast i32* [[GEP_A]] to <vscale x 4 x i32>*
+; CHECK-NEXT:    call void @llvm.masked.store.nxv4i32.p0nxv4i32(<vscale x 4 x i32> [[VECTOR]], <vscale x 4 x i32>* [[VECTOR_PTR]], i32 4, <vscale x 4 x i1> undef)
+; CHECK-NEXT:    [[INDVAR_NEXT]] = add nsw i64 [[INDVAR]], [[SCALAR_COUNT]]
+; CHECK-NEXT:    [[EXIT_COND:%.*]] = icmp eq i64 [[INDVAR_NEXT]], [[N:%.*]]
+; CHECK-NEXT:    br i1 [[EXIT_COND]], label [[EXIT:%.*]], label [[LOOP_HEADER]]
+;
+; AMKNONE-LABEL: @test(
+; AMKNONE-NEXT:  entry:
+; AMKNONE-NEXT:    [[SCALAR_VECTOR:%.*]] = alloca <vscale x 4 x i32>, align 16
+; AMKNONE-NEXT:    [[SCALAR_VECTOR1:%.*]] = bitcast <vscale x 4 x i32>* [[SCALAR_VECTOR]] to i8*
+; AMKNONE-NEXT:    [[NUM_ELM:%.*]] = call i64 @llvm.aarch64.sve.cntw(i32 31)
+; AMKNONE-NEXT:    [[SCALAR_COUNT:%.*]] = and i64 [[NUM_ELM]], -4
+; AMKNONE-NEXT:    br label [[LOOP_HEADER:%.*]]
+; AMKNONE:       exit:
+; AMKNONE-NEXT:    ret void
+; AMKNONE:       loop_header:
+; AMKNONE-NEXT:    [[INDVAR:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[INDVAR_NEXT:%.*]], [[FOR_LOOP:%.*]] ]
+; AMKNONE-NEXT:    [[GEP_A_0:%.*]] = getelementptr i32, i32* [[A:%.*]], i64 0
+; AMKNONE-NEXT:    br label [[SCALAR_LOOP:%.*]]
+; AMKNONE:       scalar_loop:
+; AMKNONE-NEXT:    [[SCALAR_IV:%.*]] = phi i64 [ 0, [[LOOP_HEADER]] ], [ [[SCALAR_IV_NEXT:%.*]], [[SCALAR_LOOP]] ]
+; AMKNONE-NEXT:    [[TMP0:%.*]] = shl i64 [[SCALAR_IV]], 2
+; AMKNONE-NEXT:    [[UGLYGEP:%.*]] = getelementptr i8, i8* [[SCALAR_VECTOR1]], i64 [[TMP0]]
+; AMKNONE-NEXT:    [[UGLYGEP2:%.*]] = bitcast i8* [[UGLYGEP]] to i32*
+; AMKNONE-NEXT:    store i32 [[V:%.*]], i32* [[UGLYGEP2]], align 4
+; AMKNONE-NEXT:    [[SCALAR_IV_NEXT]] = add i64 [[SCALAR_IV]], 1
+; AMKNONE-NEXT:    [[SCALAR_EXIT:%.*]] = icmp eq i64 [[SCALAR_COUNT]], [[SCALAR_IV_NEXT]]
+; AMKNONE-NEXT:    br i1 [[SCALAR_EXIT]], label [[FOR_LOOP]], label [[SCALAR_LOOP]]
+; AMKNONE:       for_loop:
+; AMKNONE-NEXT:    [[VECTOR:%.*]] = load <vscale x 4 x i32>, <vscale x 4 x i32>* [[SCALAR_VECTOR]], align 16
+; AMKNONE-NEXT:    [[GEP_A:%.*]] = getelementptr i32, i32* [[GEP_A_0]], i64 [[INDVAR]]
+; AMKNONE-NEXT:    [[VECTOR_PTR:%.*]] = bitcast i32* [[GEP_A]] to <vscale x 4 x i32>*
+; AMKNONE-NEXT:    call void @llvm.masked.store.nxv4i32.p0nxv4i32(<vscale x 4 x i32> [[VECTOR]], <vscale x 4 x i32>* [[VECTOR_PTR]], i32 4, <vscale x 4 x i1> undef)
+; AMKNONE-NEXT:    [[INDVAR_NEXT]] = add nsw i64 [[INDVAR]], [[SCALAR_COUNT]]
+; AMKNONE-NEXT:    [[EXIT_COND:%.*]] = icmp eq i64 [[INDVAR_NEXT]], [[N:%.*]]
+; AMKNONE-NEXT:    br i1 [[EXIT_COND]], label [[EXIT:%.*]], label [[LOOP_HEADER]]
+;
 entry:
   %scalar_vector = alloca <vscale x 4 x i32>, align 16
   %num_elm = call i64 @llvm.aarch64.sve.cntw(i32 31)
   %scalar_count = and i64 %num_elm, -4
   br label %loop_header
 
 exit:
   ret void