Replace inferred getCast(V,Ty) calls with more strict variants.

Rename getZeroExtend and getSignExtend to getZExt and getSExt to match
the the casting mnemonics in the rest of LLVM.


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

10 files changed, 103 insertions, 84 deletions

diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h
index f06d15e26d..079f156cca 100644
--- a/include/llvm/Constants.h
+++ b/include/llvm/Constants.h
@@ -514,18 +514,18 @@ public:
 
   /// Cast constant expr
   ///
-  static Constant *getTrunc      (Constant *C, const Type *Ty);
-  static Constant *getSignExtend (Constant *C, const Type *Ty);
-  static Constant *getZeroExtend (Constant *C, const Type *Ty);
-  static Constant *getFPTrunc    (Constant *C, const Type *Ty);
-  static Constant *getFPExtend   (Constant *C, const Type *Ty);
-  static Constant *getUIToFP     (Constant *C, const Type *Ty);
-  static Constant *getSIToFP     (Constant *C, const Type *Ty);
-  static Constant *getFPToUI     (Constant *C, const Type *Ty);
-  static Constant *getFPToSI     (Constant *C, const Type *Ty);
-  static Constant *getPtrToInt   (Constant *C, const Type *Ty);
-  static Constant *getIntToPtr   (Constant *C, const Type *Ty);
-  static Constant *getBitCast    (Constant *C, const Type *Ty);
+  static Constant *getTrunc   (Constant *C, const Type *Ty);
+  static Constant *getSExt    (Constant *C, const Type *Ty);
+  static Constant *getZExt    (Constant *C, const Type *Ty);
+  static Constant *getFPTrunc (Constant *C, const Type *Ty);
+  static Constant *getFPExtend(Constant *C, const Type *Ty);
+  static Constant *getUIToFP  (Constant *C, const Type *Ty);
+  static Constant *getSIToFP  (Constant *C, const Type *Ty);
+  static Constant *getFPToUI  (Constant *C, const Type *Ty);
+  static Constant *getFPToSI  (Constant *C, const Type *Ty);
+  static Constant *getPtrToInt(Constant *C, const Type *Ty);
+  static Constant *getIntToPtr(Constant *C, const Type *Ty);
+  static Constant *getBitCast (Constant *C, const Type *Ty);
 
   // @brief Convenience function for getting one of the casting operations
   // using a CastOps opcode.
