Change the interface to constant expressions to allow automatic folding

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

diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h
index f7690439b3dd5dde1ced9d8319aeda242260a9f6..396a5ca0930dd7038169a67c94bb222374fb1ecc 100644 (file)
--- a/include/llvm/Constants.h
+++ b/include/llvm/Constants.h
@@ -476,17 +476,19 @@ protected:
   ~ConstantExpr() {}
   
 public:
-  // Static methods to construct a ConstantExpr of different kinds.
+  // Static methods to construct a ConstantExpr of different kinds.  Note that
+  // these methods can return a constant of an arbitrary type, because they will
+  // attempt to fold the constant expression into something simple if they can.
   
   /// Cast constant expr
-  static ConstantExpr *getCast(Constant *C, const Type *Ty);
+  static Constant *getCast(Constant *C, const Type *Ty);
 
   /// Binary constant expr - Use with binary operators...
-  static ConstantExpr *get(unsigned Opcode, Constant *C1, Constant *C2);
+  static Constant *get(unsigned Opcode, Constant *C1, Constant *C2);
 
   /// Getelementptr form...
-  static ConstantExpr *getGetElementPtr(Constant *C,
-                                        const std::vector<Constant*> &IdxList);
+  static Constant *getGetElementPtr(Constant *C,
+                                    const std::vector<Constant*> &IdxList);
   
   /// isNullValue - Return true if this is the value that would be returned by
   /// getNullValue.

diff --git a/lib/Transforms/IPO/FunctionResolution.cpp b/lib/Transforms/IPO/FunctionResolution.cpp
index 734b62b9dc2d775dd1d7d27f8064f577d15f8545..932cdf46e8999a123abfd7c12bec16f30fc02297 100644 (file)
--- a/lib/Transforms/IPO/FunctionResolution.cpp
+++ b/lib/Transforms/IPO/FunctionResolution.cpp
@@ -207,7 +207,7 @@ static bool ResolveGlobalVariables(Module &M,
   std::vector<Constant*> Args;
   Args.push_back(Constant::getNullValue(Type::LongTy));
   Args.push_back(Constant::getNullValue(Type::LongTy));
-  ConstantExpr *Replacement =
+  Constant *Replacement =
     ConstantExpr::getGetElementPtr(ConstantPointerRef::get(Concrete), Args);
   
   for (unsigned i = 0; i != Globals.size(); ++i)

diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp
index 38494f206d1fbc33638ed7e1c51863064ce07931..70fc952891fe15c1633e2e68f11685b6477767c0 100644 (file)
--- a/lib/Transforms/Scalar/InstructionCombining.cpp
+++ b/lib/Transforms/Scalar/InstructionCombining.cpp
@@ -1011,7 +1011,7 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) {
       Indices.push_back(cast<Constant>(*I));
 
     if (I == E) {  // If they are all constants...
-      ConstantExpr *CE =
+      Constant *CE =
         ConstantExpr::getGetElementPtr(ConstantPointerRef::get(GV), Indices);
 
       // Replace all uses of the GEP with the new constexpr...

diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index 84f2566e46868da2caf1aba07208c41ee0a42653..27c48c877488a77abee51fcf69dbfecee7919ed4 100644 (file)
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -418,7 +418,7 @@ void ConstantPointerRef::replaceUsesOfWithOnConstant(Value *From, Value *To) {
 void ConstantExpr::replaceUsesOfWithOnConstant(Value *From, Value *To) {
   assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!");
 
-  ConstantExpr *Replacement = 0;
+  Constant *Replacement = 0;
   if (getOpcode() == Instruction::GetElementPtr) {
     std::vector<Constant*> Indices;
     Constant *Pointer = cast<Constant>(getOperand(0));
@@ -635,8 +635,7 @@ void ConstantPointerRef::destroyConstant() {
 typedef pair<unsigned, vector<Constant*> > ExprMapKeyType;
 static ValueMap<const ExprMapKeyType, ConstantExpr> ExprConstants;
 
-ConstantExpr *ConstantExpr::getCast(Constant *C, const Type *Ty) {
-
+Constant *ConstantExpr::getCast(Constant *C, const Type *Ty) {
   // Look up the constant in the table first to ensure uniqueness
   vector<Constant*> argVec(1, C);
   const ExprMapKeyType &Key = make_pair(Instruction::Cast, argVec);
@@ -649,7 +648,7 @@ ConstantExpr *ConstantExpr::getCast(Constant *C, const Type *Ty) {
   return Result;
 }
 
-ConstantExpr *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2) {
+Constant *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2) {
   // Look up the constant in the table first to ensure uniqueness
   vector<Constant*> argVec(1, C1); argVec.push_back(C2);
   const ExprMapKeyType &Key = make_pair(Opcode, argVec);
@@ -670,8 +669,8 @@ ConstantExpr *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2) {
   return Result;
 }
 
-ConstantExpr *ConstantExpr::getGetElementPtr(Constant *C,
-                                        const std::vector<Constant*> &IdxList) {
+Constant *ConstantExpr::getGetElementPtr(Constant *C,
+                                         const std::vector<Constant*> &IdxList){
   const Type *Ty = C->getType();
 
   // Look up the constant in the table first to ensure uniqueness