Convert the last uses of CastInst::createInferredCast to a normal cast

creation. These changes are still temporary but at least this pushes
knowledge of signedness out closer to where it can be determined properly
and allows signedness to be removed from VMCore.


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

3 files changed, 33 insertions, 11 deletions

diff --git a/lib/Transforms/ExprTypeConvert.cpp b/lib/Transforms/ExprTypeConvert.cpp
index 814318a587..d59fb4db14 100644
--- a/lib/Transforms/ExprTypeConvert.cpp
+++ b/lib/Transforms/ExprTypeConvert.cpp
@@ -228,11 +228,14 @@ Value *llvm::ConvertExpressionToType(Value *V, const Type *Ty,
   Constant *Dummy = Constant::getNullValue(Ty);
 
   switch (I->getOpcode()) {
-  case Instruction::BitCast:
+  case Instruction::BitCast: {
     assert(VMC.NewCasts.count(ValueHandle(VMC, I)) == 0);
-    Res = CastInst::createInferredCast(I->getOperand(0), Ty, Name);
+    Instruction::CastOps opcode = CastInst::getCastOpcode(I->getOperand(0),
+        I->getOperand(0)->getType()->isSigned(), Ty, Ty->isSigned());
+    Res = CastInst::create(opcode, I->getOperand(0), Ty, Name);
     VMC.NewCasts.insert(ValueHandle(VMC, Res));
     break;
+  }
 
   case Instruction::Add:
   case Instruction::Sub:
@@ -706,9 +709,12 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal,
                   Constant::getNullValue(NewTy) : 0;
 
   switch (I->getOpcode()) {
-  case Instruction::BitCast:
-    Res = CastInst::createInferredCast(NewVal, I->getType(), Name);
+  case Instruction::BitCast: {
+    Instruction::CastOps opcode = CastInst::getCastOpcode(NewVal,
+        NewVal->getType()->isSigned(), I->getType(), I->getType()->isSigned());
+    Res = CastInst::create(opcode, NewVal, I->getType(), Name);
     break;
+  }
 
   case Instruction::Add:
   case Instruction::Sub:
diff --git a/lib/Transforms/Instrumentation/ProfilingUtils.cpp b/lib/Transforms/Instrumentation/ProfilingUtils.cpp
index 274275a689..4adf09e099 100644
--- a/lib/Transforms/Instrumentation/ProfilingUtils.cpp
+++ b/lib/Transforms/Instrumentation/ProfilingUtils.cpp
@@ -62,8 +62,10 @@ void llvm::InsertProfilingInitCall(Function *MainFn, const char *FnName,
   case 2:
     AI = MainFn->arg_begin(); ++AI;
     if (AI->getType() != ArgVTy) {
+      Instruction::CastOps opcode = CastInst::getCastOpcode(AI,
+          AI->getType()->isSigned(), ArgVTy, ArgVTy->isSigned());
       InitCall->setOperand(2, 
-          CastInst::createInferredCast(AI, ArgVTy, "argv.cast", InitCall));
+          CastInst::create(opcode, AI, ArgVTy, "argv.cast", InitCall));
     } else {
       InitCall->setOperand(2, AI);
     }
@@ -74,11 +76,18 @@ void llvm::InsertProfilingInitCall(Function *MainFn, const char *FnName,
     // If the program looked at argc, have it look at the return value of the
     // init call instead.
     if (AI->getType() != Type::IntTy) {
-      if (!AI->use_empty())
+      Instruction::CastOps opcode;
+      if (!AI->use_empty()) {
+        opcode = CastInst::getCastOpcode(InitCall, 
+            InitCall->getType()->isSigned(), AI->getType(), 
+            AI->getType()->isSigned());
         AI->replaceAllUsesWith(
-          CastInst::createInferredCast(InitCall, AI->getType(), "", InsertPos));
+          CastInst::create(opcode, InitCall, AI->getType(), "", InsertPos));
+      }
+      opcode = CastInst::getCastOpcode(AI, AI->getType()->isSigned(),
+          Type::IntTy, true);
       InitCall->setOperand(1, 
-          CastInst::createInferredCast(AI, Type::IntTy, "argc.cast", InitCall));
+          CastInst::create(opcode, AI, Type::IntTy, "argc.cast", InitCall));
     } else {
       AI->replaceAllUsesWith(InitCall);
       InitCall->setOperand(1, AI);
diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp
index c63bfcb8c2..66c57a9bac 100644
--- a/lib/Transforms/Scalar/InstructionCombining.cpp
+++ b/lib/Transforms/Scalar/InstructionCombining.cpp
@@ -7009,7 +7009,9 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) {
     if ((*AI)->getType() == ParamTy) {
       Args.push_back(*AI);
     } else {
-      CastInst *NewCast = CastInst::createInferredCast(*AI, ParamTy, "tmp");
+      Instruction::CastOps opcode = CastInst::getCastOpcode(*AI,
+          (*AI)->getType()->isSigned(), ParamTy, ParamTy->isSigned());
+      CastInst *NewCast = CastInst::create(opcode, *AI, ParamTy, "tmp");
       Args.push_back(InsertNewInstBefore(NewCast, *Caller));
     }
   }
@@ -7030,7 +7032,9 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) {
         const Type *PTy = getPromotedType((*AI)->getType());
         if (PTy != (*AI)->getType()) {
           // Must promote to pass through va_arg area!
-          Instruction *Cast = CastInst::createInferredCast(*AI, PTy, "tmp");
+          Instruction::CastOps opcode = CastInst::getCastOpcode(
+              *AI, (*AI)->getType()->isSigned(), PTy, PTy->isSigned());
+          Instruction *Cast = CastInst::create(opcode, *AI, PTy, "tmp");
           InsertNewInstBefore(Cast, *Caller);
           Args.push_back(Cast);
         } else {
@@ -7058,7 +7062,10 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) {
   Value *NV = NC;
   if (Caller->getType() != NV->getType() && !Caller->use_empty()) {
     if (NV->getType() != Type::VoidTy) {
-      NV = NC = CastInst::createInferredCast(NC, Caller->getType(), "tmp");
+      const Type *CallerTy = Caller->getType();
+      Instruction::CastOps opcode = CastInst::getCastOpcode(
+          NC, NC->getType()->isSigned(), CallerTy, CallerTy->isSigned());
+      NV = NC = CastInst::create(opcode, NC, CallerTy, "tmp");
 
       // If this is an invoke instruction, we should insert it after the first
       // non-phi, instruction in the normal successor block.