[MemorySSA] Split PtrIntPair as this fails on win/arm.

[asbirlea]

Summary

Split PtrIntPair into Instruction and OptionalAlias<Result>. The latter needs 3 bits, which appear unavailable on certain archs.

llvm/trunk/include/llvm/Analysis/MemorySSA.h

 /// MemoryDef instead.
 class MemoryUseOrDef : public MemoryAccess {
 public:
   void *operator new(size_t) = delete;
 
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(MemoryAccess);
 
   /// \brief Get the instruction that this MemoryUse represents.
-  Instruction *getMemoryInst() const { return MemoryAliasPair.getPointer(); }
+  Instruction *getMemoryInst() const { return MemoryInstruction; }
 
   /// \brief Get the access that produces the memory state used by this Use.
   MemoryAccess *getDefiningAccess() const { return getOperand(0); }
 
   static bool classof(const Value *MA) {
     return MA->getValueID() == MemoryUseVal || MA->getValueID() == MemoryDefVal;
   }
 
   // Sadly, these have to be public because they are needed in some of the
   // iterators.
   inline bool isOptimized() const;
   inline MemoryAccess *getOptimized() const;
   inline void setOptimized(MemoryAccess *);
 
   // Retrieve AliasResult type of the optimized access. Ideally this would be
   // returned by the caching walker and may go away in the future.
   Optional<AliasResult> getOptimizedAccessType() const {
-    return threeBitIntToOptionalAliasResult(MemoryAliasPair.getInt());
+    return OptimizedAccessAlias;
   }
 
   /// \brief Reset the ID of what this MemoryUse was optimized to, causing it to
   /// be rewalked by the walker if necessary.
   /// This really should only be called by tests.
   inline void resetOptimized();
 
 protected:
   friend class MemorySSA;
   friend class MemorySSAUpdater;
 
   MemoryUseOrDef(LLVMContext &C, MemoryAccess *DMA, unsigned Vty,
                  DeleteValueTy DeleteValue, Instruction *MI, BasicBlock *BB)
-      : MemoryAccess(C, Vty, DeleteValue, BB, 1),
-        MemoryAliasPair(MI, optionalAliasResultToThreeBitInt(MayAlias)) {
+      : MemoryAccess(C, Vty, DeleteValue, BB, 1), MemoryInstruction(MI),
+        OptimizedAccessAlias(MayAlias) {
     setDefiningAccess(DMA);
   }
 
   // Use deleteValue() to delete a generic MemoryUseOrDef.
   ~MemoryUseOrDef() = default;
 
   void setOptimizedAccessType(Optional<AliasResult> AR) {
-    MemoryAliasPair.setInt(optionalAliasResultToThreeBitInt(AR));
+    OptimizedAccessAlias = AR;
   }
 
   void setDefiningAccess(MemoryAccess *DMA, bool Optimized = false,
                          Optional<AliasResult> AR = MayAlias) {
     if (!Optimized) {
       setOperand(0, DMA);
       return;
     }
     setOptimized(DMA);
     setOptimizedAccessType(AR);
   }
 
 private:
-  // Pair of memory instruction and Optional<AliasResult> with optimized access.
-  PointerIntPair<Instruction *, 3, int> MemoryAliasPair;
-
-  static int optionalAliasResultToThreeBitInt(Optional<AliasResult> OAR) {
-    if (OAR == None)
-      return 4;
-    return (int)OAR.getValue();
-  }
-
-  static Optional<AliasResult> threeBitIntToOptionalAliasResult(int I) {
-    assert((I <= 4 && I >= 0) &&
-           "Invalid value for converting to an Optional<AliasResult>");
-    if (I == 4)
-      return None;
-    return (AliasResult)I;
-  }
+  Instruction *MemoryInstruction;
+  Optional<AliasResult> OptimizedAccessAlias;
 };
 
 template <>
 struct OperandTraits<MemoryUseOrDef>
     : public FixedNumOperandTraits<MemoryUseOrDef, 1> {};
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(MemoryUseOrDef, MemoryAccess)
 
 /// \brief Represents read-only accesses to memory