[InstCombine] Replace calls to getNumUses with hasNUses or hasNUsesOrMore

[craig.topper]

Summary

getNumUses is a linear time operation. It traverses the user linked list to the end and counts as it goes. Since we are only interested in small constant counts, we should use hasNUses or hasNUsesMore more that terminate the traversal as soon as it can provide the answer.

There are still two other locations in InstCombine, but changing those would force a rebase of D44266 which if accepted would remove them.

[spatel]

LGTM. I was going to suggest adding a note to the header doc, but I see it's already there. I'll be more careful in the future. :)
A quick grep shows there are more potential cleanups outside of instcombine.

llvm/trunk/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

Instruction *InstCombiner::narrowMaskedBinOp(BinaryOperator &And) {
   if (!match(Op0, m_OneUse(m_Add(m_Specific(Op1), m_Constant(C)))) &&
       !match(Op0, m_OneUse(m_Mul(m_Specific(Op1), m_Constant(C)))) &&
       !match(Op0, m_OneUse(m_LShr(m_Specific(Op1), m_Constant(C)))) &&
       !match(Op0, m_OneUse(m_Shl(m_Specific(Op1), m_Constant(C)))) &&
       !match(Op0, m_OneUse(m_Sub(m_Constant(C), m_Specific(Op1)))))
     return nullptr;
 
   Value *X;
-  if (!match(Op1, m_ZExt(m_Value(X))) || Op1->getNumUses() > 2)
+  if (!match(Op1, m_ZExt(m_Value(X))) || Op1->hasNUsesOrMore(3))
     return nullptr;
 
   Type *Ty = And.getType();
   if (!isa<VectorType>(Ty) && !shouldChangeType(Ty, X->getType()))
     return nullptr;
 
   // If we're narrowing a shift, the shift amount must be safe (less than the
   // width) in the narrower type. If the shift amount is greater, instsimplify
Instruction *InstCombiner::visitXor(BinaryOperator &I) {
   if (Instruction *CastedXor = foldCastedBitwiseLogic(I))
     return CastedXor;
 
   // Canonicalize the shifty way to code absolute value to the common pattern.
   // There are 4 potential commuted variants. Move the 'ashr' candidate to Op1.
   // We're relying on the fact that we only do this transform when the shift has
   // exactly 2 uses and the add has exactly 1 use (otherwise, we might increase
   // instructions).
-  if (Op0->getNumUses() == 2)
+  if (Op0->hasNUses(2))
     std::swap(Op0, Op1);
 
   const APInt *ShAmt;
   Type *Ty = I.getType();
   if (match(Op1, m_AShr(m_Value(A), m_APInt(ShAmt))) &&
-      Op1->getNumUses() == 2 && *ShAmt == Ty->getScalarSizeInBits() - 1 &&
+      Op1->hasNUses(2) && *ShAmt == Ty->getScalarSizeInBits() - 1 &&
       match(Op0, m_OneUse(m_c_Add(m_Specific(A), m_Specific(Op1))))) {
     // B = ashr i32 A, 31 ; smear the sign bit
     // xor (add A, B), B  ; add -1 and flip bits if negative
     // --> (A < 0) ? -A : A
     Value *Cmp = Builder.CreateICmpSLT(A, ConstantInt::getNullValue(Ty));
     return SelectInst::Create(Cmp, Builder.CreateNeg(A), A);
   }
 
   return Changed ? &I : nullptr;
 }

llvm/trunk/lib/Transforms/InstCombine/InstCombineSelect.cpp

static Instruction *factorizeMinMaxTree(SelectPatternFlavor SPF, Value *LHS,
   if (SPF != L.Flavor || L.Flavor != R.Flavor)
     return nullptr;
 
   // Look for a common operand. The use checks are different than usual because
   // a min/max pattern typically has 2 uses of each op: 1 by the cmp and 1 by
   // the select.
   Value *MinMaxOp = nullptr;
   Value *ThirdOp = nullptr;
-  if (LHS->getNumUses() <= 2 && RHS->getNumUses() > 2) {
+  if (!LHS->hasNUsesOrMore(3) && RHS->hasNUsesOrMore(3)) {
     // If the LHS is only used in this chain and the RHS is used outside of it,
     // reuse the RHS min/max because that will eliminate the LHS.
     if (D == A || C == A) {
       // min(min(a, b), min(c, a)) --> min(min(c, a), b)
       // min(min(a, b), min(a, d)) --> min(min(a, d), b)
       MinMaxOp = RHS;
       ThirdOp = B;
     } else if (D == B || C == B) {
       // min(min(a, b), min(c, b)) --> min(min(c, b), a)
       // min(min(a, b), min(b, d)) --> min(min(b, d), a)
       MinMaxOp = RHS;
       ThirdOp = A;
     }
-  } else if (RHS->getNumUses() <= 2) {
+  } else if (!RHS->hasNUsesOrMore(3)) {
     // Reuse the LHS. This will eliminate the RHS.
     if (D == A || D == B) {
       // min(min(a, b), min(c, a)) --> min(min(a, b), c)
       // min(min(a, b), min(c, b)) --> min(min(a, b), c)
       MinMaxOp = LHS;
       ThirdOp = C;
     } else if (C == A || C == B) {
       // min(min(a, b), min(b, d)) --> min(min(a, b), d)