LoopAccessAnalysis.h

Go to the documentation of this file.

//===- llvm/Analysis/LoopAccessAnalysis.h -----------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines the interface for the loop memory dependence framework that
// was originally developed for the Loop Vectorizer.
//
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_ANALYSIS_LOOPACCESSANALYSIS_H
#define LLVM_ANALYSIS_LOOPACCESSANALYSIS_H
 
#include "llvm/ADT/EquivalenceClasses.h"
#include "llvm/Analysis/ScalarEvolution.h"
#include "llvm/IR/DiagnosticInfo.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/TypeSize.h"
#include <optional>
#include <variant>
 
namespace llvm {
 
class AAResults;
class DataLayout;
class Loop;
class raw_ostream;
class TargetTransformInfo;
 
/// Collection of parameters shared beetween the Loop Vectorizer and the
/// Loop Access Analysis.
struct VectorizerParams {
  /// Maximum SIMD width.
  LLVM_ABI static const unsigned MaxVectorWidth;
 
  /// VF as overridden by the user.
  LLVM_ABI static ElementCount VectorizationFactor;
  /// Interleave factor as overridden by the user.
  LLVM_ABI static unsigned VectorizationInterleave;
  /// True if force-vector-interleave was specified by the user.
  LLVM_ABI static bool isInterleaveForced();
 
  /// \When performing memory disambiguation checks at runtime do not
  /// make more than this number of comparisons.
  LLVM_ABI static unsigned RuntimeMemoryCheckThreshold;
 
  // When creating runtime checks for nested loops, where possible try to
  // write the checks in a form that allows them to be easily hoisted out of
  // the outermost loop. For example, we can do this by expanding the range of
  // addresses considered to include the entire nested loop so that they are
  // loop invariant.
  LLVM_ABI static bool HoistRuntimeChecks;
};
 
/// Maps a pointer to its symbolic (non-constant) stride. Strides are loop
/// invariant, which collectStridedAccess checks before inserting.
using SymbolicStrideMap = DenseMap<Value *, const SCEVUnknown *>;
 
/// Checks memory dependences among accesses to the same underlying
/// object to determine whether there vectorization is legal or not (and at
/// which vectorization factor).
///
/// Note: This class will compute a conservative dependence for access to
/// different underlying pointers. Clients, such as the loop vectorizer, will
/// sometimes deal these potential dependencies by emitting runtime checks.
///
/// We use the ScalarEvolution framework to symbolically evalutate access
/// functions pairs. Since we currently don't restructure the loop we can rely
/// on the program order of memory accesses to determine their safety.
/// At the moment we will only deem accesses as safe for:
///  * A negative constant distance assuming program order.
///
///      Safe: tmp = a[i + 1];     OR     a[i + 1] = x;
///            a[i] = tmp;                y = a[i];
///
///   The latter case is safe because later checks guarantuee that there can't
///   be a cycle through a phi node (that is, we check that "x" and "y" is not
///   the same variable: a header phi can only be an induction or a reduction, a
///   reduction can't have a memory sink, an induction can't have a memory
///   source). This is important and must not be violated (or we have to
///   resort to checking for cycles through memory).
///
///  * A positive constant distance assuming program order that is bigger
///    than the biggest memory access.
///
///     tmp = a[i]        OR              b[i] = x
///     a[i+2] = tmp                      y = b[i+2];
///
///     Safe distance: 2 x sizeof(a[0]), and 2 x sizeof(b[0]), respectively.
///
///  * Zero distances and all accesses have the same size.
///
class MemoryDepChecker {
public:
  using MemAccessInfo =
      PointerIntPair<Value * /* AccessPtr */, 1, bool /* IsWrite */>;
  /// Set of potential dependent memory accesses.
  using DepCandidates = EquivalenceClasses<MemAccessInfo>;
 
  /// Type to keep track of the status of the dependence check. The order of
  /// the elements is important and has to be from most permissive to least
  /// permissive.
  enum class VectorizationSafetyStatus {
    // Can vectorize safely without RT checks. All dependences are known to be
    // safe.
    Safe,
    // Can possibly vectorize with RT checks to overcome unknown dependencies.
    PossiblySafeWithRtChecks,
    // Cannot vectorize due to known unsafe dependencies.
    Unsafe,
  };
 
  /// Dependece between memory access instructions.
  struct Dependence {
    /// The type of the dependence.
    enum DepType {
      // No dependence.
      NoDep,
      // We couldn't determine the direction or the distance.
      Unknown,
      // At least one of the memory access instructions may access a loop
      // varying object, e.g. the address of underlying object is loaded inside
      // the loop, like A[B[i]]. We cannot determine direction or distance in
      // those cases, and also are unable to generate any runtime checks.
      IndirectUnsafe,
      // Both accesses to the same loop-invariant address and at least one is a
      // write. Vectorization is unsafe because different vector lanes would
      // read/write the same memory location, and the ordering of accesses
      // across lanes matters.
      InvariantUnsafe,
 
      // Lexically forward.
      //
      // FIXME: If we only have loop-independent forward dependences (e.g. a
      // read and write of A[i]), LAA will locally deem the dependence "safe"
      // without querying the MemoryDepChecker.  Therefore we can miss
      // enumerating loop-independent forward dependences in
      // getDependences.  Note that as soon as there are different
      // indices used to access the same array, the MemoryDepChecker *is*
      // queried and the dependence list is complete.
      Forward,
      // Forward, but if vectorized, is likely to prevent store-to-load
      // forwarding.
      ForwardButPreventsForwarding,
      // Lexically backward.
      Backward,
      // Backward, but the distance allows a vectorization factor of dependent
      // on MinDepDistBytes.
      BackwardVectorizable,
      // Same, but may prevent store-to-load forwarding.
      BackwardVectorizableButPreventsForwarding
    };
 
