Improved Diagnostics and Extended vectorize(enable)

[tyler.nowicki]

Summary

This patch is the combination of several llvm patches that were submitted to the mailing list. There are a couple of clang patches also on the mailing list, but they are small and should easily be reviewed. If you would prefer to see the features split out, please review the patches on the mailing list.

From the list: I’ve been working on the vectorization diagnostics a little more. The first patch makes sure the analysis diagnostics are printed unless a disabling hint is provided. And the two pairs of LLVM and Clang patches make the diagnostic messages easier to understand and extend the vectorize(enable) hint to override the mem-pointer check threshold.

The new diagnostics are:

remark: loop not vectorized: cannot prove it is safe to reorder floating-point operations; allow reordering by specifying '#pragma clang loop vectorize(enable)' before the loop or by providing the compiler option '-ffast-math’.

and

remark: loop not vectorized: cannot prove it is safe to reorder memory operations; allow reordering by specifying '#pragma clang loop vectorize(enable)' before the loop. If the arrays will always be independent specify '#pragma clang loop vectorize(assume_safety)' before the loop or provide the 'restrict' qualifier with the independent array arguments. Erroneous results will occur if these options are incorrectly applied!

Using 'vectorize(enable)' to reorder memory operations is always safe (but not for fp ops), where as using 'vectorize(assume_safety)' might be dangerous. I removed the references to the mem-check threshold because I realized only compiler developers would know what it means.

Feedback is appreciated!

[vsk]

Just nitpicks from me (comments inline).

I'd run git blame on some of these files and get one or two more reviewers.

include/llvm/Analysis/LoopAccessAnalysis.h

79 ↗

