Prefer non-virtual calls to ConstantInt::isZero over virtual calls to

Constant::isNullValue() in situations where it is possible.

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

diff --git a/lib/Analysis/ScalarEvolution.cpp b/lib/Analysis/ScalarEvolution.cpp
index 52b0af4e14ce62d7e52433196003e8d450be0769..438e42886bf20b3bc1d717742bdf71ccaef79946 100644 (file)
--- a/lib/Analysis/ScalarEvolution.cpp
+++ b/lib/Analysis/ScalarEvolution.cpp
@@ -617,7 +617,7 @@ SCEVHandle SCEVAddExpr::get(std::vector<SCEVHandle> &Ops) {
     }
 
     // If we are left with a constant zero being added, strip it off.
-    if (cast<SCEVConstant>(Ops[0])->getValue()->isNullValue()) {
+    if (cast<SCEVConstant>(Ops[0])->getValue()->isZero()) {
       Ops.erase(Ops.begin());
       --Idx;
     }
@@ -857,7 +857,7 @@ SCEVHandle SCEVMulExpr::get(std::vector<SCEVHandle> &Ops) {
     if (cast<SCEVConstant>(Ops[0])->getValue()->equalsInt(1)) {
       Ops.erase(Ops.begin());
       --Idx;
-    } else if (cast<SCEVConstant>(Ops[0])->getValue()->isNullValue()) {
+    } else if (cast<SCEVConstant>(Ops[0])->getValue()->isZero()) {
       // If we have a multiply of zero, it will always be zero.
       return Ops[0];
     }
@@ -1026,7 +1026,7 @@ SCEVHandle SCEVAddRecExpr::get(std::vector<SCEVHandle> &Operands,
   if (Operands.size() == 1) return Operands[0];
 
   if (SCEVConstant *StepC = dyn_cast<SCEVConstant>(Operands.back()))
-    if (StepC->getValue()->isNullValue()) {
+    if (StepC->getValue()->isZero()) {
       Operands.pop_back();
       return get(Operands, L);             // { X,+,0 }  -->  X
     }
@@ -2124,7 +2124,7 @@ SCEVHandle ScalarEvolutionsImpl::HowFarToZero(SCEV *V, const Loop *L) {
   // If the value is a constant
   if (SCEVConstant *C = dyn_cast<SCEVConstant>(V)) {
     // If the value is already zero, the branch will execute zero times.
-    if (C->getValue()->isNullValue()) return C;
+    if (C->getValue()->isZero()) return C;
     return UnknownValue;  // Otherwise it will loop infinitely.
   }
 
@@ -2187,7 +2187,7 @@ SCEVHandle ScalarEvolutionsImpl::HowFarToZero(SCEV *V, const Loop *L) {
         // should not accept a root of 2.
         SCEVHandle Val = AddRec->evaluateAtIteration(R1);
         if (SCEVConstant *EvalVal = dyn_cast<SCEVConstant>(Val))
-          if (EvalVal->getValue()->isNullValue())
+          if (EvalVal->getValue()->isZero())
             return R1;  // We found a quadratic root!
       }
     }
@@ -2327,7 +2327,7 @@ SCEVHandle SCEVAddRecExpr::getNumIterationsInRange(ConstantRange Range,
 
   // If the start is a non-zero constant, shift the range to simplify things.
   if (SCEVConstant *SC = dyn_cast<SCEVConstant>(getStart()))
-    if (!SC->getValue()->isNullValue()) {
+    if (!SC->getValue()->isZero()) {
       std::vector<SCEVHandle> Operands(op_begin(), op_end());
       Operands[0] = SCEVUnknown::getIntegerSCEV(0, SC->getType());
       SCEVHandle Shifted = SCEVAddRecExpr::get(Operands, getLoop());

diff --git a/lib/Analysis/ScalarEvolutionExpander.cpp b/lib/Analysis/ScalarEvolutionExpander.cpp
index 077f67bcc2f4e2cf879990c02f911313404a8e95..a50d572f68a0b238beee43a429b451df21f86ddf 100644 (file)
--- a/lib/Analysis/ScalarEvolutionExpander.cpp
+++ b/lib/Analysis/ScalarEvolutionExpander.cpp
@@ -96,7 +96,7 @@ Value *SCEVExpander::visitAddRecExpr(SCEVAddRecExpr *S) {
 
   // {X,+,F} --> X + {0,+,F}
   if (!isa<SCEVConstant>(S->getStart()) ||
-      !cast<SCEVConstant>(S->getStart())->getValue()->isNullValue()) {
+      !cast<SCEVConstant>(S->getStart())->getValue()->isZero()) {
     Value *Start = expandInTy(S->getStart(), Ty);
     std::vector<SCEVHandle> NewOps(S->op_begin(), S->op_end());
     NewOps[0] = SCEVUnknown::getIntegerSCEV(0, Ty);

diff --git a/lib/Transforms/IPO/GlobalOpt.cpp b/lib/Transforms/IPO/GlobalOpt.cpp
index dbdea1ecdd72bdc8e0dacde39297cfdd6943a214..89850d2e3da4ce05977467ed5b9f87cdaf482719 100644 (file)
--- a/lib/Transforms/IPO/GlobalOpt.cpp
+++ b/lib/Transforms/IPO/GlobalOpt.cpp
@@ -1155,7 +1155,7 @@ static void ShrinkGlobalToBoolean(GlobalVariable *GV, Constant *OtherVal) {
   // instead of a select to synthesize the desired value.
   bool IsOneZero = false;
   if (ConstantInt *CI = dyn_cast<ConstantInt>(OtherVal))
-    IsOneZero = InitVal->isNullValue() && CI->equalsInt(1);
+    IsOneZero = InitVal->isNullValue() && CI->isOne();
 
   while (!GV->use_empty()) {
     Instruction *UI = cast<Instruction>(GV->use_back());

diff --git a/lib/Transforms/IPO/SimplifyLibCalls.cpp b/lib/Transforms/IPO/SimplifyLibCalls.cpp
index 08286216f916ac775f373fd3081129e05fdc9347..6d71925867852ce46a315d88305a744d99afac23 100644 (file)
--- a/lib/Transforms/IPO/SimplifyLibCalls.cpp
+++ b/lib/Transforms/IPO/SimplifyLibCalls.cpp
@@ -584,7 +584,7 @@ public:
     for (uint64_t i = 0; i < len; ++i) {
       if (ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(i))) {
         // Check for the null terminator
-        if (CI->isNullValue())
+        if (CI->isZero())
           break; // we found end of string
         else if (CI->getSExtValue() == chr) {
           char_found = true;
@@ -2023,7 +2023,7 @@ static bool getConstantStringLength(Value *V, uint64_t &len, ConstantArray **CA)
   // Check to make sure that the first operand of the GEP is an integer and
   // has value 0 so that we are sure we're indexing into the initializer.
   if (ConstantInt* op1 = dyn_cast<ConstantInt>(GEP->getOperand(1))) {
-    if (!op1->isNullValue())
+    if (!op1->isZero())
       return false;
   } else
     return false;
@@ -2069,7 +2069,7 @@ static bool getConstantStringLength(Value *V, uint64_t &len, ConstantArray **CA)
   for (len = start_idx; len < max_elems; len++) {
     if (ConstantInt *CI = dyn_cast<ConstantInt>(A->getOperand(len))) {
       // Check for the null terminator
-      if (CI->isNullValue())
+      if (CI->isZero())
         break; // we found end of string
     } else
       return false; // This array isn't suitable, non-int initializer

diff --git a/lib/Transforms/Scalar/CondPropagate.cpp b/lib/Transforms/Scalar/CondPropagate.cpp
index fdcb404e11a583f2a5cc4cf81159eb7933603542..90a4f3048fe935d7ac0022c96aa1d3ef1e67a43a 100644 (file)
--- a/lib/Transforms/Scalar/CondPropagate.cpp
+++ b/lib/Transforms/Scalar/CondPropagate.cpp
@@ -139,7 +139,7 @@ void CondProp::SimplifyPredecessors(BranchInst *BI) {
       // ultimate destination.
       bool PHIGone = PN->getNumIncomingValues() == 2;
       RevectorBlockTo(PN->getIncomingBlock(i-1),
-                      BI->getSuccessor(CB->isNullValue()));
+                      BI->getSuccessor(CB->isZero()));
       ++NumBrThread;
 
       // If there were two predecessors before this simplification, the PHI node

diff --git a/lib/Transforms/Scalar/IndVarSimplify.cpp b/lib/Transforms/Scalar/IndVarSimplify.cpp
index 4d03f28c4b73f4102cfc69be3f7dd9c9cc9d086d..fa2b3bde30c80a55c8dfa79bf7189c8cd86d017a 100644 (file)
--- a/lib/Transforms/Scalar/IndVarSimplify.cpp
+++ b/lib/Transforms/Scalar/IndVarSimplify.cpp
@@ -178,9 +178,9 @@ void IndVarSimplify::EliminatePointerRecurrence(PHINode *PN,
               Constant *NCE = ConstantExpr::getGetElementPtr(CE->getOperand(0),
                                                              &CEIdxs[0],
                                                              CEIdxs.size());
-              GetElementPtrInst *NGEPI =
-                new GetElementPtrInst(NCE, Constant::getNullValue(Type::Int32Ty),
-                                      NewAdd, GEPI->getName(), GEPI);
+              GetElementPtrInst *NGEPI = new GetElementPtrInst(
+                  NCE, Constant::getNullValue(Type::Int32Ty), NewAdd, 
+                  GEPI->getName(), GEPI);
               GEPI->replaceAllUsesWith(NGEPI);
               GEPI->eraseFromParent();
               GEPI = NGEPI;

diff --git a/lib/Transforms/Scalar/LoopStrengthReduce.cpp b/lib/Transforms/Scalar/LoopStrengthReduce.cpp
index e97921237fcecb1bd5d76006e829160efbfb4203..1a1ea7a72b7b4811768fd36174b62dbc4fd9d1d6 100644 (file)
--- a/lib/Transforms/Scalar/LoopStrengthReduce.cpp
+++ b/lib/Transforms/Scalar/LoopStrengthReduce.cpp
@@ -540,7 +540,7 @@ Value *BasedUser::InsertCodeForBaseAtPosition(const SCEVHandle &NewBase,
   
   // If there is no immediate value, skip the next part.
   if (SCEVConstant *SC = dyn_cast<SCEVConstant>(Imm))
-    if (SC->getValue()->isNullValue())
+    if (SC->getValue()->isZero())
       return Rewriter.expandCodeFor(NewBase, BaseInsertPt,
                                     OperandValToReplace->getType());
 
@@ -779,7 +779,7 @@ static void SeparateSubExprs(std::vector<SCEVHandle> &SubExprs,
       SeparateSubExprs(SubExprs, SARE->getOperand(0));
     }
   } else if (!isa<SCEVConstant>(Expr) ||
-             !cast<SCEVConstant>(Expr)->getValue()->isNullValue()) {
+             !cast<SCEVConstant>(Expr)->getValue()->isZero()) {
     // Do not add zero.
     SubExprs.push_back(Expr);
   }
@@ -869,7 +869,7 @@ RemoveCommonExpressionsFromUseBases(std::vector<BasedUser> &Uses) {
 ///
 static bool isZero(SCEVHandle &V) {
   if (SCEVConstant *SC = dyn_cast<SCEVConstant>(V))
-    return SC->getValue()->getZExtValue() == 0;
+    return SC->getValue()->isZero();
   return false;
 }
 
@@ -883,17 +883,18 @@ unsigned LoopStrengthReduce::CheckForIVReuse(const SCEVHandle &Stride,
   if (!TLI) return 0;
 
   if (SCEVConstant *SC = dyn_cast<SCEVConstant>(Stride)) {
-    int64_t SInt = SC->getValue()->getSExtValue();
-    if (SInt == 1) return 0;
+    const APInt &SInt = SC->getValue()->getValue();
+    if (SInt == 1) 
+      return 0;
 
     for (TargetLowering::legal_am_scale_iterator
            I = TLI->legal_am_scale_begin(), E = TLI->legal_am_scale_end();
          I != E; ++I) {
-      unsigned Scale = *I;
-      if (unsigned(abs(SInt)) < Scale || (SInt % Scale) != 0)
+      APInt Scale(SInt.getBitWidth(), *I);
+      if (SInt.abs().ult(Scale) || SInt.srem(Scale) != 0)
         continue;
       std::map<SCEVHandle, IVsOfOneStride>::iterator SI =
-        IVsByStride.find(SCEVUnknown::getIntegerSCEV(SInt/Scale, UIntPtrTy));
+        IVsByStride.find(SCEVUnknown::getIntegerSCEV(SInt.sdiv(Scale)));
       if (SI == IVsByStride.end())
         continue;
       for (std::vector<IVExpr>::iterator II = SI->second.IVs.begin(),
@@ -902,7 +903,7 @@ unsigned LoopStrengthReduce::CheckForIVReuse(const SCEVHandle &Stride,
         // Only reuse previous IV if it would not require a type conversion.
         if (isZero(II->Base) && II->Base->getType() == Ty) {
           IV = *II;
-          return Scale;
+          return Scale.getZExtValue();
         }
     }
   }
@@ -1148,14 +1149,14 @@ void LoopStrengthReduce::StrengthReduceStridedIVUsers(const SCEVHandle &Stride,
         // are reusing an IV, it has not been used to initialize the PHI node.
         // Add it to the expression used to rewrite the uses.
         if (!isa<ConstantInt>(CommonBaseV) ||
-            !cast<ConstantInt>(CommonBaseV)->isNullValue())
+            !cast<ConstantInt>(CommonBaseV)->isZero())
           RewriteExpr = SCEVAddExpr::get(RewriteExpr,
                                          SCEVUnknown::get(CommonBaseV));
       }
 
       // Now that we know what we need to do, insert code before User for the
       // immediate and any loop-variant expressions.
-      if (!isa<ConstantInt>(BaseV) || !cast<ConstantInt>(BaseV)->isNullValue())
+      if (!isa<ConstantInt>(BaseV) || !cast<ConstantInt>(BaseV)->isZero())
         // Add BaseV to the PHI value if needed.
         RewriteExpr = SCEVAddExpr::get(RewriteExpr, SCEVUnknown::get(BaseV));
 
@@ -1257,14 +1258,17 @@ namespace {
       SCEVConstant *LHSC = dyn_cast<SCEVConstant>(LHS);
       SCEVConstant *RHSC = dyn_cast<SCEVConstant>(RHS);
       if (LHSC && RHSC) {
-        int64_t  LV = LHSC->getValue()->getSExtValue();
-        int64_t  RV = RHSC->getValue()->getSExtValue();
-        uint64_t ALV = (LV < 0) ? -LV : LV;
-        uint64_t ARV = (RV < 0) ? -RV : RV;
+        APInt LV(LHSC->getValue()->getValue());
+        APInt RV(RHSC->getValue()->getValue());
+        uint32_t MaxWidth = std::max(LV.getBitWidth(), RV.getBitWidth());
+        LV.sextOrTrunc(MaxWidth);
+        RV.sextOrTrunc(MaxWidth);
+        APInt ALV(LV.abs());
+        APInt ARV(RV.abs());
         if (ALV == ARV)
-          return LV > RV;
+          return LV.sgt(RV);
         else
-          return ALV < ARV;
+          return ALV.ult(ARV);
       }
       return (LHSC && !RHSC);
     }

diff --git a/lib/Transforms/Scalar/Reassociate.cpp b/lib/Transforms/Scalar/Reassociate.cpp
index aa851b290f46267e49f15d657188da9dc92ac3a3..8030a76eced4f91511233c8826a710f6ea6e42d0 100644 (file)
--- a/lib/Transforms/Scalar/Reassociate.cpp
+++ b/lib/Transforms/Scalar/Reassociate.cpp
@@ -536,7 +536,7 @@ Value *Reassociate::OptimizeExpression(BinaryOperator *I,
     switch (Opcode) {
     default: break;
     case Instruction::And:
-      if (CstVal->isNullValue()) {           // ... & 0 -> 0
+      if (CstVal->isZero()) {                // ... & 0 -> 0
         ++NumAnnihil;
         return CstVal;
       } else if (CstVal->isAllOnesValue()) { // ... & -1 -> ...
@@ -544,10 +544,10 @@ Value *Reassociate::OptimizeExpression(BinaryOperator *I,
       }
       break;
     case Instruction::Mul:
-      if (CstVal->isNullValue()) {           // ... * 0 -> 0
+      if (CstVal->isZero()) {                // ... * 0 -> 0
         ++NumAnnihil;
         return CstVal;
-      } else if (cast<ConstantInt>(CstVal)->isUnitValue()) {
+      } else if (cast<ConstantInt>(CstVal)->isOne()) {
         Ops.pop_back();                      // ... * 1 -> ...
       }
       break;
@@ -559,7 +559,7 @@ Value *Reassociate::OptimizeExpression(BinaryOperator *I,
       // FALLTHROUGH!
     case Instruction::Add:
     case Instruction::Xor:
-      if (CstVal->isNullValue())             // ... [|^+] 0 -> ...
+      if (CstVal->isZero())                  // ... [|^+] 0 -> ...
         Ops.pop_back();
       break;
     }

diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp
index 97f760ff8a51a75c4ab7c793b4d50cd5a7e7fc95..0d27a880eb462ef5d75d9c1af6c07a24a7874424 100644 (file)
--- a/lib/VMCore/ConstantFold.cpp
+++ b/lib/VMCore/ConstantFold.cpp
@@ -783,15 +783,15 @@ static FCmpInst::Predicate evaluateFCmpRelation(const Constant *V1,
       Constant *C2 = const_cast<Constant*>(V2);
       R = dyn_cast<ConstantInt>(
                              ConstantExpr::getFCmp(FCmpInst::FCMP_OEQ, C1, C2));
-      if (R && !R->isNullValue()) 
+      if (R && !R->isZero()) 
         return FCmpInst::FCMP_OEQ;
       R = dyn_cast<ConstantInt>(
                              ConstantExpr::getFCmp(FCmpInst::FCMP_OLT, C1, C2));
-      if (R && !R->isNullValue()) 
+      if (R && !R->isZero()) 
         return FCmpInst::FCMP_OLT;
       R = dyn_cast<ConstantInt>(
                              ConstantExpr::getFCmp(FCmpInst::FCMP_OGT, C1, C2));
-      if (R && !R->isNullValue()) 
+      if (R && !R->isZero()) 
         return FCmpInst::FCMP_OGT;
 
       // Nothing more we can do
@@ -850,15 +850,15 @@ static ICmpInst::Predicate evaluateICmpRelation(const Constant *V1,
       Constant *C2 = const_cast<Constant*>(V2);
       ICmpInst::Predicate pred = ICmpInst::ICMP_EQ;
       R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2));
-      if (R && !R->isNullValue()) 
+      if (R && !R->isZero()) 
         return pred;
       pred = isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
       R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2));
-      if (R && !R->isNullValue())
+      if (R && !R->isZero())
         return pred;
       pred = isSigned ?  ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
       R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2));
-      if (R && !R->isNullValue())
+      if (R && !R->isZero())
         return pred;
       
       // If we couldn't figure it out, bail.