[KnownBits] Add methods to set and clear all bits.

[craig.topper]

Summary

This adds a clearAll and setAll method to KnownBits that call either clearAllBits or setAllBits on both.

We also still need methods to clear Zero/One and and set all bits in the opposite. I'm considering makeZero() and makeAllOnes(). As I'm writing this I'm wondering if clearAllBits should be makeUnknown. Not sure what setAll would be in that naming.

I'm worried about mixing the "clearing" a bit to unknown state vs making a bit known to be zero which would be consider clearing its value. I want to be able to treat KnownBits as a value so we can say is it known negative or nonnegative or zero or all ones. But I also want to be able to refer to its unknown/known set of bits.

[craig.topper]

I think my previous diff may have been incomplete.

[craig.topper]

Fix a misnamed call.

[RKSimon]

This looks incomplete - the addition of the method to the KnownBits struct is missing and there is no context to the diff.

[RKSimon]

We also still need methods to clear Zero/One and and set all bits in the opposite. I'm considering makeZero() and makeAllOnes(). As I'm writing this I'm wondering if clearAllBits should be makeUnknown. Not sure what setAll would be in that naming.

Would KnowBits::makeInvalid make sense?

[RKSimon]

Why not KnownBits::clearAllBits() + KnownBits::setAllBits() ?

[craig.topper]

I've removed the method that sets all bits in both zero and one for now. I think that should be done in a future patch that adds intersecting support since setting all vectors always proceeds an intersection loop. Maybe the method should just be prepareForIntersection or something that stresses that its only useful for that.

I've added methods for testing and setting all ones and all zeros. To preserve existing code semantics I've added two versions of setting zero/one, one that just asserts if it creates a conflict, and one that erases all previous information. The latter is called 'force', but I'm not sure if that's a good name.

Making the vector unknown is now called resetAll. And there is a method to check if the known bits are all unknown.

Let me know if these names make sense. I'm open to other suggestions.

[RKSimon]

I'm not sure we have a need for both the 'set' and 'force' versions - AFAICT all the 'set' cases above could be 'force' as we're just making use of the fact that we know that the KnownBits are all zero at initialization. Maybe just have 'force' version and call them 'set'? If that make sense at all......

[craig.topper]

Merge setAllZero and forceAllZero. Same for AllOnes.

[RKSimon]

LGTM

lib/Analysis/ValueTracking.cpp

   // Also compute a conservative estimate for high known-0 bits.
   // More trickiness is possible, but this is sufficient for the
   // interesting case of alignment computation.