diff --git a/lib/Analysis/BasicAliasAnalysis.cpp b/lib/Analysis/BasicAliasAnalysis.cpp
index ce55b4de42..b1ea1969f3 100644
--- a/lib/Analysis/BasicAliasAnalysis.cpp
+++ b/lib/Analysis/BasicAliasAnalysis.cpp
@@ -459,11 +459,11 @@ static bool IndexOperandsEqual(Value *V1, Value *V2) {
     if (Constant *C2 = dyn_cast<Constant>(V2)) {
       // Sign extend the constants to long types, if necessary
       if (C1->getType()->getPrimitiveSizeInBits() < 64)
-        C1 = ConstantExpr::getSignExtend(C1, Type::LongTy);
+        C1 = ConstantExpr::getSExt(C1, Type::LongTy);
       else if (C1->getType() == Type::ULongTy)
         C1 = ConstantExpr::getBitCast(C1, Type::LongTy);
       if (C2->getType()->getPrimitiveSizeInBits() < 64)
-        C2 = ConstantExpr::getSignExtend(C2, Type::LongTy);
+        C2 = ConstantExpr::getSExt(C2, Type::LongTy);
       else if (C2->getType() == Type::ULongTy)
         C2 = ConstantExpr::getBitCast(C2, Type::LongTy);
       return C1 == C2;
@@ -555,11 +555,11 @@ BasicAliasAnalysis::CheckGEPInstructions(
           if (G1OC->getType() != G2OC->getType()) {
             // Sign extend both operands to long.
             if (G1OC->getType()->getPrimitiveSizeInBits() < 64)
-              G1OC = ConstantExpr::getSignExtend(G1OC, Type::LongTy);
+              G1OC = ConstantExpr::getSExt(G1OC, Type::LongTy);
             else if (G1OC->getType() == Type::ULongTy)
               G1OC = ConstantExpr::getBitCast(G1OC, Type::LongTy);
             if (G2OC->getType()->getPrimitiveSizeInBits() < 64)
-              G2OC = ConstantExpr::getSignExtend(G2OC, Type::LongTy);
+              G2OC = ConstantExpr::getSExt(G2OC, Type::LongTy);
             else if (G2OC->getType() == Type::ULongTy)
               G2OC = ConstantExpr::getBitCast(G2OC, Type::LongTy);
             GEP1Ops[FirstConstantOper] = G1OC;
diff --git a/lib/Analysis/ConstantRange.cpp b/lib/Analysis/ConstantRange.cpp
index 2c215866c6..762d5c358a 100644
--- a/lib/Analysis/ConstantRange.cpp
+++ b/lib/Analysis/ConstantRange.cpp
@@ -340,8 +340,8 @@ ConstantRange ConstantRange::zeroExtend(const Type *Ty) const {
   Constant *Lower = getLower();
   Constant *Upper = getUpper();
 
-  return ConstantRange(ConstantExpr::getCast(Instruction::ZExt, Lower, Ty),
-                       ConstantExpr::getCast(Instruction::ZExt, Upper, Ty));
+  return ConstantRange(ConstantExpr::getZExt(Lower, Ty),
+                       ConstantExpr::getZExt(Upper, Ty));
 }
 
 /// truncate - Return a new range in the specified integer type, which must be
@@ -356,8 +356,8 @@ ConstantRange ConstantRange::truncate(const Type *Ty) const {
     return ConstantRange(getType());
 
   return ConstantRange(
-      ConstantExpr::getCast(Instruction::Trunc, getLower(), Ty),
-      ConstantExpr::getCast(Instruction::Trunc, getUpper(), Ty));
+      ConstantExpr::getTrunc(getLower(), Ty),
+      ConstantExpr::getTrunc(getUpper(), Ty));
 }
 
 
diff --git a/lib/Analysis/ScalarEvolution.cpp b/lib/Analysis/ScalarEvolution.cpp
index 46b8f2629c..7d73d7d398 100644
--- a/lib/Analysis/ScalarEvolution.cpp
+++ b/lib/Analysis/ScalarEvolution.cpp
@@ -584,7 +584,7 @@ SCEVHandle SCEVTruncateExpr::get(const SCEVHandle &Op, const Type *Ty) {
 SCEVHandle SCEVZeroExtendExpr::get(const SCEVHandle &Op, const Type *Ty) {
   if (SCEVConstant *SC = dyn_cast<SCEVConstant>(Op))
     return SCEVUnknown::get(
-        ConstantExpr::getZeroExtend(SC->getValue(), Ty));
+        ConstantExpr::getZExt(SC->getValue(), Ty));
 
   // FIXME: If the input value is a chrec scev, and we can prove that the value
   // did not overflow the old, smaller, value, we can zero extend all of the
@@ -2000,11 +2000,14 @@ SCEVHandle ScalarEvolutionsImpl::getSCEVAtScope(SCEV *V, const Loop *L) {
           } else {
             SCEVHandle OpV = getSCEVAtScope(getSCEV(Op), L);
             if (SCEVConstant *SC = dyn_cast<SCEVConstant>(OpV))
-              Operands.push_back(ConstantExpr::getCast(SC->getValue(),
-                                                       Op->getType()));
+              Operands.push_back(ConstantExpr::getIntegerCast(SC->getValue(), 
+                                                              Op->getType(), 
+                                                              false));
             else if (SCEVUnknown *SU = dyn_cast<SCEVUnknown>(OpV)) {
               if (Constant *C = dyn_cast<Constant>(SU->getValue()))
-                Operands.push_back(ConstantExpr::getCast(C, Op->getType()));
+                Operands.push_back(ConstantExpr::getIntegerCast(C, 
+                                                                Op->getType(), 
+                                                                false));
               else
                 return V;
             } else {
@@ -2122,7 +2125,7 @@ SolveQuadraticEquation(const SCEVAddRecExpr *AddRec) {
 
   // Compute floor(sqrt(B^2-4ac))
   ConstantInt *SqrtVal =
-    cast<ConstantInt>(ConstantExpr::getCast(SqrtTerm,
+    cast<ConstantInt>(ConstantExpr::getBitCast(SqrtTerm,
                                    SqrtTerm->getType()->getUnsignedVersion()));
   uint64_t SqrtValV = SqrtVal->getZExtValue();
   uint64_t SqrtValV2 = (uint64_t)sqrt((double)SqrtValV);
@@ -2135,16 +2138,16 @@ SolveQuadraticEquation(const SCEVAddRecExpr *AddRec) {
   }
 
   SqrtVal = ConstantInt::get(Type::ULongTy, SqrtValV2);
-  SqrtTerm = ConstantExpr::getCast(SqrtVal, SqrtTerm->getType());
+  SqrtTerm = ConstantExpr::getTruncOrBitCast(SqrtVal, SqrtTerm->getType());
 
   Constant *NegB = ConstantExpr::getNeg(B);
   Constant *TwoA = ConstantExpr::getMul(A, Two);
 
   // The divisions must be performed as signed divisions.
   const Type *SignedTy = NegB->getType()->getSignedVersion();
-  NegB = ConstantExpr::getCast(NegB, SignedTy);
-  TwoA = ConstantExpr::getCast(TwoA, SignedTy);
-  SqrtTerm = ConstantExpr::getCast(SqrtTerm, SignedTy);
+  NegB = ConstantExpr::getBitCast(NegB, SignedTy);
+  TwoA = ConstantExpr::getBitCast(TwoA, SignedTy);
+  SqrtTerm = ConstantExpr::getBitCast(SqrtTerm, SignedTy);
 
   Constant *Solution1 =
     ConstantExpr::getSDiv(ConstantExpr::getAdd(NegB, SqrtTerm), TwoA);
diff --git a/lib/Analysis/ScalarEvolutionExpander.cpp b/lib/Analysis/ScalarEvolutionExpander.cpp
index 9432cc278b..db23a24d60 100644
--- a/lib/Analysis/ScalarEvolutionExpander.cpp
+++ b/lib/Analysis/ScalarEvolutionExpander.cpp
@@ -20,9 +20,27 @@ using namespace llvm;
 /// InsertCastOfTo - Insert a cast of V to the specified type, doing what
 /// we can to share the casts.
 Value *SCEVExpander::InsertCastOfTo(Value *V, const Type *Ty) {
+  // Compute the Cast opcode to use
+  Instruction::CastOps opcode = Instruction::BitCast;
+  if (Ty->isIntegral()) {
+    if (V->getType()->getTypeID() == Type::PointerTyID)
+      opcode = Instruction::PtrToInt;
+    else {
+      unsigned SrcBits = V->getType()->getPrimitiveSizeInBits();
+      unsigned DstBits = Ty->getPrimitiveSizeInBits();
+      opcode = (SrcBits > DstBits ? Instruction::Trunc : 
+                (SrcBits == DstBits ? Instruction::BitCast :
+                 (V->getType()->isSigned() ? Instruction::SExt : 
+                  Instruction::ZExt)));
+    }
+  } else if (Ty->isFloatingPoint())
+    opcode = Instruction::UIToFP;
+  else if (Ty->getTypeID() == Type::PointerTyID && V->getType()->isIntegral())
+    opcode = Instruction::IntToPtr;
+
   // FIXME: keep track of the cast instruction.
   if (Constant *C = dyn_cast<Constant>(V))
-    return ConstantExpr::getCast(C, Ty);
+    return ConstantExpr::getCast(opcode, C, Ty);
   
   if (Argument *A = dyn_cast<Argument>(V)) {
     // Check to see if there is already a cast!
@@ -38,8 +56,8 @@ Value *SCEVExpander::InsertCastOfTo(Value *V, const Type *Ty) {
           return CI;
         }
     }
-    return CastInst::createInferredCast(
-        V, Ty, V->getName(), A->getParent()->getEntryBlock().begin());
+    return CastInst::create(opcode, V, Ty, V->getName(), 
+                            A->getParent()->getEntryBlock().begin());
   }
     
   Instruction *I = cast<Instruction>(V);
@@ -64,7 +82,7 @@ Value *SCEVExpander::InsertCastOfTo(Value *V, const Type *Ty) {
   if (InvokeInst *II = dyn_cast<InvokeInst>(I))
     IP = II->getNormalDest()->begin();
   while (isa<PHINode>(IP)) ++IP;
-  return CastInst::createInferredCast(V, Ty, V->getName(), IP);
+  return CastInst::create(opcode, V, Ty, V->getName(), IP);
 }
 
 Value *SCEVExpander::visitMulExpr(SCEVMulExpr *S) {
diff --git a/lib/Support/ConstantRange.cpp b/lib/Support/ConstantRange.cpp
index 2c215866c6..762d5c358a 100644
--- a/lib/Support/ConstantRange.cpp
+++ b/lib/Support/ConstantRange.cpp
@@ -340,8 +340,8 @@ ConstantRange ConstantRange::zeroExtend(const Type *Ty) const {
   Constant *Lower = getLower();
   Constant *Upper = getUpper();
 
-  return ConstantRange(ConstantExpr::getCast(Instruction::ZExt, Lower, Ty),
-                       ConstantExpr::getCast(Instruction::ZExt, Upper, Ty));
+  return ConstantRange(ConstantExpr::getZExt(Lower, Ty),
+                       ConstantExpr::getZExt(Upper, Ty));
 }
 
 /// truncate - Return a new range in the specified integer type, which must be
@@ -356,8 +356,8 @@ ConstantRange ConstantRange::truncate(const Type *Ty) const {
     return ConstantRange(getType());
 
   return ConstantRange(
-      ConstantExpr::getCast(Instruction::Trunc, getLower(), Ty),
-      ConstantExpr::getCast(Instruction::Trunc, getUpper(), Ty));
+      ConstantExpr::getTrunc(getLower(), Ty),
+      ConstantExpr::getTrunc(getUpper(), Ty));
 }
 
 
diff --git a/lib/Transforms/IPO/GlobalOpt.cpp b/lib/Transforms/IPO/GlobalOpt.cpp
index 764205baaa..cf9cdaa744 100644
--- a/lib/Transforms/IPO/GlobalOpt.cpp
+++ b/lib/Transforms/IPO/GlobalOpt.cpp
@@ -708,8 +708,8 @@ static GlobalVariable *OptimizeGlobalAddressOfMalloc(GlobalVariable *GV,
 
   Constant *RepValue = NewGV;
   if (NewGV->getType() != GV->getType()->getElementType())
-    RepValue = ConstantExpr::getCast(Instruction::BitCast,
-                                     RepValue, GV->getType()->getElementType());
+    RepValue = ConstantExpr::getBitCast(RepValue, 
+                                        GV->getType()->getElementType());
 
   // If there is a comparison against null, we will insert a global bool to
   // keep track of whether the global was initialized yet or not.
@@ -1058,8 +1058,7 @@ static bool OptimizeOnceStoredGlobal(GlobalVariable *GV, Value *StoredOnceVal,
       GV->getInitializer()->isNullValue()) {
     if (Constant *SOVC = dyn_cast<Constant>(StoredOnceVal)) {
       if (GV->getInitializer()->getType() != SOVC->getType())
-        SOVC = ConstantExpr::getCast(Instruction::BitCast,
-                                     SOVC, GV->getInitializer()->getType());
+        SOVC = ConstantExpr::getBitCast(SOVC, GV->getInitializer()->getType());
 
       // Optimize away any trapping uses of the loaded value.
       if (OptimizeAwayTrappingUsesOfLoads(GV, SOVC))
@@ -1510,7 +1509,7 @@ static GlobalVariable *InstallGlobalCtors(GlobalVariable *GCL,
   if (!GCL->use_empty()) {
     Constant *V = NGV;
     if (V->getType() != GCL->getType())
-      V = ConstantExpr::getCast(Instruction::BitCast, V, GCL->getType());
+      V = ConstantExpr::getBitCast(V, GCL->getType());
     GCL->replaceAllUsesWith(V);
   }
   GCL->eraseFromParent();
diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp
index a1ed221a7e..229fb8669d 100644
--- a/lib/Transforms/Scalar/InstructionCombining.cpp
+++ b/lib/Transforms/Scalar/InstructionCombining.cpp
@@ -1792,8 +1792,7 @@ FoundSExt:
       case 8:  MiddleType = Type::SByteTy; break;
       }
       if (MiddleType) {
-        Instruction *NewTrunc = 
-          CastInst::createInferredCast(XorLHS, MiddleType, "sext");
+        Instruction *NewTrunc = new TruncInst(XorLHS, MiddleType, "sext");
         InsertNewInstBefore(NewTrunc, I);
         return new SExtInst(NewTrunc, I.getType());
       }
@@ -3097,16 +3096,12 @@ Instruction *InstCombiner::visitAnd(BinaryOperator &I) {
               // into  : and (cast X to T), trunc_or_bitcast(C1)&C2
               // This will fold the two constants together, which may allow 
               // other simplifications.
-              Instruction *NewCast =
-                CastInst::createInferredCast(CastOp->getOperand(0), I.getType(),
-                             CastOp->getName()+".shrunk");
+              Instruction *NewCast = CastInst::createTruncOrBitCast(
+                CastOp->getOperand(0), I.getType(), 
+                CastOp->getName()+".shrunk");
               NewCast = InsertNewInstBefore(NewCast, I);
               // trunc_or_bitcast(C1)&C2
-              Instruction::CastOps opc = (
-                  AndCI->getType()->getPrimitiveSizeInBits() == 
-                  I.getType()->getPrimitiveSizeInBits() ? 
-                  Instruction::BitCast : Instruction::Trunc);
-              Constant *C3 = ConstantExpr::getCast(opc, AndCI, I.getType());
+              Constant *C3 = ConstantExpr::getTruncOrBitCast(AndCI,I.getType());
               C3 = ConstantExpr::getAnd(C3, AndRHS);
               return BinaryOperator::createAnd(NewCast, C3);
             } else if (CastOp->getOpcode() == Instruction::Or) {
@@ -3286,7 +3281,8 @@ Instruction *InstCombiner::visitAnd(BinaryOperator &I) {
                                                        Op1C->getOperand(0),
                                                        I.getName());
         InsertNewInstBefore(NewOp, I);
-        return CastInst::createInferredCast(NewOp, I.getType());
+        return CastInst::createIntegerCast(NewOp, I.getType(), 
+                                           SrcTy->isSigned());
       }
     }
   }
@@ -3690,7 +3686,8 @@ Instruction *InstCombiner::visitOr(BinaryOperator &I) {
                                                       Op1C->getOperand(0),
                                                       I.getName());
         InsertNewInstBefore(NewOp, I);
-        return CastInst::createInferredCast(NewOp, I.getType());
+        return CastInst::createIntegerCast(NewOp, I.getType(),
+                                           SrcTy->isSigned());
       }
   }
       
@@ -3871,7 +3868,8 @@ Instruction *InstCombiner::visitXor(BinaryOperator &I) {
                                                        Op1C->getOperand(0),
                                                        I.getName());
         InsertNewInstBefore(NewOp, I);
-        return CastInst::createInferredCast(NewOp, I.getType());
+        return CastInst::createIntegerCast(NewOp, I.getType(), 
+                                           SrcTy->isSigned());
       }
   }
 
@@ -3947,7 +3945,7 @@ static Value *EmitGEPOffset(User *GEP, Instruction &I, InstCombiner &IC) {
       }
     } else {
       // Convert to correct type.
-      Op = IC.InsertNewInstBefore(CastInst::createInferredCast(Op, SIntPtrTy,
+      Op = IC.InsertNewInstBefore(CastInst::createSExtOrBitCast(Op, SIntPtrTy,
                                                Op->getName()+".c"), I);
       if (Size != 1)
         // We'll let instcombine(mul) convert this to a shl if possible.
@@ -4944,8 +4942,7 @@ Instruction *InstCombiner::visitSetCondInst(SetCondInst &I) {
       // If Op1 is a constant, we can fold the cast into the constant.
       if (Op1->getType() != Op0->getType())
         if (Constant *Op1C = dyn_cast<Constant>(Op1)) {
-          Op1 = ConstantExpr::getCast(Instruction::BitCast, Op1C, 
-                                      Op0->getType());
+          Op1 = ConstantExpr::getBitCast(Op1C, Op0->getType());
         } else {
           // Otherwise, cast the RHS right before the setcc
           Op1 = InsertCastBefore(Instruction::BitCast, Op1, Op0->getType(), I);
@@ -5392,8 +5389,7 @@ Instruction *InstCombiner::FoldShiftByConstant(Value *Op0, ConstantInt *Op1,
       
       Value *Op = ShiftOp->getOperand(0);
       if (isShiftOfSignedShift != isSignedShift)
-        Op = InsertNewInstBefore(
-               CastInst::createInferredCast(Op, I.getType(), "tmp"), I);
+        Op = InsertNewInstBefore(new BitCastInst(Op, I.getType(), "tmp"), I);
       ShiftInst *ShiftResult = new ShiftInst(I.getOpcode(), Op,
                            ConstantInt::get(Type::UByteTy, Amt));
       if (I.getType() == ShiftResult->getType())
@@ -5681,7 +5677,7 @@ static bool CanEvaluateInDifferentType(Value *V, const Type *Ty,
 /// evaluate the expression.
 Value *InstCombiner::EvaluateInDifferentType(Value *V, const Type *Ty) {
   if (Constant *C = dyn_cast<Constant>(V))
-    return ConstantExpr::getCast(C, Ty);
+    return ConstantExpr::getIntegerCast(C, Ty, C->getType()->isSigned());
 
   // Otherwise, it must be an instruction.
   Instruction *I = cast<Instruction>(V);
@@ -5990,7 +5986,7 @@ Instruction *InstCombiner::commonIntCastTransforms(CastInst &CI) {
             // (X&4) == 2 --> false
             // (X&4) != 2 --> true
             Constant *Res = ConstantBool::get(isSetNE);
-            Res = ConstantExpr::getZeroExtend(Res, CI.getType());
+            Res = ConstantExpr::getZExt(Res, CI.getType());
             return ReplaceInstUsesWith(CI, Res);
           }
           
@@ -6014,7 +6010,7 @@ Instruction *InstCombiner::commonIntCastTransforms(CastInst &CI) {
           if (CI.getType() == In->getType())
             return ReplaceInstUsesWith(CI, In);
           else
-            return CastInst::createInferredCast(In, CI.getType());
+            return CastInst::createIntegerCast(In, CI.getType(), false/*ZExt*/);
         }
       }
     }
@@ -6090,9 +6086,6 @@ Instruction *InstCombiner::visitZExt(CastInst &CI) {
 
   // If this is a cast of a cast
   if (CastInst *CSrc = dyn_cast<CastInst>(Src)) {   // A->B->C cast
-    // If the operand of the ZEXT is a TRUNC then we are dealing with integral
-    // types and we can convert this to a logical AND if the sizes are just 
-    // right. This will be much cheaper than the pair of casts.
     // If this is a TRUNC followed by a ZEXT then we are dealing with integral
     // types and if the sizes are just right we can convert this into a logical
     // 'and' which will be much cheaper than the pair of casts.
@@ -6113,7 +6106,7 @@ Instruction *InstCombiner::visitZExt(CastInst &CI) {
         if (And->getType() != CI.getType()) {
           And->setName(CSrc->getName()+".mask");
           InsertNewInstBefore(And, CI);
-          And = CastInst::createInferredCast(And, CI.getType());
+          And = CastInst::createIntegerCast(And, CI.getType(), false/*ZExt*/);
         }
         return And;
       }
@@ -7770,7 +7763,7 @@ static Instruction *InstCombineLoadCast(InstCombiner &IC, LoadInst &LI) {
                                                              CI->getName(),
                                                          LI.isVolatile()),LI);
         // Now cast the result of the load.
-        return CastInst::createInferredCast(NewLoad, LI.getType());
+        return new BitCastInst(NewLoad, LI.getType());
       }
     }
   }
@@ -7950,13 +7943,20 @@ static Instruction *InstCombineStoreToCast(InstCombiner &IC, StoreInst &SI) {
         // the same size.  Instead of casting the pointer before the store, cast
         // the value to be stored.
         Value *NewCast;
-        if (Constant *C = dyn_cast<Constant>(SI.getOperand(0)))
-          NewCast = ConstantExpr::getCast(C, SrcPTy);
+        Instruction::CastOps opcode = Instruction::BitCast;
+        Value *SIOp0 = SI.getOperand(0);
+        if (SrcPTy->getTypeID() == Type::PointerTyID) {
+          if (SIOp0->getType()->isIntegral())
+            opcode = Instruction::IntToPtr;
+        } else if (SrcPTy->isIntegral()) {
+          if (SIOp0->getType()->getTypeID() == Type::PointerTyID)
+            opcode = Instruction::PtrToInt;
+        }
+        if (Constant *C = dyn_cast<Constant>(SIOp0))
+          NewCast = ConstantExpr::getCast(opcode, C, SrcPTy);
         else
           NewCast = IC.InsertNewInstBefore(
-            CastInst::createInferredCast(SI.getOperand(0), SrcPTy,
-                                 SI.getOperand(0)->getName()+".c"), SI);
-
+            CastInst::create(opcode, SIOp0, SrcPTy, SIOp0->getName()+".c"), SI);
         return new StoreInst(NewCast, CastOp);
       }
     }
diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp
index bad774e67f..170df73272 100644
--- a/lib/VMCore/ConstantFold.cpp
+++ b/lib/VMCore/ConstantFold.cpp
@@ -743,8 +743,7 @@ static Constant *CastConstantPacked(ConstantPacked *CP,
         (SrcEltTy->isFloatingPoint() && DstEltTy->isFloatingPoint())) {
       for (unsigned i = 0; i != SrcNumElts; ++i)
         Result.push_back(
-          ConstantExpr::getCast(Instruction::BitCast, CP->getOperand(i), 
-                                DstEltTy));
+          ConstantExpr::getBitCast(CP->getOperand(i), DstEltTy));
       return ConstantPacked::get(Result);
     }
     
@@ -1148,11 +1147,11 @@ static int IdxCompare(Constant *C1, Constant *C2, const Type *ElTy) {
   // Ok, we have two differing integer indices.  Sign extend them to be the same
   // type.  Long is always big enough, so we use it.
   if (C1->getType() != Type::LongTy && C1->getType() != Type::ULongTy)
-    C1 = ConstantExpr::getSignExtend(C1, Type::LongTy);
+    C1 = ConstantExpr::getSExt(C1, Type::LongTy);
   else
     C1 = ConstantExpr::getBitCast(C1, Type::LongTy);
   if (C2->getType() != Type::LongTy && C1->getType() != Type::ULongTy)
-    C2 = ConstantExpr::getSignExtend(C2, Type::LongTy);
+    C2 = ConstantExpr::getSExt(C2, Type::LongTy);
   else
     C2 = ConstantExpr::getBitCast(C2, Type::LongTy);
 
@@ -1672,7 +1671,7 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C,
         R = ConstantExpr::getSExtOrBitCast(R, Idx0->getType());
         R = ConstantExpr::getMul(R, Idx0); // signed multiply
         // R is a signed integer, C is the GEP pointer so -> IntToPtr
-        return ConstantExpr::getCast(Instruction::IntToPtr, R, C->getType());
+        return ConstantExpr::getIntToPtr(R, C->getType());
       }
     }
   }
diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index 710b738cd2..a294902ad8 100644
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -1391,8 +1391,8 @@ namespace llvm {
       case Instruction::PtrToInt:
       case Instruction::IntToPtr:
       case Instruction::BitCast:
-        New = ConstantExpr::getCast(
-            OldC->getOpcode(), OldC->getOperand(0), NewTy);
+        New = ConstantExpr::getCast(OldC->getOpcode(), OldC->getOperand(0), 
+                                    NewTy);
         break;
       case Instruction::Select:
         New = ConstantExpr::getSelectTy(NewTy, OldC->getOperand(0),
@@ -1464,8 +1464,8 @@ Constant *ConstantExpr::getCast(unsigned oc, Constant *C, const Type *Ty) {
       assert(0 && "Invalid cast opcode");
       break;
     case Instruction::Trunc:    return getTrunc(C, Ty);
-    case Instruction::ZExt:     return getZeroExtend(C, Ty);
-    case Instruction::SExt:     return getSignExtend(C, Ty);
+    case Instruction::ZExt:     return getZExt(C, Ty);
+    case Instruction::SExt:     return getSExt(C, Ty);
     case Instruction::FPTrunc:  return getFPTrunc(C, Ty);
     case Instruction::FPExt:    return getFPExtend(C, Ty);
     case Instruction::UIToFP:   return getUIToFP(C, Ty);
@@ -1547,7 +1547,7 @@ Constant *ConstantExpr::getTrunc(Constant *C, const Type *Ty) {
   return getFoldedCast(Instruction::Trunc, C, Ty);
 }
 
-Constant *ConstantExpr::getSignExtend(Constant *C, const Type *Ty) {
+Constant *ConstantExpr::getSExt(Constant *C, const Type *Ty) {
   assert(C->getType()->isIntegral() && "SEXt operand must be integral");
   assert(Ty->isInteger() && "SExt produces only integer");
   assert(C->getType()->getPrimitiveSizeInBits() < Ty->getPrimitiveSizeInBits()&&
@@ -1556,7 +1556,7 @@ Constant *ConstantExpr::getSignExtend(Constant *C, const Type *Ty) {
   return getFoldedCast(Instruction::SExt, C, Ty);
 }
 
-Constant *ConstantExpr::getZeroExtend(Constant *C, const Type *Ty) {
+Constant *ConstantExpr::getZExt(Constant *C, const Type *Ty) {
   assert(C->getType()->isIntegral() && "ZEXt operand must be integral");
   assert(Ty->isInteger() && "ZExt produces only integer");
   assert(C->getType()->getPrimitiveSizeInBits() < Ty->getPrimitiveSizeInBits()&&