    /// String version of the types.
    LLVM_ABI static const char *DepName[];
 
    /// Index of the source of the dependence in the InstMap vector.
    unsigned Source;
    /// Index of the destination of the dependence in the InstMap vector.
    unsigned Destination;
    /// The type of the dependence.
    DepType Type;
 
    Dependence(unsigned Source, unsigned Destination, DepType Type)
        : Source(Source), Destination(Destination), Type(Type) {}
 
    /// Return the source instruction of the dependence.
    Instruction *getSource(const MemoryDepChecker &DepChecker) const;
    /// Return the destination instruction of the dependence.
    Instruction *getDestination(const MemoryDepChecker &DepChecker) const;
 
    /// Dependence types that don't prevent vectorization.
    LLVM_ABI static VectorizationSafetyStatus
    isSafeForVectorization(DepType Type);
 
    /// Lexically forward dependence.
    LLVM_ABI bool isForward() const;
    /// Lexically backward dependence.
    LLVM_ABI bool isBackward() const;
 
    /// May be a lexically backward dependence type (includes Unknown).
    LLVM_ABI bool isPossiblyBackward() const;
 
    /// Print the dependence.  \p Instr is used to map the instruction
    /// indices to instructions.
    LLVM_ABI void print(raw_ostream &OS, unsigned Depth,
                        const SmallVectorImpl<Instruction *> &Instrs) const;
  };
 
  MemoryDepChecker(PredicatedScalarEvolution &PSE, AssumptionCache *AC,
                   DominatorTree *DT, const Loop *L,
                   const SymbolicStrideMap &SymbolicStrides,
                   unsigned MaxTargetVectorWidthInBits,
                   std::optional<ScalarEvolution::LoopGuards> &LoopGuards)
      : PSE(PSE), AC(AC), DT(DT), InnermostLoop(L),
        SymbolicStrides(SymbolicStrides),
        MaxTargetVectorWidthInBits(MaxTargetVectorWidthInBits),
        LoopGuards(LoopGuards) {}
 
  /// Register the location (instructions are given increasing numbers)
  /// of a write access.
  LLVM_ABI void addAccess(StoreInst *SI);
 
  /// Register the location (instructions are given increasing numbers)
  /// of a write access.
  LLVM_ABI void addAccess(LoadInst *LI);
 
  /// Check whether the dependencies between the accesses are safe, and records
  /// the dependence information in Dependences if so.
  ///
  /// Only checks sets with elements in \p CheckDeps.
  LLVM_ABI bool areDepsSafe(const DepCandidates &AccessSets,
                            ArrayRef<MemAccessInfo> CheckDeps);
 
  /// No memory dependence was encountered that would inhibit
  /// vectorization.
  bool isSafeForVectorization() const {
    return Status == VectorizationSafetyStatus::Safe;
  }
 
  /// Return true if the number of elements that are safe to operate on
  /// simultaneously is not bounded.
  bool isSafeForAnyVectorWidth() const {
    return MaxSafeVectorWidthInBits == UINT_MAX;
  }
 
  /// Return the number of elements that are safe to operate on
  /// simultaneously, multiplied by the size of the element in bits.
  uint64_t getMaxSafeVectorWidthInBits() const {
    return MaxSafeVectorWidthInBits;
  }
 
  /// Return true if there are no store-load forwarding dependencies.
  bool isSafeForAnyStoreLoadForwardDistances() const {
    return MaxStoreLoadForwardSafeDistanceInBits ==
           std::numeric_limits<uint64_t>::max();
  }
 
  /// Return safe power-of-2 number of elements, which do not prevent store-load
  /// forwarding, multiplied by the size of the elements in bits.
  uint64_t getStoreLoadForwardSafeDistanceInBits() const {
    assert(!isSafeForAnyStoreLoadForwardDistances() &&
           "Expected the distance, that prevent store-load forwarding, to be "
           "set.");
    return MaxStoreLoadForwardSafeDistanceInBits;
  }
 
  /// In same cases when the dependency check fails we can still
  /// vectorize the loop with a dynamic array access check.
  bool shouldRetryWithRuntimeChecks() const {
    return ShouldRetryWithRuntimeChecks &&
           Status == VectorizationSafetyStatus::PossiblySafeWithRtChecks;
  }
 
  /// Returns the memory dependences.  If null is returned we exceeded
  /// the MaxDependences threshold and this information is not
  /// available.
  const SmallVectorImpl<Dependence> *getDependences() const {
    return RecordDependences ? &Dependences : nullptr;
  }
 
  void clearDependences() { Dependences.clear(); }
 
  /// The vector of memory access instructions.  The indices are used as
  /// instruction identifiers in the Dependence class.
  const SmallVectorImpl<Instruction *> &getMemoryInstructions() const {
    return InstMap;
  }
 
  /// Generate a mapping between the memory instructions and their
  /// indices according to program order.
  DenseMap<Instruction *, unsigned> generateInstructionOrderMap() const {
    DenseMap<Instruction *, unsigned> OrderMap;
 
    for (unsigned I = 0; I < InstMap.size(); ++I)
      OrderMap[InstMap[I]] = I;
 
    return OrderMap;
  }
 
  /// Find the set of instructions that read or write via \p Ptr.
  LLVM_ABI SmallVector<Instruction *, 4>
  getInstructionsForAccess(Value *Ptr, bool isWrite) const;
 
  /// Return the program order indices for the access location (Ptr, IsWrite).
  /// Returns an empty ArrayRef if there are no accesses for the location.
  ArrayRef<unsigned> getOrderForAccess(Value *Ptr, bool IsWrite) const {
    auto I = Accesses.find({Ptr, IsWrite});
    if (I != Accesses.end())
      return I->second;
    return {};
  }
 
  const Loop *getInnermostLoop() const { return InnermostLoop; }
 
  DenseMap<std::pair<const SCEV *, const SCEV *>,
           std::pair<const SCEV *, const SCEV *>> &
  getPointerBounds() {
    return PointerBounds;
  }
 
  DominatorTree *getDT() const {
    assert(DT && "requested DT, but it is not available");
    return DT;
  }
  AssumptionCache *getAC() const {
    assert(AC && "requested AC, but it is not available");
    return AC;
  }
 
private:
  /// A wrapper around ScalarEvolution, used to add runtime SCEV checks, and
  /// applies dynamic knowledge to simplify SCEV expressions and convert them
  /// to a more usable form. We need this in case assumptions about SCEV
  /// expressions need to be made in order to avoid unknown dependences. For
  /// example we might assume a unit stride for a pointer in order to prove
  /// that a memory access is strided and doesn't wrap.
  PredicatedScalarEvolution &PSE;
 
  AssumptionCache *AC;
  DominatorTree *DT;
 
  const Loop *InnermostLoop;
 
  /// Reference to map of pointer values to
  /// their stride symbols, if they have a symbolic stride.
  const SymbolicStrideMap &SymbolicStrides;
 
  /// Maps access locations (ptr, read/write) to program order.
  DenseMap<MemAccessInfo, std::vector<unsigned> > Accesses;
 
  /// Memory access instructions in program order.
  SmallVector<Instruction *, 16> InstMap;
 
  /// The program order index to be used for the next instruction.
  unsigned AccessIdx = 0;
 
  /// The smallest dependence distance in bytes in the loop. This may not be
  /// the same as the maximum number of bytes that are safe to operate on
  /// simultaneously.
  uint64_t MinDepDistBytes = 0;
 
  /// Number of elements (from consecutive iterations) that are safe to
  /// operate on simultaneously, multiplied by the size of the element in bits.
  /// The size of the element is taken from the memory access that is most
  /// restrictive.
  uint64_t MaxSafeVectorWidthInBits = -1U;
 
  /// Maximum power-of-2 number of elements, which do not prevent store-load
  /// forwarding, multiplied by the size of the elements in bits.
  uint64_t MaxStoreLoadForwardSafeDistanceInBits =
      std::numeric_limits<uint64_t>::max();
 
  /// Whether we should try to vectorize the loop with runtime checks, if the
  /// dependencies are not safe.
  bool ShouldRetryWithRuntimeChecks = false;
 
  /// Result of the dependence checks, indicating whether the checked
  /// dependences are safe for vectorization, require RT checks or are known to
  /// be unsafe.
  VectorizationSafetyStatus Status = VectorizationSafetyStatus::Safe;
 
  //// True if Dependences reflects the dependences in the
  //// loop.  If false we exceeded MaxDependences and
  //// Dependences is invalid.
  bool RecordDependences = true;
 
  /// Memory dependences collected during the analysis.  Only valid if
  /// RecordDependences is true.
  SmallVector<Dependence, 8> Dependences;
 
  /// The maximum width of a target's vector registers multiplied by 2 to also
  /// roughly account for additional interleaving. Is used to decide if a
  /// backwards dependence with non-constant stride should be classified as
  /// backwards-vectorizable or unknown (triggering a runtime check).
  unsigned MaxTargetVectorWidthInBits = 0;
 
  /// Mapping of SCEV expressions to their expanded pointer bounds (pair of
  /// start and end pointer expressions).
  DenseMap<std::pair<const SCEV *, const SCEV *>,
           std::pair<const SCEV *, const SCEV *>>
      PointerBounds;
 
  /// Cache for the loop guards of InnermostLoop.
  std::optional<ScalarEvolution::LoopGuards> &LoopGuards;
 
  /// Check whether there is a plausible dependence between the two
  /// accesses.
  ///
  /// Access \p A must happen before \p B in program order. The two indices
  /// identify the index into the program order map.
  ///
  /// This function checks  whether there is a plausible dependence (or the
  /// absence of such can't be proved) between the two accesses. If there is a
  /// plausible dependence but the dependence distance is bigger than one
  /// element access it records this distance in \p MinDepDistBytes (if this
  /// distance is smaller than any other distance encountered so far).
  /// Otherwise, this function returns true signaling a possible dependence.
  Dependence::DepType isDependent(const MemAccessInfo &A, unsigned AIdx,
                                  const MemAccessInfo &B, unsigned BIdx);
 
  /// Check whether the data dependence could prevent store-load
  /// forwarding.
  ///
  /// \return false if we shouldn't vectorize at all or avoid larger
  /// vectorization factors by limiting MinDepDistBytes.
  bool couldPreventStoreLoadForward(uint64_t Distance, uint64_t TypeByteSize,
                                    unsigned CommonStride = 0);
 
  /// Updates the current safety status with \p S. We can go from Safe to
  /// either PossiblySafeWithRtChecks or Unsafe and from
  /// PossiblySafeWithRtChecks to Unsafe.
  void mergeInStatus(VectorizationSafetyStatus S);
 
  struct DepDistanceStrideAndSizeInfo {
    const SCEV *Dist;
 
