[KnownBits] Avoid copying KnownBits objects

[foad]

Summary

Avoid copying KnownBits objects in some cases where we can move them or
use a slightly simpler constructor instead. NFC.

I found these cases by temporarily deleting KnownBits's copy constructor
and copy assignment operator.

[RKSimon]

Are you actually seeing a performance delta from this?

[foad]

In D74539#1874000, @RKSimon wrote:

Are you actually seeing a performance delta from this?

No, I was just doing it as a kind of drive-by clean-up, since @bjope expressed some concern that we might be copying these objects too much in comments on D74482.

[RKSimon]

llvm/lib/Analysis/ValueTracking.cpp

1097

Not sure about the std::move but using BitWidth makes sense to me.

[lebedev.ri]

Abandon this?

[foad]

llvm/lib/Analysis/ValueTracking.cpp

1097

I took the liberty of committing these bits in 94cc9eccf65f2282ae780c3e98d19c5b3b6b9069.

[RKSimon]

llvm/lib/Analysis/ValueTracking.cpp

1097

LGTM, cheers

llvm/lib/Analysis/ValueTracking.cpp

static void computeKnownBitsAddSub(bool Add, const Value *Op0, const Value *Op1,
   unsigned BitWidth = KnownOut.getBitWidth();
 
   // If an initial sequence of bits in the result is not needed, the
   // corresponding bits in the operands are not needed.
   KnownBits LHSKnown(BitWidth);
   computeKnownBits(Op0, LHSKnown, Depth + 1, Q);
   computeKnownBits(Op1, Known2, Depth + 1, Q);
 
-  KnownOut = KnownBits::computeForAddSub(Add, NSW, LHSKnown, Known2);
+  KnownOut = KnownBits::computeForAddSub(Add, NSW, LHSKnown, std::move(Known2));
 }
 
 static void computeKnownBitsMul(const Value *Op0, const Value *Op1, bool NSW,
                                 KnownBits &Known, KnownBits &Known2,
                                 unsigned Depth, const Query &Q) {
   unsigned BitWidth = Known.getBitWidth();
   computeKnownBits(Op1, Known, Depth + 1, Q);
   computeKnownBits(Op0, Known2, Depth + 1, Q);

 }
 
 static void computeKnownBitsFromOperator(const Operator *I,
                                          const APInt &DemandedElts,
                                          KnownBits &Known, unsigned Depth,
                                          const Query &Q) {
   unsigned BitWidth = Known.getBitWidth();
 
-  KnownBits Known2(Known);
+  KnownBits Known2(BitWidth);
   switch (I->getOpcode()) {
   default: break;
   case Instruction::Load:
     if (MDNode *MD =
             Q.IIQ.getMetadata(cast<LoadInst>(I), LLVMContext::MD_range))
       computeKnownBitsFromRangeMetadata(*MD, Known);
     break;
   case Instruction::And: {
if (P->getNumIncomingValues() == 2) {
           Query RecQ = Q;
 
           // Ok, we have a PHI of the form L op= R. Check for low
           // zero bits.
           RecQ.CxtI = RInst;
           computeKnownBits(R, Known2, Depth + 1, RecQ);
 
           // We need to take the minimum number of known bits
-          KnownBits Known3(Known);
+          KnownBits Known3(BitWidth);
           RecQ.CxtI = LInst;
           computeKnownBits(L, Known3, Depth + 1, RecQ);
 
           Known.Zero.setLowBits(std::min(Known2.countMinTrailingZeros(),
                                          Known3.countMinTrailingZeros()));
 
           auto *OverflowOp = dyn_cast<OverflowingBinaryOperator>(LU);
           if (OverflowOp && Q.IIQ.hasNoSignedWrap(OverflowOp)) {
if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
         if (!match(I->getOperand(2), m_APInt(SA)))
           break;
 
         // Normalize to funnel shift left.
         uint64_t ShiftAmt = SA->urem(BitWidth);
         if (II->getIntrinsicID() == Intrinsic::fshr)
           ShiftAmt = BitWidth - ShiftAmt;
 
-        KnownBits Known3(Known);
+        KnownBits Known3(BitWidth);
         computeKnownBits(I->getOperand(0), Known2, Depth + 1, Q);
         computeKnownBits(I->getOperand(1), Known3, Depth + 1, Q);
 
         Known.Zero =
             Known2.Zero.shl(ShiftAmt) | Known3.Zero.lshr(BitWidth - ShiftAmt);
         Known.One =
             Known2.One.shl(ShiftAmt) | Known3.One.lshr(BitWidth - ShiftAmt);
         break;
if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
         unsigned LeadingKnown;
         if (IsAdd)
           LeadingKnown = std::max(Known.countMinLeadingOnes(),
                                   Known2.countMinLeadingOnes());
         else
           LeadingKnown = std::max(Known.countMinLeadingZeros(),
                                   Known2.countMinLeadingOnes());
 
         Known = KnownBits::computeForAddSub(
-            IsAdd, /* NSW */ false, Known, Known2);
+            IsAdd, /* NSW */ false, Known, std::move(Known2));
 
         // We select between the operation result and all-ones/zero
         // respectively, so we can preserve known ones/zeros.
         if (IsAdd) {
           Known.One.setHighBits(LeadingKnown);
           Known.Zero.clearAllBits();
         } else {
           Known.Zero.setHighBits(LeadingKnown);

llvm/lib/CodeGen/GlobalISel/GISelKnownBits.cpp

case TargetOpcode::G_FRAME_INDEX: {
     break;
   }
   case TargetOpcode::G_SUB: {
     computeKnownBitsImpl(MI.getOperand(1).getReg(), Known, DemandedElts,
                          Depth + 1);
     computeKnownBitsImpl(MI.getOperand(2).getReg(), Known2, DemandedElts,
                          Depth + 1);
     Known = KnownBits::computeForAddSub(/*Add*/ false, /*NSW*/ false, Known,
-                                        Known2);
+                                        std::move(Known2));
     break;
   }
   case TargetOpcode::G_XOR: {
     computeKnownBitsImpl(MI.getOperand(2).getReg(), Known, DemandedElts,
                          Depth + 1);
     computeKnownBitsImpl(MI.getOperand(1).getReg(), Known2, DemandedElts,
                          Depth + 1);
 
if (DL.isNonIntegralAddressSpace(Ty.getAddressSpace()))
       break;
     LLVM_FALLTHROUGH;
   }
   case TargetOpcode::G_ADD: {
     computeKnownBitsImpl(MI.getOperand(1).getReg(), Known, DemandedElts,
                          Depth + 1);
     computeKnownBitsImpl(MI.getOperand(2).getReg(), Known2, DemandedElts,
                          Depth + 1);
     Known =
-        KnownBits::computeForAddSub(/*Add*/ true, /*NSW*/ false, Known, Known2);
+        KnownBits::computeForAddSub(/*Add*/ true, /*NSW*/ false, Known, std::move(Known2));
     break;
   }
   case TargetOpcode::G_AND: {
     // If either the LHS or the RHS are Zero, the result is zero.
     computeKnownBitsImpl(MI.getOperand(2).getReg(), Known, DemandedElts,
                          Depth + 1);
     computeKnownBitsImpl(MI.getOperand(1).getReg(), Known2, DemandedElts,
                          Depth + 1);

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

case ISD::SSUBO:
     LLVM_FALLTHROUGH;
   case ISD::SUB:
   case ISD::SUBC: {
     assert(Op.getResNo() == 0 &&
            "We only compute knownbits for the difference here.");
 
     Known = computeKnownBits(Op.getOperand(0), DemandedElts, Depth + 1);
     Known2 = computeKnownBits(Op.getOperand(1), DemandedElts, Depth + 1);
     Known = KnownBits::computeForAddSub(/* Add */ false, /* NSW */ false,
-                                        Known, Known2);
+                                        Known, std::move(Known2));
     break;
   }
   case ISD::UADDO:
   case ISD::SADDO:
   case ISD::ADDCARRY:
     if (Op.getResNo() == 1) {
       // If we know the result of a setcc has the top bits zero, use this info.
       if (TLI->getBooleanContents(Op.getOperand(0).getValueType()) ==

llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp

if (!DemandedSrcBits.isAllOnesValue() ||
       if (SDValue DemandedSrc = SimplifyMultipleUseDemandedBits(
               Src, DemandedSrcBits, DemandedSrcElts, TLO.DAG, Depth + 1)) {
         SDValue NewOp =
             TLO.DAG.getNode(Op.getOpcode(), dl, VT, DemandedSrc, Idx);
         return TLO.CombineTo(Op, NewOp);
       }
     }
 
-    Known = Known2;
+    Known = std::move(Known2);
     if (BitWidth > EltBitWidth)
       Known = Known.anyext(BitWidth);
     break;
   }
   case ISD::BITCAST: {
     SDValue Src = Op.getOperand(0);
     EVT SrcVT = Src.getValueType();
     unsigned NumSrcEltBits = SrcVT.getScalarSizeInBits();

llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

case Instruction::Sub: {
     // demanding the LSB.
     if ((I->getOpcode() == Instruction::Add ||
          DemandedFromOps.isOneValue()) &&
         DemandedFromOps.isSubsetOf(LHSKnown.Zero))
       return I->getOperand(1);
 
     // Otherwise just compute the known bits of the result.
     bool NSW = cast<OverflowingBinaryOperator>(I)->hasNoSignedWrap();
     Known = KnownBits::computeForAddSub(I->getOpcode() == Instruction::Add,
-                                        NSW, LHSKnown, RHSKnown);
+                                        NSW, LHSKnown, std::move(RHSKnown));
     break;
   }
   case Instruction::Shl: {
     const APInt *SA;
     if (match(I->getOperand(1), m_APInt(SA))) {
       const APInt *ShrAmt;
       if (match(I->getOperand(0), m_Shr(m_Value(), m_APInt(ShrAmt))))
         if (Instruction *Shr = dyn_cast<Instruction>(I->getOperand(0)))