Remove SCEVAllocSizeExpr and SCEVFieldOffsetExpr, and in their place

use plain SCEVUnknowns with ConstantExpr::getSizeOf and
ConstantExpr::getOffsetOf constants. This eliminates a bunch of
special-case code.

Also add code for pattern-matching these expressions, for clients that
want to recognize them.

Move ScalarEvolution's logic for expanding array and vector sizeof
expressions into an element count times the element size, to expose
the multiplication to subsequent folding, into the regular constant
folder.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@94737 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 11 insertions, 94 deletions

diff --git a/include/llvm/Analysis/ScalarEvolutionExpressions.h b/include/llvm/Analysis/ScalarEvolutionExpressions.h
index 64b8b0bf78..5b93458f11 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
   };
 
   //===--------------------------------------------------------------------===//
@@ -512,95 +512,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 +526,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 StructType *&STy, Constant *&FieldNo) const;
+
     virtual bool isLoopInvariant(const Loop *L) const;
     virtual bool hasComputableLoopEvolution(const Loop *QL) const {
       return false; // not computable
@@ -665,10 +586,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: