1 //===- LoopAccessAnalysis.cpp - Loop Access Analysis Implementation --------==//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // The implementation for the loop memory dependence that was originally
11 // developed for the loop vectorizer.
13 //===----------------------------------------------------------------------===//
15 #include "llvm/Analysis/LoopAccessAnalysis.h"
16 #include "llvm/Analysis/LoopInfo.h"
17 #include "llvm/Analysis/ScalarEvolutionExpander.h"
18 #include "llvm/Analysis/ValueTracking.h"
19 #include "llvm/IR/DiagnosticInfo.h"
20 #include "llvm/IR/Dominators.h"
21 #include "llvm/IR/IRBuilder.h"
22 #include "llvm/Support/Debug.h"
23 #include "llvm/Transforms/Utils/VectorUtils.h"
26 #define DEBUG_TYPE "loop-vectorize"
28 void VectorizationReport::emitAnalysis(VectorizationReport &Message,
29 const Function *TheFunction,
30 const Loop *TheLoop) {
31 DebugLoc DL = TheLoop->getStartLoc();
32 if (Instruction *I = Message.getInstr())
33 DL = I->getDebugLoc();
34 emitOptimizationRemarkAnalysis(TheFunction->getContext(), DEBUG_TYPE,
35 *TheFunction, DL, Message.str());
38 Value *llvm::stripIntegerCast(Value *V) {
39 if (CastInst *CI = dyn_cast<CastInst>(V))
40 if (CI->getOperand(0)->getType()->isIntegerTy())
41 return CI->getOperand(0);
45 const SCEV *llvm::replaceSymbolicStrideSCEV(ScalarEvolution *SE,
46 ValueToValueMap &PtrToStride,
47 Value *Ptr, Value *OrigPtr) {
49 const SCEV *OrigSCEV = SE->getSCEV(Ptr);
51 // If there is an entry in the map return the SCEV of the pointer with the
52 // symbolic stride replaced by one.
53 ValueToValueMap::iterator SI = PtrToStride.find(OrigPtr ? OrigPtr : Ptr);
54 if (SI != PtrToStride.end()) {
55 Value *StrideVal = SI->second;
58 StrideVal = stripIntegerCast(StrideVal);
60 // Replace symbolic stride by one.
61 Value *One = ConstantInt::get(StrideVal->getType(), 1);
62 ValueToValueMap RewriteMap;
63 RewriteMap[StrideVal] = One;
66 SCEVParameterRewriter::rewrite(OrigSCEV, *SE, RewriteMap, true);
67 DEBUG(dbgs() << "LV: Replacing SCEV: " << *OrigSCEV << " by: " << *ByOne
72 // Otherwise, just return the SCEV of the original pointer.
73 return SE->getSCEV(Ptr);
76 void LoopAccessInfo::RuntimePointerCheck::insert(ScalarEvolution *SE, Loop *Lp,
77 Value *Ptr, bool WritePtr,
80 ValueToValueMap &Strides) {
81 // Get the stride replaced scev.
82 const SCEV *Sc = replaceSymbolicStrideSCEV(SE, Strides, Ptr);
83 const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(Sc);
84 assert(AR && "Invalid addrec expression");
85 const SCEV *Ex = SE->getBackedgeTakenCount(Lp);
86 const SCEV *ScEnd = AR->evaluateAtIteration(Ex, *SE);
87 Pointers.push_back(Ptr);
88 Starts.push_back(AR->getStart());
89 Ends.push_back(ScEnd);
90 IsWritePtr.push_back(WritePtr);
91 DependencySetId.push_back(DepSetId);
92 AliasSetId.push_back(ASId);
95 bool LoopAccessInfo::RuntimePointerCheck::needsChecking(unsigned I,
97 // No need to check if two readonly pointers intersect.
98 if (!IsWritePtr[I] && !IsWritePtr[J])
101 // Only need to check pointers between two different dependency sets.
102 if (DependencySetId[I] == DependencySetId[J])
105 // Only need to check pointers in the same alias set.
106 if (AliasSetId[I] != AliasSetId[J])
113 /// \brief Analyses memory accesses in a loop.
115 /// Checks whether run time pointer checks are needed and builds sets for data
116 /// dependence checking.
117 class AccessAnalysis {
119 /// \brief Read or write access location.
120 typedef PointerIntPair<Value *, 1, bool> MemAccessInfo;
121 typedef SmallPtrSet<MemAccessInfo, 8> MemAccessInfoSet;
123 /// \brief Set of potential dependent memory accesses.
124 typedef EquivalenceClasses<MemAccessInfo> DepCandidates;
126 AccessAnalysis(const DataLayout *Dl, AliasAnalysis *AA, DepCandidates &DA) :
127 DL(Dl), AST(*AA), DepCands(DA), IsRTCheckNeeded(false) {}
129 /// \brief Register a load and whether it is only read from.
130 void addLoad(AliasAnalysis::Location &Loc, bool IsReadOnly) {
131 Value *Ptr = const_cast<Value*>(Loc.Ptr);
132 AST.add(Ptr, AliasAnalysis::UnknownSize, Loc.AATags);
133 Accesses.insert(MemAccessInfo(Ptr, false));
135 ReadOnlyPtr.insert(Ptr);
138 /// \brief Register a store.
139 void addStore(AliasAnalysis::Location &Loc) {
140 Value *Ptr = const_cast<Value*>(Loc.Ptr);
141 AST.add(Ptr, AliasAnalysis::UnknownSize, Loc.AATags);
142 Accesses.insert(MemAccessInfo(Ptr, true));
145 /// \brief Check whether we can check the pointers at runtime for
146 /// non-intersection.
147 bool canCheckPtrAtRT(LoopAccessInfo::RuntimePointerCheck &RtCheck,
148 unsigned &NumComparisons,
149 ScalarEvolution *SE, Loop *TheLoop,
150 ValueToValueMap &Strides,
151 bool ShouldCheckStride = false);
153 /// \brief Goes over all memory accesses, checks whether a RT check is needed
154 /// and builds sets of dependent accesses.
155 void buildDependenceSets() {
156 processMemAccesses();
159 bool isRTCheckNeeded() { return IsRTCheckNeeded; }
161 bool isDependencyCheckNeeded() { return !CheckDeps.empty(); }
162 void resetDepChecks() { CheckDeps.clear(); }
164 MemAccessInfoSet &getDependenciesToCheck() { return CheckDeps; }
167 typedef SetVector<MemAccessInfo> PtrAccessSet;
169 /// \brief Go over all memory access and check whether runtime pointer checks
170 /// are needed /// and build sets of dependency check candidates.
171 void processMemAccesses();
173 /// Set of all accesses.
174 PtrAccessSet Accesses;
176 /// Set of accesses that need a further dependence check.
177 MemAccessInfoSet CheckDeps;
179 /// Set of pointers that are read only.
180 SmallPtrSet<Value*, 16> ReadOnlyPtr;
182 const DataLayout *DL;
184 /// An alias set tracker to partition the access set by underlying object and
185 //intrinsic property (such as TBAA metadata).
188 /// Sets of potentially dependent accesses - members of one set share an
189 /// underlying pointer. The set "CheckDeps" identfies which sets really need a
190 /// dependence check.
191 DepCandidates &DepCands;
193 bool IsRTCheckNeeded;
196 } // end anonymous namespace
198 /// \brief Check whether a pointer can participate in a runtime bounds check.
199 static bool hasComputableBounds(ScalarEvolution *SE, ValueToValueMap &Strides,
201 const SCEV *PtrScev = replaceSymbolicStrideSCEV(SE, Strides, Ptr);
202 const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(PtrScev);
206 return AR->isAffine();
209 /// \brief Check the stride of the pointer and ensure that it does not wrap in
210 /// the address space.
211 static int isStridedPtr(ScalarEvolution *SE, const DataLayout *DL, Value *Ptr,
212 const Loop *Lp, ValueToValueMap &StridesMap);
214 bool AccessAnalysis::canCheckPtrAtRT(
215 LoopAccessInfo::RuntimePointerCheck &RtCheck,
216 unsigned &NumComparisons, ScalarEvolution *SE, Loop *TheLoop,
217 ValueToValueMap &StridesMap, bool ShouldCheckStride) {
218 // Find pointers with computable bounds. We are going to use this information
219 // to place a runtime bound check.
222 bool IsDepCheckNeeded = isDependencyCheckNeeded();
225 // We assign a consecutive id to access from different alias sets.
226 // Accesses between different groups doesn't need to be checked.
228 for (auto &AS : AST) {
229 unsigned NumReadPtrChecks = 0;
230 unsigned NumWritePtrChecks = 0;
232 // We assign consecutive id to access from different dependence sets.
233 // Accesses within the same set don't need a runtime check.
234 unsigned RunningDepId = 1;
235 DenseMap<Value *, unsigned> DepSetId;
238 Value *Ptr = A.getValue();
239 bool IsWrite = Accesses.count(MemAccessInfo(Ptr, true));
240 MemAccessInfo Access(Ptr, IsWrite);
247 if (hasComputableBounds(SE, StridesMap, Ptr) &&
248 // When we run after a failing dependency check we have to make sure we
249 // don't have wrapping pointers.
250 (!ShouldCheckStride ||
251 isStridedPtr(SE, DL, Ptr, TheLoop, StridesMap) == 1)) {
252 // The id of the dependence set.
255 if (IsDepCheckNeeded) {
256 Value *Leader = DepCands.getLeaderValue(Access).getPointer();
257 unsigned &LeaderId = DepSetId[Leader];
259 LeaderId = RunningDepId++;
262 // Each access has its own dependence set.
263 DepId = RunningDepId++;
265 RtCheck.insert(SE, TheLoop, Ptr, IsWrite, DepId, ASId, StridesMap);
267 DEBUG(dbgs() << "LV: Found a runtime check ptr:" << *Ptr << '\n');
273 if (IsDepCheckNeeded && CanDoRT && RunningDepId == 2)
274 NumComparisons += 0; // Only one dependence set.
276 NumComparisons += (NumWritePtrChecks * (NumReadPtrChecks +
277 NumWritePtrChecks - 1));
283 // If the pointers that we would use for the bounds comparison have different
284 // address spaces, assume the values aren't directly comparable, so we can't
285 // use them for the runtime check. We also have to assume they could
286 // overlap. In the future there should be metadata for whether address spaces
288 unsigned NumPointers = RtCheck.Pointers.size();
289 for (unsigned i = 0; i < NumPointers; ++i) {
290 for (unsigned j = i + 1; j < NumPointers; ++j) {
291 // Only need to check pointers between two different dependency sets.
292 if (RtCheck.DependencySetId[i] == RtCheck.DependencySetId[j])
294 // Only need to check pointers in the same alias set.
295 if (RtCheck.AliasSetId[i] != RtCheck.AliasSetId[j])
298 Value *PtrI = RtCheck.Pointers[i];
299 Value *PtrJ = RtCheck.Pointers[j];
301 unsigned ASi = PtrI->getType()->getPointerAddressSpace();
302 unsigned ASj = PtrJ->getType()->getPointerAddressSpace();
304 DEBUG(dbgs() << "LV: Runtime check would require comparison between"
305 " different address spaces\n");
314 void AccessAnalysis::processMemAccesses() {
315 // We process the set twice: first we process read-write pointers, last we
316 // process read-only pointers. This allows us to skip dependence tests for
317 // read-only pointers.
319 DEBUG(dbgs() << "LV: Processing memory accesses...\n");
320 DEBUG(dbgs() << " AST: "; AST.dump());
321 DEBUG(dbgs() << "LV: Accesses:\n");
323 for (auto A : Accesses)
324 dbgs() << "\t" << *A.getPointer() << " (" <<
325 (A.getInt() ? "write" : (ReadOnlyPtr.count(A.getPointer()) ?
326 "read-only" : "read")) << ")\n";
329 // The AliasSetTracker has nicely partitioned our pointers by metadata
330 // compatibility and potential for underlying-object overlap. As a result, we
331 // only need to check for potential pointer dependencies within each alias
333 for (auto &AS : AST) {
334 // Note that both the alias-set tracker and the alias sets themselves used
335 // linked lists internally and so the iteration order here is deterministic
336 // (matching the original instruction order within each set).
338 bool SetHasWrite = false;
340 // Map of pointers to last access encountered.
341 typedef DenseMap<Value*, MemAccessInfo> UnderlyingObjToAccessMap;
342 UnderlyingObjToAccessMap ObjToLastAccess;
344 // Set of access to check after all writes have been processed.
345 PtrAccessSet DeferredAccesses;
347 // Iterate over each alias set twice, once to process read/write pointers,
348 // and then to process read-only pointers.
349 for (int SetIteration = 0; SetIteration < 2; ++SetIteration) {
350 bool UseDeferred = SetIteration > 0;
351 PtrAccessSet &S = UseDeferred ? DeferredAccesses : Accesses;
354 Value *Ptr = AV.getValue();
356 // For a single memory access in AliasSetTracker, Accesses may contain
357 // both read and write, and they both need to be handled for CheckDeps.
359 if (AC.getPointer() != Ptr)
362 bool IsWrite = AC.getInt();
364 // If we're using the deferred access set, then it contains only
366 bool IsReadOnlyPtr = ReadOnlyPtr.count(Ptr) && !IsWrite;
367 if (UseDeferred && !IsReadOnlyPtr)
369 // Otherwise, the pointer must be in the PtrAccessSet, either as a
371 assert(((IsReadOnlyPtr && UseDeferred) || IsWrite ||
372 S.count(MemAccessInfo(Ptr, false))) &&
373 "Alias-set pointer not in the access set?");
375 MemAccessInfo Access(Ptr, IsWrite);
376 DepCands.insert(Access);
378 // Memorize read-only pointers for later processing and skip them in
379 // the first round (they need to be checked after we have seen all
380 // write pointers). Note: we also mark pointer that are not
381 // consecutive as "read-only" pointers (so that we check
382 // "a[b[i]] +="). Hence, we need the second check for "!IsWrite".
383 if (!UseDeferred && IsReadOnlyPtr) {
384 DeferredAccesses.insert(Access);
388 // If this is a write - check other reads and writes for conflicts. If
389 // this is a read only check other writes for conflicts (but only if
390 // there is no other write to the ptr - this is an optimization to
391 // catch "a[i] = a[i] + " without having to do a dependence check).
392 if ((IsWrite || IsReadOnlyPtr) && SetHasWrite) {
393 CheckDeps.insert(Access);
394 IsRTCheckNeeded = true;
400 // Create sets of pointers connected by a shared alias set and
401 // underlying object.
402 typedef SmallVector<Value *, 16> ValueVector;
403 ValueVector TempObjects;
404 GetUnderlyingObjects(Ptr, TempObjects, DL);
405 for (Value *UnderlyingObj : TempObjects) {
406 UnderlyingObjToAccessMap::iterator Prev =
407 ObjToLastAccess.find(UnderlyingObj);
408 if (Prev != ObjToLastAccess.end())
409 DepCands.unionSets(Access, Prev->second);
411 ObjToLastAccess[UnderlyingObj] = Access;
420 /// \brief Checks memory dependences among accesses to the same underlying
421 /// object to determine whether there vectorization is legal or not (and at
422 /// which vectorization factor).
424 /// This class works under the assumption that we already checked that memory
425 /// locations with different underlying pointers are "must-not alias".
426 /// We use the ScalarEvolution framework to symbolically evalutate access
427 /// functions pairs. Since we currently don't restructure the loop we can rely
428 /// on the program order of memory accesses to determine their safety.
429 /// At the moment we will only deem accesses as safe for:
430 /// * A negative constant distance assuming program order.
432 /// Safe: tmp = a[i + 1]; OR a[i + 1] = x;
433 /// a[i] = tmp; y = a[i];
435 /// The latter case is safe because later checks guarantuee that there can't
436 /// be a cycle through a phi node (that is, we check that "x" and "y" is not
437 /// the same variable: a header phi can only be an induction or a reduction, a
438 /// reduction can't have a memory sink, an induction can't have a memory
439 /// source). This is important and must not be violated (or we have to
440 /// resort to checking for cycles through memory).
442 /// * A positive constant distance assuming program order that is bigger
443 /// than the biggest memory access.
445 /// tmp = a[i] OR b[i] = x
446 /// a[i+2] = tmp y = b[i+2];
448 /// Safe distance: 2 x sizeof(a[0]), and 2 x sizeof(b[0]), respectively.
450 /// * Zero distances and all accesses have the same size.
452 class MemoryDepChecker {
454 typedef PointerIntPair<Value *, 1, bool> MemAccessInfo;
455 typedef SmallPtrSet<MemAccessInfo, 8> MemAccessInfoSet;
457 MemoryDepChecker(ScalarEvolution *Se, const DataLayout *Dl, const Loop *L,
458 const LoopAccessInfo::VectorizerParams &VectParams)
459 : SE(Se), DL(Dl), InnermostLoop(L), AccessIdx(0),
460 ShouldRetryWithRuntimeCheck(false), VectParams(VectParams) {}
462 /// \brief Register the location (instructions are given increasing numbers)
463 /// of a write access.
464 void addAccess(StoreInst *SI) {
465 Value *Ptr = SI->getPointerOperand();
466 Accesses[MemAccessInfo(Ptr, true)].push_back(AccessIdx);
467 InstMap.push_back(SI);
471 /// \brief Register the location (instructions are given increasing numbers)
472 /// of a write access.
473 void addAccess(LoadInst *LI) {
474 Value *Ptr = LI->getPointerOperand();
475 Accesses[MemAccessInfo(Ptr, false)].push_back(AccessIdx);
476 InstMap.push_back(LI);
480 /// \brief Check whether the dependencies between the accesses are safe.
482 /// Only checks sets with elements in \p CheckDeps.
483 bool areDepsSafe(AccessAnalysis::DepCandidates &AccessSets,
484 MemAccessInfoSet &CheckDeps, ValueToValueMap &Strides);
486 /// \brief The maximum number of bytes of a vector register we can vectorize
487 /// the accesses safely with.
488 unsigned getMaxSafeDepDistBytes() { return MaxSafeDepDistBytes; }
490 /// \brief In same cases when the dependency check fails we can still
491 /// vectorize the loop with a dynamic array access check.
492 bool shouldRetryWithRuntimeCheck() { return ShouldRetryWithRuntimeCheck; }
496 const DataLayout *DL;
497 const Loop *InnermostLoop;
499 /// \brief Maps access locations (ptr, read/write) to program order.
500 DenseMap<MemAccessInfo, std::vector<unsigned> > Accesses;
502 /// \brief Memory access instructions in program order.
503 SmallVector<Instruction *, 16> InstMap;
505 /// \brief The program order index to be used for the next instruction.
508 // We can access this many bytes in parallel safely.
509 unsigned MaxSafeDepDistBytes;
511 /// \brief If we see a non-constant dependence distance we can still try to
512 /// vectorize this loop with runtime checks.
513 bool ShouldRetryWithRuntimeCheck;
515 /// \brief Vectorizer parameters used by the analysis.
516 LoopAccessInfo::VectorizerParams VectParams;
518 /// \brief Check whether there is a plausible dependence between the two
521 /// Access \p A must happen before \p B in program order. The two indices
522 /// identify the index into the program order map.
524 /// This function checks whether there is a plausible dependence (or the
525 /// absence of such can't be proved) between the two accesses. If there is a
526 /// plausible dependence but the dependence distance is bigger than one
527 /// element access it records this distance in \p MaxSafeDepDistBytes (if this
528 /// distance is smaller than any other distance encountered so far).
529 /// Otherwise, this function returns true signaling a possible dependence.
530 bool isDependent(const MemAccessInfo &A, unsigned AIdx,
531 const MemAccessInfo &B, unsigned BIdx,
532 ValueToValueMap &Strides);
534 /// \brief Check whether the data dependence could prevent store-load
536 bool couldPreventStoreLoadForward(unsigned Distance, unsigned TypeByteSize);
539 } // end anonymous namespace
541 static bool isInBoundsGep(Value *Ptr) {
542 if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Ptr))
543 return GEP->isInBounds();
547 /// \brief Check whether the access through \p Ptr has a constant stride.
548 static int isStridedPtr(ScalarEvolution *SE, const DataLayout *DL, Value *Ptr,
549 const Loop *Lp, ValueToValueMap &StridesMap) {
550 const Type *Ty = Ptr->getType();
551 assert(Ty->isPointerTy() && "Unexpected non-ptr");
553 // Make sure that the pointer does not point to aggregate types.
554 const PointerType *PtrTy = cast<PointerType>(Ty);
555 if (PtrTy->getElementType()->isAggregateType()) {
556 DEBUG(dbgs() << "LV: Bad stride - Not a pointer to a scalar type" << *Ptr
561 const SCEV *PtrScev = replaceSymbolicStrideSCEV(SE, StridesMap, Ptr);
563 const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(PtrScev);
565 DEBUG(dbgs() << "LV: Bad stride - Not an AddRecExpr pointer " << *Ptr
566 << " SCEV: " << *PtrScev << "\n");
570 // The accesss function must stride over the innermost loop.
571 if (Lp != AR->getLoop()) {
572 DEBUG(dbgs() << "LV: Bad stride - Not striding over innermost loop " << *Ptr
573 << " SCEV: " << *PtrScev << "\n");
576 // The address calculation must not wrap. Otherwise, a dependence could be
578 // An inbounds getelementptr that is a AddRec with a unit stride
579 // cannot wrap per definition. The unit stride requirement is checked later.
580 // An getelementptr without an inbounds attribute and unit stride would have
581 // to access the pointer value "0" which is undefined behavior in address
582 // space 0, therefore we can also vectorize this case.
583 bool IsInBoundsGEP = isInBoundsGep(Ptr);
584 bool IsNoWrapAddRec = AR->getNoWrapFlags(SCEV::NoWrapMask);
585 bool IsInAddressSpaceZero = PtrTy->getAddressSpace() == 0;
586 if (!IsNoWrapAddRec && !IsInBoundsGEP && !IsInAddressSpaceZero) {
587 DEBUG(dbgs() << "LV: Bad stride - Pointer may wrap in the address space "
588 << *Ptr << " SCEV: " << *PtrScev << "\n");
592 // Check the step is constant.
593 const SCEV *Step = AR->getStepRecurrence(*SE);
595 // Calculate the pointer stride and check if it is consecutive.
596 const SCEVConstant *C = dyn_cast<SCEVConstant>(Step);
598 DEBUG(dbgs() << "LV: Bad stride - Not a constant strided " << *Ptr
599 << " SCEV: " << *PtrScev << "\n");
603 int64_t Size = DL->getTypeAllocSize(PtrTy->getElementType());
604 const APInt &APStepVal = C->getValue()->getValue();
606 // Huge step value - give up.
607 if (APStepVal.getBitWidth() > 64)
610 int64_t StepVal = APStepVal.getSExtValue();
613 int64_t Stride = StepVal / Size;
614 int64_t Rem = StepVal % Size;
618 // If the SCEV could wrap but we have an inbounds gep with a unit stride we
619 // know we can't "wrap around the address space". In case of address space
620 // zero we know that this won't happen without triggering undefined behavior.
621 if (!IsNoWrapAddRec && (IsInBoundsGEP || IsInAddressSpaceZero) &&
622 Stride != 1 && Stride != -1)
628 bool MemoryDepChecker::couldPreventStoreLoadForward(unsigned Distance,
629 unsigned TypeByteSize) {
630 // If loads occur at a distance that is not a multiple of a feasible vector
631 // factor store-load forwarding does not take place.
632 // Positive dependences might cause troubles because vectorizing them might
633 // prevent store-load forwarding making vectorized code run a lot slower.
634 // a[i] = a[i-3] ^ a[i-8];
635 // The stores to a[i:i+1] don't align with the stores to a[i-3:i-2] and
636 // hence on your typical architecture store-load forwarding does not take
637 // place. Vectorizing in such cases does not make sense.
638 // Store-load forwarding distance.
639 const unsigned NumCyclesForStoreLoadThroughMemory = 8*TypeByteSize;
640 // Maximum vector factor.
641 unsigned MaxVFWithoutSLForwardIssues =
642 VectParams.MaxVectorWidth * TypeByteSize;
643 if (MaxSafeDepDistBytes < MaxVFWithoutSLForwardIssues)
644 MaxVFWithoutSLForwardIssues = MaxSafeDepDistBytes;
646 for (unsigned vf = 2*TypeByteSize; vf <= MaxVFWithoutSLForwardIssues;
648 if (Distance % vf && Distance / vf < NumCyclesForStoreLoadThroughMemory) {
649 MaxVFWithoutSLForwardIssues = (vf >>=1);
654 if (MaxVFWithoutSLForwardIssues < 2 * TypeByteSize) {
655 DEBUG(dbgs() << "LV: Distance " << Distance
656 << " that could cause a store-load forwarding conflict\n");
660 if (MaxVFWithoutSLForwardIssues < MaxSafeDepDistBytes &&
661 MaxVFWithoutSLForwardIssues != VectParams.MaxVectorWidth * TypeByteSize)
662 MaxSafeDepDistBytes = MaxVFWithoutSLForwardIssues;
666 bool MemoryDepChecker::isDependent(const MemAccessInfo &A, unsigned AIdx,
667 const MemAccessInfo &B, unsigned BIdx,
668 ValueToValueMap &Strides) {
669 assert (AIdx < BIdx && "Must pass arguments in program order");
671 Value *APtr = A.getPointer();
672 Value *BPtr = B.getPointer();
673 bool AIsWrite = A.getInt();
674 bool BIsWrite = B.getInt();
676 // Two reads are independent.
677 if (!AIsWrite && !BIsWrite)
680 // We cannot check pointers in different address spaces.
681 if (APtr->getType()->getPointerAddressSpace() !=
682 BPtr->getType()->getPointerAddressSpace())
685 const SCEV *AScev = replaceSymbolicStrideSCEV(SE, Strides, APtr);
686 const SCEV *BScev = replaceSymbolicStrideSCEV(SE, Strides, BPtr);
688 int StrideAPtr = isStridedPtr(SE, DL, APtr, InnermostLoop, Strides);
689 int StrideBPtr = isStridedPtr(SE, DL, BPtr, InnermostLoop, Strides);
691 const SCEV *Src = AScev;
692 const SCEV *Sink = BScev;
694 // If the induction step is negative we have to invert source and sink of the
696 if (StrideAPtr < 0) {
699 std::swap(APtr, BPtr);
700 std::swap(Src, Sink);
701 std::swap(AIsWrite, BIsWrite);
702 std::swap(AIdx, BIdx);
703 std::swap(StrideAPtr, StrideBPtr);
706 const SCEV *Dist = SE->getMinusSCEV(Sink, Src);
708 DEBUG(dbgs() << "LV: Src Scev: " << *Src << "Sink Scev: " << *Sink
709 << "(Induction step: " << StrideAPtr << ")\n");
710 DEBUG(dbgs() << "LV: Distance for " << *InstMap[AIdx] << " to "
711 << *InstMap[BIdx] << ": " << *Dist << "\n");
713 // Need consecutive accesses. We don't want to vectorize
714 // "A[B[i]] += ..." and similar code or pointer arithmetic that could wrap in
715 // the address space.
716 if (!StrideAPtr || !StrideBPtr || StrideAPtr != StrideBPtr){
717 DEBUG(dbgs() << "Non-consecutive pointer access\n");
721 const SCEVConstant *C = dyn_cast<SCEVConstant>(Dist);
723 DEBUG(dbgs() << "LV: Dependence because of non-constant distance\n");
724 ShouldRetryWithRuntimeCheck = true;
728 Type *ATy = APtr->getType()->getPointerElementType();
729 Type *BTy = BPtr->getType()->getPointerElementType();
730 unsigned TypeByteSize = DL->getTypeAllocSize(ATy);
732 // Negative distances are not plausible dependencies.
733 const APInt &Val = C->getValue()->getValue();
734 if (Val.isNegative()) {
735 bool IsTrueDataDependence = (AIsWrite && !BIsWrite);
736 if (IsTrueDataDependence &&
737 (couldPreventStoreLoadForward(Val.abs().getZExtValue(), TypeByteSize) ||
741 DEBUG(dbgs() << "LV: Dependence is negative: NoDep\n");
745 // Write to the same location with the same size.
746 // Could be improved to assert type sizes are the same (i32 == float, etc).
750 DEBUG(dbgs() << "LV: Zero dependence difference but different types\n");
754 assert(Val.isStrictlyPositive() && "Expect a positive value");
756 // Positive distance bigger than max vectorization factor.
759 << "LV: ReadWrite-Write positive dependency with different types\n");
763 unsigned Distance = (unsigned) Val.getZExtValue();
765 // Bail out early if passed-in parameters make vectorization not feasible.
766 unsigned ForcedFactor =
767 (VectParams.VectorizationFactor ? VectParams.VectorizationFactor : 1);
768 unsigned ForcedUnroll =
769 (VectParams.VectorizationInterleave ? VectParams.VectorizationInterleave
772 // The distance must be bigger than the size needed for a vectorized version
773 // of the operation and the size of the vectorized operation must not be
774 // bigger than the currrent maximum size.
775 if (Distance < 2*TypeByteSize ||
776 2*TypeByteSize > MaxSafeDepDistBytes ||
777 Distance < TypeByteSize * ForcedUnroll * ForcedFactor) {
778 DEBUG(dbgs() << "LV: Failure because of Positive distance "
779 << Val.getSExtValue() << '\n');
783 MaxSafeDepDistBytes = Distance < MaxSafeDepDistBytes ?
784 Distance : MaxSafeDepDistBytes;
786 bool IsTrueDataDependence = (!AIsWrite && BIsWrite);
787 if (IsTrueDataDependence &&
788 couldPreventStoreLoadForward(Distance, TypeByteSize))
791 DEBUG(dbgs() << "LV: Positive distance " << Val.getSExtValue()
792 << " with max VF = " << MaxSafeDepDistBytes / TypeByteSize
798 bool MemoryDepChecker::areDepsSafe(AccessAnalysis::DepCandidates &AccessSets,
799 MemAccessInfoSet &CheckDeps,
800 ValueToValueMap &Strides) {
802 MaxSafeDepDistBytes = -1U;
803 while (!CheckDeps.empty()) {
804 MemAccessInfo CurAccess = *CheckDeps.begin();
806 // Get the relevant memory access set.
807 EquivalenceClasses<MemAccessInfo>::iterator I =
808 AccessSets.findValue(AccessSets.getLeaderValue(CurAccess));
810 // Check accesses within this set.
811 EquivalenceClasses<MemAccessInfo>::member_iterator AI, AE;
812 AI = AccessSets.member_begin(I), AE = AccessSets.member_end();
814 // Check every access pair.
816 CheckDeps.erase(*AI);
817 EquivalenceClasses<MemAccessInfo>::member_iterator OI = std::next(AI);
819 // Check every accessing instruction pair in program order.
820 for (std::vector<unsigned>::iterator I1 = Accesses[*AI].begin(),
821 I1E = Accesses[*AI].end(); I1 != I1E; ++I1)
822 for (std::vector<unsigned>::iterator I2 = Accesses[*OI].begin(),
823 I2E = Accesses[*OI].end(); I2 != I2E; ++I2) {
824 if (*I1 < *I2 && isDependent(*AI, *I1, *OI, *I2, Strides))
826 if (*I2 < *I1 && isDependent(*OI, *I2, *AI, *I1, Strides))
837 bool LoopAccessInfo::canVectorizeMemory(ValueToValueMap &Strides) {
839 typedef SmallVector<Value*, 16> ValueVector;
840 typedef SmallPtrSet<Value*, 16> ValueSet;
842 // Holds the Load and Store *instructions*.
846 // Holds all the different accesses in the loop.
847 unsigned NumReads = 0;
848 unsigned NumReadWrites = 0;
850 PtrRtCheck.Pointers.clear();
851 PtrRtCheck.Need = false;
853 const bool IsAnnotatedParallel = TheLoop->isAnnotatedParallel();
854 MemoryDepChecker DepChecker(SE, DL, TheLoop, VectParams);
857 for (Loop::block_iterator bb = TheLoop->block_begin(),
858 be = TheLoop->block_end(); bb != be; ++bb) {
860 // Scan the BB and collect legal loads and stores.
861 for (BasicBlock::iterator it = (*bb)->begin(), e = (*bb)->end(); it != e;
864 // If this is a load, save it. If this instruction can read from memory
865 // but is not a load, then we quit. Notice that we don't handle function
866 // calls that read or write.
867 if (it->mayReadFromMemory()) {
868 // Many math library functions read the rounding mode. We will only
869 // vectorize a loop if it contains known function calls that don't set
870 // the flag. Therefore, it is safe to ignore this read from memory.
871 CallInst *Call = dyn_cast<CallInst>(it);
872 if (Call && getIntrinsicIDForCall(Call, TLI))
875 LoadInst *Ld = dyn_cast<LoadInst>(it);
876 if (!Ld || (!Ld->isSimple() && !IsAnnotatedParallel)) {
877 emitAnalysis(VectorizationReport(Ld)
878 << "read with atomic ordering or volatile read");
879 DEBUG(dbgs() << "LV: Found a non-simple load.\n");
884 DepChecker.addAccess(Ld);
888 // Save 'store' instructions. Abort if other instructions write to memory.
889 if (it->mayWriteToMemory()) {
890 StoreInst *St = dyn_cast<StoreInst>(it);
892 emitAnalysis(VectorizationReport(it)
893 << "instruction cannot be vectorized");
896 if (!St->isSimple() && !IsAnnotatedParallel) {
897 emitAnalysis(VectorizationReport(St)
898 << "write with atomic ordering or volatile write");
899 DEBUG(dbgs() << "LV: Found a non-simple store.\n");
903 Stores.push_back(St);
904 DepChecker.addAccess(St);
909 // Now we have two lists that hold the loads and the stores.
910 // Next, we find the pointers that they use.
912 // Check if we see any stores. If there are no stores, then we don't
913 // care if the pointers are *restrict*.
914 if (!Stores.size()) {
915 DEBUG(dbgs() << "LV: Found a read-only loop!\n");
919 AccessAnalysis::DepCandidates DependentAccesses;
920 AccessAnalysis Accesses(DL, AA, DependentAccesses);
922 // Holds the analyzed pointers. We don't want to call GetUnderlyingObjects
923 // multiple times on the same object. If the ptr is accessed twice, once
924 // for read and once for write, it will only appear once (on the write
925 // list). This is okay, since we are going to check for conflicts between
926 // writes and between reads and writes, but not between reads and reads.
929 ValueVector::iterator I, IE;
930 for (I = Stores.begin(), IE = Stores.end(); I != IE; ++I) {
931 StoreInst *ST = cast<StoreInst>(*I);
932 Value* Ptr = ST->getPointerOperand();
934 if (isUniform(Ptr)) {
936 VectorizationReport(ST)
937 << "write to a loop invariant address could not be vectorized");
938 DEBUG(dbgs() << "LV: We don't allow storing to uniform addresses\n");
942 // If we did *not* see this pointer before, insert it to the read-write
943 // list. At this phase it is only a 'write' list.
944 if (Seen.insert(Ptr).second) {
947 AliasAnalysis::Location Loc = AA->getLocation(ST);
948 // The TBAA metadata could have a control dependency on the predication
949 // condition, so we cannot rely on it when determining whether or not we
950 // need runtime pointer checks.
951 if (blockNeedsPredication(ST->getParent(), TheLoop, DT))
952 Loc.AATags.TBAA = nullptr;
954 Accesses.addStore(Loc);
958 if (IsAnnotatedParallel) {
959 DEBUG(dbgs() << "LV: A loop annotated parallel, ignore memory dependency "
964 for (I = Loads.begin(), IE = Loads.end(); I != IE; ++I) {
965 LoadInst *LD = cast<LoadInst>(*I);
966 Value* Ptr = LD->getPointerOperand();
967 // If we did *not* see this pointer before, insert it to the
968 // read list. If we *did* see it before, then it is already in
969 // the read-write list. This allows us to vectorize expressions
970 // such as A[i] += x; Because the address of A[i] is a read-write
971 // pointer. This only works if the index of A[i] is consecutive.
972 // If the address of i is unknown (for example A[B[i]]) then we may
973 // read a few words, modify, and write a few words, and some of the
974 // words may be written to the same address.
975 bool IsReadOnlyPtr = false;
976 if (Seen.insert(Ptr).second ||
977 !isStridedPtr(SE, DL, Ptr, TheLoop, Strides)) {
979 IsReadOnlyPtr = true;
982 AliasAnalysis::Location Loc = AA->getLocation(LD);
983 // The TBAA metadata could have a control dependency on the predication
984 // condition, so we cannot rely on it when determining whether or not we
985 // need runtime pointer checks.
986 if (blockNeedsPredication(LD->getParent(), TheLoop, DT))
987 Loc.AATags.TBAA = nullptr;
989 Accesses.addLoad(Loc, IsReadOnlyPtr);
992 // If we write (or read-write) to a single destination and there are no
993 // other reads in this loop then is it safe to vectorize.
994 if (NumReadWrites == 1 && NumReads == 0) {
995 DEBUG(dbgs() << "LV: Found a write-only loop!\n");
999 // Build dependence sets and check whether we need a runtime pointer bounds
1001 Accesses.buildDependenceSets();
1002 bool NeedRTCheck = Accesses.isRTCheckNeeded();
1004 // Find pointers with computable bounds. We are going to use this information
1005 // to place a runtime bound check.
1006 unsigned NumComparisons = 0;
1007 bool CanDoRT = false;
1009 CanDoRT = Accesses.canCheckPtrAtRT(PtrRtCheck, NumComparisons, SE, TheLoop,
1012 DEBUG(dbgs() << "LV: We need to do " << NumComparisons
1013 << " pointer comparisons.\n");
1015 // If we only have one set of dependences to check pointers among we don't
1016 // need a runtime check.
1017 if (NumComparisons == 0 && NeedRTCheck)
1018 NeedRTCheck = false;
1020 // Check that we did not collect too many pointers or found an unsizeable
1022 if (!CanDoRT || NumComparisons > VectParams.RuntimeMemoryCheckThreshold) {
1028 DEBUG(dbgs() << "LV: We can perform a memory runtime check if needed.\n");
1031 if (NeedRTCheck && !CanDoRT) {
1032 emitAnalysis(VectorizationReport() << "cannot identify array bounds");
1033 DEBUG(dbgs() << "LV: We can't vectorize because we can't find "
1034 << "the array bounds.\n");
1039 PtrRtCheck.Need = NeedRTCheck;
1041 bool CanVecMem = true;
1042 if (Accesses.isDependencyCheckNeeded()) {
1043 DEBUG(dbgs() << "LV: Checking memory dependencies\n");
1044 CanVecMem = DepChecker.areDepsSafe(
1045 DependentAccesses, Accesses.getDependenciesToCheck(), Strides);
1046 MaxSafeDepDistBytes = DepChecker.getMaxSafeDepDistBytes();
1048 if (!CanVecMem && DepChecker.shouldRetryWithRuntimeCheck()) {
1049 DEBUG(dbgs() << "LV: Retrying with memory checks\n");
1052 // Clear the dependency checks. We assume they are not needed.
1053 Accesses.resetDepChecks();
1056 PtrRtCheck.Need = true;
1058 CanDoRT = Accesses.canCheckPtrAtRT(PtrRtCheck, NumComparisons, SE,
1059 TheLoop, Strides, true);
1060 // Check that we did not collect too many pointers or found an unsizeable
1062 if (!CanDoRT || NumComparisons > VectParams.RuntimeMemoryCheckThreshold) {
1063 if (!CanDoRT && NumComparisons > 0)
1064 emitAnalysis(VectorizationReport()
1065 << "cannot check memory dependencies at runtime");
1067 emitAnalysis(VectorizationReport()
1068 << NumComparisons << " exceeds limit of "
1069 << VectParams.RuntimeMemoryCheckThreshold
1070 << " dependent memory operations checked at runtime");
1071 DEBUG(dbgs() << "LV: Can't vectorize with memory checks\n");
1081 emitAnalysis(VectorizationReport()
1082 << "unsafe dependent memory operations in loop");
1084 DEBUG(dbgs() << "LV: We" << (NeedRTCheck ? "" : " don't")
1085 << " need a runtime memory check.\n");
1090 bool LoopAccessInfo::blockNeedsPredication(BasicBlock *BB, Loop *TheLoop,
1091 DominatorTree *DT) {
1092 assert(TheLoop->contains(BB) && "Unknown block used");
1094 // Blocks that do not dominate the latch need predication.
1095 BasicBlock* Latch = TheLoop->getLoopLatch();
1096 return !DT->dominates(BB, Latch);
1099 void LoopAccessInfo::emitAnalysis(VectorizationReport &Message) {
1100 VectorizationReport::emitAnalysis(Message, TheFunction, TheLoop);
1103 bool LoopAccessInfo::isUniform(Value *V) {
1104 return (SE->isLoopInvariant(SE->getSCEV(V), TheLoop));
1107 // FIXME: this function is currently a duplicate of the one in
1108 // LoopVectorize.cpp.
1109 static Instruction *getFirstInst(Instruction *FirstInst, Value *V,
1113 if (Instruction *I = dyn_cast<Instruction>(V))
1114 return I->getParent() == Loc->getParent() ? I : nullptr;
1118 std::pair<Instruction *, Instruction *>
1119 LoopAccessInfo::addRuntimeCheck(Instruction *Loc) {
1120 Instruction *tnullptr = nullptr;
1121 if (!PtrRtCheck.Need)
1122 return std::pair<Instruction *, Instruction *>(tnullptr, tnullptr);
1124 unsigned NumPointers = PtrRtCheck.Pointers.size();
1125 SmallVector<TrackingVH<Value> , 2> Starts;
1126 SmallVector<TrackingVH<Value> , 2> Ends;
1128 LLVMContext &Ctx = Loc->getContext();
1129 SCEVExpander Exp(*SE, "induction");
1130 Instruction *FirstInst = nullptr;
1132 for (unsigned i = 0; i < NumPointers; ++i) {
1133 Value *Ptr = PtrRtCheck.Pointers[i];
1134 const SCEV *Sc = SE->getSCEV(Ptr);
1136 if (SE->isLoopInvariant(Sc, TheLoop)) {
1137 DEBUG(dbgs() << "LV: Adding RT check for a loop invariant ptr:" << *Ptr
1139 Starts.push_back(Ptr);
1140 Ends.push_back(Ptr);
1142 DEBUG(dbgs() << "LV: Adding RT check for range:" << *Ptr << '\n');
1143 unsigned AS = Ptr->getType()->getPointerAddressSpace();
1145 // Use this type for pointer arithmetic.
1146 Type *PtrArithTy = Type::getInt8PtrTy(Ctx, AS);
1148 Value *Start = Exp.expandCodeFor(PtrRtCheck.Starts[i], PtrArithTy, Loc);
1149 Value *End = Exp.expandCodeFor(PtrRtCheck.Ends[i], PtrArithTy, Loc);
1150 Starts.push_back(Start);
1151 Ends.push_back(End);
1155 IRBuilder<> ChkBuilder(Loc);
1156 // Our instructions might fold to a constant.
1157 Value *MemoryRuntimeCheck = nullptr;
1158 for (unsigned i = 0; i < NumPointers; ++i) {
1159 for (unsigned j = i+1; j < NumPointers; ++j) {
1160 if (!PtrRtCheck.needsChecking(i, j))
1163 unsigned AS0 = Starts[i]->getType()->getPointerAddressSpace();
1164 unsigned AS1 = Starts[j]->getType()->getPointerAddressSpace();
1166 assert((AS0 == Ends[j]->getType()->getPointerAddressSpace()) &&
1167 (AS1 == Ends[i]->getType()->getPointerAddressSpace()) &&
1168 "Trying to bounds check pointers with different address spaces");
1170 Type *PtrArithTy0 = Type::getInt8PtrTy(Ctx, AS0);
1171 Type *PtrArithTy1 = Type::getInt8PtrTy(Ctx, AS1);
1173 Value *Start0 = ChkBuilder.CreateBitCast(Starts[i], PtrArithTy0, "bc");
1174 Value *Start1 = ChkBuilder.CreateBitCast(Starts[j], PtrArithTy1, "bc");
1175 Value *End0 = ChkBuilder.CreateBitCast(Ends[i], PtrArithTy1, "bc");
1176 Value *End1 = ChkBuilder.CreateBitCast(Ends[j], PtrArithTy0, "bc");
1178 Value *Cmp0 = ChkBuilder.CreateICmpULE(Start0, End1, "bound0");
1179 FirstInst = getFirstInst(FirstInst, Cmp0, Loc);
1180 Value *Cmp1 = ChkBuilder.CreateICmpULE(Start1, End0, "bound1");
1181 FirstInst = getFirstInst(FirstInst, Cmp1, Loc);
1182 Value *IsConflict = ChkBuilder.CreateAnd(Cmp0, Cmp1, "found.conflict");
1183 FirstInst = getFirstInst(FirstInst, IsConflict, Loc);
1184 if (MemoryRuntimeCheck) {
1185 IsConflict = ChkBuilder.CreateOr(MemoryRuntimeCheck, IsConflict,
1187 FirstInst = getFirstInst(FirstInst, IsConflict, Loc);
1189 MemoryRuntimeCheck = IsConflict;
1193 // We have to do this trickery because the IRBuilder might fold the check to a
1194 // constant expression in which case there is no Instruction anchored in a
1196 Instruction *Check = BinaryOperator::CreateAnd(MemoryRuntimeCheck,
1197 ConstantInt::getTrue(Ctx));
1198 ChkBuilder.Insert(Check, "memcheck.conflict");
1199 FirstInst = getFirstInst(FirstInst, Check, Loc);
1200 return std::make_pair(FirstInst, Check);