[KnownBits] Add a sextOrTrunc method

[qcolombet]

Summary

We already offer zextOrTrunc and it seems natural to offer the
same capability for sign extension.

This patch is a preparatory addition useful for future computeKnownBits
developments.

[lebedev.ri]

Could use a test, but it generally makes sense to have such a method.

[RKSimon]

LGTM

[qcolombet]

• Add a test for the new method

[qcolombet]

Hi @lebedev.ri ,

Could use a test, but it generally makes sense to have such a method.

I didn't see a test for zextOrTrunc that I could mimic so I come up with something.

Let me know what do you think.

Cheers,
-Quentin

[lebedev.ri]

Seems fine

llvm/unittests/Support/KnownBitsTest.cpp

205

I guess i was thinking of something like this:

TEST(KnownBitsTest, GetMinMaxVal) {
  const unsigned NarrowerSize = 4;
  const unsigned BaseSize = 6;
  const unsigned WiderSize = 8;
  ForeachKnownBits(BaseSize, [&](const KnownBits &KnownBase) {
    for (unsigned Size : {NarrowerSize, BaseSize, WiderSize}) {
      KnownBits Test;
      if(Size == BaseSize)
        Test = KnownBase
      else
        Test = Size < BaseSize ? KnownBase.trunc(Size) :  KnownBase.sext(Size);
      EXPECT_EQ(Test, KnownBase.sextOrTrunc(Size));
    }
  });
}

which seems pretty tautological i guess, so maybe we should go with your test.

llvm/include/llvm/Support/KnownBits.h

public:
   KnownBits zextOrTrunc(unsigned BitWidth) const {
     if (BitWidth > getBitWidth())
       return zext(BitWidth);
     if (BitWidth < getBitWidth())
       return trunc(BitWidth);
     return *this;
   }
 
+  /// Return known bits for a sign extension or truncation of the value we're
+  /// tracking.
+  KnownBits sextOrTrunc(unsigned BitWidth) const {
+    if (BitWidth > getBitWidth())
+      return sext(BitWidth);
+    if (BitWidth < getBitWidth())
+      return trunc(BitWidth);
+    return *this;
+  }
+
   /// Return a KnownBits with the extracted bits
   /// [bitPosition,bitPosition+numBits).
   KnownBits extractBits(unsigned NumBits, unsigned BitPosition) const {
     return KnownBits(Zero.extractBits(NumBits, BitPosition),
                      One.extractBits(NumBits, BitPosition));
   }
 
   /// Return KnownBits based on this, but updated given that the underlying

llvm/unittests/Support/KnownBitsTest.cpp

ForeachKnownBits(Bits, [&](const KnownBits &Known) {
     ForeachNumInKnownBits(Known, [&](const APInt &N) {
       Min = APIntOps::umin(Min, N);
       Max = APIntOps::umax(Max, N);
     });
     EXPECT_EQ(Min, Known.getMinValue());
     EXPECT_EQ(Max, Known.getMaxValue());
   });
 }
 
+TEST(KnownBitsTest, SExtOrTrunc) {
+  const unsigned NarrowerSize = 4;
+  const unsigned BaseSize = 6;
+  const unsigned WiderSize = 8;
+  APInt NegativeFitsNarrower(BaseSize, -4, /*isSigned*/ true);
+  APInt NegativeDoesntFitNarrower(BaseSize, -28, /*isSigned*/ true);
+  APInt PositiveFitsNarrower(BaseSize, 14);
+  APInt PositiveDoesntFitNarrower(BaseSize, 36);
+  auto InitKnownBits = [&](KnownBits &Res, const APInt &Input) {
+    Res = KnownBits(Input.getBitWidth());
+    Res.One = Input;
+    Res.Zero = ~Input;
+  };
+
+  for (unsigned Size : {NarrowerSize, BaseSize, WiderSize}) {
+    for (const APInt &Input :
+         {NegativeFitsNarrower, NegativeDoesntFitNarrower, PositiveFitsNarrower,
+          PositiveDoesntFitNarrower}) {
+      KnownBits Test;
+      InitKnownBits(Test, Input);
+      KnownBits Baseline;
+      InitKnownBits(Baseline, Input.sextOrTrunc(Size));
+      Test = Test.sextOrTrunc(Size);
+      EXPECT_EQ(Test.One, Baseline.One);
+      EXPECT_EQ(Test.Zero, Baseline.Zero);
+    }
+  }
+}
+
 } // end anonymous namespace