+ friend class MemoryDependenceAnalysis;
+ /// Dirty - Entries with this marker occur in a LocalDeps map or
+ /// NonLocalDeps map when the instruction they previously referenced was
+ /// removed from MemDep. In either case, the entry may include an
+ /// instruction pointer. If so, the pointer is an instruction in the
+ /// block where scanning can start from, saving some work.
+ ///
+ /// In a default-constructed MemDepResult object, the type will be Dirty
+ /// and the instruction pointer will be null.
+ ///
+
+ /// isDirty - Return true if this is a MemDepResult in its dirty/invalid.
+ /// state.
+ bool isDirty() const { return Value.getInt() == Invalid; }
+
+ static MemDepResult getDirty(Instruction *Inst) {
+ return MemDepResult(PairTy(Inst, Invalid));
+ }
+ };
+
+ /// MemoryDependenceAnalysis - This is an analysis that determines, for a
+ /// given memory operation, what preceding memory operations it depends on.
+ /// It builds on alias analysis information, and tries to provide a lazy,
+ /// caching interface to a common kind of alias information query.
+ ///
+ /// The dependency information returned is somewhat unusual, but is pragmatic.
+ /// If queried about a store or call that might modify memory, the analysis
+ /// will return the instruction[s] that may either load from that memory or
+ /// store to it. If queried with a load or call that can never modify memory,
+ /// the analysis will return calls and stores that might modify the pointer,
+ /// but generally does not return loads unless a) they are volatile, or
+ /// b) they load from *must-aliased* pointers. Returning a dependence on
+ /// must-alias'd pointers instead of all pointers interacts well with the
+ /// internal caching mechanism.
+ ///
+ class MemoryDependenceAnalysis : public FunctionPass {
+ // A map from instructions to their dependency.
+ typedef DenseMap<Instruction*, MemDepResult> LocalDepMapType;
+ LocalDepMapType LocalDeps;
+
+ public:
+ typedef std::pair<BasicBlock*, MemDepResult> NonLocalDepEntry;
+ typedef std::vector<NonLocalDepEntry> NonLocalDepInfo;
+ private:
+ /// ValueIsLoadPair - This is a pair<Value*, bool> where the bool is true if
+ /// the dependence is a read only dependence, false if read/write.
+ typedef PointerIntPair<Value*, 1, bool> ValueIsLoadPair;
+
+ /// BBSkipFirstBlockPair - This pair is used when caching information for a
+ /// block. If the pointer is null, the cache value is not a full query that
+ /// starts at the specified block. If non-null, the bool indicates whether
+ /// or not the contents of the block was skipped.
+ typedef PointerIntPair<BasicBlock*, 1, bool> BBSkipFirstBlockPair;