1 files changed, 16 insertions, 96 deletions

diff --git a/include/llvm/Analysis/ScalarEvolutionExpressions.h b/include/llvm/Analysis/ScalarEvolutionExpressions.h
index 64b8b0b..0ab3b3f 100644
--- a/include/llvm/Analysis/ScalarEvolutionExpressions.h
+++ b/include/llvm/Analysis/ScalarEvolutionExpressions.h
@@ -27,7 +27,7 @@ namespace llvm {
     // folders simpler.
     scConstant, scTruncate, scZeroExtend, scSignExtend, scAddExpr, scMulExpr,
     scUDivExpr, scAddRecExpr, scUMaxExpr, scSMaxExpr,
-    scFieldOffset, scAllocSize, scUnknown, scCouldNotCompute
+    scUnknown, scCouldNotCompute
   };
 
   //===--------------------------------------------------------------------===//
@@ -412,12 +412,15 @@ namespace llvm {
     }
 
     virtual bool hasComputableLoopEvolution(const Loop *QL) const {
-      if (L == QL) return true;
-      return false;
+      return L == QL;
     }
 
     virtual bool isLoopInvariant(const Loop *QueryLoop) const;
 
+    bool dominates(BasicBlock *BB, DominatorTree *DT) const;
+
+    bool properlyDominates(BasicBlock *BB, DominatorTree *DT) const;
+
     /// isAffine - Return true if this is an affine AddRec (i.e., it represents
     /// an expressions A+B*x where A and B are loop invariant values.
     bool isAffine() const {
@@ -512,95 +515,6 @@ namespace llvm {
   };
 
   //===--------------------------------------------------------------------===//
-  /// SCEVTargetDataConstant - This node is the base class for representing
-  /// target-dependent values in a target-independent way.
-  ///
-  class SCEVTargetDataConstant : public SCEV {
-  protected:
-    const Type *Ty;
-    SCEVTargetDataConstant(const FoldingSetNodeID &ID, enum SCEVTypes T,
-                           const Type *ty) :
-      SCEV(ID, T), Ty(ty) {}
-
-  public:
-    virtual bool isLoopInvariant(const Loop *) const { return true; }
-    virtual bool hasComputableLoopEvolution(const Loop *) const {
-      return false; // not computable
-    }
-
-    virtual bool hasOperand(const SCEV *) const {
-      return false;
-    }
-
-    bool dominates(BasicBlock *, DominatorTree *) const {
-      return true;
-    }
-
-    bool properlyDominates(BasicBlock *, DominatorTree *) const {
-      return true;
-    }
-
-    virtual const Type *getType() const { return Ty; }
-
-    /// Methods for support type inquiry through isa, cast, and dyn_cast:
-    static inline bool classof(const SCEVTargetDataConstant *S) { return true; }
-    static inline bool classof(const SCEV *S) {
-      return S->getSCEVType() == scFieldOffset ||
-             S->getSCEVType() == scAllocSize;
-    }
-  };
-
-  //===--------------------------------------------------------------------===//
-  /// SCEVFieldOffsetExpr - This node represents an offsetof expression.
-  ///
-  class SCEVFieldOffsetExpr : public SCEVTargetDataConstant {
-    friend class ScalarEvolution;
-
-    const StructType *STy;
-    unsigned FieldNo;
-    SCEVFieldOffsetExpr(const FoldingSetNodeID &ID, const Type *ty,
-                        const StructType *sty, unsigned fieldno) :
-      SCEVTargetDataConstant(ID, scFieldOffset, ty),
-      STy(sty), FieldNo(fieldno) {}
-
-  public:
-    const StructType *getStructType() const { return STy; }
-    unsigned getFieldNo() const { return FieldNo; }
-
-    virtual void print(raw_ostream &OS) const;
-
-    /// Methods for support type inquiry through isa, cast, and dyn_cast:
-    static inline bool classof(const SCEVFieldOffsetExpr *S) { return true; }
-    static inline bool classof(const SCEV *S) {
-      return S->getSCEVType() == scFieldOffset;
-    }
-  };
-
-  //===--------------------------------------------------------------------===//
-  /// SCEVAllocSize - This node represents a sizeof expression.
-  ///
-  class SCEVAllocSizeExpr : public SCEVTargetDataConstant {
-    friend class ScalarEvolution;
-
-    const Type *AllocTy;
-    SCEVAllocSizeExpr(const FoldingSetNodeID &ID,
-                      const Type *ty, const Type *allocty) :
-      SCEVTargetDataConstant(ID, scAllocSize, ty),
-      AllocTy(allocty) {}
-
-  public:
-    const Type *getAllocType() const { return AllocTy; }
-
-    virtual void print(raw_ostream &OS) const;
-
-    /// Methods for support type inquiry through isa, cast, and dyn_cast:
-    static inline bool classof(const SCEVAllocSizeExpr *S) { return true; }
-    static inline bool classof(const SCEV *S) {
-      return S->getSCEVType() == scAllocSize;
-    }
-  };
-
-  //===--------------------------------------------------------------------===//
   /// SCEVUnknown - This means that we are dealing with an entirely unknown SCEV
   /// value, and only represent it as its LLVM Value.  This is the "bottom"
   /// value for the analysis.
@@ -615,6 +529,16 @@ namespace llvm {
   public:
     Value *getValue() const { return V; }
 
+    /// isSizeOf, isAlignOf, isOffsetOf - Test whether this is a special
+    /// constant representing a type size, alignment, or field offset in
+    /// a target-independent manner, and hasn't happened to have been
+    /// folded with other operations into something unrecognizable. This
+    /// is mainly only useful for pretty-printing and other situations
+    /// where it isn't absolutely required for these to succeed.
+    bool isSizeOf(const Type *&AllocTy) const;
+    bool isAlignOf(const Type *&AllocTy) const;
+    bool isOffsetOf(const Type *&STy, Constant *&FieldNo) const;
+
     virtual bool isLoopInvariant(const Loop *L) const;
     virtual bool hasComputableLoopEvolution(const Loop *QL) const {
       return false; // not computable
@@ -665,10 +589,6 @@ namespace llvm {
         return ((SC*)this)->visitSMaxExpr((const SCEVSMaxExpr*)S);
       case scUMaxExpr:
         return ((SC*)this)->visitUMaxExpr((const SCEVUMaxExpr*)S);
-      case scFieldOffset:
-        return ((SC*)this)->visitFieldOffsetExpr((const SCEVFieldOffsetExpr*)S);
-      case scAllocSize:
-        return ((SC*)this)->visitAllocSizeExpr((const SCEVAllocSizeExpr*)S);
       case scUnknown:
         return ((SC*)this)->visitUnknown((const SCEVUnknown*)S);
       case scCouldNotCompute: