For PR950:

The long awaited CAST patch. This introduces 12 new instructions into LLVM
to replace the cast instruction. Corresponding changes throughout LLVM are
provided. This passes llvm-test, llvm/test, and SPEC CPUINT2000 with the
exception of 175.vpr which fails only on a slight floating point output
difference.


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

4 files changed, 32 insertions, 16 deletions

diff --git a/lib/Transforms/Utils/Local.cpp b/lib/Transforms/Utils/Local.cpp
index 9a16bfccb3..366a95c49c 100644
--- a/lib/Transforms/Utils/Local.cpp
+++ b/lib/Transforms/Utils/Local.cpp
@@ -122,8 +122,19 @@ Constant *llvm::ConstantFoldInstOperands(unsigned Opc, const Type *DestTy,
   case Instruction::LShr:
   case Instruction::AShr:
     return ConstantExpr::get(Opc, Ops[0], Ops[1]);
-  case Instruction::Cast:
-    return ConstantExpr::getCast(Ops[0], DestTy);
+  case Instruction::Trunc:
+  case Instruction::ZExt:
+  case Instruction::SExt:
+  case Instruction::FPTrunc:
+  case Instruction::FPExt:
+  case Instruction::UIToFP:
+  case Instruction::SIToFP:
+  case Instruction::FPToUI:
+  case Instruction::FPToSI:
+  case Instruction::PtrToInt:
+  case Instruction::IntToPtr:
+  case Instruction::BitCast:
+    return ConstantExpr::getCast(Opc, Ops[0], DestTy);
   case Instruction::Select:
     return ConstantExpr::getSelect(Ops[0], Ops[1], Ops[2]);
   case Instruction::ExtractElement:
diff --git a/lib/Transforms/Utils/LowerAllocations.cpp b/lib/Transforms/Utils/LowerAllocations.cpp
index d08235cd9d..b7e4040145 100644
--- a/lib/Transforms/Utils/LowerAllocations.cpp
+++ b/lib/Transforms/Utils/LowerAllocations.cpp
@@ -134,7 +134,7 @@ bool LowerAllocations::runOnBasicBlock(BasicBlock &BB) {
         } else {
           Value *Scale = MI->getOperand(0);
           if (Scale->getType() != IntPtrTy)
-            Scale = new CastInst(Scale, IntPtrTy, "", I);
+            Scale = CastInst::createInferredCast(Scale, IntPtrTy, "", I);
 
           // Multiply it by the array size if necessary...
           MallocArg = BinaryOperator::create(Instruction::Mul, Scale,
@@ -148,10 +148,13 @@ bool LowerAllocations::runOnBasicBlock(BasicBlock &BB) {
       if (MallocFTy->getNumParams() > 0 || MallocFTy->isVarArg()) {
         if (MallocFTy->isVarArg()) {
           if (MallocArg->getType() != IntPtrTy)
-            MallocArg = new CastInst(MallocArg, IntPtrTy, "", I);
+            MallocArg = CastInst::createInferredCast(MallocArg, IntPtrTy, "", 
+                                                     I);
         } else if (MallocFTy->getNumParams() > 0 &&
                    MallocFTy->getParamType(0) != Type::UIntTy)
-          MallocArg = new CastInst(MallocArg, MallocFTy->getParamType(0), "",I);
+          MallocArg = 
+            CastInst::createInferredCast(MallocArg, MallocFTy->getParamType(0),
+                                         "",I);
         MallocArgs.push_back(MallocArg);
       }
 
@@ -166,7 +169,7 @@ bool LowerAllocations::runOnBasicBlock(BasicBlock &BB) {
       // Create a cast instruction to convert to the right type...
       Value *MCast;
       if (MCall->getType() != Type::VoidTy)
-        MCast = new CastInst(MCall, MI->getType(), "", I);
+        MCast = CastInst::createInferredCast(MCall, MI->getType(), "", I);
       else
         MCast = Constant::getNullValue(MI->getType());
 
@@ -183,7 +186,8 @@ bool LowerAllocations::runOnBasicBlock(BasicBlock &BB) {
         Value *MCast = FI->getOperand(0);
         if (FreeFTy->getNumParams() > 0 &&
             FreeFTy->getParamType(0) != MCast->getType())
-          MCast = new CastInst(MCast, FreeFTy->getParamType(0), "", I);
+          MCast = CastInst::createInferredCast(MCast, FreeFTy->getParamType(0), 
+                                               "", I);
         FreeArgs.push_back(MCast);
       }
 
diff --git a/lib/Transforms/Utils/LowerInvoke.cpp b/lib/Transforms/Utils/LowerInvoke.cpp
index 3385ba1c64..507fb86f56 100644
--- a/lib/Transforms/Utils/LowerInvoke.cpp
+++ b/lib/Transforms/Utils/LowerInvoke.cpp
@@ -326,7 +326,7 @@ splitLiveRangesLiveAcrossInvokes(std::vector<InvokeInst*> &Invokes) {
   Function *F = Invokes.back()->getParent()->getParent();
   
   // To avoid having to handle incoming arguments specially, we lower each arg
-  // to a copy instruction in the entry block.  This ensure that the argument
+  // to a copy instruction in the entry block.  This ensures that the argument
   // value itself cannot be live across the entry block.
   BasicBlock::iterator AfterAllocaInsertPt = F->begin()->begin();
   while (isa<AllocaInst>(AfterAllocaInsertPt) &&
@@ -334,10 +334,16 @@ splitLiveRangesLiveAcrossInvokes(std::vector<InvokeInst*> &Invokes) {
     ++AfterAllocaInsertPt;
   for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end();
        AI != E; ++AI) {
-    CastInst *NC = new CastInst(AI, AI->getType(), AI->getName()+".tmp",
-                                AfterAllocaInsertPt);
+    // This is always a no-op cast because we're casting AI to AI->getType() so
+    // src and destination types are identical. BitCast is the only possibility.
+    CastInst *NC = new BitCastInst(
+      AI, AI->getType(), AI->getName()+".tmp", AfterAllocaInsertPt);
     AI->replaceAllUsesWith(NC);
-    NC->setOperand(0, AI);
+    // Normally its is forbidden to replace a CastInst's operand because it
+    // could cause the opcode to reflect an illegal conversion. However, we're
+    // replacing it here with the same value it was constructed with to simply
+    // make NC its user.
+    NC->setOperand(0, AI); 
   }
   
   // Finally, scan the code looking for instructions with bad live ranges.
diff --git a/lib/Transforms/Utils/SimplifyCFG.cpp b/lib/Transforms/Utils/SimplifyCFG.cpp
index a17e7f1399..8d4cb83e17 100644
--- a/lib/Transforms/Utils/SimplifyCFG.cpp
+++ b/lib/Transforms/Utils/SimplifyCFG.cpp
@@ -425,11 +425,6 @@ static Value *GatherConstantSetNEs(Value *V, std::vector<ConstantInt*> &Values){
         Values.push_back(C);
         return Inst->getOperand(1);
       }
-    } else if (Inst->getOpcode() == Instruction::Cast) {
-      // Cast of X to bool is really a comparison against zero.
-      assert(Inst->getType() == Type::BoolTy && "Can only handle bool values!");
-      Values.push_back(ConstantInt::get(Inst->getOperand(0)->getType(), 0));
-      return Inst->getOperand(0);
     } else if (Inst->getOpcode() == Instruction::And) {
       if (Value *LHS = GatherConstantSetNEs(Inst->getOperand(0), Values))
         if (Value *RHS = GatherConstantSetNEs(Inst->getOperand(1), Values))