    /// Strides here are scaled; i.e. in bytes, taking the size of the
    /// underlying type into account.
    uint64_t MaxStride;
    std::optional<uint64_t> CommonStride;
 
    /// TypeByteSize is either the common store size of both accesses, or 0 when
    /// store sizes mismatch.
    uint64_t TypeByteSize;
 
    bool AIsWrite;
    bool BIsWrite;
 
    DepDistanceStrideAndSizeInfo(const SCEV *Dist, uint64_t MaxStride,
                                 std::optional<uint64_t> CommonStride,
                                 uint64_t TypeByteSize, bool AIsWrite,
                                 bool BIsWrite)
        : Dist(Dist), MaxStride(MaxStride), CommonStride(CommonStride),
          TypeByteSize(TypeByteSize), AIsWrite(AIsWrite), BIsWrite(BIsWrite) {}
  };
 
  /// Get the dependence distance, strides, type size and whether it is a write
  /// for the dependence between A and B. Returns a DepType, if we can prove
  /// there's no dependence or the analysis fails. Outlined to lambda to limit
  /// he scope of various temporary variables, like A/BPtr, StrideA/BPtr and
  /// others. Returns either the dependence result, if it could already be
  /// determined, or a DepDistanceStrideAndSizeInfo struct, noting that
  /// TypeByteSize could be 0 when store sizes mismatch, and this should be
  /// checked in the caller.
  std::variant<Dependence::DepType, DepDistanceStrideAndSizeInfo>
  getDependenceDistanceStrideAndSize(const MemAccessInfo &A, Instruction *AInst,
                                     const MemAccessInfo &B,
                                     Instruction *BInst);
 
  // Return true if we can prove that \p Sink only accesses memory after \p
  // Src's end or vice versa.
  bool areAccessesCompletelyBeforeOrAfter(const SCEV *Src, Type *SrcTy,
                                          const SCEV *Sink, Type *SinkTy);
};
 
class RuntimePointerChecking;
/// A grouping of pointers. A single memcheck is required between
/// two groups.
struct RuntimeCheckingPtrGroup {
  /// Create a new pointer checking group containing a single
  /// pointer, with index \p Index in RtCheck.
  LLVM_ABI RuntimeCheckingPtrGroup(unsigned Index,
                                   const RuntimePointerChecking &RtCheck);
 
  /// Tries to add the pointer recorded in RtCheck at index
  /// \p Index to this pointer checking group. We can only add a pointer
  /// to a checking group if we will still be able to get
  /// the upper and lower bounds of the check. Returns true in case
  /// of success, false otherwise.
  LLVM_ABI bool addPointer(unsigned Index,
                           const RuntimePointerChecking &RtCheck);
  LLVM_ABI bool addPointer(unsigned Index, const SCEV *Start, const SCEV *End,
                           unsigned AS, bool NeedsFreeze, ScalarEvolution &SE);
 
  /// The SCEV expression which represents the upper bound of all the
  /// pointers in this group.
  const SCEV *High;
  /// The SCEV expression which represents the lower bound of all the
  /// pointers in this group.
  const SCEV *Low;
  /// Indices of all the pointers that constitute this grouping.
  SmallVector<unsigned, 2> Members;
  /// Address space of the involved pointers.
  unsigned AddressSpace;
  /// Whether the pointer needs to be frozen after expansion, e.g. because it
  /// may be poison outside the loop.
  bool NeedsFreeze = false;
};
 
/// A memcheck which made up of a pair of grouped pointers.
using RuntimePointerCheck =
    std::pair<const RuntimeCheckingPtrGroup *, const RuntimeCheckingPtrGroup *>;
 
struct PointerDiffInfo {
  const SCEV *SrcStart;
  const SCEV *SinkStart;
  unsigned AccessSize;
  bool NeedsFreeze;
 
  PointerDiffInfo(const SCEV *SrcStart, const SCEV *SinkStart,
                  unsigned AccessSize, bool NeedsFreeze)
      : SrcStart(SrcStart), SinkStart(SinkStart), AccessSize(AccessSize),
        NeedsFreeze(NeedsFreeze) {}
};
 
/// Holds information about the memory runtime legality checks to verify
/// that a group of pointers do not overlap.
class RuntimePointerChecking {
  friend struct RuntimeCheckingPtrGroup;
 
public:
  struct PointerInfo {
    /// Holds the pointer value that we need to check.
    TrackingVH<Value> PointerValue;
    /// Holds the smallest byte address accessed by the pointer throughout all
    /// iterations of the loop.
    const SCEV *Start;
    /// Holds the largest byte address accessed by the pointer throughout all
    /// iterations of the loop, plus 1.
    const SCEV *End;
    /// Holds the information if this pointer is used for writing to memory.
    bool IsWritePtr;
    /// Holds the id of the set of pointers that could be dependent because of a
    /// shared underlying object.
    unsigned DependencySetId;
    /// Holds the id of the disjoint alias set to which this pointer belongs.
    unsigned AliasSetId;
    /// SCEV for the access.
    const SCEV *Expr;
    /// True if the pointer expressions needs to be frozen after expansion.
    bool NeedsFreeze;
 
    PointerInfo(Value *PointerValue, const SCEV *Start, const SCEV *End,
                bool IsWritePtr, unsigned DependencySetId, unsigned AliasSetId,
                const SCEV *Expr, bool NeedsFreeze)
        : PointerValue(PointerValue), Start(Start), End(End),
          IsWritePtr(IsWritePtr), DependencySetId(DependencySetId),
          AliasSetId(AliasSetId), Expr(Expr), NeedsFreeze(NeedsFreeze) {}
  };
 