(On Diff #32891)

Nitpick, but from the coding style document: "Variable names should be nouns (as they represent state)". "VectorizationForced" might be a good compromise (and it's consistent).

lib/Analysis/LoopAccessAnalysis.cpp

30 ↗

(On Diff #32891)

Same nitpick, see above.

lib/Transforms/Vectorize/LoopVectorize.cpp

933

It'd be helpful to restructure this code to return early when possible. E.g;

if (getWidth() == 1) return LV_NAME
if (getForce() == LVH::Disabled) return LV_NAME
if (getForce() != LVH::Enabled && getWidth() <= 1 && getInterleave() <= 1) return LV_NAME
return DI:AlwaysPrint

You may have to double-check that logic. Also, the third conditional looks like it could be simplified (given the first two).

934

Please add a newline (and perhaps a comment?) before allowReordering().

[tyler.nowicki]

Thanks for the review. I've updated the patch.

I noticed that no_fpmath wasn't able to correctly test the generation of analysis remarks without specifying -pass-remarks-analysis. I moved the test to no_switch. This test always fails and thus will emit an analysis remark when vectorization is forced.

[vsk]

This looks fine to me. Could someone more familiar with LoopVectorize chime in?

[mzolotukhin]

Hi Tyler,

Please find some comments/questions from me inline:

lib/Analysis/LoopAccessAnalysis.cpp

32–33 ↗

(On Diff #33038)

From the description it's not clear what the number stands for (I'd expect force-vectorization to be boolean). Could you please reword this somehow?

lib/Transforms/Vectorize/LoopVectorize.cpp

847

Why do we change this (default?) value?

932–933

Don't we start returning AlwaysPrint for all vectorized loops if no hint is specified (getForce() == LoopVectorizeHints::FK_Undefined, getWidth() == 4/8/16)?

1537

Why is allowReordering a part of ThresholdReached?

1822–1824

Why do we distinguish these two? If we don't want to see one of them in -R-reports, should we just make it DEBUG(dbgs() << "...") instead of emitOptimizationRemarkAnalysis?

[tyler.nowicki]

Hi Michael,

Thanks for the comments. I made some changes, replies inline.

Tyler

lib/Transforms/Vectorize/LoopVectorize.cpp

932–933

No. Only when a hint is specified. This really means that the user only sees the analysis when vectorization fails on a loop with the hint enabled. If vectorization is possible, the user rarely sees any analysis. If there is something wrong with the loop then they will see the analysis.

1537

So vectorize(enable) can be used to override the threshold. But a comment in another discussion asked for another maximum threshold to prevent huge code. Thus we have two thresholds.

1822–1824

Vectorization analysis remarks are Always Printed when a vectorization loop hint is provided. We don't want to print interleaving analysis remarks when a vectorization loop hint is provided.

In the future we should, but that is for another patch. Part of the changes that should go in related to thise include detangling the metadata for enabling vectorization. Right now interleave(enable) and vectorize(enable) use the same metadata ...vectorize.enable.

[mzolotukhin]

Hi Tyler,

Thanks for the explanation - please find my replies inline. They are mostly cosmetic, so in general the patch looks good to me.

Michael

lib/Transforms/Vectorize/LoopVectorize.cpp

937–943

It's a bit unclear, what getWidth() has to do with reordering of operations. Do we basically check that the loop has any vectorization hint attached to it (and that it's not "don't vectorize this loop")? If my understanding is correct, could you please mention it in the comment somehow?

1537

I think I wasn't clear enough - I meant that while we do want to check this condition, it shouldn't be computed as a part of ThresholdReached variable, because semantically it doesn't belong there. I meant that we just need to pull out && !Hints.allowReordering to the check below.

[tyler.nowicki]

lib/Transforms/Vectorize/LoopVectorize.cpp

937–943

I'll modify the comment to make it a little more clear that an enabling hint indicates reordering.

[vsk]

Done in llvm/r244523

lib/Transforms/Vectorize/LoopVectorize.cpp

static cl::opt<bool> EnableCondStoresVectorization(
     "enable-cond-stores-vec", cl::init(false), cl::Hidden,
     cl::desc("Enable if predication of stores during vectorization."));
 
 static cl::opt<unsigned> MaxNestedScalarReductionIC(
     "max-nested-scalar-reduction-interleave", cl::init(2), cl::Hidden,
     cl::desc("The maximum interleave count to use when interleaving a scalar "
              "reduction in a nested loop."));
 
+static cl::opt<unsigned> PragmaVectorizeMemoryCheckThreshold(
+    "pragma-vectorize-memory-check-threshold", cl::init(128), cl::Hidden,
+    cl::desc("The maximum allowed number of runtime memory checks with a "
+             "vectorize(enable) pragma."));
+
 namespace {
 
 // Forward declarations.
 class LoopVectorizeHints;
 class LoopVectorizationLegality;
 class LoopVectorizationCostModel;
 class LoopVectorizationRequirements;
 
enum ForceKind {
     FK_Disabled = 0,   ///< Forcing disabled.
     FK_Enabled = 1,    ///< Forcing enabled.
   };
 
   LoopVectorizeHints(const Loop *L, bool DisableInterleaving)
       : Width("vectorize.width", VectorizerParams::VectorizationFactor,
               HK_WIDTH),
         Interleave("interleave.count", DisableInterleaving, HK_UNROLL),
         Force("vectorize.enable", FK_Undefined, HK_FORCE),
         TheLoop(L) {
     // Populate values with existing loop metadata.
     getHintsFromMetadata();
 
     // force-vector-interleave overrides DisableInterleaving.
     if (VectorizerParams::isInterleaveForced())
       Interleave.Value = VectorizerParams::VectorizationInterleave;
 
     DEBUG(if (DisableInterleaving && Interleave.Value == 1) dbgs()
           << "LV: Interleaving disabled by the pass manager\n");
   }
 
   /// Mark the loop L as already vectorized by setting the width to 1.
   void setAlreadyVectorized() {
     Width.Value = Interleave.Value = 1;
     Hint Hints[] = {Width, Interleave};
     writeHintsToMetadata(Hints);
   }
 
   bool allowVectorization(Function *F, Loop *L, bool AlwaysVectorize) const {
     if (getForce() == LoopVectorizeHints::FK_Disabled) {
       DEBUG(dbgs() << "LV: Not vectorizing: #pragma vectorize disable.\n");
-      emitOptimizationRemarkAnalysis(F->getContext(), DEBUG_TYPE, *F,
+      emitOptimizationRemarkAnalysis(F->getContext(),
+                                     vectorizeAnalysisPassName(), *F,
                                      L->getStartLoc(), emitRemark());
       return false;
     }
 
     if (!AlwaysVectorize && getForce() != LoopVectorizeHints::FK_Enabled) {
       DEBUG(dbgs() << "LV: Not vectorizing: No #pragma vectorize enable.\n");
-      emitOptimizationRemarkAnalysis(F->getContext(), DEBUG_TYPE, *F,
+      emitOptimizationRemarkAnalysis(F->getContext(),
+                                     vectorizeAnalysisPassName(), *F,
                                      L->getStartLoc(), emitRemark());
       return false;
     }
 
     if (getWidth() == 1 && getInterleave() == 1) {
       // FIXME: Add a separate metadata to indicate when the loop has already
       // been vectorized instead of setting width and count to 1.
       DEBUG(dbgs() << "LV: Not vectorizing: Disabled/already vectorized.\n");
       // FIXME: Add interleave.disable metadata. This will allow
       // vectorize.disable to be used without disabling the pass and errors
       // to differentiate between disabled vectorization and a width of 1.
       emitOptimizationRemarkAnalysis(
-          F->getContext(), DEBUG_TYPE, *F, L->getStartLoc(),
+          F->getContext(), vectorizeAnalysisPassName(), *F, L->getStartLoc(),
           "loop not vectorized: vectorization and interleaving are explicitly "
           "disabled, or vectorize width and interleave count are both set to "
           "1");
       return false;
     }
 
     return true;
   }
std::string emitRemark() const {
     }
 
     return R.str();
   }
 
   unsigned getWidth() const { return Width.Value; }
   unsigned getInterleave() const { return Interleave.Value; }
   enum ForceKind getForce() const { return (ForceKind)Force.Value; }
-  bool isForced() const {
-    return getForce() == LoopVectorizeHints::FK_Enabled || getWidth() > 1 ||
-           getInterleave() > 1;
+  const char *vectorizeAnalysisPassName() const {
+    // If hints are provided that don't disable vectorization use the
+    // AlwaysPrint pass name to force the frontend to print the diagnostic.
+    if (getWidth() == 1)
+      return LV_NAME;
+    if (getForce() == LoopVectorizeHints::FK_Disabled)
+      return LV_NAME;
+    if (getForce() == LoopVectorizeHints::FK_Undefined && getWidth() == 0)
+      return LV_NAME;
+    return DiagnosticInfo::AlwaysPrint;
+  }
+
+  bool allowReordering() const {
+    // Allow the vectorizer to change the order of operations that is given by
+    // the scalar loop when it is potentially unsafe or inefficient. For
+    // example, changing the order of floating-point operations can affect the
+    // result due to differences in floating-point round-off. Specifying a loop
+    // hint instructs the vectorizer to proceed.
+    return getForce() == LoopVectorizeHints::FK_Enabled || getWidth() > 1;
   }
 
 private:
   /// Find hints specified in the loop metadata and update local values.
   void getHintsFromMetadata() {
     MDNode *LoopID = TheLoop->getLoopID();
     if (!LoopID)
       return;
private:
 
   /// The loop these hints belong to.
   const Loop *TheLoop;
 };
 
 static void emitAnalysisDiag(const Function *TheFunction, const Loop *TheLoop,
                              const LoopVectorizeHints &Hints,
                              const LoopAccessReport &Message) {
-  // If a loop hint is provided the diagnostic is always produced.
-  const char *Name = Hints.isForced() ? DiagnosticInfo::AlwaysPrint : LV_NAME;
+  const char *Name = Hints.vectorizeAnalysisPassName();
   LoopAccessReport::emitAnalysis(Message, TheFunction, TheLoop, Name);
 }
 
 static void emitMissedWarning(Function *F, Loop *L,
                               const LoopVectorizeHints &LH) {
-  emitOptimizationRemarkMissed(F->getContext(), DEBUG_TYPE, *F,
-                               L->getStartLoc(), LH.emitRemark());
+  emitOptimizationRemarkMissed(F->getContext(), LV_NAME, *F, L->getStartLoc(),
+                               LH.emitRemark());
 
   if (LH.getForce() == LoopVectorizeHints::FK_Enabled) {
     if (LH.getWidth() != 1)
       emitLoopVectorizeWarning(
           F->getContext(), *F, L->getStartLoc(),
           "failed explicitly specified loop vectorization");
     else if (LH.getInterleave() != 1)
       emitLoopInterleaveWarning(
void addUnsafeAlgebraInst(Instruction *I) {
     // First unsafe algebra instruction.
     if (!UnsafeAlgebraInst)
       UnsafeAlgebraInst = I;
   }
 
   void addRuntimePointerChecks(unsigned Num) { NumRuntimePointerChecks = Num; }
 
   bool doesNotMeet(Function *F, Loop *L, const LoopVectorizeHints &Hints) {
-    // If a loop hint is provided the diagnostic is always produced.
-    const char *Name = Hints.isForced() ? DiagnosticInfo::AlwaysPrint : LV_NAME;
+    const char *Name = Hints.vectorizeAnalysisPassName();
     bool Failed = false;
-    if (UnsafeAlgebraInst &&
-        Hints.getForce() == LoopVectorizeHints::FK_Undefined &&
-        Hints.getWidth() == 0) {
+    if (UnsafeAlgebraInst && !Hints.allowReordering()) {
       emitOptimizationRemarkAnalysisFPCommute(
           F->getContext(), Name, *F, UnsafeAlgebraInst->getDebugLoc(),
-          VectorizationReport() << "vectorization requires changes in the "
-                                   "order of operations, however IEEE 754 "
-                                   "floating-point operations are not "
-                                   "commutative");
+          VectorizationReport() << "cannot prove it is safe to reorder "
+                                   "floating-point operations");
       Failed = true;
     }
 
-    if (NumRuntimePointerChecks >
-        VectorizerParams::RuntimeMemoryCheckThreshold) {
+    // Test if runtime memcheck thresholds are exceeded.
+    bool PragmaThresholdReached =
+        NumRuntimePointerChecks > PragmaVectorizeMemoryCheckThreshold;
+    bool ThresholdReached = NumRuntimePointerChecks >
+                                VectorizerParams::RuntimeMemoryCheckThreshold &&
+                            !Hints.allowReordering();
+    if (ThresholdReached || PragmaThresholdReached) {
       emitOptimizationRemarkAnalysisAliasing(
           F->getContext(), Name, *F, L->getStartLoc(),
           VectorizationReport()
-              << "cannot prove pointers refer to independent arrays in memory. "
-                 "The loop requires "
-              << NumRuntimePointerChecks
-              << " runtime independence checks to vectorize the loop, but that "
-                 "would exceed the limit of "
-              << VectorizerParams::RuntimeMemoryCheckThreshold << " checks");
+              << "cannot prove it is safe to reorder memory operations");
       DEBUG(dbgs() << "LV: Too many memory checks needed.\n");
       Failed = true;
     }
 
     return Failed;
   }
 
 private:
if (IC == 1 && UserIC <= 1) {
                    "but is explicitly disabled or interleave count is set to 1";
       InterleaveLoop = false;
     }
 
     // Override IC if user provided an interleave count.
     IC = UserIC > 0 ? UserIC : IC;
 
     // Emit diagnostic messages, if any.
+    const char *VAPassName = Hints.vectorizeAnalysisPassName();
     if (!VectorizeLoop && !InterleaveLoop) {
       // Do not vectorize or interleaving the loop.
-      emitOptimizationRemarkAnalysis(F->getContext(), DEBUG_TYPE, *F,
+      emitOptimizationRemarkAnalysis(F->getContext(), VAPassName, *F,
                                      L->getStartLoc(), VecDiagMsg);
-      emitOptimizationRemarkAnalysis(F->getContext(), DEBUG_TYPE, *F,
+      emitOptimizationRemarkAnalysis(F->getContext(), LV_NAME, *F,
                                      L->getStartLoc(), IntDiagMsg);
       return false;
     } else if (!VectorizeLoop && InterleaveLoop) {
       DEBUG(dbgs() << "LV: Interleave Count is " << IC << '\n');
-      emitOptimizationRemarkAnalysis(F->getContext(), DEBUG_TYPE, *F,
+      emitOptimizationRemarkAnalysis(F->getContext(), VAPassName, *F,
                                      L->getStartLoc(), VecDiagMsg);
     } else if (VectorizeLoop && !InterleaveLoop) {
       DEBUG(dbgs() << "LV: Found a vectorizable loop (" << VF.Width << ") in "
                    << DebugLocStr << '\n');
-      emitOptimizationRemarkAnalysis(F->getContext(), DEBUG_TYPE, *F,
+      emitOptimizationRemarkAnalysis(F->getContext(), LV_NAME, *F,
                                      L->getStartLoc(), IntDiagMsg);
     } else if (VectorizeLoop && InterleaveLoop) {
       DEBUG(dbgs() << "LV: Found a vectorizable loop (" << VF.Width << ") in "
                    << DebugLocStr << '\n');
       DEBUG(dbgs() << "LV: Interleave Count is " << IC << '\n');
     }
 
     if (!VectorizeLoop) {
       assert(IC > 1 && "interleave count should not be 1 or 0");
       // If we decided that it is not legal to vectorize the loop then
       // interleave it.
       InnerLoopUnroller Unroller(L, SE, LI, DT, TLI, TTI, IC);
       Unroller.vectorize(&LVL);
 
-      emitOptimizationRemark(F->getContext(), DEBUG_TYPE, *F, L->getStartLoc(),
+      emitOptimizationRemark(F->getContext(), LV_NAME, *F, L->getStartLoc(),
                              Twine("interleaved loop (interleaved count: ") +
                                  Twine(IC) + ")");
     } else {
       // If we decided that it is *legal* to vectorize the loop then do it.
       InnerLoopVectorizer LB(L, SE, LI, DT, TLI, TTI, VF.Width, IC);
       LB.vectorize(&LVL);
       ++LoopsVectorized;
 
       // Add metadata to disable runtime unrolling scalar loop when there's no
       // runtime check about strides and memory. Because at this situation,
       // scalar loop is rarely used not worthy to be unrolled.
       if (!LB.IsSafetyChecksAdded())
         AddRuntimeUnrollDisableMetaData(L);
 
       // Report the vectorization decision.
-      emitOptimizationRemark(F->getContext(), DEBUG_TYPE, *F, L->getStartLoc(),
+      emitOptimizationRemark(F->getContext(), LV_NAME, *F, L->getStartLoc(),
                              Twine("vectorized loop (vectorization width: ") +
                                  Twine(VF.Width) + ", interleaved count: " +
                                  Twine(IC) + ")");
     }
 
     // Mark the loop as already vectorized to avoid vectorizing again.
     Hints.setAlreadyVectorized();
 

test/Transforms/LoopVectorize/X86/no_fpmath.ll

 ; RUN: opt < %s -loop-vectorize -mtriple=x86_64-unknown-linux -S -pass-remarks='loop-vectorize' -pass-remarks-missed='loop-vectorize' -pass-remarks-analysis='loop-vectorize' 2>&1 | FileCheck %s
 
-; CHECK: remark: no_fpmath.c:6:11: loop not vectorized: vectorization requires changes in the order of operations, however IEEE 754 floating-point operations are not commutative
+; CHECK: remark: no_fpmath.c:6:11: loop not vectorized: cannot prove it is safe to reorder floating-point operations
 ; CHECK: remark: no_fpmath.c:6:14: loop not vectorized:
 ; CHECK: remark: no_fpmath.c:17:14: vectorized loop (vectorization width: 2, interleaved count: 2)
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.10.0"
 
 ; Function Attrs: nounwind readonly ssp uwtable
 define double @cond_sum(i32* nocapture readonly %v, i32 %n) #0 {

test/Transforms/LoopVectorize/no_switch.ll

-; RUN: opt < %s -loop-vectorize -force-vector-width=4 -S -pass-remarks-missed='loop-vectorize' 2>&1 | FileCheck %s
+; RUN: opt < %s -loop-vectorize -force-vector-width=4 -S 2>&1 | FileCheck %s
+; RUN: opt < %s -loop-vectorize -force-vector-width=1 -S 2>&1 | FileCheck %s -check-prefix=NOANALYSIS
+; RUN: opt < %s -loop-vectorize -force-vector-width=4 -pass-remarks-missed='loop-vectorize' -S 2>&1 | FileCheck %s -check-prefix=MOREINFO
 
 ; CHECK: remark: source.cpp:4:5: loop not vectorized: loop contains a switch statement
-; CHECK: remark: source.cpp:4:5: loop not vectorized: use -Rpass-analysis=loop-vectorize for more info (Force=true, Vector Width=4)
 ; CHECK: warning: source.cpp:4:5: loop not vectorized: failed explicitly specified loop vectorization
 
+; NOANALYSIS-NOT: remark: {{.*}}
+; NOANALYSIS: warning: source.cpp:4:5: loop not interleaved: failed explicitly specified loop interleaving
+
+; MOREINFO: remark: source.cpp:4:5: loop not vectorized: loop contains a switch statement
+; MOREINFO: remark: source.cpp:4:5: loop not vectorized: use -Rpass-analysis=loop-vectorize for more info (Force=true, Vector Width=4)
+; MOREINFO: warning: source.cpp:4:5: loop not vectorized: failed explicitly specified loop vectorization
+
 ; CHECK: _Z11test_switchPii
 ; CHECK-NOT: x i32>
 ; CHECK: ret
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 ; Function Attrs: nounwind optsize ssp uwtable
 define void @_Z11test_switchPii(i32* nocapture %A, i32 %Length) #0 {

test/Transforms/LoopVectorize/runtime-limit.ll

-; RUN: opt < %s  -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -pass-remarks=loop-vectorize -pass-remarks-missed=loop-vectorize -S 2>&1 | FileCheck %s
+; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -dce -instcombine -pass-remarks=loop-vectorize -pass-remarks-missed=loop-vectorize -S 2>&1 | FileCheck %s
+; RUN: opt < %s -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -dce -instcombine -pass-remarks=loop-vectorize -pass-remarks-missed=loop-vectorize -S 2>&1 | FileCheck %s -check-prefix=OVERRIDE
+; RUN: opt < %s -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -pragma-vectorize-memory-check-threshold=6 -dce -instcombine -pass-remarks=loop-vectorize -pass-remarks-missed=loop-vectorize -S 2>&1 | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.8.0"
 
 ; First loop produced diagnostic pass remark.
-;CHECK: remark: {{.*}}:0:0: vectorized loop (vectorization width: 4, interleaved count: 1)
+;CHECK: remark: {{.*}}:0:0: vectorized loop (vectorization width: {{[0-9]}}, interleaved count: 1)
 ; Second loop produces diagnostic analysis remark.
-;CHECK: remark: {{.*}}:0:0: loop not vectorized: cannot prove pointers refer to independent arrays in memory. The loop requires 11 runtime independence checks to vectorize the loop, but that would exceed the limit of 8 checks
+;CHECK: remark: {{.*}}:0:0: loop not vectorized: cannot prove it is safe to reorder memory operations
+
+; First loop produced diagnostic pass remark.
+;OVERRIDE: remark: {{.*}}:0:0: vectorized loop (vectorization width: {{[0-9]}}, interleaved count: 1)
+; Second loop produces diagnostic pass remark.
+;OVERRIDE: remark: {{.*}}:0:0: vectorized loop (vectorization width: {{[0-9]}}, interleaved count: 1)
 
 ; We are vectorizing with 6 runtime checks.
 ;CHECK-LABEL: func1x6(
-;CHECK: <4 x i32>
+;CHECK: <{{[0-9]}} x i32>
 ;CHECK: ret
+;OVERRIDE-LABEL: func1x6(
+;OVERRIDE: <4 x i32>
+;OVERRIDE: ret
 define i32 @func1x6(i32* nocapture %out, i32* nocapture %A, i32* nocapture %B, i32* nocapture %C, i32* nocapture %D, i32* nocapture %E, i32* nocapture %F) {
 entry:
   br label %for.body
 
 for.body:                                         ; preds = %for.body, %entry
   %i.016 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
   %arrayidx = getelementptr inbounds i32, i32* %A, i64 %i.016
   %0 = load i32, i32* %arrayidx, align 4
for.body:                                         ; preds = %for.body, %entry
   br i1 %exitcond, label %for.end, label %for.body
 
 for.end:                                          ; preds = %for.body
   ret i32 undef
 }
 
 ; We are not vectorizing with 12 runtime checks.
 ;CHECK-LABEL: func2x6(
-;CHECK-NOT: <4 x i32>
+;CHECK-NOT: <{{[0-9]}} x i32>
 ;CHECK: ret
+; We vectorize with 12 checks if a vectorization hint is provided.
+;OVERRIDE-LABEL: func2x6(
+;OVERRIDE: <4 x i32>
+;OVERRIDE: ret
 define i32 @func2x6(i32* nocapture %out, i32* nocapture %out2, i32* nocapture %A, i32* nocapture %B, i32* nocapture %C, i32* nocapture %D, i32* nocapture %E, i32* nocapture %F) {
 entry:
   br label %for.body
 
 for.body:                                         ; preds = %for.body, %entry
   %i.037 = phi i64 [ 0, %entry ], [ %inc, %for.body ]
   %arrayidx = getelementptr inbounds i32, i32* %A, i64 %i.037
   %0 = load i32, i32* %arrayidx, align 4