/// Optimization analysis message produced during vectorization. Messages inform
/// the user why vectorization did not occur.
-class VectorizationReport {
+class LoopAccessReport {
std::string Message;
const Instruction *Instr;
+protected:
+ LoopAccessReport(const Twine &Message, const Instruction *I)
+ : Message(Message.str()), Instr(I) {}
+
public:
- VectorizationReport(const Instruction *I = nullptr)
- : Message("loop not vectorized: "), Instr(I) {}
+ LoopAccessReport(const Instruction *I = nullptr) : Instr(I) {}
- template <typename A> VectorizationReport &operator<<(const A &Value) {
+ template <typename A> LoopAccessReport &operator<<(const A &Value) {
raw_string_ostream Out(Message);
Out << Value;
return *this;
/// \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(const VectorizationReport &Message,
+ static void emitAnalysis(const LoopAccessReport &Message,
const Function *TheFunction,
const Loop *TheLoop,
const char *PassName);
/// \\brief When performing memory disambiguation checks at runtime do not
/// make more than this number of comparisons.
- static const unsigned RuntimeMemoryCheckThreshold;
+ static unsigned RuntimeMemoryCheckThreshold;
};
/// \brief Drive the analysis of memory accesses in the loop
/// Insert a pointer and calculate the start and end SCEVs.
void insert(ScalarEvolution *SE, Loop *Lp, Value *Ptr, bool WritePtr,
- unsigned DepSetId, unsigned ASId, ValueToValueMap &Strides);
+ unsigned DepSetId, unsigned ASId,
+ const ValueToValueMap &Strides);
+
+ /// \brief No run-time memory checking is necessary.
+ bool empty() const { return Pointers.empty(); }
/// \brief Decide whether we need to issue a run-time check for pointer at
/// index \p I and \p J to prove their independence.
bool needsChecking(unsigned I, unsigned J) const;
+ /// \brief Print the list run-time memory checks necessary.
+ void print(raw_ostream &OS, unsigned Depth = 0) const;
+
/// This flag indicates if we need to add the runtime check.
bool Need;
/// Holds the pointers that we need to check.
LoopAccessInfo(Loop *L, ScalarEvolution *SE, const DataLayout *DL,
const TargetLibraryInfo *TLI, AliasAnalysis *AA,
- DominatorTree *DT, ValueToValueMap &Strides);
+ DominatorTree *DT, const ValueToValueMap &Strides);
/// Return true we can analyze the memory accesses in the loop and there are
/// no memory dependence cycles.
- bool canVectorizeMemory() { return CanVecMem; }
+ bool canVectorizeMemory() const { return CanVecMem; }
- RuntimePointerCheck *getRuntimePointerCheck() { return &PtrRtCheck; }
+ const RuntimePointerCheck *getRuntimePointerCheck() const {
+ return &PtrRtCheck;
+ }
/// Return true if the block BB needs to be predicated in order for the loop
/// to be vectorized.
DominatorTree *DT);
/// Returns true if the value V is uniform within the loop.
- bool isUniform(Value *V);
+ bool isUniform(Value *V) const;
unsigned getMaxSafeDepDistBytes() const { return MaxSafeDepDistBytes; }
unsigned getNumStores() const { return NumStores; }
/// Returns a pair of instructions where the first element is the first
/// instruction generated in possibly a sequence of instructions and the
/// second value is the final comparator value or NULL if no check is needed.
- std::pair<Instruction *, Instruction *> addRuntimeCheck(Instruction *Loc);
+ std::pair<Instruction *, Instruction *>
+ addRuntimeCheck(Instruction *Loc) const;
/// \brief The diagnostics report generated for the analysis. E.g. why we
/// couldn't analyze the loop.
- Optional<VectorizationReport> &getReport() { return Report; }
+ const Optional<LoopAccessReport> &getReport() const { return Report; }
+
+ /// \brief Print the information about the memory accesses in the loop.
+ void print(raw_ostream &OS, unsigned Depth = 0) const;
/// \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.
+ /// Only used in DEBUG build but we don't want NDEBUG-dependent ABI.
unsigned NumSymbolicStrides;
private:
/// \brief Analyze the loop. Substitute symbolic strides using Strides.
- void analyzeLoop(ValueToValueMap &Strides);
+ void analyzeLoop(const ValueToValueMap &Strides);
/// \brief Check if the structure of the loop allows it to be analyzed by this
/// pass.
bool canAnalyzeLoop();
- void emitAnalysis(VectorizationReport &Message);
+ void emitAnalysis(LoopAccessReport &Message);
/// We need to check that all of the pointers in this list are disjoint
/// at runtime.
/// \brief The diagnostics report generated for the analysis. E.g. why we
/// couldn't analyze the loop.
- Optional<VectorizationReport> Report;
+ Optional<LoopAccessReport> Report;
};
Value *stripIntegerCast(Value *V);
/// Ptr. \p PtrToStride provides the mapping between the pointer value and its
/// stride as collected by LoopVectorizationLegality::collectStridedAccess.
const SCEV *replaceSymbolicStrideSCEV(ScalarEvolution *SE,
- ValueToValueMap &PtrToStride,
+ const ValueToValueMap &PtrToStride,
Value *Ptr, Value *OrigPtr = nullptr);
/// \brief This analysis provides dependence information for the memory accesses
/// 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);
+ const LoopAccessInfo &getInfo(Loop *L, const ValueToValueMap &Strides);
void releaseMemory() override {
// Invalidate the cache when the pass is freed.
LoopAccessInfoMap.clear();
}
+ /// \brief Print the result of the analysis when invoked with -analyze.
+ void print(raw_ostream &OS, const Module *M = nullptr) const override;
+
private:
/// \brief The cache.
DenseMap<Loop *, std::unique_ptr<LoopAccessInfo>> LoopAccessInfoMap;
projects / oota-llvm.git / blobdiff