  RuntimePointerChecking(MemoryDepChecker &DC, ScalarEvolution *SE,
                         std::optional<ScalarEvolution::LoopGuards> &LoopGuards)
      : DC(DC), SE(SE), LoopGuards(LoopGuards) {}
 
  /// Reset the state of the pointer runtime information.
  void reset() {
    Need = false;
    CanUseDiffCheck = true;
    Pointers.clear();
    Checks.clear();
    DiffChecks.clear();
    CheckingGroups.clear();
  }
 
  /// Insert a pointer and calculate the start and end SCEVs.
  /// We need \p PSE in order to compute the SCEV expression of the pointer
  /// according to the assumptions that we've made during the analysis.
  /// The method might also version the pointer stride according to \p Strides,
  /// and add new predicates to \p PSE.
  LLVM_ABI void insert(Loop *Lp, Value *Ptr, const SCEV *PtrExpr,
                       Type *AccessTy, bool WritePtr, unsigned DepSetId,
                       unsigned ASId, PredicatedScalarEvolution &PSE,
                       bool NeedsFreeze);
 
  /// No run-time memory checking is necessary.
  bool empty() const { return Pointers.empty(); }
 
  /// Generate the checks and store it.  This also performs the grouping
  /// of pointers to reduce the number of memchecks necessary.
  LLVM_ABI void generateChecks(MemoryDepChecker::DepCandidates &DepCands);
 
  /// Returns the checks that generateChecks created. They can be used to ensure
  /// no read/write accesses overlap across all loop iterations.
  const SmallVectorImpl<RuntimePointerCheck> &getChecks() const {
    return Checks;
  }
 
  // Returns an optional list of (pointer-difference expressions, access size)
  // pairs that can be used to prove that there are no vectorization-preventing
  // dependencies at runtime. There are is a vectorization-preventing dependency
  // if any pointer-difference is <u VF * InterleaveCount * access size. Returns
  // std::nullopt if pointer-difference checks cannot be used.
  std::optional<ArrayRef<PointerDiffInfo>> getDiffChecks() const {
    if (!CanUseDiffCheck)
      return std::nullopt;
    return {DiffChecks};
  }
 
  /// Decide if we need to add a check between two groups of pointers,
  /// according to needsChecking.
  LLVM_ABI bool needsChecking(const RuntimeCheckingPtrGroup &M,
                              const RuntimeCheckingPtrGroup &N) const;
 
  /// Returns the number of run-time checks required according to
  /// needsChecking.
  unsigned getNumberOfChecks() const { return Checks.size(); }
 
  /// Print the list run-time memory checks necessary.
  LLVM_ABI void print(raw_ostream &OS, unsigned Depth = 0) const;
 
  /// Print \p Checks.
  LLVM_ABI void printChecks(raw_ostream &OS,
                            const SmallVectorImpl<RuntimePointerCheck> &Checks,
                            unsigned Depth = 0) const;
 
  /// This flag indicates if we need to add the runtime check.
  bool Need = false;
 
  /// Information about the pointers that may require checking.
  SmallVector<PointerInfo, 2> Pointers;
 
  /// Holds a partitioning of pointers into "check groups".
  SmallVector<RuntimeCheckingPtrGroup, 2> CheckingGroups;
 
  /// Check if pointers are in the same partition
  ///
  /// \p PtrToPartition contains the partition number for pointers (-1 if the
  /// pointer belongs to multiple partitions).
  LLVM_ABI static bool
  arePointersInSamePartition(const SmallVectorImpl<int> &PtrToPartition,
                             unsigned PtrIdx1, unsigned PtrIdx2);
 
  /// Decide whether we need to issue a run-time check for pointer at
  /// index \p I and \p J to prove their independence.
  LLVM_ABI bool needsChecking(unsigned I, unsigned J) const;
 
  /// Return PointerInfo for pointer at index \p PtrIdx.
  const PointerInfo &getPointerInfo(unsigned PtrIdx) const {
    return Pointers[PtrIdx];
  }
 
  ScalarEvolution *getSE() const { return SE; }
 
private:
  /// Groups pointers such that a single memcheck is required
  /// between two different groups. This will clear the CheckingGroups vector
  /// and re-compute it.
  void groupChecks(MemoryDepChecker::DepCandidates &DepCands);
 
  /// Generate the checks and return them.
  SmallVector<RuntimePointerCheck, 4> generateChecks();
 
  /// Try to create add a new (pointer-difference, access size) pair to
  /// DiffCheck for checking groups \p CGI and \p CGJ. If pointer-difference
  /// checks cannot be used for the groups, set CanUseDiffCheck to false.
  bool tryToCreateDiffCheck(const RuntimeCheckingPtrGroup &CGI,
                            const RuntimeCheckingPtrGroup &CGJ);
 
  MemoryDepChecker &DC;
 
  /// Holds a pointer to the ScalarEvolution analysis.
  ScalarEvolution *SE;
 
  /// Cache for the loop guards of the loop.
  std::optional<ScalarEvolution::LoopGuards> &LoopGuards;
 
  /// Set of run-time checks required to establish independence of
  /// otherwise may-aliasing pointers in the loop.
  SmallVector<RuntimePointerCheck, 4> Checks;
 
  /// Flag indicating if pointer-difference checks can be used
  bool CanUseDiffCheck = true;
 
