From f95d9b99b3ca878e11d7615e7462507237ae3610 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Wed, 15 Oct 2003 16:48:29 +0000 Subject: [PATCH] Decrease usage of use_size() llvm-svn: 9135 --- llvm/lib/AsmParser/llvmAsmParser.y | 2 +- llvm/lib/CWriter/Writer.cpp | 2 +- .../CodeGen/InstrSelection/InstrForest.cpp | 2 +- llvm/lib/Target/X86/InstSelectSimple.cpp | 2 +- llvm/lib/Transforms/ExprTypeConvert.cpp | 2 +- llvm/lib/Transforms/IPO/InlineSimple.cpp | 2 +- .../lib/Transforms/Scalar/CorrelatedExprs.cpp | 2 +- .../Scalar/InstructionCombining.cpp | 24 +++++++++---------- llvm/lib/Transforms/Scalar/Reassociate.cpp | 6 ++--- 9 files changed, 22 insertions(+), 22 deletions(-) diff --git a/llvm/lib/AsmParser/llvmAsmParser.y b/llvm/lib/AsmParser/llvmAsmParser.y index bb556f2eb541..3347e8833a43 100644 --- a/llvm/lib/AsmParser/llvmAsmParser.y +++ b/llvm/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(U); diff --git a/llvm/lib/CWriter/Writer.cpp b/llvm/lib/CWriter/Writer.cpp index a3607be8a0f0..af33e4b85fbd 100644 --- a/llvm/lib/CWriter/Writer.cpp +++ b/llvm/lib/CWriter/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(I) || isa(I) || isa(I) || isa(I) || isa(I)) // Don't inline a load across a store or other bad things! diff --git a/llvm/lib/CodeGen/InstrSelection/InstrForest.cpp b/llvm/lib/CodeGen/InstrSelection/InstrForest.cpp index f4736b59eace..496e279ef90a 100644 --- a/llvm/lib/CodeGen/InstrSelection/InstrForest.cpp +++ b/llvm/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(operand) && operand->use_size() == 1 && + if (isa(operand) && operand->hasOneUse() && cast(operand)->getParent() == instr->getParent() && instr->getOpcode() != Instruction::PHINode && instr->getOpcode() != Instruction::Call) diff --git a/llvm/lib/Target/X86/InstSelectSimple.cpp b/llvm/lib/Target/X86/InstSelectSimple.cpp index 9e4e499de9cb..a6dc7c9fb4ca 100644 --- a/llvm/lib/Target/X86/InstSelectSimple.cpp +++ b/llvm/lib/Target/X86/InstSelectSimple.cpp @@ -554,7 +554,7 @@ void ISel::SelectPHINodes() { // static SetCondInst *canFoldSetCCIntoBranch(Value *V) { if (SetCondInst *SCI = dyn_cast(V)) - if (SCI->use_size() == 1 && isa(SCI->use_back()) && + if (SCI->hasOneUse() && isa(SCI->use_back()) && SCI->getParent() == cast(SCI->use_back())->getParent()) { const Type *Ty = SCI->getOperand(0)->getType(); if (Ty != Type::LongTy && Ty != Type::ULongTy) diff --git a/llvm/lib/Transforms/ExprTypeConvert.cpp b/llvm/lib/Transforms/ExprTypeConvert.cpp index d076f9a4f7d8..5adf12b7e27b 100644 --- a/llvm/lib/Transforms/ExprTypeConvert.cpp +++ b/llvm/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! diff --git a/llvm/lib/Transforms/IPO/InlineSimple.cpp b/llvm/lib/Transforms/IPO/InlineSimple.cpp index b2299c3ecfa6..0e2f0190135e 100644 --- a/llvm/lib/Transforms/IPO/InlineSimple.cpp +++ b/llvm/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 diff --git a/llvm/lib/Transforms/Scalar/CorrelatedExprs.cpp b/llvm/lib/Transforms/Scalar/CorrelatedExprs.cpp index 59b8b0f28c82..5bc34b8aa37f 100644 --- a/llvm/lib/Transforms/Scalar/CorrelatedExprs.cpp +++ b/llvm/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... diff --git a/llvm/lib/Transforms/Scalar/InstructionCombining.cpp b/llvm/lib/Transforms/Scalar/InstructionCombining.cpp index f2f96c0da5f3..d69176f343e2 100644 --- a/llvm/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/llvm/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(V); + return V->hasOneUse() || isa(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(V)) if (I->getOpcode() == Instruction::Mul) if (isa(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(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(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(Op0)) { // xor (setcc A, B), true = not (setcc A, B) = setncc A, B if (SetCondInst *SCI = dyn_cast(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(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(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(Op0)) if (ConstantInt *Op0C = dyn_cast(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(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()); diff --git a/llvm/lib/Transforms/Scalar/Reassociate.cpp b/llvm/lib/Transforms/Scalar/Reassociate.cpp index 892010af70ad..c837f0bb6e94 100644 --- a/llvm/lib/Transforms/Scalar/Reassociate.cpp +++ b/llvm/lib/Transforms/Scalar/Reassociate.cpp @@ -126,7 +126,7 @@ bool Reassociate::ReassociateExpr(BinaryOperator *I) { // only expression using it... // if (BinaryOperator *LHSI = dyn_cast(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(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(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),