diff --git a/llvm/include/llvm/Analysis/LoopAccessAnalysis.h b/llvm/include/llvm/Analysis/LoopAccessAnalysis.h --- a/llvm/include/llvm/Analysis/LoopAccessAnalysis.h +++ b/llvm/include/llvm/Analysis/LoopAccessAnalysis.h @@ -258,6 +258,10 @@ SmallVector getInstructionsForAccess(Value *Ptr, bool isWrite) const; + const SmallVector &getUnsafeDependences() const { + return UnsafeDependences; + } + private: /// A wrapper around ScalarEvolution, used to add runtime SCEV checks, and /// applies dynamic knowledge to simplify SCEV expressions and convert them @@ -304,6 +308,10 @@ /// RecordDependences is true. SmallVector Dependences; + /// Unsafe memory dependences collected during the analysis. + /// Used for generating optimization remarks. + SmallVector UnsafeDependences; + /// Check whether there is a plausible dependence between the two /// accesses. /// @@ -524,6 +532,14 @@ /// PSE must be emitted in order for the results of this analysis to be valid. class LoopAccessInfo { public: + /// Reasons why memory accesses cannot be vectorized (used for OptRemarks) + enum class FailureReason { + UnsafeDataDependence, + UnsafeDataDependenceTriedRT, + UnknownArrayBounds, + Unknown + }; + LoopAccessInfo(Loop *L, ScalarEvolution *SE, const TargetLibraryInfo *TLI, AAResults *AA, DominatorTree *DT, LoopInfo *LI); @@ -531,6 +547,10 @@ /// no memory dependence cycles. bool canVectorizeMemory() const { return CanVecMem; } + /// Return reason describing why memory access cannot be vectorized. + // Used for the OptRemark generation. + FailureReason getFailureReason() const { return FailReason; } + /// Return true if there is a convergent operation in the loop. There may /// still be reported runtime pointer checks that would be required, but it is /// not legal to insert them. @@ -589,6 +609,10 @@ return HasDependenceInvolvingLoopInvariantAddress; } + const SmallPtrSet &getUncomputablePtrs() const { + return UncomputablePtrs; + } + /// Used to add runtime SCEV checks. Simplifies SCEV expressions and converts /// them to a more usable form. All SCEV expressions during the analysis /// should be re-written (and therefore simplified) according to PSE. @@ -653,6 +677,13 @@ /// Set of symbolic strides values. SmallPtrSet StrideSet; + + /// Reason why memory accesses cannot be vectorized (used for OptRemarks) + FailureReason FailReason; + + /// Set of uncomputable pointers. + /// Used when emitting OptRemarks + SmallPtrSet UncomputablePtrs; }; Value *stripIntegerCast(Value *V); diff --git a/llvm/include/llvm/Transforms/Vectorize/LoopVectorizationLegality.h b/llvm/include/llvm/Transforms/Vectorize/LoopVectorizationLegality.h --- a/llvm/include/llvm/Transforms/Vectorize/LoopVectorizationLegality.h +++ b/llvm/include/llvm/Transforms/Vectorize/LoopVectorizationLegality.h @@ -402,6 +402,10 @@ /// If false, good old LV code. bool canVectorizeLoopNestCFG(Loop *Lp, bool UseVPlanNativePath); + /// Elaborate on the summary report from LoopAccessAnalysis + /// with more remarks based on the failure reasons. + void elaborateMemoryReport(); + /// Set up outer loop inductions by checking Phis in outer loop header for /// supported inductions (int inductions). Return false if any of these Phis /// is not a supported induction or if we fail to find an induction. @@ -463,6 +467,9 @@ return LAI ? &LAI->getSymbolicStrides() : nullptr; } + OptimizationRemarkAnalysis + createMissedAnalysis(StringRef RemarkName, Instruction *I = nullptr) const; + /// The loop that we evaluate. Loop *TheLoop; diff --git a/llvm/lib/Analysis/LoopAccessAnalysis.cpp b/llvm/lib/Analysis/LoopAccessAnalysis.cpp --- a/llvm/lib/Analysis/LoopAccessAnalysis.cpp +++ b/llvm/lib/Analysis/LoopAccessAnalysis.cpp @@ -584,6 +584,11 @@ MemAccessInfoList &getDependenciesToCheck() { return CheckDeps; } + /// Set of uncomputable pointers. + // + // Used when emitting no_vec_unknown_array_bounds insight. + SmallPtrSet UncomputablePtrs; + private: typedef SetVector PtrAccessSet; @@ -768,6 +773,7 @@ for (auto &Access : AccessInfos) { if (!createCheckForAccess(RtCheck, Access, StridesMap, DepSetId, TheLoop, RunningDepId, ASId, ShouldCheckWrap, false)) { + UncomputablePtrs.insert(Access.getPointer()); LLVM_DEBUG(dbgs() << "LAA: Can't find bounds for ptr:" << *Access.getPointer() << '\n'); Retries.push_back(Access); @@ -1711,6 +1717,15 @@ isDependent(*A.first, A.second, *B.first, B.second, Strides); mergeInStatus(Dependence::isSafeForVectorization(Type)); + // Runtime checks are only feasible, if all unsafe dependencies are + // unknown. For other unsafe deps, we already know they will fail + // the runtime checks at compile time. + if (!isSafeForVectorization()) { + // TODO: Add minDistanc, actual distance, minIter and type size + // for unsafe dependences to generate better insight + UnsafeDependences.push_back(Dependence(A.second, B.second, Type)); + } + // Gather dependences unless we accumulated MaxDependences // dependences. In that case return as soon as we find the first // unsafe dependence. This puts a limit on this quadratic @@ -2026,6 +2041,8 @@ LLVM_DEBUG(dbgs() << "LAA: We can't vectorize because we can't find " << "the array bounds.\n"); CanVecMem = false; + FailReason = FailureReason::UnknownArrayBounds; + UncomputablePtrs = std::move(Accesses.UncomputablePtrs); return; } @@ -2058,6 +2075,7 @@ << "cannot check memory dependencies at runtime"; LLVM_DEBUG(dbgs() << "LAA: Can't vectorize with memory checks\n"); CanVecMem = false; + FailReason = FailureReason::UnsafeDataDependenceTriedRT; return; } @@ -2086,6 +2104,7 @@ "to attempt to isolate the offending operations into a separate " "loop"; LLVM_DEBUG(dbgs() << "LAA: unsafe dependent memory operations in loop\n"); + FailReason = FailureReason::UnsafeDataDependence; } } @@ -2195,8 +2214,8 @@ PtrRtChecking(std::make_unique(SE)), DepChecker(std::make_unique(*PSE, L)), TheLoop(L), NumLoads(0), NumStores(0), MaxSafeDepDistBytes(-1), CanVecMem(false), - HasConvergentOp(false), - HasDependenceInvolvingLoopInvariantAddress(false) { + HasConvergentOp(false), HasDependenceInvolvingLoopInvariantAddress(false), + FailReason(FailureReason::Unknown) { if (canAnalyzeLoop()) analyzeLoop(AA, LI, TLI, DT); } diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorizationLegality.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorizationLegality.cpp --- a/llvm/lib/Transforms/Vectorize/LoopVectorizationLegality.cpp +++ b/llvm/lib/Transforms/Vectorize/LoopVectorizationLegality.cpp @@ -77,6 +77,34 @@ namespace llvm { +/// Create an analysis remark that explains why vectorization failed +/// +/// \p PassName is the name of the pass (e.g. can be AlwaysPrint). \p +/// RemarkName is the identifier for the remark. If \p I is passed it is an +/// instruction that prevents vectorization. Otherwise \p TheLoop is used for +/// the location of the remark. \return the remark object that can be +/// streamed to. +static OptimizationRemarkAnalysis +createMissedAnalysis(const char *PassName, StringRef RemarkName, Loop *TheLoop, + Instruction *I = nullptr) { + Value *CodeRegion = TheLoop->getHeader(); + DebugLoc StartLoc = TheLoop->getLocRange().getStart(); + + if (I) { + CodeRegion = I->getParent(); + // If there is no debug location attached to the instruction, or if the + // location is invalid, revert back to using the loop's. + if (DebugLoc DL = I->getDebugLoc()) + if (DL->getLine() != 0) + StartLoc = DL; + } + + auto LocRange = DiagnosticLocation(StartLoc); + OptimizationRemarkAnalysis R(PassName, RemarkName, LocRange, CodeRegion); + R << "loop not vectorized: "; + return R; +} + bool LoopVectorizeHints::Hint::validate(unsigned Val) { switch (Kind) { case HK_WIDTH: @@ -419,6 +447,18 @@ return false; } +/// Create an analysis remark that explains why vectorization failed +/// +/// \p RemarkName is the identifier for the remark. If \p I is passed it is +/// an instruction that prevents vectorization. Otherwise the loop is used +/// for the location of the remark. \return the remark object that can be +/// streamed to. +OptimizationRemarkAnalysis LoopVectorizationLegality::createMissedAnalysis( + StringRef RemarkName, Instruction *I /*= nullptr*/) const { + return ::createMissedAnalysis(Hints->vectorizeAnalysisPassName(), RemarkName, + TheLoop, I); +} + int LoopVectorizationLegality::isConsecutivePtr(Value *Ptr) const { const ValueToValueMap &Strides = getSymbolicStrides() ? *getSymbolicStrides() : ValueToValueMap(); @@ -876,6 +916,95 @@ return true; } +static DebugLoc getDebugLocFromInstruction(Instruction *I) { + DebugLoc Loc; + if (auto *D = dyn_cast(I)) { + Loc = D->getDebugLoc(); + + if (auto *DD = dyn_cast(isa(D) + ? cast(D)->getRawDest() + : getPointerOperand(D))) + Loc = DD->getDebugLoc(); + } + return Loc; +} + +/// Add memory access related remarks for TheLoop. +void LoopVectorizationLegality::elaborateMemoryReport() { + switch (LAI->getFailureReason()) { + case LoopAccessInfo::FailureReason::UnsafeDataDependence: { + const auto &UnsafeDependences = LAI->getDepChecker().getUnsafeDependences(); + unsigned NumUnsafeDeps = UnsafeDependences.size(); + assert(NumUnsafeDeps > 0 && "expected unsafe dependencies but found none"); + + // Emit detailed remarks for each unsafe dependence + for (const auto &Dep : UnsafeDependences) { + switch (Dep.Type) { + case MemoryDepChecker::Dependence::NoDep: + case MemoryDepChecker::Dependence::Forward: + case MemoryDepChecker::Dependence::BackwardVectorizable: + // Don't emit a remark for dependences that don't block vectorization. + continue; + default: + break; + } + + DebugLoc SourceLoc = getDebugLocFromInstruction(Dep.getSource(*LAI)); + DebugLoc DestinationLoc = + getDebugLocFromInstruction(Dep.getDestination(*LAI)); + + OptimizationRemarkAnalysis R(Hints->vectorizeAnalysisPassName(), + "UnsafeDep", DestinationLoc, + TheLoop->getHeader()); + R << "loop not vectorized: "; + std::string LocText = " Memory location is the same as accessed at line "; + if (SourceLoc) { + LocText += std::to_string(SourceLoc.getLine()) + ":" + + std::to_string(SourceLoc.getCol()); + } else { + LocText += ":"; + } + switch (Dep.Type) { + case MemoryDepChecker::Dependence::NoDep: + case MemoryDepChecker::Dependence::Forward: + case MemoryDepChecker::Dependence::BackwardVectorizable: + llvm_unreachable("Unexpected dependency"); + case MemoryDepChecker::Dependence::Backward: + ORE->emit(R << "Backward loop carried data dependence." + LocText); + break; + case MemoryDepChecker::Dependence::ForwardButPreventsForwarding: + ORE->emit(R << "Forward loop carried data dependence that prevents " + "store-to-load forwarding." + + LocText); + break; + case MemoryDepChecker::Dependence:: + BackwardVectorizableButPreventsForwarding: + ORE->emit(R << "Backward loop carried data dependence that prevents " + "store-to-load forwarding." + + LocText); + break; + case MemoryDepChecker::Dependence::Unknown: + ORE->emit(R << "Unknown data dependence." + LocText); + break; + } + } + break; + } + case LoopAccessInfo::FailureReason::UnknownArrayBounds: { + // add detailed remarks at locations of pointers where bound cannot + // be computed + for (Value *Ptr : LAI->getUncomputablePtrs()) + if (auto *I = dyn_cast(Ptr)) + ORE->emit(createMissedAnalysis("UnknownArrayBounds", I) + << "Unknown array bounds"); + break; + } + case LoopAccessInfo::FailureReason::Unknown: + case LoopAccessInfo::FailureReason::UnsafeDataDependenceTriedRT: + break; + } +} + bool LoopVectorizationLegality::canVectorizeMemory() { LAI = &(*GetLAA)(*TheLoop); const OptimizationRemarkAnalysis *LAR = LAI->getReport(); @@ -886,8 +1015,10 @@ }); } - if (!LAI->canVectorizeMemory()) + if (!LAI->canVectorizeMemory()) { + elaborateMemoryReport(); return false; + } if (LAI->hasDependenceInvolvingLoopInvariantAddress()) { reportVectorizationFailure("Stores to a uniform address", diff --git a/llvm/test/Transforms/LoopVectorize/X86/vectorization-remarks-missed.ll b/llvm/test/Transforms/LoopVectorize/X86/vectorization-remarks-missed.ll --- a/llvm/test/Transforms/LoopVectorize/X86/vectorization-remarks-missed.ll +++ b/llvm/test/Transforms/LoopVectorize/X86/vectorization-remarks-missed.ll @@ -82,6 +82,15 @@ ; YAML-NEXT: - String: 'loop not vectorized: ' ; YAML-NEXT: - String: cannot identify array bounds ; YAML-NEXT: ... +; YAML-NEXT: --- !Analysis +; YAML-NEXT: Pass: '' +; YAML-NEXT: Name: UnknownArrayBounds +; YAML-NEXT: DebugLoc: { File: source.cpp, Line: 19, Column: 5 } +; YAML-NEXT: Function: _Z17test_array_boundsPiS_i +; YAML-NEXT: Args: +; YAML-NEXT: - String: 'loop not vectorized: ' +; YAML-NEXT: - String: Unknown array bounds +; YAML-NEXT: ... ; YAML-NEXT: --- !Missed ; YAML-NEXT: Pass: loop-vectorize ; YAML-NEXT: Name: MissedDetails diff --git a/llvm/test/Transforms/LoopVectorize/loopvectorize-opt-remarks.ll b/llvm/test/Transforms/LoopVectorize/loopvectorize-opt-remarks.ll new file mode 100644 --- /dev/null +++ b/llvm/test/Transforms/LoopVectorize/loopvectorize-opt-remarks.ll @@ -0,0 +1,546 @@ +; RUN: opt -enable-new-pm=0 -loop-vectorize -analyze -pass-remarks-analysis=loop-vectorize < %s 2>&1 | FileCheck %s +target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128" + + +; void test_unknown_bounds(int* A, int* B, int n) { +; for(int i = 0; i < n ; ++i) +; A[i] = A[B[i]] + 1; +; } + +; CHECK: remark: source.c:3:5: loop not vectorized: cannot identify array bounds +; CHECK: remark: source.c:4:16: loop not vectorized: Unknown array bounds + +define void @test_unknown_bounds(i32* nocapture %A, i32* nocapture readonly %B, i64 %n) !dbg !13 { +entry: + %cmp10 = icmp sgt i64 %n, 0 + br i1 %cmp10, label %for.body, label %for.cond.cleanup + +for.cond.cleanup: ; preds = %for.body, %entry + ret void + +for.body: ; preds = %entry, %for.body + %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] + %arrayidx = getelementptr inbounds i32, i32* %B, i64 %indvars.iv + %0 = load i32, i32* %arrayidx, align 4, !tbaa !31 + %idxprom1 = sext i32 %0 to i64, !dbg !35 + %arrayidx2 = getelementptr inbounds i32, i32* %A, i64 %idxprom1, !dbg !35 + %1 = load i32, i32* %arrayidx2, align 4, !dbg !35, !tbaa !31 + %add = add nsw i32 %1, 1 + %arrayidx4 = getelementptr inbounds i32, i32* %A, i64 %indvars.iv + store i32 %add, i32* %arrayidx4, align 4, !tbaa !31 + %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 + %exitcond.not = icmp eq i64 %indvars.iv.next, %n + br i1 %exitcond.not, label %for.cond.cleanup, label %for.body, !llvm.loop !40 +} + +; // a) Dependence::NoDep +; // Loop containing only reads does not hinder vectorization +; void test_nodep(int n, int* A, int* B, int* C) { +; for(int i = 1; i < n ; ++i) { +; B[i] = A[i-1]; +; C[i] = A[i+2]; +; } +; } + +; CHECK: remark: source.c:15:3: loop not vectorized: vectorization and interleaving are explicitly disabled, or the loop has already been vectorized + +define void @test_nodep(i64 %n, i32* nocapture readonly %A, i32* nocapture %B, i32* nocapture %C) !dbg !43 { +entry: + %cmp14 = icmp sgt i64 %n, 1 + br i1 %cmp14, label %for.body.preheader, label %for.cond.cleanup, !dbg !57 + +for.body.preheader: ; preds = %entry + %0 = add nsw i64 %n, -1, !dbg !57 + %min.iters.check = icmp ult i64 %0, 8, !dbg !57 + br i1 %min.iters.check, label %for.body.preheader40, label %vector.memcheck, !dbg !57 + +vector.memcheck: ; preds = %for.body.preheader + %scevgep = getelementptr i32, i32* %B, i64 1, !dbg !57 + %scevgep21 = getelementptr i32, i32* %B, i64 %n, !dbg !57 + %scevgep23 = getelementptr i32, i32* %C, i64 1, !dbg !57 + %scevgep25 = getelementptr i32, i32* %C, i64 %n, !dbg !57 + %1 = add nuw nsw i64 %n, 2, !dbg !57 + %scevgep28 = getelementptr i32, i32* %A, i64 %1, !dbg !57 + %bound0 = icmp ult i32* %scevgep, %scevgep25, !dbg !57 + %bound1 = icmp ult i32* %scevgep23, %scevgep21, !dbg !57 + %found.conflict = and i1 %bound0, %bound1, !dbg !57 + %bound030 = icmp ult i32* %scevgep, %scevgep28, !dbg !57 + %bound131 = icmp ugt i32* %scevgep21, %A, !dbg !57 + %found.conflict32 = and i1 %bound030, %bound131, !dbg !57 + %conflict.rdx = or i1 %found.conflict, %found.conflict32, !dbg !57 + %bound033 = icmp ult i32* %scevgep23, %scevgep28, !dbg !57 + %bound134 = icmp ugt i32* %scevgep25, %A, !dbg !57 + %found.conflict35 = and i1 %bound033, %bound134, !dbg !57 + %conflict.rdx36 = or i1 %conflict.rdx, %found.conflict35, !dbg !57 + br i1 %conflict.rdx36, label %for.body.preheader40, label %vector.ph, !dbg !57 + +vector.ph: ; preds = %vector.memcheck + %n.vec = and i64 %0, -8, !dbg !57 + %ind.end = or i64 %n.vec, 1, !dbg !57 + br label %vector.body, !dbg !57 + +vector.body: ; preds = %vector.body, %vector.ph + %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ] + %offset.idx = or i64 %index, 1 + %2 = getelementptr inbounds i32, i32* %A, i64 %index + %3 = bitcast i32* %2 to <4 x i32>* + %wide.load = load <4 x i32>, <4 x i32>* %3, align 4, !tbaa !31, !alias.scope !60 + %4 = getelementptr inbounds i32, i32* %2, i64 4 + %5 = bitcast i32* %4 to <4 x i32>* + %wide.load37 = load <4 x i32>, <4 x i32>* %5, align 4, !tbaa !31, !alias.scope !60 + %6 = getelementptr inbounds i32, i32* %B, i64 %offset.idx + %7 = bitcast i32* %6 to <4 x i32>* + store <4 x i32> %wide.load, <4 x i32>* %7, align 4, !tbaa !31, !alias.scope !65, !noalias !67 + %8 = getelementptr inbounds i32, i32* %6, i64 4 + %9 = bitcast i32* %8 to <4 x i32>* + store <4 x i32> %wide.load37, <4 x i32>* %9, align 4, !tbaa !31, !alias.scope !65, !noalias !67 + %10 = or i64 %index, 3 + %11 = getelementptr inbounds i32, i32* %A, i64 %10 + %12 = bitcast i32* %11 to <4 x i32>* + %wide.load38 = load <4 x i32>, <4 x i32>* %12, align 4, !tbaa !31, !alias.scope !60 + %13 = getelementptr inbounds i32, i32* %11, i64 4 + %14 = bitcast i32* %13 to <4 x i32>* + %wide.load39 = load <4 x i32>, <4 x i32>* %14, align 4, !tbaa !31, !alias.scope !60 + %15 = getelementptr inbounds i32, i32* %C, i64 %offset.idx + %16 = bitcast i32* %15 to <4 x i32>* + store <4 x i32> %wide.load38, <4 x i32>* %16, align 4, !tbaa !31, !alias.scope !73, !noalias !60 + %17 = getelementptr inbounds i32, i32* %15, i64 4 + %18 = bitcast i32* %17 to <4 x i32>* + store <4 x i32> %wide.load39, <4 x i32>* %18, align 4, !tbaa !31, !alias.scope !73, !noalias !60 + %index.next = add nuw i64 %index, 8 + %19 = icmp eq i64 %index.next, %n.vec + br i1 %19, label %middle.block, label %vector.body, !llvm.loop !74 + +middle.block: ; preds = %vector.body + %cmp.n = icmp eq i64 %0, %n.vec, !dbg !57 + br i1 %cmp.n, label %for.cond.cleanup, label %for.body.preheader40, !dbg !57 + +for.body.preheader40: ; preds = %vector.memcheck, %for.body.preheader, %middle.block + %indvars.iv.ph = phi i64 [ 1, %vector.memcheck ], [ 1, %for.body.preheader ], [ %ind.end, %middle.block ] + br label %for.body, !dbg !57 + +for.cond.cleanup: ; preds = %for.body, %middle.block, %entry + ret void + +for.body: ; preds = %for.body.preheader40, %for.body + %indvars.iv = phi i64 [ %indvars.iv.next, %for.body ], [ %indvars.iv.ph, %for.body.preheader40 ] + %20 = add nsw i64 %indvars.iv, -1 + %arrayidx = getelementptr inbounds i32, i32* %A, i64 %20 + %21 = load i32, i32* %arrayidx, align 4, !tbaa !31 + %arrayidx2 = getelementptr inbounds i32, i32* %B, i64 %indvars.iv + store i32 %21, i32* %arrayidx2, align 4, !tbaa !31 + %22 = add nuw nsw i64 %indvars.iv, 2 + %arrayidx4 = getelementptr inbounds i32, i32* %A, i64 %22 + %23 = load i32, i32* %arrayidx4, align 4, !tbaa !31 + %arrayidx6 = getelementptr inbounds i32, i32* %C, i64 %indvars.iv + store i32 %23, i32* %arrayidx6, align 4, !tbaa !31 + %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 + %exitcond.not = icmp eq i64 %indvars.iv.next, %n + br i1 %exitcond.not, label %for.cond.cleanup, label %for.body, !dbg !57, !llvm.loop !80 +} + + +; // b) Dependence::Forward +; // Loop gets vectorized since it contains only a forward +; // dependency between A[i-2] and A[i] +; void test_forward(int n, int* A, int* B) { +; for(int i=1; i < n; ++i) { +; A[i] = 10; +; B[i] = A[i-2]; +; } +; } + +; CHECK: remark: source.c:25:3: loop not vectorized: vectorization and interleaving are explicitly disabled, or the loop has already been vectorized +define void @test_forward(i64 %n, i32* nocapture %A, i32* nocapture %B) !dbg !81 { +entry: + %cmp11 = icmp sgt i64 %n, 1 + br i1 %cmp11, label %for.body.preheader, label %for.cond.cleanup, !dbg !94 + +for.body.preheader: ; preds = %entry + %0 = add nsw i64 %n, -1, !dbg !94 + %min.iters.check = icmp ult i64 %0, 4, !dbg !94 + br i1 %min.iters.check, label %for.body.preheader22, label %vector.memcheck, !dbg !94 + +vector.memcheck: ; preds = %for.body.preheader + %scevgep = getelementptr i32, i32* %A, i64 -1, !dbg !94 + %scevgep16 = getelementptr i32, i32* %A, i64 %n, !dbg !94 + %scevgep18 = getelementptr i32, i32* %B, i64 1, !dbg !94 + %scevgep20 = getelementptr i32, i32* %B, i64 %n, !dbg !94 + %bound0 = icmp ult i32* %scevgep, %scevgep20, !dbg !94 + %bound1 = icmp ult i32* %scevgep18, %scevgep16, !dbg !94 + %found.conflict = and i1 %bound0, %bound1, !dbg !94 + br i1 %found.conflict, label %for.body.preheader22, label %vector.ph, !dbg !94 + +vector.ph: ; preds = %vector.memcheck + %n.vec = and i64 %0, -4, !dbg !94 + %ind.end = or i64 %n.vec, 1, !dbg !94 + br label %vector.body, !dbg !94 + +vector.body: ; preds = %vector.body, %vector.ph + %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ] + %offset.idx = or i64 %index, 1 + %1 = getelementptr inbounds i32, i32* %A, i64 %offset.idx + %2 = bitcast i32* %1 to <4 x i32>* + store <4 x i32> , <4 x i32>* %2, align 4, !tbaa !31, !alias.scope !98, !noalias !101 + %3 = add i64 %index, -1 + %4 = getelementptr inbounds i32, i32* %A, i64 %3 + %5 = bitcast i32* %4 to <4 x i32>* + %wide.load = load <4 x i32>, <4 x i32>* %5, align 4, !tbaa !31, !alias.scope !98, !noalias !101 + %6 = getelementptr inbounds i32, i32* %B, i64 %offset.idx + %7 = bitcast i32* %6 to <4 x i32>* + store <4 x i32> %wide.load, <4 x i32>* %7, align 4, !tbaa !31, !alias.scope !101 + %index.next = add nuw i64 %index, 4 + %8 = icmp eq i64 %index.next, %n.vec + br i1 %8, label %middle.block, label %vector.body, !llvm.loop !107 + +middle.block: ; preds = %vector.body + %cmp.n = icmp eq i64 %0, %n.vec, !dbg !94 + br i1 %cmp.n, label %for.cond.cleanup, label %for.body.preheader22, !dbg !94 + +for.body.preheader22: ; preds = %vector.memcheck, %for.body.preheader, %middle.block + %indvars.iv.ph = phi i64 [ 1, %vector.memcheck ], [ 1, %for.body.preheader ], [ %ind.end, %middle.block ] + br label %for.body, !dbg !94 + +for.cond.cleanup: ; preds = %for.body, %middle.block, %entry + ret void + +for.body: ; preds = %for.body.preheader22, %for.body + %indvars.iv = phi i64 [ %indvars.iv.next, %for.body ], [ %indvars.iv.ph, %for.body.preheader22 ] + %arrayidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv + store i32 10, i32* %arrayidx, align 4, !tbaa !31 + %9 = add nsw i64 %indvars.iv, -2 + %arrayidx2 = getelementptr inbounds i32, i32* %A, i64 %9 + %10 = load i32, i32* %arrayidx2, align 4, !tbaa !31 + %arrayidx4 = getelementptr inbounds i32, i32* %B, i64 %indvars.iv + store i32 %10, i32* %arrayidx4, align 4, !tbaa !31 + %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 + %exitcond.not = icmp eq i64 %indvars.iv.next, %n + br i1 %exitcond.not, label %for.cond.cleanup, label %for.body, !dbg !94, !llvm.loop !111 +} + +; // c) Dependence::BackwardVectorizable +; // Loop gets vectorized since it contains a backward dependency +; // between A[i] and A[i-4], but the dependency distance (4) is +; // greater than the minimum possible VF (2 in this case) +; void test_backwardVectorizable(int n, int* A, int* B) { +; for(int i=4; i < n; ++i) { +; A[i] = A[i-4] + 1; +; } +; } + +; CHECK: remark: source.c:37:3: loop not vectorized: vectorization and interleaving are explicitly disabled, or the loop has already been vectorized + +define void @test_backwardVectorizable(i64 %n, i32* nocapture %A, i32* nocapture readnone %B) !dbg !112 { +entry: + %A11 = bitcast i32* %A to <4 x i32>* + %cmp8 = icmp sgt i64 %n, 4 + br i1 %cmp8, label %for.body.preheader, label %for.cond.cleanup + +for.body.preheader: ; preds = %entry + %0 = add nsw i64 %n, -4 + %min.iters.check = icmp ult i64 %0, 4 + br i1 %min.iters.check, label %for.body.preheader12, label %vector.ph + +vector.ph: ; preds = %for.body.preheader + %n.vec = and i64 %0, -4 + %ind.end = add nsw i64 %n.vec, 4 + %load_initial = load <4 x i32>, <4 x i32>* %A11, align 4 + br label %vector.body + +vector.body: ; preds = %vector.body, %vector.ph + %store_forwarded = phi <4 x i32> [ %load_initial, %vector.ph ], [ %1, %vector.body ] + %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ] + %offset.idx = add i64 %index, 4 + %1 = add nsw <4 x i32> %store_forwarded, + %2 = getelementptr inbounds i32, i32* %A, i64 %offset.idx + %3 = bitcast i32* %2 to <4 x i32>* + store <4 x i32> %1, <4 x i32>* %3, align 4, !tbaa !31 + %index.next = add nuw i64 %index, 4 + %4 = icmp eq i64 %index.next, %n.vec + br i1 %4, label %middle.block, label %vector.body, !llvm.loop !128 + +middle.block: ; preds = %vector.body + %cmp.n = icmp eq i64 %0, %n.vec + br i1 %cmp.n, label %for.cond.cleanup, label %for.body.preheader12 + +for.body.preheader12: ; preds = %for.body.preheader, %middle.block + %indvars.iv.ph = phi i64 [ 4, %for.body.preheader ], [ %ind.end, %middle.block ] + br label %for.body + +for.cond.cleanup: ; preds = %for.body, %middle.block, %entry + ret void + +for.body: ; preds = %for.body.preheader12, %for.body + %indvars.iv = phi i64 [ %indvars.iv.next, %for.body ], [ %indvars.iv.ph, %for.body.preheader12 ] + %5 = add nsw i64 %indvars.iv, -4 + %arrayidx = getelementptr inbounds i32, i32* %A, i64 %5 + %6 = load i32, i32* %arrayidx, align 4, !tbaa !31 + %add = add nsw i32 %6, 1 + %arrayidx2 = getelementptr inbounds i32, i32* %A, i64 %indvars.iv + store i32 %add, i32* %arrayidx2, align 4, !tbaa !31 + %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 + %exitcond.not = icmp eq i64 %indvars.iv.next, %n + br i1 %exitcond.not, label %for.cond.cleanup, label %for.body, !llvm.loop !134 +} + + +; // d) Dependence::Backward +; // Loop does not get vectorized since it contains a backward +; // dependency between A[i] and A[i+3]. +; void test_backward_dep(int n, double *A) { +; for (int i = 1; i <= n - 3; i += 3) { +; A[i] = A[i-1]; +; A[i+1] = A[i+3]; +; } +; } + +; CHECK: remark: source.c:48:14: loop not vectorized: Backward loop carried data dependence. Memory location is the same as accessed at line 47:5 + +define void @test_backward_dep(i32 %n, double* nocapture %A) { +entry: + %cmp.not19 = icmp slt i32 %n, 4 + br i1 %cmp.not19, label %for.cond.cleanup, label %for.body.preheader + +for.body.preheader: ; preds = %entry + %sub = add nsw i32 %n, -3 + %0 = zext i32 %sub to i64 + br label %for.body + +for.cond.cleanup: ; preds = %for.body, %entry + ret void + +for.body: ; preds = %for.body.preheader, %for.body + %indvars.iv = phi i64 [ 1, %for.body.preheader ], [ %indvars.iv.next, %for.body ] + %1 = add nsw i64 %indvars.iv, -1 + %arrayidx = getelementptr inbounds double, double* %A, i64 %1 + %2 = load double, double* %arrayidx, align 8, !tbaa !155 + %arrayidx3 = getelementptr inbounds double, double* %A, i64 %indvars.iv, !dbg !157 + store double %2, double* %arrayidx3, align 8, !tbaa !155 + %indvars.iv.next = add nuw nsw i64 %indvars.iv, 3 + %arrayidx5 = getelementptr inbounds double, double* %A, i64 %indvars.iv.next, !dbg !160 + %3 = load double, double* %arrayidx5, align 8, !tbaa !155 + %4 = add nuw nsw i64 %indvars.iv, 1 + %arrayidx8 = getelementptr inbounds double, double* %A, i64 %4 + store double %3, double* %arrayidx8, align 8, !tbaa !155 + %cmp.not = icmp ugt i64 %indvars.iv.next, %0 + br i1 %cmp.not, label %for.cond.cleanup, label %for.body +} + +; // e) Dependence::ForwardButPreventsForwarding +; // Loop does not get vectorized despite only having a forward +; // dependency between A[i] and A[i-3]. +; // This is because the store-to-load forwarding distance (here 3) +; // needs to be a multiple of vector factor otherwise the +; // store (A[5:6] in i=5) and load (A[4:5],A[6:7] in i=7,9) are unaligned. +; void test_forwardPreventsForwarding_dep(int* A, int* B, int n) { +; for(int i=3; i < n; ++i) { +; A[i] = 10; +; B[i] = A[i-3]; +; } +; } + +; CHECK: remark: source.c:61:12: loop not vectorized: Forward loop carried data dependence that prevents store-to-load forwarding. Memory location is the same as accessed at line 60:5 + +define void @test_forwardPreventsForwarding_dep(i32* nocapture %A, i32* nocapture %B, i64 %n) !dbg !166 { +entry: + %cmp11 = icmp sgt i64 %n, 3 + br i1 %cmp11, label %for.body, label %for.cond.cleanup + +for.cond.cleanup: ; preds = %for.body, %entry + ret void + +for.body: ; preds = %entry, %for.body + %indvars.iv = phi i64 [ 3, %entry ], [ %indvars.iv.next, %for.body ] + %arrayidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv, !dbg !179 + store i32 10, i32* %arrayidx, align 4, !tbaa !31 + %0 = add nsw i64 %indvars.iv, -3 + %arrayidx2 = getelementptr inbounds i32, i32* %A, i64 %0, !dbg !183 + %1 = load i32, i32* %arrayidx2, align 4, !tbaa !31 + %arrayidx4 = getelementptr inbounds i32, i32* %B, i64 %indvars.iv + store i32 %1, i32* %arrayidx4, align 4, !tbaa !31 + %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 + %exitcond.not = icmp eq i64 %indvars.iv.next, %n + br i1 %exitcond.not, label %for.cond.cleanup, label %for.body +} + +; // f) Dependence::BackwardVectorizableButPreventsForwarding +; // Loop does not get vectorized despite having a backward +; // but vectorizable dependency between A[i] and A[i-15]. +; // +; // This is because the store-to-load forwarding distance (here 15) +; // needs to be a multiple of vector factor otherwise +; // store (A[16:17] in i=16) and load (A[15:16], A[17:18] in i=30,32) are unaligned. +; void test_backwardVectorizableButPreventsForwarding(int* A, int n) { +; for(int i=15; i < n; ++i) { +; A[i] = A[i-2] + A[i-15]; +; } +; } + +; CHECK: remark: source.c:74:5: loop not vectorized: Backward loop carried data dependence that prevents store-to-load forwarding. Memory location is the same as accessed at line 74:21 + +define void @test_backwardVectorizableButPreventsForwarding(i32* nocapture %A, i64 %n) !dbg !189 { +entry: + %cmp13 = icmp sgt i64 %n, 15 + br i1 %cmp13, label %for.body, label %for.cond.cleanup + +for.cond.cleanup: ; preds = %for.body, %entry + ret void + +for.body: ; preds = %entry, %for.body + %indvars.iv = phi i64 [ 15, %entry ], [ %indvars.iv.next, %for.body ] + %0 = add nsw i64 %indvars.iv, -2 + %arrayidx = getelementptr inbounds i32, i32* %A, i64 %0 + %1 = load i32, i32* %arrayidx, align 4, !tbaa !31 + %2 = add nsw i64 %indvars.iv, -15 + %arrayidx3 = getelementptr inbounds i32, i32* %A, i64 %2, !dbg !207 + %3 = load i32, i32* %arrayidx3, align 4, !tbaa !31 + %add = add nsw i32 %3, %1 + %arrayidx5 = getelementptr inbounds i32, i32* %A, i64 %indvars.iv, !dbg !209 + store i32 %add, i32* %arrayidx5, align 4, !tbaa !31 + %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 + %exitcond.not = icmp eq i64 %indvars.iv.next, %n + br i1 %exitcond.not, label %for.cond.cleanup, label %for.body +} + +; // g) Dependence::Unknown +; // Different stride lengths +; void test_unknown_dep(int* A, int n) { +; for(int i=0; i < n; ++i) { +; A[(i+1)*4] = 10; +; A[i] = 100; +; } +; } + +; CHECK: remark: source.c:83:7: loop not vectorized: Unknown data dependence. Memory location is the same as accessed at line 82:7 + +define void @test_unknown_dep(i32* nocapture %A, i64 %n) !dbg !214 { +entry: + %cmp8 = icmp sgt i64 %n, 0 + br i1 %cmp8, label %for.body, label %for.cond.cleanup + +for.cond.cleanup: ; preds = %for.body, %entry + ret void + +for.body: ; preds = %entry, %for.body + %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ] + %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 + %0 = shl nsw i64 %indvars.iv.next, 2 + %arrayidx = getelementptr inbounds i32, i32* %A, i64 %0, !dbg !229 + store i32 10, i32* %arrayidx, align 4, !tbaa !31 + %arrayidx2 = getelementptr inbounds i32, i32* %A, i64 %indvars.iv, !dbg !231 + store i32 100, i32* %arrayidx2, align 4, !tbaa !31 + %exitcond.not = icmp eq i64 %indvars.iv.next, %n + br i1 %exitcond.not, label %for.cond.cleanup, label %for.body +} + +!llvm.dbg.cu = !{!0} +!llvm.module.flags = !{!4} + +!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 14.0.0 (https://github.com/llvm/llvm-project.git 54f0f826c5c7d0ff16c230b259cb6aad33e18d97)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None) +!1 = !DIFile(filename: "source.c", directory: "") +!2 = !{} +!4 = !{i32 2, !"Debug Info Version", i32 3} +!13 = distinct !DISubprogram(name: "test_unknown_bounds", scope: !1, file: !1, line: 2, type: !14, scopeLine: 2, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !18) +!14 = !DISubroutineType(types: !15) +!15 = !{null, !16, !16, !17} +!16 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !17, size: 64) +!17 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed) +!18 = !{} +!23 = distinct !DILexicalBlock(scope: !13, file: !1, line: 3, column: 5) +!27 = distinct !DILexicalBlock(scope: !23, file: !1, line: 3, column: 5) +!28 = !DILocation(line: 3, column: 5, scope: !23) +!31 = !{!32, !32, i64 0} +!32 = !{!"int", !33, i64 0} +!33 = !{!"omnipotent char", !34, i64 0} +!34 = !{!"Simple C/C++ TBAA"} +!35 = !DILocation(line: 4, column: 16, scope: !27) +!40 = distinct !{!40, !28, !42} +!42 = !{!"llvm.loop.mustprogress"} +!43 = distinct !DISubprogram(name: "test_nodep", scope: !1, file: !1, line: 14, type: !44, scopeLine: 14, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !46) +!44 = !DISubroutineType(types: !45) +!45 = !{null, !17, !16, !16, !16} +!46 = !{} +!52 = distinct !DILexicalBlock(scope: !43, file: !1, line: 15, column: 3) +!56 = distinct !DILexicalBlock(scope: !52, file: !1, line: 15, column: 3) +!57 = !DILocation(line: 15, column: 3, scope: !52) +!60 = !{!61} +!61 = distinct !{!61, !62} +!62 = distinct !{!62, !"LVerDomain"} +!65 = !{!66} +!66 = distinct !{!66, !62} +!67 = !{!68, !61} +!68 = distinct !{!68, !62} +!73 = !{!68} +!74 = distinct !{!74, !57, !75, !42, !76} +!75 = !DILocation(line: 18, column: 3, scope: !52) +!76 = !{!"llvm.loop.isvectorized", i32 1} +!80 = distinct !{!80, !57, !75, !42, !76} +!81 = distinct !DISubprogram(name: "test_forward", scope: !1, file: !1, line: 24, type: !82, scopeLine: 24, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !84) +!82 = !DISubroutineType(types: !83) +!83 = !{null, !17, !16, !16} +!84 = !{} +!89 = distinct !DILexicalBlock(scope: !81, file: !1, line: 25, column: 3) +!93 = distinct !DILexicalBlock(scope: !89, file: !1, line: 25, column: 3) +!94 = !DILocation(line: 25, column: 3, scope: !89) +!98 = !{!99} +!99 = distinct !{!99, !100} +!100 = distinct !{!100, !"LVerDomain"} +!101 = !{!102} +!102 = distinct !{!102, !100} +!107 = distinct !{!107, !94, !108, !42, !76} +!108 = !DILocation(line: 28, column: 3, scope: !89) +!111 = distinct !{!111, !94, !108, !42, !76} +!112 = distinct !DISubprogram(name: "test_backwardVectorizable", scope: !1, file: !1, line: 36, type: !82, scopeLine: 36, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !113) +!113 = !{} +!118 = distinct !DILexicalBlock(scope: !112, file: !1, line: 37, column: 3) +!122 = distinct !DILexicalBlock(scope: !118, file: !1, line: 37, column: 3) +!123 = !DILocation(line: 37, column: 3, scope: !118) +!128 = distinct !{!128, !123, !42, !76} +!134 = distinct !{!134, !123, !42, !135, !76} +!135 = !{!"llvm.loop.unroll.runtime.disable"} +!136 = distinct !DISubprogram(name: "test_backward_dep", scope: !1, file: !1, line: 45, type: !137, scopeLine: 45, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !141) +!137 = !DISubroutineType(types: !138) +!138 = !{null, !17, !139} +!139 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !140, size: 64) +!140 = !DIBasicType(name: "double", size: 64, encoding: DW_ATE_float) +!141 = !{} +!145 = distinct !DILexicalBlock(scope: !136, file: !1, line: 46, column: 3) +!149 = distinct !DILexicalBlock(scope: !145, file: !1, line: 46, column: 3) +!153 = distinct !DILexicalBlock(scope: !149, file: !1, line: 46, column: 39) +!155 = !{!156, !156, i64 0} +!156 = !{!"double", !33, i64 0} +!157 = !DILocation(line: 47, column: 5, scope: !153) +!160 = !DILocation(line: 48, column: 14, scope: !153) +!166 = distinct !DISubprogram(name: "test_forwardPreventsForwarding_dep", scope: !1, file: !1, line: 58, type: !14, scopeLine: 58, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !167) +!167 = !{} +!172 = distinct !DILexicalBlock(scope: !166, file: !1, line: 59, column: 3) +!175 = !DILocation(line: 59, column: 18, scope: !176) +!176 = distinct !DILexicalBlock(scope: !172, file: !1, line: 59, column: 3) +!177 = !DILocation(line: 59, column: 3, scope: !172) +!178 = !DILocation(line: 63, column: 1, scope: !166) +!179 = !DILocation(line: 60, column: 5, scope: !180) +!180 = distinct !DILexicalBlock(scope: !176, file: !1, line: 59, column: 28) +!181 = !DILocation(line: 60, column: 10, scope: !180) +!182 = !DILocation(line: 61, column: 15, scope: !180) +!183 = !DILocation(line: 61, column: 12, scope: !180) +!184 = !DILocation(line: 61, column: 5, scope: !180) +!185 = !DILocation(line: 61, column: 10, scope: !180) +!186 = !DILocation(line: 59, column: 23, scope: !176) +!187 = distinct !{!187, !177, !188, !42} +!188 = !DILocation(line: 62, column: 3, scope: !172) +!189 = distinct !DISubprogram(name: "test_backwardVectorizableButPreventsForwarding", scope: !1, file: !1, line: 72, type: !190, scopeLine: 72, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !192) +!190 = !DISubroutineType(types: !191) +!191 = !{null, !16, !17} +!192 = !{} +!196 = distinct !DILexicalBlock(scope: !189, file: !1, line: 73, column: 3) +!200 = distinct !DILexicalBlock(scope: !196, file: !1, line: 73, column: 3) +!204 = distinct !DILexicalBlock(scope: !200, file: !1, line: 73, column: 29) +!207 = !DILocation(line: 74, column: 21, scope: !204) +!209 = !DILocation(line: 74, column: 5, scope: !204) +!214 = distinct !DISubprogram(name: "test_unknown_dep", scope: !1, file: !1, line: 80, type: !190, scopeLine: 80, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !215) +!215 = !{} +!219 = distinct !DILexicalBlock(scope: !214, file: !1, line: 81, column: 3) +!223 = distinct !DILexicalBlock(scope: !219, file: !1, line: 81, column: 3) +!227 = distinct !DILexicalBlock(scope: !223, file: !1, line: 81, column: 28) +!229 = !DILocation(line: 82, column: 7, scope: !227) +!231 = !DILocation(line: 83, column: 7, scope: !227)