  /// A list of (pointer-difference, access size) pairs that can be used to
  /// prove that there are no vectorization-preventing dependencies.
  SmallVector<PointerDiffInfo> DiffChecks;
};
 
/// Drive the analysis of memory accesses in the loop
///
/// This class is responsible for analyzing the memory accesses of a loop.  It
/// collects the accesses and then its main helper the AccessAnalysis class
/// finds and categorizes the dependences in buildDependenceSets.
///
/// For memory dependences that can be analyzed at compile time, it determines
/// whether the dependence is part of cycle inhibiting vectorization.  This work
/// is delegated to the MemoryDepChecker class.
///
/// For memory dependences that cannot be determined at compile time, it
/// generates run-time checks to prove independence.  This is done by
/// AccessAnalysis::canCheckPtrAtRT and the checks are maintained by the
/// RuntimePointerCheck class. \p AllowPartial determines whether partial checks
/// are generated when not all pointers could be analyzed.
///
/// If pointers can wrap or can't be expressed as affine AddRec expressions by
/// ScalarEvolution, we will generate run-time checks by emitting a
/// SCEVUnionPredicate.
///
/// Checks for both memory dependences and the SCEV predicates contained in the
/// PSE must be emitted in order for the results of this analysis to be valid.
class LoopAccessInfo {
public:
  LLVM_ABI LoopAccessInfo(Loop *L, ScalarEvolution *SE,
                          const TargetTransformInfo *TTI,
                          const TargetLibraryInfo *TLI, AAResults *AA,
                          DominatorTree *DT, LoopInfo *LI, AssumptionCache *AC,
                          bool AllowPartial = false);
 
  /// Return true we can analyze the memory accesses in the loop and there are
  /// no memory dependence cycles. Note that for dependences between loads &
  /// stores with uniform addresses,
  /// hasStoreStoreDependenceInvolvingLoopInvariantAddress and
  /// hasLoadStoreDependenceInvolvingLoopInvariantAddress also need to be
  /// checked.
  bool canVectorizeMemory() const { return CanVecMem; }
 
  /// 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.
  bool hasConvergentOp() const { return HasConvergentOp; }
 
  /// Return true if, when runtime pointer checking does not have complete
  /// results, it instead has partial results for those memory accesses that
  /// could be analyzed.
  bool hasAllowPartial() const { return AllowPartial; }
 
  const RuntimePointerChecking *getRuntimePointerChecking() const {
    return PtrRtChecking.get();
  }
 
  /// Number of memchecks required to prove independence of otherwise
  /// may-alias pointers.
  unsigned getNumRuntimePointerChecks() const {
    return PtrRtChecking->getNumberOfChecks();
  }
 
  /// Return true if the block BB needs to be predicated in order for the loop
  /// to be vectorized.
  /// \pre \p TheLoop has a unique latch.
  LLVM_ABI static bool blockNeedsPredication(const BasicBlock *BB,
                                             const Loop *TheLoop,
                                             const DominatorTree *DT);
 
  /// Returns true if value \p V is loop invariant.
  LLVM_ABI bool isInvariant(Value *V) const;
 
  unsigned getNumStores() const { return NumStores; }
  unsigned getNumLoads() const { return NumLoads;}
 
  /// The diagnostics report generated for the analysis.  E.g. why we
  /// couldn't analyze the loop.
  const OptimizationRemarkAnalysis *getReport() const { return Report.get(); }
 
  /// the Memory Dependence Checker which can determine the
  /// loop-independent and loop-carried dependences between memory accesses.
  const MemoryDepChecker &getDepChecker() const { return *DepChecker; }
 
  /// Return the list of instructions that use \p Ptr to read or write
  /// memory.
  SmallVector<Instruction *, 4> getInstructionsForAccess(Value *Ptr,
                                                         bool isWrite) const {
    return DepChecker->getInstructionsForAccess(Ptr, isWrite);
  }
 
  /// If an access has a symbolic strides, this maps the pointer value to
  /// the stride symbol.
  const SymbolicStrideMap &getSymbolicStrides() const {
    return SymbolicStrides;
  }
 
  /// Print the information about the memory accesses in the loop.
  LLVM_ABI void print(raw_ostream &OS, unsigned Depth = 0) const;
 
  /// Return true if the loop has memory dependence involving two stores to an
  /// invariant address, else return false.
  bool hasStoreStoreDependenceInvolvingLoopInvariantAddress() const {
    return HasStoreStoreDependenceInvolvingLoopInvariantAddress;
  }
 
  /// Return true if the loop has memory dependence involving a load and a store
  /// to an invariant address, else return false.
  bool hasLoadStoreDependenceInvolvingLoopInvariantAddress() const {
    return HasLoadStoreDependenceInvolvingLoopInvariantAddress;
  }
 
  /// Return the list of stores to invariant addresses.
  ArrayRef<StoreInst *> getStoresToInvariantAddresses() const {
    return StoresToInvariantAddresses;
  }
 
  /// 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.
  /// A user of LoopAccessAnalysis will need to emit the runtime checks
  /// associated with this predicate.
  const PredicatedScalarEvolution &getPSE() const { return *PSE; }
 
private:
  /// Analyze the loop. Returns true if all memory access in the loop can be
  /// vectorized.
  bool analyzeLoop(AAResults *AA, const LoopInfo *LI,
                   const TargetLibraryInfo *TLI, DominatorTree *DT);
 
  /// Check if the structure of the loop allows it to be analyzed by this
  /// pass.
  bool canAnalyzeLoop();
 
  /// Save the analysis remark.
  ///
  /// LAA does not directly emits the remarks.  Instead it stores it which the
  /// client can retrieve and presents as its own analysis
  /// (e.g. -Rpass-analysis=loop-vectorize).
  OptimizationRemarkAnalysis &
  recordAnalysis(StringRef RemarkName, const Instruction *Instr = nullptr);
 
