6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-05-22 03:39:03 +00:00
Code Issues Projects Releases Wiki Activity

Decrease usage of use_size()

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@9135 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2003-10-15 16:48:29 +00:00
parent 33922eb648
commit fd05924946
12 changed files with 25 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/AsmParser/llvmAsmParser.y
View File

@ -103,7 +103,7 @@ static struct PerModuleInfo {
// Loop over all of the uses of the GlobalValue. The only thing they are // Loop over all of the uses of the GlobalValue. The only thing they are
// allowed to be is ConstantPointerRef's. // 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... User *U = OldGV->use_back(); // Must be a ConstantPointerRef...
ConstantPointerRef *CPR = cast<ConstantPointerRef>(U); ConstantPointerRef *CPR = cast<ConstantPointerRef>(U);

2
lib/CodeGen/InstrSelection/InstrForest.cpp
View File

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

2
lib/Target/CBackend/CBackend.cpp
View File

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

2
lib/Target/CBackend/Writer.cpp
View File

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

2
lib/Target/SparcV9/InstrSelection/InstrForest.cpp
View File

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

2
lib/Target/X86/InstSelectSimple.cpp
View File

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

2
lib/Target/X86/X86ISelSimple.cpp
View File

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

2
lib/Transforms/ExprTypeConvert.cpp
View File

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

2
lib/Transforms/IPO/InlineSimple.cpp
View File

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

2
lib/Transforms/Scalar/CorrelatedExprs.cpp
View File

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

24
lib/Transforms/Scalar/InstructionCombining.cpp
View File

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

6
lib/Transforms/Scalar/Reassociate.cpp
View File

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