fixup: Clean up uses of UINT32_MAX and INT32_MAX

Use ~0u for the end-of-range sigil, and numeric_limits for math involving the
limits of uint32_t and int32_t.

Author: bogner

llvm/include/llvm/Frontend/HLSL/HLSLBinding.h

@@ -37,8 +37,8 @@ namespace hlsl {
 /// UAVSpaces {
 ///   ResClass = ResourceClass::UAV,
 ///   Spaces = {
-///     { Space = 0, FreeRanges = {{ 0, 2 }, { 13, UINT32_MAX }} },
-///     { Space = 2, FreeRanges = {{ 0, 4 }} }
+///     { Space = 0u, FreeRanges = {{ 0u, 2u }, { 13u, ~0u }} },
+///     { Space = 2u, FreeRanges = {{ 0u, 4u }} }
 ///   }
 /// }
 class BindingInfo {
@@ -53,7 +53,7 @@ class BindingInfo {
     uint32_t Space;
     SmallVector<BindingRange> FreeRanges;
     RegisterSpace(uint32_t Space) : Space(Space) {
-      FreeRanges.emplace_back(0, UINT32_MAX);
+      FreeRanges.emplace_back(0, ~0u);
     }
     // Size == -1 means unbounded array
     LLVM_ABI std::optional<uint32_t> findAvailableBinding(int32_t Size);

llvm/lib/Frontend/HLSL/HLSLBinding.cpp

@@ -42,7 +42,7 @@ BindingInfo::RegisterSpace::findAvailableBinding(int32_t Size) {
   // unbounded array
   if (Size == -1) {
     BindingRange &Last = FreeRanges.back();
-    if (Last.UpperBound != UINT32_MAX)
+    if (Last.UpperBound != ~0u)
       // this space is already occupied by an unbounded array
       return std::nullopt;
     uint32_t RegSlot = Last.LowerBound;
@@ -52,8 +52,7 @@ BindingInfo::RegisterSpace::findAvailableBinding(int32_t Size) {
 
   // single resource or fixed-size array
   for (BindingRange &R : FreeRanges) {
-    // compare the size as uint64_t to prevent overflow for range (0,
-    // UINT32_MAX)
+    // compare the size as uint64_t to prevent overflow for range (0, ~0u)
     if ((uint64_t)R.UpperBound - R.LowerBound + 1 < (uint64_t)Size)
       continue;
     uint32_t RegSlot = R.LowerBound;
@@ -102,24 +101,24 @@ BindingInfo BindingInfoBuilder::calculateBindingInfo(
     // The space is full - there are no free slots left, or the rest of the
     // slots are taken by an unbounded array. Set flag to report overlapping
     // binding later.
-    if (S->FreeRanges.empty() || S->FreeRanges.back().UpperBound < UINT32_MAX) {
+    if (S->FreeRanges.empty() || S->FreeRanges.back().UpperBound < ~0u) {
       ReportOverlap(*this, B);
       continue;
     }
     // adjust the last free range lower bound, split it in two, or remove it
     BindingInfo::BindingRange &LastFreeRange = S->FreeRanges.back();
     if (LastFreeRange.LowerBound == B.LowerBound) {
-      if (B.UpperBound < UINT32_MAX)
+      if (B.UpperBound < ~0u)
         LastFreeRange.LowerBound = B.UpperBound + 1;
       else
         S->FreeRanges.pop_back();
     } else if (LastFreeRange.LowerBound < B.LowerBound) {
       LastFreeRange.UpperBound = B.LowerBound - 1;
-      if (B.UpperBound < UINT32_MAX)
-        S->FreeRanges.emplace_back(B.UpperBound + 1, UINT32_MAX);
+      if (B.UpperBound < ~0u)
+        S->FreeRanges.emplace_back(B.UpperBound + 1, ~0u);
     } else {
       ReportOverlap(*this, B);
-      if (B.UpperBound < UINT32_MAX)
+      if (B.UpperBound < ~0u)
         LastFreeRange.LowerBound =
             std::max(LastFreeRange.LowerBound, B.UpperBound + 1);
       else

llvm/unittests/Frontend/HLSLBindingTest.cpp

@@ -49,7 +49,7 @@ TEST(HLSLBindingTest, TestTrivialCase) {
   EXPECT_EQ(UAVSpaces.RC, ResourceClass::UAV);
   EXPECT_EQ(UAVSpaces.Spaces.size(), 1u);
   checkExpectedSpaceAndFreeRanges(UAVSpaces.Spaces[0], 0,
-                                  {0, 4, 6, UINT32_MAX});
+                                  {0u, 4u, 6u, ~0u});
 
   // check that other kinds of register spaces are all available
   for (auto RC :
@@ -97,31 +97,30 @@ TEST(HLSLBindingTest, TestManyBindings) {
   EXPECT_EQ(SRVSpaces.RC, ResourceClass::SRV);
   EXPECT_EQ(SRVSpaces.Spaces.size(), 1u);
   // verify that consecutive bindings are merged
-  // (SRVSpaces has only one free space range {6, UINT32_MAX}).
-  checkExpectedSpaceAndFreeRanges(SRVSpaces.Spaces[0], 0, {6, UINT32_MAX});
+  // (SRVSpaces has only one free space range {6, ~0u}).
+  checkExpectedSpaceAndFreeRanges(SRVSpaces.Spaces[0], 0, {6u, ~0u});
 
   hlsl::BindingInfo::BindingSpaces &UAVSpaces =
       Info.getBindingSpaces(ResourceClass::UAV);
   EXPECT_EQ(UAVSpaces.RC, ResourceClass::UAV);
   EXPECT_EQ(UAVSpaces.Spaces.size(), 2u);
   checkExpectedSpaceAndFreeRanges(UAVSpaces.Spaces[0], 0,
-                                  {0, 1, 4, 4, 6, UINT32_MAX});
-  checkExpectedSpaceAndFreeRanges(UAVSpaces.Spaces[1], 20,
-                                  {0, 9, 15, UINT32_MAX});
+                                  {0u, 1u, 4u, 4u, 6u, ~0u});
+  checkExpectedSpaceAndFreeRanges(UAVSpaces.Spaces[1], 20, {0u, 9u, 15u, ~0u});
 
   hlsl::BindingInfo::BindingSpaces &CBufferSpaces =
       Info.getBindingSpaces(ResourceClass::CBuffer);
   EXPECT_EQ(CBufferSpaces.RC, ResourceClass::CBuffer);
   EXPECT_EQ(CBufferSpaces.Spaces.size(), 1u);
   checkExpectedSpaceAndFreeRanges(CBufferSpaces.Spaces[0], 0,
-                                  {0, 2, 4, UINT32_MAX});
+                                  {0u, 2u, 4u, ~0u});
 
   hlsl::BindingInfo::BindingSpaces &SamplerSpaces =
       Info.getBindingSpaces(ResourceClass::Sampler);
   EXPECT_EQ(SamplerSpaces.RC, ResourceClass::Sampler);
   EXPECT_EQ(SamplerSpaces.Spaces.size(), 1u);
   checkExpectedSpaceAndFreeRanges(SamplerSpaces.Spaces[0], 2,
-                                  {0, 3, 6, UINT32_MAX});
+                                  {0u, 3u, 6u, ~0u});
 }
 
 TEST(HLSLBindingTest, TestUnboundedAndOverlap) {
@@ -175,8 +174,7 @@ TEST(HLSLBindingTest, TestExactOverlap) {
       Info.getBindingSpaces(ResourceClass::SRV);
   EXPECT_EQ(SRVSpaces.RC, ResourceClass::SRV);
   EXPECT_EQ(SRVSpaces.Spaces.size(), 1u);
-  checkExpectedSpaceAndFreeRanges(SRVSpaces.Spaces[0], 0,
-                                  {0, 4, 6, UINT32_MAX});
+  checkExpectedSpaceAndFreeRanges(SRVSpaces.Spaces[0], 0, {0u, 4u, 6u, ~0u});
 }
 
 TEST(HLSLBindingTest, TestEndOfRange) {
@@ -203,14 +201,17 @@ TEST(HLSLBindingTest, TestEndOfRange) {
       Info.getBindingSpaces(ResourceClass::UAV);
   EXPECT_EQ(UAVSpaces.RC, ResourceClass::UAV);
   EXPECT_EQ(UAVSpaces.Spaces.size(), 3u);
-  checkExpectedSpaceAndFreeRanges(UAVSpaces.Spaces[0], 0, {0, UINT32_MAX - 1});
-  checkExpectedSpaceAndFreeRanges(UAVSpaces.Spaces[1], 1, {0, UINT32_MAX - 10});
+  checkExpectedSpaceAndFreeRanges(
+      UAVSpaces.Spaces[0], 0, {0, std::numeric_limits<uint32_t>::max() - 1});
+  checkExpectedSpaceAndFreeRanges(
+      UAVSpaces.Spaces[1], 1, {0, std::numeric_limits<uint32_t>::max() - 10});
   checkExpectedSpaceAndFreeRanges(
       UAVSpaces.Spaces[2], 2,
-      {0, (uint32_t)INT32_MAX - 1, (uint32_t)INT32_MAX + 10, UINT32_MAX});
+      {0, static_cast<uint32_t>(std::numeric_limits<int32_t>::max()) - 1u,
+       static_cast<uint32_t>(std::numeric_limits<int32_t>::max()) + 10u,
+       std::numeric_limits<uint32_t>::max()});
 }
 
-
 TEST(HLSLBindingTest, TestFindAvailable) {
   hlsl::BindingInfoBuilder Builder;