[llvm-commits] CVS: llvm/lib/Analysis/ScalarEvolution.cpp

[Chris Lattner]

Changes in directory llvm/lib/Analysis:

ScalarEvolution.cpp updated: 1.91 -> 1.92
---
Log message:

The local "ConstantFold" method is now just a watered down version of
ConstantFoldInstOperands.  Switch to ConstantFoldInstOperands and remove
ConstantFold.


---
Diffs of the changes:  (+3 -37)

 ScalarEvolution.cpp |   40 +++-------------------------------------
 1 files changed, 3 insertions(+), 37 deletions(-)


Index: llvm/lib/Analysis/ScalarEvolution.cpp
diff -u llvm/lib/Analysis/ScalarEvolution.cpp:1.91 llvm/lib/Analysis/ScalarEvolution.cpp:1.92
--- llvm/lib/Analysis/ScalarEvolution.cpp:1.91	Tue Jan 30 17:15:43 2007
+++ llvm/lib/Analysis/ScalarEvolution.cpp	Tue Jan 30 17:52:44 2007
@@ -1746,41 +1746,6 @@
   return false;
 }
 
-/// ConstantFold - Constant fold an instruction of the specified type with the
-/// specified constant operands.  This function may modify the operands vector.
-static Constant *ConstantFold(const Instruction *I,
-                              std::vector<Constant*> &Operands) {
-  if (isa<BinaryOperator>(I) || isa<ShiftInst>(I))
-    return ConstantExpr::get(I->getOpcode(), Operands[0], Operands[1]);
-
-  if (isa<CastInst>(I))
-    return ConstantExpr::getCast(I->getOpcode(), Operands[0], I->getType());
-
-  switch (I->getOpcode()) {
-  case Instruction::Select:
-    return ConstantExpr::getSelect(Operands[0], Operands[1], Operands[2]);
-  case Instruction::Call:
-    if (Function *GV = dyn_cast<Function>(Operands[0])) {
-      return ConstantFoldCall(cast<Function>(GV), &Operands[1],
-                              Operands.size()-1);
-    }
-    return 0;
-  case Instruction::GetElementPtr: {
-    Constant *Base = Operands[0];
-    Operands.erase(Operands.begin());
-    return ConstantExpr::getGetElementPtr(Base, Operands);
-  }
-  case Instruction::ICmp:
-    return ConstantExpr::getICmp(
-        cast<ICmpInst>(I)->getPredicate(), Operands[0], Operands[1]);
-  case Instruction::FCmp:
-    return ConstantExpr::getFCmp(
-        cast<FCmpInst>(I)->getPredicate(), Operands[0], Operands[1]);
-  }
-  return 0;
-}
-
-
 /// getConstantEvolvingPHI - Given an LLVM value and a loop, return a PHI node
 /// in the loop that V is derived from.  We allow arbitrary operations along the
 /// way, but the operands of an operation must either be constants or a value
@@ -1841,7 +1806,7 @@
     if (Operands[i] == 0) return 0;
   }
 
-  return ConstantFold(I, Operands);
+  return ConstantFoldInstOperands(I, &Operands[0], Operands.size());
 }
 
 /// getConstantEvolutionLoopExitValue - If we know that the specified Phi is
@@ -2006,7 +1971,8 @@
             }
           }
         }
-        return SCEVUnknown::get(ConstantFold(I, Operands));
+        Constant *C =ConstantFoldInstOperands(I, &Operands[0], Operands.size());
+        return SCEVUnknown::get(C);
       }
     }