[ADT] Switch from a hacky use of PointerIntPair and poorly chosen arbitrary integers cast to Instruction pointers to a sum type over Instruction * and a PointerEmbeddedInt.

[chandlerc]

Summary

This is a good example of how PointerSumType and PointerEmbeddedInt can be used
to create a more clean sum type abstraction.

No functionality changed.

Depends on D15843.
Depneds on D15844.

[chandlerc]

Rebase on top of my cleanups to memdep.

[chandlerc]

FIx my bad merge.

[bkramer]

LGTM

include/llvm/Analysis/MemoryDependenceAnalysis.h

 // This file defines the MemoryDependenceAnalysis analysis pass.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ANALYSIS_MEMORYDEPENDENCEANALYSIS_H
 #define LLVM_ANALYSIS_MEMORYDEPENDENCEANALYSIS_H
 
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/PointerIntPair.h"
+#include "llvm/ADT/PointerSumType.h"
+#include "llvm/ADT/PointerEmbeddedInt.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/PredIteratorCache.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/Pass.h"
 
 namespace llvm {
   class Function;
   class FunctionPass;
   class Instruction;
   class CallSite;
   class AssumptionCache;
   class MemoryDependenceAnalysis;
   class PredIteratorCache;
   class DominatorTree;
   class PHITransAddr;
 
   /// MemDepResult - A memory dependence query can return one of three different
   /// answers, described below.
   class MemDepResult {
     enum DepType {
-      /// Invalid - Clients of MemDep never see this.
-      Invalid = 0,
+      /// Dirty - Entries with this marker are never exposed to users of this
+      /// interface, but 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.
+      Dirty = 0,
 
       /// Clobber - This is a dependence on the specified instruction which
       /// clobbers the desired value.  The pointer member of the MemDepResult
       /// pair holds the instruction that clobbers the memory.  For example,
       /// this occurs when we see a may-aliased store to the memory location we
       /// care about.
       ///
       /// There are several cases that may be interesting here:
enum DepType {
       ///      first store to (that part of) the allocation.
       ///   3. Dependence queries on calls return Def only when they are
       ///      readonly calls or memory use intrinsics with identical callees
       ///      and no intervening clobbers.  No validation is done that the
       ///      operands to the calls are the same.
       Def,
 
       /// Other - This marker indicates that the query has no known dependency
-      /// in the specified block.  More detailed state info is encoded in the
-      /// upper part of the pair (i.e. the Instruction*)
+      /// in the specified block. More detailed state info is provided as
+      /// a PointerEmbeddedInt<OtherType, ...>.
       Other
+
     };
     /// If DepType is "Other", the upper part of the pair
     /// (i.e. the Instruction* part) is instead used to encode more detailed
     /// type information as follows
     enum OtherType {
       /// NonLocal - This marker indicates that the query has no dependency in
       /// the specified block.  To find out more, the client should query other
       /// predecessor blocks.
-      NonLocal = 0x4,
+      NonLocal = 1,
+
       /// NonFuncLocal - This marker indicates that the query has no
       /// dependency in the specified function.
-      NonFuncLocal = 0x8,
+      NonFuncLocal,
+
       /// Unknown - This marker indicates that the query dependency
       /// is unknown.
-      Unknown = 0xc
+      Unknown
     };
 
-    typedef PointerIntPair<Instruction*, 2, DepType> PairTy;
-    PairTy Value;
-    explicit MemDepResult(PairTy V) : Value(V) {}
+    typedef PointerSumType<
+        DepType, PointerSumTypeMember<Dirty, Instruction *>,
+        PointerSumTypeMember<Clobber, Instruction *>,
+        PointerSumTypeMember<Def, Instruction *>,
+        PointerSumTypeMember<Other, PointerEmbeddedInt<OtherType, 3>>>
+        ValueTy;
+    ValueTy Value;
+    explicit MemDepResult(ValueTy V) : Value(V) {}
 
   public:
-    MemDepResult() : Value(nullptr, Invalid) {}
+    MemDepResult() : Value() {}
 
     /// get methods: These are static ctor methods for creating various
     /// MemDepResult kinds.
     static MemDepResult getDef(Instruction *Inst) {
       assert(Inst && "Def requires inst");
-      return MemDepResult(PairTy(Inst, Def));
+      return MemDepResult(ValueTy::create<Def>(Inst));
     }
     static MemDepResult getClobber(Instruction *Inst) {
       assert(Inst && "Clobber requires inst");
-      return MemDepResult(PairTy(Inst, Clobber));
+      return MemDepResult(ValueTy::create<Clobber>(Inst));
     }
     static MemDepResult getNonLocal() {
-      return MemDepResult(
-        PairTy(reinterpret_cast<Instruction*>(NonLocal), Other));
+      return MemDepResult(ValueTy::create<Other>(NonLocal));
     }
     static MemDepResult getNonFuncLocal() {
-      return MemDepResult(
-        PairTy(reinterpret_cast<Instruction*>(NonFuncLocal), Other));
+      return MemDepResult(ValueTy::create<Other>(NonFuncLocal));
     }
     static MemDepResult getUnknown() {
-      return MemDepResult(
-        PairTy(reinterpret_cast<Instruction*>(Unknown), Other));
+      return MemDepResult(ValueTy::create<Other>(Unknown));
     }
 
     /// isClobber - Return true if this MemDepResult represents a query that is
     /// an instruction clobber dependency.
-    bool isClobber() const { return Value.getInt() == Clobber; }
+    bool isClobber() const { return Value.is<Clobber>(); }
 
     /// isDef - Return true if this MemDepResult represents a query that is
     /// an instruction definition dependency.
-    bool isDef() const { return Value.getInt() == Def; }
+    bool isDef() const { return Value.is<Def>(); }
 
     /// isNonLocal - Return true if this MemDepResult represents a query that
     /// is transparent to the start of the block, but where a non-local hasn't
     /// been done.
     bool isNonLocal() const {
-      return Value.getInt() == Other
-        && Value.getPointer() == reinterpret_cast<Instruction*>(NonLocal);
+      return Value.is<Other>() && Value.cast<Other>() == NonLocal;
     }
 
     /// isNonFuncLocal - Return true if this MemDepResult represents a query
     /// that is transparent to the start of the function.
     bool isNonFuncLocal() const {
-      return Value.getInt() == Other
-        && Value.getPointer() == reinterpret_cast<Instruction*>(NonFuncLocal);
+      return Value.is<Other>() && Value.cast<Other>() == NonFuncLocal;
     }
 
     /// isUnknown - Return true if this MemDepResult represents a query which
     /// cannot and/or will not be computed.
     bool isUnknown() const {
-      return Value.getInt() == Other
-        && Value.getPointer() == reinterpret_cast<Instruction*>(Unknown);
+      return Value.is<Other>() && Value.cast<Other>() == Unknown;
     }
 
     /// getInst() - If this is a normal dependency, return the instruction that
     /// is depended on.  Otherwise, return null.
     Instruction *getInst() const {
-      if (Value.getInt() == Other) return nullptr;
-      return Value.getPointer();
+      switch (Value.getTag()) {
+      case Dirty:
+        return Value.cast<Dirty>();
+      case Clobber:
+        return Value.cast<Clobber>();
+      case Def:
+        return Value.cast<Def>();
+      case Other:
+        return nullptr;
+      }
+      llvm_unreachable("Unknown discriminant!");
     }
 
     bool operator==(const MemDepResult &M) const { return Value == M.Value; }
     bool operator!=(const MemDepResult &M) const { return Value != M.Value; }
     bool operator<(const MemDepResult &M) const { return Value < M.Value; }
     bool operator>(const MemDepResult &M) const { return Value > M.Value; }
 
   private:
     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; }
+    bool isDirty() const { return Value.is<Dirty>(); }
 
     static MemDepResult getDirty(Instruction *Inst) {
-      return MemDepResult(PairTy(Inst, Invalid));
+      return MemDepResult(ValueTy::create<Dirty>(Inst));
     }
   };
 
   /// NonLocalDepEntry - This is an entry in the NonLocalDepInfo cache.  For
   /// each BasicBlock (the BB entry) it keeps a MemDepResult.
   class NonLocalDepEntry {
     BasicBlock *BB;
     MemDepResult Result;