For PR1043:

Merge ConstantIntegral and ConstantBool into ConstantInt.
Remove ConstantIntegral and ConstantBool from LLVM.


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

5 files changed, 21 insertions, 15 deletions

diff --git a/lib/Transforms/Utils/CloneFunction.cpp b/lib/Transforms/Utils/CloneFunction.cpp
index 896c39943c..cb98dc58e2 100644
--- a/lib/Transforms/Utils/CloneFunction.cpp
+++ b/lib/Transforms/Utils/CloneFunction.cpp
@@ -226,11 +226,14 @@ void PruningFunctionCloner::CloneBlock(const BasicBlock *BB) {
   if (const BranchInst *BI = dyn_cast<BranchInst>(OldTI)) {
     if (BI->isConditional()) {
       // If the condition was a known constant in the callee...
-      ConstantBool *Cond = dyn_cast<ConstantBool>(BI->getCondition());
-      if (Cond == 0)  // Or is a known constant in the caller...
-        Cond = dyn_cast_or_null<ConstantBool>(ValueMap[BI->getCondition()]);
-      if (Cond) {     // Constant fold to uncond branch!
-        BasicBlock *Dest = BI->getSuccessor(!Cond->getValue());
+      ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition());
+      // Or is a known constant in the caller...
+      if (Cond == 0)  
+        Cond = dyn_cast_or_null<ConstantInt>(ValueMap[BI->getCondition()]);
+
+      // Constant fold to uncond branch!
+      if (Cond) {
+        BasicBlock *Dest = BI->getSuccessor(!Cond->getBoolValue());
         ValueMap[OldTI] = new BranchInst(Dest, NewBB);
         CloneBlock(Dest);
         TerminatorDone = true;
diff --git a/lib/Transforms/Utils/CodeExtractor.cpp b/lib/Transforms/Utils/CodeExtractor.cpp
index ebf1ac63c6..f922a984f3 100644
--- a/lib/Transforms/Utils/CodeExtractor.cpp
+++ b/lib/Transforms/Utils/CodeExtractor.cpp
@@ -470,7 +470,7 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer,
           case 0:
           case 1: break;  // No value needed.
           case 2:         // Conditional branch, return a bool
-            brVal = ConstantBool::get(!SuccNum);
+            brVal = ConstantInt::get(!SuccNum);
             break;
           default:
             brVal = ConstantInt::get(Type::Int16Ty, SuccNum);
diff --git a/lib/Transforms/Utils/Local.cpp b/lib/Transforms/Utils/Local.cpp
index 236ec4b8be..f3d6ca85cc 100644
--- a/lib/Transforms/Utils/Local.cpp
+++ b/lib/Transforms/Utils/Local.cpp
@@ -173,11 +173,11 @@ bool llvm::ConstantFoldTerminator(BasicBlock *BB) {
     BasicBlock *Dest1 = cast<BasicBlock>(BI->getOperand(0));
     BasicBlock *Dest2 = cast<BasicBlock>(BI->getOperand(1));
 
-    if (ConstantBool *Cond = dyn_cast<ConstantBool>(BI->getCondition())) {
+    if (ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition())) {
       // Are we branching on constant?
       // YES.  Change to unconditional branch...
-      BasicBlock *Destination = Cond->getValue() ? Dest1 : Dest2;
-      BasicBlock *OldDest     = Cond->getValue() ? Dest2 : Dest1;
+      BasicBlock *Destination = Cond->getBoolValue() ? Dest1 : Dest2;
+      BasicBlock *OldDest     = Cond->getBoolValue() ? Dest2 : Dest1;
 
       //cerr << "Function: " << T->getParent()->getParent()
       //     << "\nRemoving branch from " << T->getParent()
diff --git a/lib/Transforms/Utils/SimplifyCFG.cpp b/lib/Transforms/Utils/SimplifyCFG.cpp
index b44ab09362..0304aa3ff5 100644
--- a/lib/Transforms/Utils/SimplifyCFG.cpp
+++ b/lib/Transforms/Utils/SimplifyCFG.cpp
@@ -968,12 +968,14 @@ static bool FoldCondBranchOnPHI(BranchInst *BI) {
   
   // Okay, this is a simple enough basic block.  See if any phi values are
   // constants.
-  for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
-    if (ConstantBool *CB = dyn_cast<ConstantBool>(PN->getIncomingValue(i))) {
+  for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
+    ConstantInt *CB;
+    if ((CB = dyn_cast<ConstantInt>(PN->getIncomingValue(i))) &&
+        CB->getType() == Type::BoolTy) {
       // Okay, we now know that all edges from PredBB should be revectored to
       // branch to RealDest.
       BasicBlock *PredBB = PN->getIncomingBlock(i);
-      BasicBlock *RealDest = BI->getSuccessor(!CB->getValue());
+      BasicBlock *RealDest = BI->getSuccessor(!CB->getBoolValue());
       
       if (RealDest == BB) continue;  // Skip self loops.
       
@@ -1037,6 +1039,7 @@ static bool FoldCondBranchOnPHI(BranchInst *BI) {
       // Recurse, simplifying any other constants.
       return FoldCondBranchOnPHI(BI) | true;
     }
+  }
 
   return false;
 }
@@ -1506,7 +1509,7 @@ bool llvm::SimplifyCFG(BasicBlock *BB) {
               if (BB->getSinglePredecessor()) {
                 // Turn this into a branch on constant.
                 bool CondIsTrue = PBI->getSuccessor(0) == BB;
-                BI->setCondition(ConstantBool::get(CondIsTrue));
+                BI->setCondition(ConstantInt::get(CondIsTrue));
                 return SimplifyCFG(BB);  // Nuke the branch on constant.
               }
               
@@ -1522,7 +1525,7 @@ bool llvm::SimplifyCFG(BasicBlock *BB) {
                       PBI->getCondition() == BI->getCondition() &&
                       PBI->getSuccessor(0) != PBI->getSuccessor(1)) {
                     bool CondIsTrue = PBI->getSuccessor(0) == BB;
-                    NewPN->addIncoming(ConstantBool::get(CondIsTrue), *PI);
+                    NewPN->addIncoming(ConstantInt::get(CondIsTrue), *PI);
                   } else {
                     NewPN->addIncoming(BI->getCondition(), *PI);
                   }
diff --git a/lib/Transforms/Utils/ValueMapper.cpp b/lib/Transforms/Utils/ValueMapper.cpp
index f8afabc75f..371bee195a 100644
--- a/lib/Transforms/Utils/ValueMapper.cpp
+++ b/lib/Transforms/Utils/ValueMapper.cpp
@@ -28,7 +28,7 @@ Value *llvm::MapValue(const Value *V, std::map<const Value*, Value*> &VM) {
     return VMSlot = const_cast<Value*>(V);
 
   if (Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V))) {
-    if (isa<ConstantIntegral>(C) || isa<ConstantFP>(C) ||
+    if (isa<ConstantInt>(C) || isa<ConstantFP>(C) ||
         isa<ConstantPointerNull>(C) || isa<ConstantAggregateZero>(C) ||
         isa<UndefValue>(C))
       return VMSlot = C;           // Primitive constants map directly