[NFC][libc] Add Block::PREV_FIELD_SIZE for use in tests

Author: mysterymath

libc/src/__support/block.h

@@ -358,6 +358,10 @@ class Block {
   ///   previous block is free.
   /// * If the `last` flag is set, the block is the sentinel last block. It is
   ///   summarily considered used and has no next block.
+
+public:
+  /// Only for testing.
+  static constexpr size_t PREV_FIELD_SIZE = sizeof(prev_);
 };
 
 static_assert(alignof(max_align_t) >= 4,

libc/test/src/__support/block_test.cpp

@@ -43,7 +43,7 @@ TEST(LlvmLibcBlockTest, CanCreateSingleAlignedBlock) {
       reinterpret_cast<uintptr_t>(last) - reinterpret_cast<uintptr_t>(block);
   EXPECT_EQ(block->outer_size(), block_outer_size);
   EXPECT_EQ(block->inner_size(),
-            block_outer_size - sizeof(Block) + sizeof(size_t));
+            block_outer_size - sizeof(Block) + Block::PREV_FIELD_SIZE);
   EXPECT_EQ(block->prev_free(), static_cast<Block *>(nullptr));
   EXPECT_FALSE(block->used());
 }
@@ -75,9 +75,8 @@ TEST(LlvmLibcBlockTest, CannotCreateTooSmallBlock) {
 
 TEST(LlvmLibcBlockTest, CanSplitBlock) {
   constexpr size_t kN = 1024;
-  constexpr size_t prev_field_size = sizeof(size_t);
   // Give the split position a large alignment.
-  constexpr size_t kSplitN = 512 + prev_field_size;
+  constexpr size_t kSplitN = 512 + Block::PREV_FIELD_SIZE;
 
   array<byte, kN> bytes;
   auto result = Block::init(bytes);
@@ -90,7 +89,8 @@ TEST(LlvmLibcBlockTest, CanSplitBlock) {
   auto *block2 = *result;
 
   EXPECT_EQ(block1->inner_size(), kSplitN);
-  EXPECT_EQ(block1->outer_size(), kSplitN - prev_field_size + sizeof(Block));
+  EXPECT_EQ(block1->outer_size(),
+            kSplitN - Block::PREV_FIELD_SIZE + sizeof(Block));
 
   EXPECT_EQ(block2->outer_size(), orig_size - block1->outer_size());
   EXPECT_FALSE(block2->used());
@@ -223,7 +223,7 @@ TEST(LlvmLibcBlockTest, CanMakeMinimalSizeSecondBlock) {
   result = block1->split(Block::prev_possible_block_start(
                              reinterpret_cast<uintptr_t>(block1->next())) -
                          reinterpret_cast<uintptr_t>(block1->usable_space()) +
-                         sizeof(size_t));
+                         Block::PREV_FIELD_SIZE);
   ASSERT_TRUE(result.has_value());
   EXPECT_LE((*result)->outer_size(), sizeof(Block) + alignof(max_align_t));
 }
@@ -387,8 +387,7 @@ TEST(LlvmLibcBlockTest, AllocateAlreadyAligned) {
   Block *block = *result;
   uintptr_t orig_end = reinterpret_cast<uintptr_t>(block) + block->outer_size();
 
-  // Request a size one byte more than the prev_ field.
-  constexpr size_t SIZE = sizeof(size_t) + 1;
+  constexpr size_t SIZE = Block::PREV_FIELD_SIZE + 1;
 
   auto [aligned_block, prev, next] =
       Block::allocate(block, alignof(max_align_t), SIZE);

libc/test/src/__support/freestore_test.cpp

@@ -24,7 +24,7 @@ TEST(LlvmLibcFreeStore, TooSmall) {
   optional<Block *> maybeBlock = Block::init(mem);
   ASSERT_TRUE(maybeBlock.has_value());
   Block *too_small = *maybeBlock;
-  maybeBlock = too_small->split(sizeof(size_t));
+  maybeBlock = too_small->split(Block::PREV_FIELD_SIZE);
   ASSERT_TRUE(maybeBlock.has_value());
   Block *remainder = *maybeBlock;
 
@@ -43,12 +43,12 @@ TEST(LlvmLibcFreeStore, RemoveBestFit) {
   ASSERT_TRUE(maybeBlock.has_value());
 
   Block *smallest = *maybeBlock;
-  maybeBlock = smallest->split(sizeof(FreeList::Node) + sizeof(size_t));
+  maybeBlock = smallest->split(sizeof(FreeList::Node) + Block::PREV_FIELD_SIZE);
   ASSERT_TRUE(maybeBlock.has_value());
 
   Block *largest_small = *maybeBlock;
-  maybeBlock = largest_small->split(sizeof(FreeTrie::Node) + sizeof(size_t) -
-                                    alignof(max_align_t));
+  maybeBlock = largest_small->split(
+      sizeof(FreeTrie::Node) + Block::PREV_FIELD_SIZE - alignof(max_align_t));
   ASSERT_TRUE(maybeBlock.has_value());
   if (largest_small->inner_size() == smallest->inner_size())
     largest_small = smallest;
@@ -86,7 +86,7 @@ TEST(LlvmLibcFreeStore, Remove) {
   ASSERT_TRUE(maybeBlock.has_value());
 
   Block *small = *maybeBlock;
-  maybeBlock = small->split(sizeof(FreeList::Node) + sizeof(size_t));
+  maybeBlock = small->split(sizeof(FreeList::Node) + Block::PREV_FIELD_SIZE);
   ASSERT_TRUE(maybeBlock.has_value());
 
   Block *remainder = *maybeBlock;