#define LLVM_ANALYSIS_LOOPACCESSANALYSIS_H
#include "llvm/ADT/EquivalenceClasses.h"
+#include "llvm/ADT/Optional.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/Analysis/AliasSetTracker.h"
#include "llvm/Analysis/ScalarEvolutionExpressions.h"
#include "llvm/IR/ValueHandle.h"
+#include "llvm/Pass.h"
#include "llvm/Support/raw_ostream.h"
namespace llvm {
std::string &str() { return Message; }
operator Twine() { return Message; }
- /// \brief Emit an analysis note with the debug location from the instruction
- /// in \p Message if available. Otherwise use the location of \p TheLoop.
+ /// \brief Emit an analysis note for \p PassName with the debug location from
+ /// the instruction in \p Message if available. Otherwise use the location of
+ /// \p TheLoop.
static void emitAnalysis(VectorizationReport &Message,
- const Function *TheFunction, const Loop *TheLoop);
+ const Function *TheFunction,
+ const Loop *TheLoop,
+ const char *PassName);
+};
+
+/// \brief Collection of parameters shared beetween the Loop Vectorizer and the
+/// Loop Access Analysis.
+struct VectorizerParams {
+ /// \brief Maximum SIMD width.
+ static const unsigned MaxVectorWidth;
+
+ /// \brief VF as overridden by the user.
+ static unsigned VectorizationFactor;
+ /// \brief Interleave factor as overridden by the user.
+ static unsigned VectorizationInterleave;
+ /// \brief True if force-vector-interleave was specified by the user.
+ static bool isInterleaveForced();
+
+ /// \\brief When performing memory disambiguation checks at runtime do not
+ /// make more than this number of comparisons.
+ static const unsigned RuntimeMemoryCheckThreshold;
};
/// \brief Drive the analysis of memory accesses in the loop
/// RuntimePointerCheck class.
class LoopAccessInfo {
public:
- /// \brief Collection of parameters used from the vectorizer.
- struct VectorizerParams {
- /// \brief Maximum simd width.
- unsigned MaxVectorWidth;
-
- /// \brief VF as overridden by the user.
- unsigned VectorizationFactor;
- /// \brief Interleave factor as overridden by the user.
- unsigned VectorizationInterleave;
-
- /// \\brief When performing memory disambiguation checks at runtime do not
- /// make more than this number of comparisons.
- unsigned RuntimeMemoryCheckThreshold;
-
- VectorizerParams(unsigned MaxVectorWidth, unsigned VectorizationFactor,
- unsigned VectorizationInterleave,
- unsigned RuntimeMemoryCheckThreshold)
- : MaxVectorWidth(MaxVectorWidth),
- VectorizationFactor(VectorizationFactor),
- VectorizationInterleave(VectorizationInterleave),
- RuntimeMemoryCheckThreshold(RuntimeMemoryCheckThreshold) {}
- };
-
/// This struct holds information about the memory runtime legality check that
/// a group of pointers do not overlap.
struct RuntimePointerCheck {
SmallVector<unsigned, 2> AliasSetId;
};
- LoopAccessInfo(Function *F, Loop *L, ScalarEvolution *SE,
- const DataLayout *DL, const TargetLibraryInfo *TLI,
- AliasAnalysis *AA, DominatorTree *DT,
- const VectorizerParams &VectParams)
- : TheFunction(F), TheLoop(L), SE(SE), DL(DL), TLI(TLI), AA(AA), DT(DT),
- NumLoads(0), NumStores(0), MaxSafeDepDistBytes(-1U),
- VectParams(VectParams) {}
+ LoopAccessInfo(Loop *L, ScalarEvolution *SE, const DataLayout *DL,
+ const TargetLibraryInfo *TLI, AliasAnalysis *AA,
+ DominatorTree *DT, ValueToValueMap &Strides);
/// Return true we can analyze the memory accesses in the loop and there are
- /// no memory dependence cycles. Replaces symbolic strides using Strides.
- bool canVectorizeMemory(ValueToValueMap &Strides);
+ /// no memory dependence cycles.
+ bool canVectorizeMemory() { return CanVecMem; }
RuntimePointerCheck *getRuntimePointerCheck() { return &PtrRtCheck; }
/// second value is the final comparator value or NULL if no check is needed.
std::pair<Instruction *, Instruction *> addRuntimeCheck(Instruction *Loc);
+ /// \brief The diagnostics report generated for the analysis. E.g. why we
+ /// couldn't analyze the loop.
+ Optional<VectorizationReport> &getReport() { return Report; }
+
+ /// \brief Used to ensure that if the analysis was run with speculating the
+ /// value of symbolic strides, the client queries it with the same assumption.
+ /// Only used in DEBUG build but we don't want NDEBUG-depedent ABI.
+ unsigned NumSymbolicStrides;
+
private:
+ /// \brief Analyze the loop. Substitute symbolic strides using Strides.
+ void analyzeLoop(ValueToValueMap &Strides);
+
void emitAnalysis(VectorizationReport &Message);
/// We need to check that all of the pointers in this list are disjoint
/// at runtime.
RuntimePointerCheck PtrRtCheck;
- Function *TheFunction;
Loop *TheLoop;
ScalarEvolution *SE;
const DataLayout *DL;
unsigned MaxSafeDepDistBytes;
- /// \brief Vectorizer parameters used by the analysis.
- VectorizerParams VectParams;
+ /// \brief Cache the result of analyzeLoop.
+ bool CanVecMem;
+
+ /// \brief The diagnostics report generated for the analysis. E.g. why we
+ /// couldn't analyze the loop.
+ Optional<VectorizationReport> Report;
};
Value *stripIntegerCast(Value *V);
ValueToValueMap &PtrToStride,
Value *Ptr, Value *OrigPtr = nullptr);
+/// \brief 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 LAA::getInfo. getInfo return a
+/// LoopAccessInfo object. See this class for the specifics of what information
+/// is provided.
+class LoopAccessAnalysis : public FunctionPass {
+public:
+ static char ID;
+
+ LoopAccessAnalysis() : FunctionPass(ID) {
+ initializeLoopAccessAnalysisPass(*PassRegistry::getPassRegistry());
+ }
+
+ bool runOnFunction(Function &F) override;
+
+ void getAnalysisUsage(AnalysisUsage &AU) const override;
+
+ /// \brief Query the result of the loop access information for the loop \p L.
+ ///
+ /// If the client speculates (and then issues run-time checks) for the values
+ /// of symbolic strides, \p Strides provides the mapping (see
+ /// replaceSymbolicStrideSCEV). If there is no cached result available run
+ /// the analysis.
+ LoopAccessInfo &getInfo(Loop *L, ValueToValueMap &Strides);
+
+ void releaseMemory() override {
+ // Invalidate the cache when the pass is freed.
+ LoopAccessInfoMap.clear();
+ }
+
+private:
+ /// \brief The cache.
+ DenseMap<Loop *, std::unique_ptr<LoopAccessInfo>> LoopAccessInfoMap;
+
+ // The used analysis passes.
+ ScalarEvolution *SE;
+ const DataLayout *DL;
+ const TargetLibraryInfo *TLI;
+ AliasAnalysis *AA;
+ DominatorTree *DT;
+};
} // End llvm namespace
#endif
projects / oota-llvm.git / blobdiff