GlobalISel: Add maskedValueIsZero and signBitIsZero to known bits

[arsenm]

Summary

I dropped the DemandedElts since it seems to be missing from some of
the new interfaces, but not others.

[arsenm]

r370389

include/llvm/CodeGen/GlobalISel/GISelKnownBits.h

public:
 
   // KnownBitsAPI
   KnownBits getKnownBits(Register R);
   // Calls getKnownBits for first operand def of MI.
   KnownBits getKnownBits(MachineInstr &MI);
   APInt getKnownZeroes(Register R);
   APInt getKnownOnes(Register R);
 
+  /// \return true if 'V & Mask' is known to be zero in DemandedElts. We use
+  /// this predicate to simplify operations downstream.
+  /// Mask is known to be zero for bits that V cannot have.
+  bool maskedValueIsZero(Register Val, const APInt &Mask) {
+    return Mask.isSubsetOf(getKnownBits(Val).Zero);
+  }
+
+  /// \return true if the sign bit of Op is known to be zero.  We use this
+  /// predicate to simplify operations downstream.
+  bool signBitIsZero(Register Op);
+
   // FIXME: Is this the right place for G_FRAME_INDEX? Should it be in
   // TargetLowering?
   void computeKnownBitsForFrameIndex(Register R, KnownBits &Known,
                                      const APInt &DemandedElts,
                                      unsigned Depth = 0);
   static unsigned inferAlignmentForFrameIdx(int FrameIdx, int Offset,
                                             const MachineFunction &MF);
   static void computeKnownBitsForAlignment(KnownBits &Known, unsigned Align);

lib/CodeGen/GlobalISel/GISelKnownBits.cpp

KnownBits GISelKnownBits::getKnownBits(Register R) {
   KnownBits Known;
   LLT Ty = MRI.getType(R);
   APInt DemandedElts =
       Ty.isVector() ? APInt::getAllOnesValue(Ty.getNumElements()) : APInt(1, 1);
   computeKnownBitsImpl(R, Known, DemandedElts);
   return Known;
 }
 
+bool GISelKnownBits::signBitIsZero(Register R) {
+  LLT Ty = MRI.getType(R);
+  unsigned BitWidth = Ty.getScalarSizeInBits();
+  return maskedValueIsZero(R, APInt::getSignMask(BitWidth));
+}
+
 APInt GISelKnownBits::getKnownZeroes(Register R) {
   return getKnownBits(R).Zero;
 }
 
 APInt GISelKnownBits::getKnownOnes(Register R) { return getKnownBits(R).One; }
 
 void GISelKnownBits::computeKnownBitsImpl(Register R, KnownBits &Known,
                                           const APInt &DemandedElts,

unittests/CodeGen/GlobalISel/KnownBitsTest.cpp

TEST_F(GISelMITest, TestKnownBits) {
   GISelKnownBits Info(*MF);
   KnownBits Known = Info.getKnownBits(SrcReg);
   EXPECT_FALSE(Known.hasConflict());
   EXPECT_EQ(0u, Known.One.getZExtValue());
   EXPECT_EQ(31u, Known.Zero.getZExtValue());
   APInt Zeroes = Info.getKnownZeroes(SrcReg);
   EXPECT_EQ(Known.Zero, Zeroes);
 }
+
+TEST_F(GISelMITest, TestSignBitIsZero) {
+  if (!TM)
+    return;
+
+  const LLT S32 = LLT::scalar(32);
+  auto SignBit = B.buildConstant(S32, 0x8000000);
+  auto Zero = B.buildConstant(S32, 0);
+
+  GISelKnownBits KnownBits(*MF);
+
+  EXPECT_TRUE(KnownBits.signBitIsZero(Zero.getReg(0)));
+  EXPECT_FALSE(KnownBits.signBitIsZero(Zero.getReg(0)));
+  EXPECT_FALSE(KnownBits.signBitIsZero(SignBit.getReg(0)));
+  EXPECT_TRUE(KnownBits.signBitIsZero(SignBit.getReg(0)));
+}