Use size_t since this is the type stored anyway

Author: Thomas Kiley

src/ansi-c/ansi_c_internal_additions.cpp

@@ -122,7 +122,6 @@ static std::string architecture_string(T value, const char *s)
          std::string(s) + "=" + std::to_string(value) + ";\n";
 }
 
-using max_alloc_sizet = uint64_t;
 /// The maximum allocation size is determined by the number of bits that
 /// are left in the pointer of width \p pointer_width.
 ///
@@ -131,7 +130,7 @@ using max_alloc_sizet = uint64_t;
 /// \param pointer_width: The width of the pointer
 /// \param object_bits : The number of bits used to represent the ID
 /// \return The size in bytes of the maximum allocation supported.
-static max_alloc_sizet
+static size_t
 max_malloc_size(std::size_t pointer_width, std::size_t object_bits)
 {
   PRECONDITION(pointer_width >= 1);
@@ -142,9 +141,8 @@ max_malloc_size(std::size_t pointer_width, std::size_t object_bits)
   // but also down to -allocation_size + 1, therefore the size is allowable
   // is number of bits, less the signed bit.
   const auto bits_for_positive_offset = offset_bits - 1;
-  PRECONDITION(
-    bits_for_positive_offset < std::numeric_limits<max_alloc_sizet>::digits);
-  return ((max_alloc_sizet)1) << (max_alloc_sizet)bits_for_positive_offset;
+  PRECONDITION(bits_for_positive_offset < std::numeric_limits<size_t>::digits);
+  return ((size_t)1) << (size_t)bits_for_positive_offset;
 }
 
 void ansi_c_internal_additions(std::string &code)

unit/ansi-c/max_malloc_size.cpp

@@ -33,15 +33,32 @@ TEST_CASE(
     REQUIRE_THROWS_AS(max_malloc_size(0, 0), invariant_failedt);
   }
 
-  SECTION("Max allocation size overflow")
-  {
-    REQUIRE_THROWS_AS(max_malloc_size(128, 63), invariant_failedt);
-  }
-
   SECTION("Valid allocation size configurations")
   {
     // Here we use 4 bits for the object ID, leaving 3 for the offset
     REQUIRE(max_malloc_size(8, 4) == 8);
-    REQUIRE(max_malloc_size(128, 64) == 9223372036854775808ull /*2^63*/);
+  }
+  if(std::numeric_limits<size_t>::digits == 64)
+  {
+    SECTION("Overflow edge cases")
+    {
+      REQUIRE_THROWS_AS(max_malloc_size(128, 63), invariant_failedt);
+      REQUIRE(max_malloc_size(128, 64) == 9223372036854775808ull /*2^63*/);
+    }
+  }
+  else if(std::numeric_limits<size_t>::digits == 32)
+  {
+    SECTION("Overflow edge cases")
+    {
+      REQUIRE_THROWS_AS(max_malloc_size(64, 31), invariant_failedt);
+      REQUIRE(max_malloc_size(64, 32) == 2147483648ull /*2^31*/);
+    }
+  }
+  else
+  {
+    INFO(
+      "Unit test not supported on platform with "
+      << std::numeric_limits<size_t>::digits << " digits");
+    REQUIRE(false);
   }
 }