  /// Collect memory access with loop invariant strides.
  ///
  /// Looks for accesses like "a[i * StrideA]" where "StrideA" is loop
  /// invariant.
  void collectStridedAccess(Value *LoadOrStoreInst);
 
  // Emits the first unsafe memory dependence in a loop.
  // Emits nothing if there are no unsafe dependences
  // or if the dependences were not recorded.
  void emitUnsafeDependenceRemark();
 
  std::unique_ptr<PredicatedScalarEvolution> PSE;
 
  /// We need to check that all of the pointers in this list are disjoint
  /// at runtime. Using std::unique_ptr to make using move ctor simpler.
  /// If AllowPartial is true then this list may contain only partial
  /// information when we've failed to analyze all the memory accesses in the
  /// loop, in which case HasCompletePtrRtChecking will be false.
  std::unique_ptr<RuntimePointerChecking> PtrRtChecking;
 
  /// The Memory Dependence Checker which can determine the
  /// loop-independent and loop-carried dependences between memory accesses.
  /// This will be empty if we've failed to analyze all the memory access in the
  /// loop (i.e. CanVecMem is false).
  std::unique_ptr<MemoryDepChecker> DepChecker;
 
  Loop *TheLoop;
 
  /// Cache for the loop guards of TheLoop.
  std::optional<ScalarEvolution::LoopGuards> LoopGuards;
 
  /// Determines whether we should generate partial runtime checks when not all
  /// memory accesses could be analyzed.
  bool AllowPartial;
 
  unsigned NumLoads = 0;
  unsigned NumStores = 0;
 
  /// Cache the result of analyzeLoop.
  bool CanVecMem = false;
  bool HasConvergentOp = false;
  bool HasCompletePtrRtChecking = false;
 
  /// Indicator that there are two non vectorizable stores to the same uniform
  /// address.
  bool HasStoreStoreDependenceInvolvingLoopInvariantAddress = false;
  /// Indicator that there is non vectorizable load and store to the same
  /// uniform address.
  bool HasLoadStoreDependenceInvolvingLoopInvariantAddress = false;
 
  /// List of stores to invariant addresses.
  SmallVector<StoreInst *> StoresToInvariantAddresses;
 
  /// The diagnostics report generated for the analysis.  E.g. why we
  /// couldn't analyze the loop.
  std::unique_ptr<OptimizationRemarkAnalysis> Report;
 
