Change Constant::getNullConstant to Constant::getNullValue

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

6 files changed, 14 insertions, 17 deletions

diff --git a/lib/Analysis/InductionVariable.cpp b/lib/Analysis/InductionVariable.cpp
index 1550174..8c02dfa 100644
--- a/lib/Analysis/InductionVariable.cpp
+++ b/lib/Analysis/InductionVariable.cpp
@@ -115,7 +115,7 @@ InductionVariable::InductionVariable(PHINode *P, cfg::LoopInfo *LoopInfo) {
     Step = 0;
 
     if (V2 == Phi) {  // referencing the PHI directly?  Must have zero step
-      Step = Constant::getNullConstant(Phi->getType());
+      Step = Constant::getNullValue(Phi->getType());
     } else if (BinaryOperator *I = dyn_cast<BinaryOperator>(V2)) {
       // TODO: This could be much better...
       if (I->getOpcode() == Instruction::Add) {
@@ -143,7 +143,7 @@ InductionVariable::InductionVariable(PHINode *P, cfg::LoopInfo *LoopInfo) {
         if (StepE.Offset)
           Step = (Value*)StepE.Offset;
         else
-          Step = Constant::getNullConstant(Step->getType());
+          Step = Constant::getNullValue(Step->getType());
         const Type *ETy = Phi->getType();
         if (ETy->isPointerType()) ETy = Type::ULongTy;
         Step  = (Value*)(StepE.Offset ? StepE.Offset : ConstantInt::get(ETy,0));
diff --git a/lib/Target/SparcV9/SparcV9InstrSelection.cpp b/lib/Target/SparcV9/SparcV9InstrSelection.cpp
index 5e6aafd..9906e5b 100644
--- a/lib/Target/SparcV9/SparcV9InstrSelection.cpp
+++ b/lib/Target/SparcV9/SparcV9InstrSelection.cpp
@@ -1205,11 +1205,10 @@ CreateCopyInstructionsByType(const TargetMachine& target,
       // Use (unsigned long) 0 for a NULL pointer value.
       // 
       const Type* zeroValueType =
-        (resultType->getPrimitiveID() == Type::PointerTyID)? Type::ULongTy
-                                                           : resultType;
+        isa<PointerType>(resultType) ? Type::ULongTy : resultType;
       MachineInstr* minstr = new MachineInstr(opCode);
       minstr->SetMachineOperandVal(0, MachineOperand::MO_VirtualRegister,
-                                   Constant::getNullConstant(zeroValueType));
+                                   Constant::getNullValue(zeroValueType));
       minstr->SetMachineOperandVal(1, MachineOperand::MO_VirtualRegister, src);
       minstr->SetMachineOperandVal(2, MachineOperand::MO_VirtualRegister,dest);
       minstrVec.push_back(minstr);
diff --git a/lib/Transforms/ExprTypeConvert.cpp b/lib/Transforms/ExprTypeConvert.cpp
index a73b461..181ff70 100644
--- a/lib/Transforms/ExprTypeConvert.cpp
+++ b/lib/Transforms/ExprTypeConvert.cpp
@@ -386,7 +386,7 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC) {
 
   ValueHandle IHandle(VMC, I);  // Prevent I from being removed!
   
-  Constant *Dummy = Constant::getNullConstant(Ty);
+  Constant *Dummy = Constant::getNullValue(Ty);
 
   switch (I->getOpcode()) {
   case Instruction::Cast:
@@ -415,7 +415,7 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC) {
     LoadInst *LI = cast<LoadInst>(I);
     assert(!LI->hasIndices() || AllIndicesZero(LI));
 
-    Res = new LoadInst(Constant::getNullConstant(PointerType::get(Ty)), Name);
+    Res = new LoadInst(Constant::getNullValue(PointerType::get(Ty)), Name);
     VMC.ExprMap[I] = Res;
     Res->setOperand(0, ConvertExpressionToType(LI->getPointerOperand(),
                                                PointerType::get(Ty), VMC));
@@ -499,7 +499,7 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC) {
                                           Indices, &It);
       if (ElTy) {        
         assert(ElTy == PVTy && "Internal error, setup wrong!");
-        Res = new GetElementPtrInst(Constant::getNullConstant(NewSrcTy),
+        Res = new GetElementPtrInst(Constant::getNullValue(NewSrcTy),
                                     Indices, Name);
         VMC.ExprMap[I] = Res;
         Res->setOperand(0, ConvertExpressionToType(I->getOperand(0),
@@ -514,7 +514,7 @@ Value *ConvertExpressionToType(Value *V, const Type *Ty, ValueMapCache &VMC) {
     //
     if (Res == 0) {
       const PointerType *NewSrcTy = PointerType::get(PVTy);
-      Res = new GetElementPtrInst(Constant::getNullConstant(NewSrcTy),
+      Res = new GetElementPtrInst(Constant::getNullValue(NewSrcTy),
                                   GEP->copyIndices(), Name);
       VMC.ExprMap[I] = Res;
       Res->setOperand(0, ConvertExpressionToType(I->getOperand(0),
@@ -925,7 +925,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal,
 
   const Type *NewTy = NewVal->getType();
   Constant *Dummy = (NewTy != Type::VoidTy) ? 
-                  Constant::getNullConstant(NewTy) : 0;
+                  Constant::getNullValue(NewTy) : 0;
 
   switch (I->getOpcode()) {
   case Instruction::Cast:
@@ -1001,7 +1001,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal,
   case Instruction::Store: {
     if (I->getOperand(0) == OldVal) {  // Replace the source value
       const PointerType *NewPT = PointerType::get(NewTy);
-      Res = new StoreInst(NewVal, Constant::getNullConstant(NewPT));
+      Res = new StoreInst(NewVal, Constant::getNullValue(NewPT));
       VMC.ExprMap[I] = Res;
       Res->setOperand(1, ConvertExpressionToType(I->getOperand(1), NewPT, VMC));
     } else {                           // Replace the source pointer
@@ -1015,7 +1015,7 @@ static void ConvertOperandToType(User *U, Value *OldVal, Value *NewVal,
         assert(Offset == 0 && ValTy);
       }
 
-      Res = new StoreInst(Constant::getNullConstant(ValTy), NewVal, Indices);
+      Res = new StoreInst(Constant::getNullValue(ValTy), NewVal, Indices);
       VMC.ExprMap[I] = Res;
       Res->setOperand(0, ConvertExpressionToType(I->getOperand(0), ValTy, VMC));
     }
diff --git a/lib/Transforms/Scalar/DCE.cpp b/lib/Transforms/Scalar/DCE.cpp
index c48fa2f..6169730 100644
--- a/lib/Transforms/Scalar/DCE.cpp
+++ b/lib/Transforms/Scalar/DCE.cpp
@@ -108,10 +108,8 @@ static bool RemoveSingularPHIs(BasicBlock *BB) {
 }
 
 static void ReplaceUsesWithConstant(Instruction *I) {
-  Constant *CPV = Constant::getNullConstant(I->getType());
-  
   // Make all users of this instruction reference the constant instead
-  I->replaceAllUsesWith(CPV);
+  I->replaceAllUsesWith(Constant::getNullValue(I->getType()));
 }
 
 // PropogatePredecessors - This gets "Succ" ready to have the predecessors from
diff --git a/lib/Transforms/Scalar/IndVarSimplify.cpp b/lib/Transforms/Scalar/IndVarSimplify.cpp
index e852452..a388025 100644
--- a/lib/Transforms/Scalar/IndVarSimplify.cpp
+++ b/lib/Transforms/Scalar/IndVarSimplify.cpp
@@ -101,7 +101,7 @@ static bool TransformLoop(cfg::LoopInfo *Loops, cfg::Loop *Loop) {
     assert(PI == pred_end(Header) && "Loop headers should have 2 preds!");
     
     // Add incoming values for the PHI node...
-    PN->addIncoming(Constant::getNullConstant(Type::UIntTy), Incoming);
+    PN->addIncoming(Constant::getNullValue(Type::UIntTy), Incoming);
     PN->addIncoming(Add, BackEdgeBlock);
 
     // Analyze the new induction variable...
diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp
index 311ceae..c2fa84c 100644
--- a/lib/Transforms/Scalar/InstructionCombining.cpp
+++ b/lib/Transforms/Scalar/InstructionCombining.cpp
@@ -123,7 +123,7 @@ Instruction *InstCombiner::visitSub(BinaryOperator *I) {
   //
   if (Constant *Op2 = dyn_cast<Constant>(I->getOperand(1)))
     // Calculate 0 - RHS
-    if (Constant *RHS = *Constant::getNullConstant(I->getType()) - *Op2) {
+    if (Constant *RHS = *Constant::getNullValue(I->getType()) - *Op2) {
       return BinaryOperator::create(Instruction::Add, I->getOperand(0), RHS,
                                     I->getName());
     }