[ARM] Don't aggressively unroll vector remainder loops

[dmgreen]

Summary

We already do not unroll loops with vector instructions under MVE, but that does not include the remainder loops that the vectorizer produces. These remainder loops will be rarely executed and are not worth unrolling, as the trip count is likely to be low if they get executed at all. Luckily they get llvm.loop.isvectorized to make recognizing them simpler.

We have wanted to do this for a while but hit issues with low overhead loops being reverted due to difficult registry allocation. With recent changes that seems to be less of an issue now.

[SjoerdMeijer]

Yeah, looks very reasonable.

llvm/include/llvm/Transforms/Utils/LoopUtils.h

 /// @}
 
 /// Set input string into loop metadata by keeping other values intact.
 /// If the string is already in loop metadata update value if it is
 /// different.
 void addStringMetadataToLoop(Loop *TheLoop, const char *MDString,
                              unsigned V = 0);
 
+/// Returns true if Name is applied to TheLoop and enabled.
+bool getBooleanLoopAttribute(const Loop *TheLoop, StringRef Name);
+
 /// Returns a loop's estimated trip count based on branch weight metadata.
 /// In addition if \p EstimatedLoopInvocationWeight is not null it is
 /// initialized with weight of loop's latch leading to the exit.
 /// Returns 0 when the count is estimated to be 0, or None when a meaningful
 /// estimate can not be made.
 Optional<unsigned>
 getLoopEstimatedTripCount(Loop *L,
                           unsigned *EstimatedLoopInvocationWeight = nullptr);

llvm/lib/Target/ARM/ARMTargetTransformInfo.cpp

void ARMTTIImpl::getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
   if (ExitingBlocks.size() > 2)
     return;
 
   // Limit the CFG of the loop body for targets with a branch predictor.
   // Allowing 4 blocks permits if-then-else diamonds in the body.
   if (ST->hasBranchPredictor() && L->getNumBlocks() > 4)
     return;
 
+  // Don't unroll vectorized loops, including the remainder loop
+  if (getBooleanLoopAttribute(L, "llvm.loop.isvectorized"))
+    return;
+
   // Scan the loop: don't unroll loops with calls as this could prevent
   // inlining.
   unsigned Cost = 0;
   for (auto *BB : L->getBlocks()) {
     for (auto &I : *BB) {
       // Don't unroll vectorised loop. MVE does not benefit from it as much as
       // scalar code.
       if (I.getType()->isVectorTy())

llvm/lib/Transforms/Utils/LoopUtils.cpp

case 2:
     if (ConstantInt *IntMD =
             mdconst::extract_or_null<ConstantInt>(MD->getOperand(1).get()))
       return IntMD->getZExtValue();
     return true;
   }
   llvm_unreachable("unexpected number of options");
 }
 
-static bool getBooleanLoopAttribute(const Loop *TheLoop, StringRef Name) {
+bool llvm::getBooleanLoopAttribute(const Loop *TheLoop, StringRef Name) {
   return getOptionalBoolLoopAttribute(TheLoop, Name).getValueOr(false);
 }
 
 llvm::Optional<int> llvm::getOptionalIntLoopAttribute(Loop *TheLoop,
                                                       StringRef Name) {
   const MDOperand *AttrMD =
       findStringMetadataForLoop(TheLoop, Name).getValueOr(nullptr);
   if (!AttrMD)

llvm/test/Transforms/LoopUnroll/ARM/mve-nounroll.ll

for.body:                                         ; preds = %for.body.preheader13, %for.body
   br i1 %exitcond, label %for.cond.cleanup.loopexit, label %for.body, !llvm.loop !2
 }
 
 
 ; Same as above but without the nounroll on the remainder loop. Neither loop should be unrolled.
 
 ; CHECK-LABEL: @remainder
 ; CHECK: vector.body:
-; CHECK:   br i1 %13, label %middle.block, label %vector.body, !llvm.loop !0
+; CHECK:   br i1 %7, label %middle.block, label %vector.body, !llvm.loop !0
 ; CHECK: middle.block:
 ; CHECK:   br i1 %cmp.n, label %for.cond.cleanup, label %for.body.preheader13
 ; CHECK: for.body:
-; CHECK:   br i1 %exitcond.3, label %for.cond.cleanup.loopexit.unr-lcssa, label %for.body, !llvm.loop !0
-; CHECK: for.body.prol.1:
-; CHECK:   br i1 %prol.iter.cmp.1, label %for.body.prol.2, label %for.body.prol.loopexit.unr-lcssa
-; CHECK: for.body.prol.2:
-; CHECK:   br label %for.body.prol.loopexit.unr-lcssa
+; CHECK:   br i1 %exitcond, label %for.cond.cleanup.loopexit, label %for.body, !llvm.loop !0
 
 define void @remainder(float* %s1, float* %s2, float* %d, i32 %n) {
 entry:
   %cmp10 = icmp sgt i32 %n, 0
   br i1 %cmp10, label %for.body.preheader, label %for.cond.cleanup
 
 for.body.preheader:                               ; preds = %entry
   %min.iters.check = icmp ult i32 %n, 4