  /// If an access has a symbolic strides, this maps the pointer value to
  /// the stride symbol.
  SymbolicStrideMap SymbolicStrides;
};
 
/// Return the SCEV corresponding to a pointer with the symbolic stride
/// replaced with constant one, assuming the SCEV predicate associated with
/// \p PSE is true.
///
/// If necessary this method will version the stride of the pointer according
/// to \p PtrToStride and therefore add further predicates to \p PSE.
///
/// \p PtrToStride provides the mapping between the pointer value and its
/// stride as collected by LoopVectorizationLegality::collectStridedAccess.
LLVM_ABI const SCEV *
replaceSymbolicStrideSCEV(PredicatedScalarEvolution &PSE,
                          const SymbolicStrideMap &PtrToStride, Value *Ptr);
 
/// If \p AR is an affine AddRec for \p Lp with a constant step, return the
/// step in units of \p AccessTy's allocation size. Returns std::nullopt if the
/// step is not constant, does not divide the access size, or \p AccessTy is a
/// scalable vector. \p Ptr is only used for debug output and may be null.
LLVM_ABI std::optional<int64_t>
getStrideFromAddRec(const SCEVAddRecExpr *AR, const Loop *Lp, Type *AccessTy,
                    Value *Ptr, PredicatedScalarEvolution &PSE);
 
/// If the pointer has a constant stride return it in units of the access type
/// size. If the pointer is loop-invariant, return 0. Otherwise return
/// std::nullopt.
///
/// Ensure that it does not wrap in the address space, assuming the predicate
/// associated with \p PSE is true.
///
/// If necessary this method will version the stride of the pointer according
/// to \p PtrToStride and therefore add further predicates to \p PSE.
///
/// If \p Predicates is non-null, add no-wrap SCEV predicates if needed.
///
/// Note that the analysis results are defined if-and-only-if the original
/// memory access was defined.  If that access was dead, or UB, then the
/// result of this function is undefined.
LLVM_ABI std::optional<int64_t>
getPtrStride(PredicatedScalarEvolution &PSE, Type *AccessTy, Value *Ptr,
             const Loop *Lp, const DominatorTree &DT,
             const SymbolicStrideMap &StridesMap = SymbolicStrideMap(),
             bool ShouldCheckWrap = true,
             SmallVectorImpl<const SCEVPredicate *> *Predicates = nullptr);
 
/// Overload of \ref getPtrStride that adds the no-wrap predicates directly to
/// \p PSE. The \p Assume parameter indicates whether such additional run-time
/// assumptions are allowed.
LLVM_ABI std::optional<int64_t>
getPtrStride(PredicatedScalarEvolution &PSE, Type *AccessTy, Value *Ptr,
             const Loop *Lp, const DominatorTree &DT,
             const SymbolicStrideMap &StridesMap, bool Assume,
             bool ShouldCheckWrap = true);
 
/// Returns the distance between the pointers \p PtrA and \p PtrB iff they are
/// compatible and it is possible to calculate the distance between them. This
/// is a simple API that does not depend on the analysis pass.
/// \param StrictCheck Ensure that the calculated distance matches the
/// type-based one after all the bitcasts removal in the provided pointers.
LLVM_ABI std::optional<int64_t>
getPointersDiff(Type *ElemTyA, Value *PtrA, Type *ElemTyB, Value *PtrB,
                const DataLayout &DL, ScalarEvolution &SE,
                bool StrictCheck = false, bool CheckType = true);
 
/// Attempt to sort the pointers in \p VL and return the sorted indices
/// in \p SortedIndices, if reordering is required.
///
/// Returns 'true' if sorting is legal, otherwise returns 'false'.
///
/// For example, for a given \p VL of memory accesses in program order, a[i+4],
/// a[i+0], a[i+1] and a[i+7], this function will sort the \p VL and save the
/// sorted indices in \p SortedIndices as a[i+0], a[i+1], a[i+4], a[i+7] and
/// saves the mask for actual memory accesses in program order in
/// \p SortedIndices as <1,2,0,3>
LLVM_ABI bool sortPtrAccesses(ArrayRef<Value *> VL, Type *ElemTy,
                              const DataLayout &DL, ScalarEvolution &SE,
                              SmallVectorImpl<unsigned> &SortedIndices);
 
/// Returns true if the memory operations \p A and \p B are consecutive.
/// This is a simple API that does not depend on the analysis pass.
LLVM_ABI bool isConsecutiveAccess(Value *A, Value *B, const DataLayout &DL,
                                  ScalarEvolution &SE, bool CheckType = true);
 
/// Calculate Start and End points of memory access using exact backedge taken
/// count \p BTC if computable or maximum backedge taken count \p MaxBTC
/// otherwise.
///
/// Let's assume A is the first access and B is a memory access on N-th loop
/// iteration. Then B is calculated as:
///   B = A + Step*N .
/// Step value may be positive or negative.
/// N is a calculated back-edge taken count:
///     N = (TripCount > 0) ? RoundDown(TripCount -1 , VF) : 0
/// Start and End points are calculated in the following way:
/// Start = UMIN(A, B) ; End = UMAX(A, B) + SizeOfElt,
/// where SizeOfElt is the size of single memory access in bytes.
///
/// There is no conflict when the intervals are disjoint:
/// NoConflict = (P2.Start >= P1.End) || (P1.Start >= P2.End)
LLVM_ABI std::pair<const SCEV *, const SCEV *> getStartAndEndForAccess(
    const Loop *Lp, const SCEV *PtrExpr, Type *AccessTy, const SCEV *BTC,
    const SCEV *MaxBTC, ScalarEvolution *SE,
    DenseMap<std::pair<const SCEV *, const SCEV *>,
             std::pair<const SCEV *, const SCEV *>> *PointerBounds,
    DominatorTree *DT, AssumptionCache *AC,
    std::optional<ScalarEvolution::LoopGuards> &LoopGuards);
LLVM_ABI std::pair<const SCEV *, const SCEV *> getStartAndEndForAccess(
    const Loop *Lp, const SCEV *PtrExpr, const SCEV *EltSizeSCEV,
    const SCEV *BTC, const SCEV *MaxBTC, ScalarEvolution *SE,
    DenseMap<std::pair<const SCEV *, const SCEV *>,
             std::pair<const SCEV *, const SCEV *>> *PointerBounds,
    DominatorTree *DT, AssumptionCache *AC,
    std::optional<ScalarEvolution::LoopGuards> &LoopGuards);
 
class LoopAccessInfoManager {
  /// The cache.
  DenseMap<Loop *, std::unique_ptr<LoopAccessInfo>> LoopAccessInfoMap;
 
  // The used analysis passes.
  ScalarEvolution &SE;
  AAResults &AA;
  DominatorTree &DT;
  LoopInfo &LI;
  TargetTransformInfo *TTI;
  const TargetLibraryInfo *TLI = nullptr;
  AssumptionCache *AC;
 
public:
  LoopAccessInfoManager(ScalarEvolution &SE, AAResults &AA, DominatorTree &DT,
                        LoopInfo &LI, TargetTransformInfo *TTI,
                        const TargetLibraryInfo *TLI, AssumptionCache *AC)
      : SE(SE), AA(AA), DT(DT), LI(LI), TTI(TTI), TLI(TLI), AC(AC) {}
 
  LLVM_ABI const LoopAccessInfo &getInfo(Loop &L, bool AllowPartial = false);
 
  LLVM_ABI void clear();
 
  LLVM_ABI bool invalidate(Function &F, const PreservedAnalyses &PA,
                           FunctionAnalysisManager::Invalidator &Inv);
};
 
/// This analysis provides dependence information for the memory
/// accesses of a loop.
///
/// It runs the analysis for a loop on demand.  This can be initiated by
/// querying the loop access info via AM.getResult<LoopAccessAnalysis>.
/// getResult return a LoopAccessInfo object.  See this class for the
/// specifics of what information is provided.
class LoopAccessAnalysis
    : public AnalysisInfoMixin<LoopAccessAnalysis> {
  friend AnalysisInfoMixin<LoopAccessAnalysis>;
  LLVM_ABI static AnalysisKey Key;
 
public:
  using Result = LoopAccessInfoManager;
 
  LLVM_ABI Result run(Function &F, FunctionAnalysisManager &AM);
};
 
inline Instruction *MemoryDepChecker::Dependence::getSource(
    const MemoryDepChecker &DepChecker) const {
  return DepChecker.getMemoryInstructions()[Source];
}
 
inline Instruction *MemoryDepChecker::Dependence::getDestination(
    const MemoryDepChecker &DepChecker) const {
  return DepChecker.getMemoryInstructions()[Destination];
}
 
} // End llvm namespace
 
#endif