[APInt] Added APInt::clearBits() method #137098

liamsemeria · 2025-04-24T00:37:02Z

Added APInt::clearBits(unsigned loBit, unsigned hiBit) that clears bits within a certain range.

github-actions · 2025-04-24T00:37:21Z

Thank you for submitting a Pull Request (PR) to the LLVM Project!

This PR will be automatically labeled and the relevant teams will be notified.

If you wish to, you can add reviewers by using the "Reviewers" section on this page.

If this is not working for you, it is probably because you do not have write permissions for the repository. In which case you can instead tag reviewers by name in a comment by using @ followed by their GitHub username.

If you have received no comments on your PR for a week, you can request a review by "ping"ing the PR by adding a comment “Ping”. The common courtesy "ping" rate is once a week. Please remember that you are asking for valuable time from other developers.

If you have further questions, they may be answered by the LLVM GitHub User Guide.

You can also ask questions in a comment on this PR, on the LLVM Discord or on the forums.

llvmbot · 2025-04-24T00:37:51Z

@llvm/pr-subscribers-llvm-selectiondag

@llvm/pr-subscribers-llvm-support

Author: Liam Semeria (liamsemeria)

Changes

Added APInt::clearBits(unsigned loBit, unsigned hiBit) that clears bits within a certain range.
Issue here

Full diff: https://github.com/llvm/llvm-project/pull/137098.diff

3 Files Affected:

(modified) llvm/include/llvm/ADT/APInt.h (+23)
(modified) llvm/lib/Support/APInt.cpp (+27)
(modified) llvm/unittests/ADT/APIntTest.cpp (+56)

diff --git a/llvm/include/llvm/ADT/APInt.h b/llvm/include/llvm/ADT/APInt.h
index 02d58d8c3d31c..c724411261388 100644
--- a/llvm/include/llvm/ADT/APInt.h
+++ b/llvm/include/llvm/ADT/APInt.h
@@ -1413,6 +1413,26 @@ class [[nodiscard]] APInt {
       U.pVal[whichWord(BitPosition)] &= Mask;
   }
 
