Decrease usage of use_size()

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

lib/AsmParser/llvmAsmParser.y

@@ -103,7 +103,7 @@ static struct PerModuleInfo {
       
       // Loop over all of the uses of the GlobalValue.  The only thing they are
       // allowed to be is ConstantPointerRef's.
-      assert(OldGV->use_size() == 1 && "Only one reference should exist!");
+      assert(OldGV->hasOneUse() && "Only one reference should exist!");
       User *U = OldGV->use_back();  // Must be a ConstantPointerRef...
       ConstantPointerRef *CPR = cast<ConstantPointerRef>(U);
         

lib/CodeGen/InstrSelection/InstrForest.cpp

@@ -297,7 +297,7 @@ InstrForest::buildTreeForInstruction(Instruction *instr)
 	  // is used directly, i.e., made a child of the instruction node.
 	  // 
 	  InstrTreeNode* opTreeNode;
-	  if (isa<Instruction>(operand) && operand->use_size() == 1 &&
+	  if (isa<Instruction>(operand) && operand->hasOneUse() &&
 	      cast<Instruction>(operand)->getParent() == instr->getParent() &&
 	      instr->getOpcode() != Instruction::PHINode &&
 	      instr->getOpcode() != Instruction::Call)

lib/Target/CBackend/CBackend.cpp

@@ -88,7 +88,7 @@ namespace {
     static bool isInlinableInst(const Instruction &I) {
       // Must be an expression, must be used exactly once.  If it is dead, we
       // emit it inline where it would go.
-      if (I.getType() == Type::VoidTy || I.use_size() != 1 ||
+      if (I.getType() == Type::VoidTy || !I.hasOneUse() ||
           isa<TerminatorInst>(I) || isa<CallInst>(I) || isa<PHINode>(I) || 
           isa<LoadInst>(I) || isa<VarArgInst>(I))
         // Don't inline a load across a store or other bad things!

lib/Target/CBackend/Writer.cpp

@@ -88,7 +88,7 @@ namespace {
     static bool isInlinableInst(const Instruction &I) {
       // Must be an expression, must be used exactly once.  If it is dead, we
       // emit it inline where it would go.
-      if (I.getType() == Type::VoidTy || I.use_size() != 1 ||
+      if (I.getType() == Type::VoidTy || !I.hasOneUse() ||
           isa<TerminatorInst>(I) || isa<CallInst>(I) || isa<PHINode>(I) || 
           isa<LoadInst>(I) || isa<VarArgInst>(I))
         // Don't inline a load across a store or other bad things!

lib/Target/SparcV9/InstrSelection/InstrForest.cpp

@@ -297,7 +297,7 @@ InstrForest::buildTreeForInstruction(Instruction *instr)
 	  // is used directly, i.e., made a child of the instruction node.
 	  // 
 	  InstrTreeNode* opTreeNode;
-	  if (isa<Instruction>(operand) && operand->use_size() == 1 &&
+	  if (isa<Instruction>(operand) && operand->hasOneUse() &&
 	      cast<Instruction>(operand)->getParent() == instr->getParent() &&
 	      instr->getOpcode() != Instruction::PHINode &&
 	      instr->getOpcode() != Instruction::Call)

lib/Target/X86/InstSelectSimple.cpp

@@ -554,7 +554,7 @@ void ISel::SelectPHINodes() {
 //
 static SetCondInst *canFoldSetCCIntoBranch(Value *V) {
   if (SetCondInst *SCI = dyn_cast<SetCondInst>(V))
-    if (SCI->use_size() == 1 && isa<BranchInst>(SCI->use_back()) &&
+    if (SCI->hasOneUse() && isa<BranchInst>(SCI->use_back()) &&
         SCI->getParent() == cast<BranchInst>(SCI->use_back())->getParent()) {
       const Type *Ty = SCI->getOperand(0)->getType();
       if (Ty != Type::LongTy && Ty != Type::ULongTy)

lib/Target/X86/X86ISelSimple.cpp

@@ -554,7 +554,7 @@ void ISel::SelectPHINodes() {
 //
 static SetCondInst *canFoldSetCCIntoBranch(Value *V) {
   if (SetCondInst *SCI = dyn_cast<SetCondInst>(V))
-    if (SCI->use_size() == 1 && isa<BranchInst>(SCI->use_back()) &&
+    if (SCI->hasOneUse() && isa<BranchInst>(SCI->use_back()) &&
         SCI->getParent() == cast<BranchInst>(SCI->use_back())->getParent()) {
       const Type *Ty = SCI->getOperand(0)->getType();
       if (Ty != Type::LongTy && Ty != Type::ULongTy)

lib/Transforms/ExprTypeConvert.cpp

@@ -1271,7 +1271,7 @@ static void RecursiveDelete(ValueMapCache &Cache, Instruction *I) {
 }
 
 ValueHandle::~ValueHandle() {
-  if (Operands[0]->use_size() == 1) {
+  if (Operands[0]->hasOneUse()) {
     Value *V = Operands[0];
     Operands[0] = 0;   // Drop use!
 

lib/Transforms/IPO/InlineSimple.cpp

@@ -49,7 +49,7 @@ int SimpleInliner::getInlineCost(CallSite CS) {
   // If there is only one call of the function, and it has internal linkage,
   // make it almost guaranteed to be inlined.
   //
-  if (Callee->use_size() == 1 && Callee->hasInternalLinkage())
+  if (Callee->hasOneUse() && Callee->hasInternalLinkage())
     InlineCost -= 30000;
 
   // Add to the inline quality for properties that make the call valuable to

lib/Transforms/Scalar/CorrelatedExprs.cpp

@@ -379,7 +379,7 @@ static bool isBlockSimpleEnough(BasicBlock *BB) {
   // Check the common case first: empty block, or block with just a setcc.
   if (BB->size() == 1 ||
       (BB->size() == 2 && &BB->front() == BI->getCondition() &&
-       BI->getCondition()->use_size() == 1))
+       BI->getCondition()->hasOneUse()))
     return true;
 
   // Check the more complex case now...

lib/Transforms/Scalar/InstructionCombining.cpp

@@ -159,7 +159,7 @@ static unsigned getComplexity(Value *V) {
 // isOnlyUse - Return true if this instruction will be deleted if we stop using
 // it.
 static bool isOnlyUse(Value *V) {
-  return V->use_size() == 1 || isa<Constant>(V);
+  return V->hasOneUse() || isa<Constant>(V);
 }
 
 // SimplifyCommutative - This performs a few simplifications for commutative
@@ -238,7 +238,7 @@ static inline Value *dyn_castNotVal(Value *V) {
 // non-constant operand of the multiply.
 //
 static inline Value *dyn_castFoldableMul(Value *V) {
-  if (V->use_size() == 1 && V->getType()->isInteger())
+  if (V->hasOneUse() && V->getType()->isInteger())
     if (Instruction *I = dyn_cast<Instruction>(V))
       if (I->getOpcode() == Instruction::Mul)
         if (isa<Constant>(I->getOperand(1)))
@@ -292,7 +292,7 @@ Instruction *AssociativeOpt(BinaryOperator &Root, const Functor &F) {
 
   // Otherwise, if the LHS is not of the same opcode as the root, return.
   Instruction *LHSI = dyn_cast<Instruction>(LHS);
-  while (LHSI && LHSI->getOpcode() == Opcode && LHSI->use_size() == 1) {
+  while (LHSI && LHSI->getOpcode() == Opcode && LHSI->hasOneUse()) {
     // Should we apply this transform to the RHS?
     bool ShouldApply = F.shouldApply(LHSI->getOperand(1));
 
@@ -484,7 +484,7 @@ Instruction *InstCombiner::visitSub(BinaryOperator &I) {
       return BinaryOperator::createNot(Op1);
 
   if (BinaryOperator *Op1I = dyn_cast<BinaryOperator>(Op1))
-    if (Op1I->use_size() == 1) {
+    if (Op1I->hasOneUse()) {
       // Replace (x - (y - z)) with (x + (z - y)) if the (y - z) subexpression
       // is not used by anyone else...
       //
@@ -749,7 +749,7 @@ Instruction *InstCombiner::OptAndOp(Instruction *Op,
     if ((*AndRHS & *OpRHS)->isNullValue()) {
       // (X ^ C1) & C2 --> (X & C2) iff (C1&C2) == 0
       return BinaryOperator::create(Instruction::And, X, AndRHS);
-    } else if (Op->use_size() == 1) {
+    } else if (Op->hasOneUse()) {
       // (X ^ C1) & C2 --> (X & C2) ^ (C1&C2)
       std::string OpName = Op->getName(); Op->setName("");
       Instruction *And = BinaryOperator::create(Instruction::And,
@@ -767,7 +767,7 @@ Instruction *InstCombiner::OptAndOp(Instruction *Op,
       if (Together == AndRHS) // (X | C) & C --> C
         return ReplaceInstUsesWith(TheAnd, AndRHS);
       
-      if (Op->use_size() == 1 && Together != OpRHS) {
+      if (Op->hasOneUse() && Together != OpRHS) {
         // (X | C1) & C2 --> (X | (C1&C2)) & C2
         std::string Op0Name = Op->getName(); Op->setName("");
         Instruction *Or = BinaryOperator::create(Instruction::Or, X,
@@ -778,7 +778,7 @@ Instruction *InstCombiner::OptAndOp(Instruction *Op,
     }
     break;
   case Instruction::Add:
-    if (Op->use_size() == 1) {
+    if (Op->hasOneUse()) {
       // Adding a one to a single bit bit-field should be turned into an XOR
       // of the bit.  First thing to check is to see if this AND is with a
       // single bit constant.
@@ -987,7 +987,7 @@ Instruction *InstCombiner::visitXor(BinaryOperator &I) {
     if (BinaryOperator *Op0I = dyn_cast<BinaryOperator>(Op0)) {
       // xor (setcc A, B), true = not (setcc A, B) = setncc A, B
       if (SetCondInst *SCI = dyn_cast<SetCondInst>(Op0I))
-        if (RHS == ConstantBool::True && SCI->use_size() == 1)
+        if (RHS == ConstantBool::True && SCI->hasOneUse())
           return new SetCondInst(SCI->getInverseCondition(),
                                  SCI->getOperand(0), SCI->getOperand(1));
           
@@ -1026,7 +1026,7 @@ Instruction *InstCombiner::visitXor(BinaryOperator &I) {
       }
 
   if (Instruction *Op0I = dyn_cast<Instruction>(Op0))
-    if (Op0I->getOpcode() == Instruction::Or && Op0I->use_size() == 1) {
+    if (Op0I->getOpcode() == Instruction::Or && Op0I->hasOneUse()) {
       if (Op0I->getOperand(0) == Op1)                // (B|A)^B == (A|B)^B
         cast<BinaryOperator>(Op0I)->swapOperands();
       if (Op0I->getOperand(1) == Op1) {              // (A|B)^B == A & ~B
@@ -1144,7 +1144,7 @@ Instruction *InstCombiner::visitSetCondInst(BinaryOperator &I) {
               return new SetCondInst(I.getOpcode(), BOp0, NegVal);
             else if (Value *NegVal = dyn_castNegVal(BOp0))
               return new SetCondInst(I.getOpcode(), NegVal, BOp1);
-            else if (BO->use_size() == 1) {
+            else if (BO->hasOneUse()) {
               Instruction *Neg = BinaryOperator::createNeg(BOp1, BO->getName());
               BO->setName("");
               InsertNewInstBefore(Neg, I);
@@ -1291,7 +1291,7 @@ Instruction *InstCombiner::visitShiftInst(ShiftInst &I) {
 
     // If the operand is an bitwise operator with a constant RHS, and the
     // shift is the only use, we can pull it out of the shift.
-    if (Op0->use_size() == 1)
+    if (Op0->hasOneUse())
       if (BinaryOperator *Op0BO = dyn_cast<BinaryOperator>(Op0))
         if (ConstantInt *Op0C = dyn_cast<ConstantInt>(Op0BO->getOperand(1))) {
           bool isValid = true;     // Valid only for And, Or, Xor
@@ -1533,7 +1533,7 @@ Instruction *InstCombiner::visitCastInst(CastInst &CI) {
   // propagate the cast into the instruction.  Also, only handle integral types
   // for now.
   if (Instruction *SrcI = dyn_cast<Instruction>(Src))
-    if (SrcI->use_size() == 1 && Src->getType()->isIntegral() &&
+    if (SrcI->hasOneUse() && Src->getType()->isIntegral() &&
         CI.getType()->isInteger()) {  // Don't mess with casts to bool here
       const Type *DestTy = CI.getType();
       unsigned SrcBitSize = getTypeSizeInBits(Src->getType());

lib/Transforms/Scalar/Reassociate.cpp

@@ -126,7 +126,7 @@ bool Reassociate::ReassociateExpr(BinaryOperator *I) {
   // only expression using it...
   //
   if (BinaryOperator *LHSI = dyn_cast<BinaryOperator>(LHS))
-    if (LHSI->getOpcode() == I->getOpcode() && LHSI->use_size() == 1) {
+    if (LHSI->getOpcode() == I->getOpcode() && LHSI->hasOneUse()) {
       // If the rank of our current RHS is less than the rank of the LHS's LHS,
       // then we reassociate the two instructions...
 
@@ -177,7 +177,7 @@ static Value *NegateValue(Value *V, BasicBlock::iterator &BI) {
   // we introduce tons of unnecessary negation instructions...
   //
   if (Instruction *I = dyn_cast<Instruction>(V))
-    if (I->getOpcode() == Instruction::Add && I->use_size() == 1) {
+    if (I->getOpcode() == Instruction::Add && I->hasOneUse()) {
       Value *RHS = NegateValue(I->getOperand(1), BI);
       Value *LHS = NegateValue(I->getOperand(0), BI);
 
@@ -242,7 +242,7 @@ bool Reassociate::ReassociateBB(BasicBlock *BB) {
         Instruction *RHSI = dyn_cast<Instruction>(I->getOperand(1));
         if (LHSI && (int)LHSI->getOpcode() == I->getOpcode() &&
             RHSI && (int)RHSI->getOpcode() == I->getOpcode() &&
-            RHSI->use_size() == 1) {
+            RHSI->hasOneUse()) {
           // Insert a new temporary instruction... (A+B)+C
           BinaryOperator *Tmp = BinaryOperator::create(I->getOpcode(), LHSI,
                                                        RHSI->getOperand(0),