-  Known.One.clearAllBits();
+  Known.clearAll();
   unsigned TrailZ = Known.Zero.countTrailingOnes() +
                     Known2.Zero.countTrailingOnes();
   unsigned LeadZ =  std::max(Known.Zero.countLeadingOnes() +

 
   TrailZ = std::min(TrailZ, BitWidth);
   LeadZ = std::min(LeadZ, BitWidth);
-  Known.Zero.clearAllBits();
   Known.Zero.setLowBits(TrailZ);
   Known.Zero.setHighBits(LeadZ);
 

   // behavior, or we might have a bug in the compiler. We can't assert/crash, so
   // clear out the known bits, try to warn the user, and hope for the best.
   if (Known.Zero.intersects(Known.One)) {
-    Known.Zero.clearAllBits();
-    Known.One.clearAllBits();
+    Known.clearAll();
 
     if (Q.ORE) {
       auto *CxtI = const_cast<Instruction *>(Q.CxtI);

     // If there is conflict between Known.Zero and Known.One, this must be an
     // overflowing left shift, so the shift result is undefined. Clear Known
     // bits so that other code could propagate this undef.
-    if ((Known.Zero & Known.One) != 0) {
-      Known.Zero.clearAllBits();
-      Known.One.clearAllBits();
-    }
+    if ((Known.Zero & Known.One) != 0)
+      Known.clearAll();
 
     return;
   }

   // If the shift amount could be greater than or equal to the bit-width of the LHS, the
   // value could be undef, so we don't know anything about it.
   if ((~Known.Zero).uge(BitWidth)) {
-    Known.Zero.clearAllBits();
-    Known.One.clearAllBits();
+    Known.clearAll();
     return;
   }
 

 
   // It would be more-clearly correct to use the two temporaries for this
   // calculation. Reusing the APInts here to prevent unnecessary allocations.
-  Known.Zero.clearAllBits();
-  Known.One.clearAllBits();
+  Known.clearAll();
 
   // If we know the shifter operand is nonzero, we can sometimes infer more
   // known bits. However this is expensive to compute, so be lazy about it and

   // stay disjoint (it should be better for some other code to actually
   // propagate the undef than to pick a value here using known bits).
   if (Known.Zero.intersects(Known.One)) {
-    Known.Zero.clearAllBits();
-    Known.One.clearAllBits();
+    Known.clearAll();
   }
 }
 

                                        m_Value(Y))) ||
          match(I->getOperand(1), m_Add(m_Specific(I->getOperand(0)),
                                        m_Value(Y))))) {
-      Known2.Zero.clearAllBits(); Known2.One.clearAllBits();
+      Known2.clearAll();
       computeKnownBits(Y, Known2, Depth + 1, Q);
       if (Known2.One.countTrailingOnes() > 0)
         Known.Zero.setBit(0);

     computeKnownBits(I->getOperand(0), Known2, Depth + 1, Q);
     unsigned LeadZ = Known2.Zero.countLeadingOnes();
 
-    Known2.One.clearAllBits();
-    Known2.Zero.clearAllBits();
+    Known2.clearAll();
     computeKnownBits(I->getOperand(1), Known2, Depth + 1, Q);
     unsigned RHSUnknownLeadingOnes = Known2.One.countLeadingZeros();
     if (RHSUnknownLeadingOnes != BitWidth)

 
     unsigned Leaders = std::max(Known.Zero.countLeadingOnes(),
                                 Known2.Zero.countLeadingOnes());
-    Known.One.clearAllBits();
-    Known.Zero.clearAllBits();
+    Known.clearAll();
     Known.Zero.setHighBits(Leaders);
     break;
   }

       Constant *Element = CV->getAggregateElement(i);
       auto *ElementCI = dyn_cast_or_null<ConstantInt>(Element);
       if (!ElementCI) {
-        Known.Zero.clearAllBits();
-        Known.One.clearAllBits();
+        Known.clearAll();
         return;
       }
       Elt = ElementCI->getValue();

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

       if (M < 0) {
         // For UNDEF elements, we don't know anything about the common state of
         // the shuffle result.
-        Known.One.clearAllBits();
-        Known.Zero.clearAllBits();
+        Known.clearAll();
         DemandedLHS.clearAllBits();
         DemandedRHS.clearAllBits();
         break;

 
       computeKnownBits(N0, Known2, SubDemandedElts, Depth + 1);
 
-      Known.Zero.setAllBits(); Known.One.setAllBits();
+      Known.setAll();
       for (unsigned i = 0; i != NumElts; ++i)
         if (DemandedElts[i]) {
           unsigned Offset = (i % SubScale) * BitWidth;

     // Also compute a conservative estimate for high known-0 bits.
     // More trickiness is possible, but this is sufficient for the
     // interesting case of alignment computation.
-    Known.One.clearAllBits();
+    Known.clearAll();
     unsigned TrailZ = Known.Zero.countTrailingOnes() +
                       Known2.Zero.countTrailingOnes();
     unsigned LeadZ =  std::max(Known.Zero.countLeadingOnes() +
                                Known2.Zero.countLeadingOnes(),
                                BitWidth) - BitWidth;
 
-    Known.Zero.clearAllBits();
     Known.Zero.setLowBits(std::min(TrailZ, BitWidth));
     Known.Zero.setHighBits(std::min(LeadZ, BitWidth));
     break;

 
     uint32_t Leaders = std::max(Known.Zero.countLeadingOnes(),
                                 Known2.Zero.countLeadingOnes());
-    Known.One.clearAllBits();
-    Known.Zero.clearAllBits();
+    Known.clearAll();
     Known.Zero.setHighBits(Leaders);
     break;
   }

lib/CodeGen/SelectionDAG/TargetLowering.cpp

     return false;   // Don't fall through, will infinitely loop.
   case ISD::BUILD_VECTOR:
     // Collect the known bits that are shared by every constant vector element.
-    Known.Zero.setAllBits(); Known.One.setAllBits();
+    Known.setAll();
     for (SDValue SrcOp : Op->ops()) {
       if (!isa<ConstantSDNode>(SrcOp)) {
         // We can only handle all constant values - bail out with no known bits.

           Op.getOpcode() == ISD::INTRINSIC_VOID) &&
          "Should use MaskedValueIsZero if you don't know whether Op"
          " is a target node!");
-  Known.Zero.clearAllBits(); Known.One.clearAllBits();
+  Known.clearAll();
 }
 
 /// This method can be implemented by targets that want to expose additional

lib/Target/AMDGPU/AMDGPUISelLowering.cpp

     const SDValue Op, KnownBits &Known,
     const APInt &DemandedElts, const SelectionDAG &DAG, unsigned Depth) const {
 
-  Known.Zero.clearAllBits(); Known.One.clearAllBits(); // Don't know anything.
+  Known.clearAll(); // Don't know anything.
 
   KnownBits Known2;
   unsigned Opc = Op.getOpcode();

lib/Target/ARM/ARMISelLowering.cpp

                                                       const SelectionDAG &DAG,
                                                       unsigned Depth) const {
   unsigned BitWidth = Known.getBitWidth();
-  Known.Zero.clearAllBits(); Known.One.clearAllBits();
+  Known.clearAll();
   switch (Op.getOpcode()) {
   default: break;
   case ARMISD::ADDC:

lib/Target/PowerPC/PPCISelLowering.cpp

                                                       const APInt &DemandedElts,
                                                       const SelectionDAG &DAG,
                                                       unsigned Depth) const {
-  Known.Zero.clearAllBits(); Known.One.clearAllBits();
+  Known.clearAll();
   switch (Op.getOpcode()) {
   default: break;
   case PPCISD::LBRX: {

lib/Target/Sparc/SparcISelLowering.cpp

                                  const SelectionDAG &DAG,
                                  unsigned Depth) const {
   KnownBits Known2;
-  Known.Zero.clearAllBits(); Known.One.clearAllBits();
+  Known.clearAll();
 
   switch (Op.getOpcode()) {
   default: break;

lib/Target/XCore/XCoreISelLowering.cpp

                                                         const APInt &DemandedElts,
                                                         const SelectionDAG &DAG,
                                                         unsigned Depth) const {
-  Known.Zero.clearAllBits(); Known.One.clearAllBits();
+  Known.clearAll();
   switch (Op.getOpcode()) {
   default: break;
   case XCoreISD::LADD:

lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

     return nullptr;
   }
 
-  Known.Zero.clearAllBits();
-  Known.One.clearAllBits();
+  Known.clearAll();
   if (DemandedMask == 0)     // Not demanding any bits from V.
     return UndefValue::get(VTy);