+  /// Clear the bits from loBit (inclusive) to hiBit (exclusive) to 0.
+  /// This function handles case when \p loBit <= \p hiBit.
+  void clearBits(unsigned loBit, unsigned hiBit) {
+    assert(hiBit <= BitWidth && "hiBit out of range");
+    assert(loBit <= BitWidth && "loBit out of range");
+    assert(loBit <= hiBit && "loBit greater than hiBit");
+    if (loBit == hiBit)
+      return;
+    if (loBit < APINT_BITS_PER_WORD && hiBit <= APINT_BITS_PER_WORD) {
+      uint64_t mask = WORDTYPE_MAX >> (APINT_BITS_PER_WORD - (hiBit - loBit));
+      mask = ~(mask << loBit);
+      if (isSingleWord())
+        U.VAL &= mask;
+      else
+        U.pVal[0] &= mask;
+    } else {
+      clearBitsSlowCase(loBit, hiBit);
+    }
+  }
+
   /// Set bottom loBits bits to 0.
   void clearLowBits(unsigned loBits) {
     assert(loBits <= BitWidth && "More bits than bitwidth");
@@ -2051,6 +2071,9 @@ class [[nodiscard]] APInt {
   /// out-of-line slow case for setBits.
   void setBitsSlowCase(unsigned loBit, unsigned hiBit);
 
+  /// out-of-line slow case for clearBits.
+  void clearBitsSlowCase(unsigned loBit, unsigned hiBit);
+
   /// out-of-line slow case for flipAllBits.
   void flipAllBitsSlowCase();
 
diff --git a/llvm/lib/Support/APInt.cpp b/llvm/lib/Support/APInt.cpp
index 4e45416b4598f..da7f223d48956 100644
--- a/llvm/lib/Support/APInt.cpp
+++ b/llvm/lib/Support/APInt.cpp
@@ -336,6 +336,33 @@ void APInt::setBitsSlowCase(unsigned loBit, unsigned hiBit) {
     U.pVal[word] = WORDTYPE_MAX;
 }
 
+void APInt::clearBitsSlowCase(unsigned loBit, unsigned hiBit) {
+  unsigned loWord = whichWord(loBit);
+  unsigned hiWord = whichWord(hiBit);
+
+  // Create an initial mask for the low word with ones below loBit.
+  uint64_t loMask = ~(WORDTYPE_MAX << whichBit(loBit));
+
+  // If hiBit is not aligned, we need a high mask.
+  unsigned hiShiftAmt = whichBit(hiBit);
+  if (hiShiftAmt != 0) {
+    // Create a high mask with ones above hiBit.
+    uint64_t hiMask = ~(WORDTYPE_MAX >> (APINT_BITS_PER_WORD - hiShiftAmt));
+    // If loWord and hiWord are equal, then we combine the masks. Otherwise,
+    // set the bits in hiWord.
+    if (hiWord == loWord)
+      loMask &= hiMask;
+    else
+      U.pVal[hiWord] &= hiMask;
+  }
+  // Apply the mask to the low word.
+  U.pVal[loWord] &= loMask;
+
+  // Fill any words between loWord and hiWord with all zeros.
+  for (unsigned word = loWord + 1; word < hiWord; ++word)
+    U.pVal[word] = 0;
+}
+
 // Complement a bignum in-place.
 static void tcComplement(APInt::WordType *dst, unsigned parts) {
   for (unsigned i = 0; i < parts; i++)
diff --git a/llvm/unittests/ADT/APIntTest.cpp b/llvm/unittests/ADT/APIntTest.cpp
index b14366eac2185..d4411dfe36cc9 100644
--- a/llvm/unittests/ADT/APIntTest.cpp
+++ b/llvm/unittests/ADT/APIntTest.cpp
@@ -2520,6 +2520,62 @@ TEST(APIntTest, setAllBits) {
   EXPECT_EQ(128u, i128.popcount());
 }
 
+TEST(APIntTest, clearBits) {
+  APInt i32 = APInt::getAllOnes(32);
+  i32.clearBits(1, 3);
+  EXPECT_EQ(1u, i32.countr_one());
+  EXPECT_EQ(0u, i32.countr_zero());
+  EXPECT_EQ(32u, i32.getActiveBits());
+  EXPECT_EQ(0u, i32.countl_zero());
+  EXPECT_EQ(29u, i32.countl_one());
+  EXPECT_EQ(30u, i32.popcount());
+
+  i32.clearBits(15, 15);
+  EXPECT_EQ(1u, i32.countr_one());
+  EXPECT_EQ(0u, i32.countr_zero());
+  EXPECT_EQ(32u, i32.getActiveBits());
+  EXPECT_EQ(0u, i32.countl_zero());
+  EXPECT_EQ(29u, i32.countl_one());
+  EXPECT_EQ(30u, i32.popcount());
+
+  i32.clearBits(28, 31);
+  EXPECT_EQ(1u, i32.countr_one());
+  EXPECT_EQ(0u, i32.countr_zero());
+  EXPECT_EQ(32u, i32.getActiveBits());
+  EXPECT_EQ(0u, i32.countl_zero());
+  EXPECT_EQ(1u, i32.countl_one());
+  EXPECT_EQ(27u, i32.popcount());
+  EXPECT_EQ(static_cast<uint64_t>((1 << 31) | ((~0u >> 4) & (~0u << 3)) | 1),
+            i32.getZExtValue());
+
+  APInt i256 = APInt::getAllOnes(256);
+  i256.clearBits(10, 250);
+  EXPECT_EQ(10u, i256.countr_one());
+  EXPECT_EQ(0u, i256.countr_zero());
+  EXPECT_EQ(256u, i256.getActiveBits());
+  EXPECT_EQ(0u, i256.countl_zero());
+  EXPECT_EQ(6u, i256.countl_one());
+  EXPECT_EQ(16u, i256.popcount());
+
+  APInt i64hi32 = APInt::getAllOnes(64);
+  i64hi32.clearBits(0, 32);
+  EXPECT_EQ(32u, i64hi32.countl_one());
+  EXPECT_EQ(0u, i64hi32.countl_zero());
+  EXPECT_EQ(64u, i64hi32.getActiveBits());
+  EXPECT_EQ(32u, i64hi32.countr_zero());
+  EXPECT_EQ(0u, i64hi32.countr_one());
+  EXPECT_EQ(32u, i64hi32.popcount());
+
+  i64hi32 = APInt::getAllOnes(64);
+  i64hi32.clearBits(32, 64);
+  EXPECT_EQ(32u, i64hi32.countr_one());
+  EXPECT_EQ(0u, i64hi32.countr_zero());
+  EXPECT_EQ(32u, i64hi32.getActiveBits());
+  EXPECT_EQ(32u, i64hi32.countl_zero());
+  EXPECT_EQ(0u, i64hi32.countl_one());
+  EXPECT_EQ(32u, i64hi32.popcount());
+}
+
 TEST(APIntTest, getLoBits) {
   APInt i32(32, 0xfa);
   i32.setHighBits(1);

llvmbot · 2025-04-24T00:37:51Z

@llvm/pr-subscribers-llvm-adt

Author: Liam Semeria (liamsemeria)

Changes

Added APInt::clearBits(unsigned loBit, unsigned hiBit) that clears bits within a certain range.
Issue here

Full diff: https://github.com/llvm/llvm-project/pull/137098.diff

3 Files Affected:

(modified) llvm/include/llvm/ADT/APInt.h (+23)
(modified) llvm/lib/Support/APInt.cpp (+27)
(modified) llvm/unittests/ADT/APIntTest.cpp (+56)

diff --git a/llvm/include/llvm/ADT/APInt.h b/llvm/include/llvm/ADT/APInt.h
index 02d58d8c3d31c..c724411261388 100644
--- a/llvm/include/llvm/ADT/APInt.h
+++ b/llvm/include/llvm/ADT/APInt.h
@@ -1413,6 +1413,26 @@ class [[nodiscard]] APInt {
       U.pVal[whichWord(BitPosition)] &= Mask;
   }
 
+  /// Clear the bits from loBit (inclusive) to hiBit (exclusive) to 0.
+  /// This function handles case when \p loBit <= \p hiBit.
+  void clearBits(unsigned loBit, unsigned hiBit) {
+    assert(hiBit <= BitWidth && "hiBit out of range");
+    assert(loBit <= BitWidth && "loBit out of range");
+    assert(loBit <= hiBit && "loBit greater than hiBit");
+    if (loBit == hiBit)
+      return;
+    if (loBit < APINT_BITS_PER_WORD && hiBit <= APINT_BITS_PER_WORD) {
+      uint64_t mask = WORDTYPE_MAX >> (APINT_BITS_PER_WORD - (hiBit - loBit));
+      mask = ~(mask << loBit);
+      if (isSingleWord())
+        U.VAL &= mask;
+      else
+        U.pVal[0] &= mask;
+    } else {
+      clearBitsSlowCase(loBit, hiBit);
+    }
+  }
+
   /// Set bottom loBits bits to 0.
   void clearLowBits(unsigned loBits) {
     assert(loBits <= BitWidth && "More bits than bitwidth");
@@ -2051,6 +2071,9 @@ class [[nodiscard]] APInt {
   /// out-of-line slow case for setBits.
   void setBitsSlowCase(unsigned loBit, unsigned hiBit);
 
+  /// out-of-line slow case for clearBits.
+  void clearBitsSlowCase(unsigned loBit, unsigned hiBit);
+
   /// out-of-line slow case for flipAllBits.
   void flipAllBitsSlowCase();
 
diff --git a/llvm/lib/Support/APInt.cpp b/llvm/lib/Support/APInt.cpp
index 4e45416b4598f..da7f223d48956 100644
--- a/llvm/lib/Support/APInt.cpp
+++ b/llvm/lib/Support/APInt.cpp
@@ -336,6 +336,33 @@ void APInt::setBitsSlowCase(unsigned loBit, unsigned hiBit) {
     U.pVal[word] = WORDTYPE_MAX;
 }
 
+void APInt::clearBitsSlowCase(unsigned loBit, unsigned hiBit) {
+  unsigned loWord = whichWord(loBit);
+  unsigned hiWord = whichWord(hiBit);
+
+  // Create an initial mask for the low word with ones below loBit.
+  uint64_t loMask = ~(WORDTYPE_MAX << whichBit(loBit));
+
+  // If hiBit is not aligned, we need a high mask.
+  unsigned hiShiftAmt = whichBit(hiBit);
+  if (hiShiftAmt != 0) {
+    // Create a high mask with ones above hiBit.
+    uint64_t hiMask = ~(WORDTYPE_MAX >> (APINT_BITS_PER_WORD - hiShiftAmt));
+    // If loWord and hiWord are equal, then we combine the masks. Otherwise,
+    // set the bits in hiWord.
+    if (hiWord == loWord)
+      loMask &= hiMask;
+    else
+      U.pVal[hiWord] &= hiMask;
+  }
+  // Apply the mask to the low word.
+  U.pVal[loWord] &= loMask;
+
+  // Fill any words between loWord and hiWord with all zeros.
+  for (unsigned word = loWord + 1; word < hiWord; ++word)
+    U.pVal[word] = 0;
+}
+
 // Complement a bignum in-place.
 static void tcComplement(APInt::WordType *dst, unsigned parts) {
   for (unsigned i = 0; i < parts; i++)
diff --git a/llvm/unittests/ADT/APIntTest.cpp b/llvm/unittests/ADT/APIntTest.cpp
index b14366eac2185..d4411dfe36cc9 100644
--- a/llvm/unittests/ADT/APIntTest.cpp
+++ b/llvm/unittests/ADT/APIntTest.cpp
@@ -2520,6 +2520,62 @@ TEST(APIntTest, setAllBits) {
   EXPECT_EQ(128u, i128.popcount());
 }
 
+TEST(APIntTest, clearBits) {
+  APInt i32 = APInt::getAllOnes(32);
+  i32.clearBits(1, 3);
+  EXPECT_EQ(1u, i32.countr_one());
+  EXPECT_EQ(0u, i32.countr_zero());
+  EXPECT_EQ(32u, i32.getActiveBits());
+  EXPECT_EQ(0u, i32.countl_zero());
+  EXPECT_EQ(29u, i32.countl_one());
+  EXPECT_EQ(30u, i32.popcount());
+
+  i32.clearBits(15, 15);
+  EXPECT_EQ(1u, i32.countr_one());
+  EXPECT_EQ(0u, i32.countr_zero());
+  EXPECT_EQ(32u, i32.getActiveBits());
+  EXPECT_EQ(0u, i32.countl_zero());
+  EXPECT_EQ(29u, i32.countl_one());
+  EXPECT_EQ(30u, i32.popcount());
+
+  i32.clearBits(28, 31);
+  EXPECT_EQ(1u, i32.countr_one());
+  EXPECT_EQ(0u, i32.countr_zero());
+  EXPECT_EQ(32u, i32.getActiveBits());
+  EXPECT_EQ(0u, i32.countl_zero());
+  EXPECT_EQ(1u, i32.countl_one());
+  EXPECT_EQ(27u, i32.popcount());
+  EXPECT_EQ(static_cast<uint64_t>((1 << 31) | ((~0u >> 4) & (~0u << 3)) | 1),
+            i32.getZExtValue());
+
+  APInt i256 = APInt::getAllOnes(256);
+  i256.clearBits(10, 250);
+  EXPECT_EQ(10u, i256.countr_one());
+  EXPECT_EQ(0u, i256.countr_zero());
+  EXPECT_EQ(256u, i256.getActiveBits());
+  EXPECT_EQ(0u, i256.countl_zero());
+  EXPECT_EQ(6u, i256.countl_one());
+  EXPECT_EQ(16u, i256.popcount());
+
+  APInt i64hi32 = APInt::getAllOnes(64);
+  i64hi32.clearBits(0, 32);
+  EXPECT_EQ(32u, i64hi32.countl_one());
+  EXPECT_EQ(0u, i64hi32.countl_zero());
+  EXPECT_EQ(64u, i64hi32.getActiveBits());
+  EXPECT_EQ(32u, i64hi32.countr_zero());
+  EXPECT_EQ(0u, i64hi32.countr_one());
+  EXPECT_EQ(32u, i64hi32.popcount());
+
+  i64hi32 = APInt::getAllOnes(64);
+  i64hi32.clearBits(32, 64);
+  EXPECT_EQ(32u, i64hi32.countr_one());
+  EXPECT_EQ(0u, i64hi32.countr_zero());
+  EXPECT_EQ(32u, i64hi32.getActiveBits());
+  EXPECT_EQ(32u, i64hi32.countl_zero());
+  EXPECT_EQ(0u, i64hi32.countl_one());
+  EXPECT_EQ(32u, i64hi32.popcount());
+}
+
 TEST(APIntTest, getLoBits) {
   APInt i32(32, 0xfa);
   i32.setHighBits(1);

RKSimon

Thank you!

Please can you search for "DemandedSrcElts.insertBits(APInt::getZero(NumSubElts), Idx);" and replace that INSERT_SUBVECTOR demanded elts handling with clearBits?

RKSimon · 2025-04-24T08:09:21Z

llvm/unittests/ADT/APIntTest.cpp

+  EXPECT_EQ(static_cast<uint64_t>((1 << 31) | ((~0u >> 4) & (~0u << 3)) | 1),
+            i32.getZExtValue());
+
+  APInt i256 = APInt::getAllOnes(256);


Please can you add an additional case of > 64 bits that isn't a multiple of 64 bits (e.g. APInt::getAllOnes(311))? This will test clearBitsSlowCase more thoroughly

Yeah I'll add that test case.

dan-german · 2025-04-24T08:13:19Z

llvm/unittests/ADT/APIntTest.cpp

@@ -2520,6 +2520,62 @@ TEST(APIntTest, setAllBits) {
  EXPECT_EQ(128u, i128.popcount());
 }

+TEST(APIntTest, clearBits) {


Tip: tests might be shorter and clearer with the string‑based APInt ctor:

APInt hi = APInt::getAllOnes(64); hi.clearBits(0, 32); EXPECT_EQ(APInt(64, "FFFFFFFF00000000", 16), hi);

thats very helpful thanks for the tip!

…ndling

RKSimon

LGTM - cheers!

jayfoad · 2025-04-25T13:21:37Z

llvm/include/llvm/ADT/APInt.h

+  /// This function handles case when \p loBit <= \p hiBit.
+  void clearBits(unsigned loBit, unsigned hiBit) {
+    assert(hiBit <= BitWidth && "hiBit out of range");
+    assert(loBit <= BitWidth && "loBit out of range");


Don't need this assert. It's implied by the other two.

jayfoad · 2025-04-25T13:22:30Z

llvm/include/llvm/ADT/APInt.h

+    assert(loBit <= hiBit && "loBit greater than hiBit");
+    if (loBit == hiBit)
+      return;
+    if (loBit < APINT_BITS_PER_WORD && hiBit <= APINT_BITS_PER_WORD) {


Simplify this to:

Suggested change

if (loBit < APINT_BITS_PER_WORD && hiBit <= APINT_BITS_PER_WORD) {

if (hiBit <= APINT_BITS_PER_WORD) {

llvm/include/llvm/ADT/APInt.h

jayfoad · 2025-04-25T13:24:23Z

llvm/include/llvm/ADT/APInt.h

@@ -1413,6 +1413,26 @@ class [[nodiscard]] APInt {
      U.pVal[whichWord(BitPosition)] &= Mask;
  }

+  /// Clear the bits from loBit (inclusive) to hiBit (exclusive) to 0.
+  /// This function handles case when \p loBit <= \p hiBit.
+  void clearBits(unsigned loBit, unsigned hiBit) {


Variable and parameter names should start with a capital letter. Same for mask below.

RKSimon · 2025-04-25T13:44:29Z

@jayfoad Its likely that APInt::setBits already suffers from the same issues as this is mainly a copy of that

liamsemeria · 2025-04-25T19:04:29Z

I wanted to keep it similar to setBits but I can make those changes to clearBits and setBits should I do that?

RKSimon · 2025-04-28T11:17:05Z

If you're willing, I'd recommend doing a separate cleanup PR to fix the setBits equivalent issues that @jayfoad identified first, then merge the changes (after they're accepted) into this clearBits patch - make sense?

liamsemeria · 2025-04-28T18:48:15Z

Yeah that makes sense. That would just be changes to setBits and not to the unit tests right?

…8038) During [pull request](#137098) it was suggested that I remove these redundant parts of APInt::SetBits.

…etBits (#138038) During [pull request](llvm/llvm-project#137098) it was suggested that I remove these redundant parts of APInt::SetBits.

RKSimon

Please update to match your APInt::setBits changes

RKSimon

Just need to fix the style issue of variables/parameters starting with capital letter

liamsemeria · 2025-05-14T19:01:14Z

thats an issue across the entire file. Do you want me to just do that for clearBits?

RKSimon · 2025-05-14T19:45:11Z

Yes, just any new code. Avoids excess churn.

RKSimon

A final couple of trivial minors - @jayfoad any more comments?

RKSimon · 2025-05-15T07:35:39Z

llvm/include/llvm/ADT/APInt.h

+  /// Clear the bits from loBit (inclusive) to hiBit (exclusive) to 0.
+  /// This function handles case when \p loBit <= \p hiBit.
+  void clearBits(unsigned LoBit, unsigned HiBit) {
+    assert(HiBit <= BitWidth && "hiBit out of range");


HiBit out of range

RKSimon · 2025-05-15T07:35:55Z

llvm/include/llvm/ADT/APInt.h

+  /// This function handles case when \p loBit <= \p hiBit.
+  void clearBits(unsigned LoBit, unsigned HiBit) {
+    assert(HiBit <= BitWidth && "hiBit out of range");
+    assert(LoBit <= HiBit && "loBit greater than hiBit");


LoBit greater than HiBit

RKSimon · 2025-05-15T07:36:15Z

llvm/include/llvm/ADT/APInt.h

@@ -2051,6 +2070,9 @@ class [[nodiscard]] APInt {
  /// out-of-line slow case for setBits.
  void setBitsSlowCase(unsigned loBit, unsigned hiBit);

+  /// out-of-line slow case for clearBits.
+  void clearBitsSlowCase(unsigned loBit, unsigned hiBit);


LoBit + HiBit

jayfoad · 2025-05-15T08:34:38Z

llvm/include/llvm/ADT/APInt.h

+  /// Clear the bits from loBit (inclusive) to hiBit (exclusive) to 0.
+  /// This function handles case when \p loBit <= \p hiBit.


Fix argument names in this comment.

RKSimon

LGTM

jayfoad

LGTM

github-actions · 2025-05-19T11:41:26Z

@liamsemeria Congratulations on having your first Pull Request (PR) merged into the LLVM Project!

Your changes will be combined with recent changes from other authors, then tested by our build bots. If there is a problem with a build, you may receive a report in an email or a comment on this PR.

Please check whether problems have been caused by your change specifically, as the builds can include changes from many authors. It is not uncommon for your change to be included in a build that fails due to someone else's changes, or infrastructure issues.

How to do this, and the rest of the post-merge process, is covered in detail here.

If your change does cause a problem, it may be reverted, or you can revert it yourself. This is a normal part of LLVM development. You can fix your changes and open a new PR to merge them again.

If you don't get any reports, no action is required from you. Your changes are working as expected, well done!

RKSimon · 2025-05-22T17:02:16Z

llvm/lib/Support/APInt.cpp

+    // If LoWord and HiWord are equal, then we combine the masks. Otherwise,
+    // set the bits in HiWord.
+    if (HiWord == LoWord)
+      LoMask &= HiMask;


@liamsemeria should this be LoMask |= HiMask? Noticed when triaging #141098

Additional unit test (clear bits in same word) that fails without the fix:

APInt i299 = APInt::getAllOnes(299); i299.clearBits(240, 250); EXPECT_EQ(240u, i299.countr_one()); EXPECT_EQ(0u, i299.countr_zero()); EXPECT_EQ(299u, i299.getActiveBits()); EXPECT_EQ(0u, i299.countl_zero()); EXPECT_EQ(49u, i299.countl_one()); EXPECT_EQ(289u, i299.popcount());

I agree it should be LoMask |= HiMask. I've confirmed it fixes the failure on qemu.

I'll clean up my tests and put up a PR

Added APInt::clearBits(unsigned loBit, unsigned hiBit) that clears bits within a certain range. Fixes llvm#136550 --------- Co-authored-by: Simon Pilgrim <[email protected]>

[APInt] Added APInt::clearBits() method issue llvm#136550

a17519a

llvmbot added llvm:support llvm:adt labels Apr 24, 2025

liamsemeria mentioned this pull request Apr 24, 2025

[APInt] Add APInt::clearBits() method #136550

Closed

RKSimon self-requested a review April 24, 2025 08:06

RKSimon reviewed Apr 24, 2025

View reviewed changes

RKSimon changed the title ~~[APInt] Added APInt::clearBits() method issue #136550~~ [APInt] Added APInt::clearBits() method Apr 24, 2025

dan-german reviewed Apr 24, 2025

View reviewed changes

liamsemeria added 2 commits April 24, 2025 16:52

updated AP::IntCLearBits test

bbf8c16

replaced APInt::insertBits with APInt::clearBits for demanded elts ha…

6700a18

…ndling

llvmbot added the llvm:SelectionDAG SelectionDAGISel as well label Apr 25, 2025

RKSimon approved these changes Apr 25, 2025

View reviewed changes

jayfoad reviewed Apr 25, 2025

View reviewed changes

llvm/include/llvm/ADT/APInt.h Outdated Show resolved Hide resolved

jayfoad reviewed Apr 25, 2025

View reviewed changes

liamsemeria mentioned this pull request Apr 30, 2025

Removed redundant assert and condition in APInt::SetBits #138038

Merged

RKSimon pushed a commit that referenced this pull request May 12, 2025

[APInt] Removed redundant assert and condition in APInt::SetBits (#13…

3ffde4a

…8038) During [pull request](#137098) it was suggested that I remove these redundant parts of APInt::SetBits.

RKSimon requested changes May 12, 2025

View reviewed changes

APInt::clearBits updated to match APInt::setBits changes

e85f09c

RKSimon reviewed May 14, 2025

View reviewed changes

changed capitalization for APInt::clearbits

2d8fa9d

RKSimon reviewed May 15, 2025

View reviewed changes

jayfoad reviewed May 15, 2025

View reviewed changes

changed more capitalization

cfbf324

RKSimon approved these changes May 19, 2025

View reviewed changes

jayfoad approved these changes May 19, 2025

View reviewed changes

Merge branch 'main' into main

28cb871

RKSimon merged commit d067014 into llvm:main May 19, 2025
11 checks passed

RKSimon reviewed May 22, 2025

View reviewed changes

liamsemeria deleted the main branch June 7, 2025 15:50

	if (loBit < APINT_BITS_PER_WORD && hiBit <= APINT_BITS_PER_WORD) {
	if (hiBit <= APINT_BITS_PER_WORD) {

		/// Clear the bits from loBit (inclusive) to hiBit (exclusive) to 0.
		/// This function handles case when \p loBit <= \p hiBit.

[APInt] Added APInt::clearBits() method #137098

[APInt] Added APInt::clearBits() method #137098

Uh oh!

Conversation

liamsemeria commented Apr 24, 2025 • edited by RKSimon Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

github-actions bot commented Apr 24, 2025

Uh oh!

llvmbot commented Apr 24, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

llvmbot commented Apr 24, 2025

Uh oh!

RKSimon left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

liamsemeria Apr 24, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

RKSimon left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

RKSimon commented Apr 25, 2025

Uh oh!

liamsemeria commented Apr 25, 2025

Uh oh!

RKSimon commented Apr 28, 2025

Uh oh!

liamsemeria commented Apr 28, 2025

Uh oh!

RKSimon left a comment

Choose a reason for hiding this comment

Uh oh!

RKSimon left a comment

Choose a reason for hiding this comment

Uh oh!

liamsemeria commented May 14, 2025

Uh oh!

RKSimon commented May 14, 2025

Uh oh!

RKSimon left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

RKSimon left a comment

Choose a reason for hiding this comment

Uh oh!

jayfoad left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

github-actions bot commented May 19, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

topperc May 22, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

liamsemeria commented Apr 24, 2025 •

edited by RKSimon

Loading

llvmbot commented Apr 24, 2025 •

edited

Loading

liamsemeria Apr 24, 2025 •

edited

Loading

topperc May 22, 2025 •

edited

Loading