Remove the is_nested bit from the BlockInfo structure.

syzygy/agent/asan/heaps/zebra_block_heap_unittest.cc

 // Copyright 2014 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 78 matching lines @@
 TEST(ZebraBlockHeapTest, AllocateEmptyBlock) {
   TestZebraBlockHeap h;
   BlockLayout layout = {};
   BlockInfo block = {};
 
   // Allocate and free a zero-sized allocation. This should succeed
   // by definition.
   void* alloc = h.AllocateBlock(0, 0, 0, &layout);
   EXPECT_NE(reinterpret_cast<void*>(NULL), alloc);
   EXPECT_TRUE(IsAligned(alloc, kShadowRatio));
-  BlockInitialize(layout, alloc, false, &block);
+  BlockInitialize(layout, alloc, &block);
   EXPECT_TRUE(h.FreeBlock(block));
 }
 
 TEST(ZebraBlockHeapTest, EndToEnd) {
   TestZebraBlockHeap h;
   BlockLayout layout = {};
   BlockInfo block = {};
 
   // Make a bunch of different sized allocations.
   std::vector<BlockInfo> blocks;
   for (uint32_t i = 1; i < 100; i++) {
     void* alloc = h.AllocateBlock(i, 0, 0, &layout);
     EXPECT_NE(reinterpret_cast<void*>(NULL), alloc);
     EXPECT_TRUE(IsAligned(alloc, kShadowRatio));
-    BlockInitialize(layout, alloc, false, &block);
+    BlockInitialize(layout, alloc, &block);
     blocks.push_back(block);
   }
 
   // Now free them.
   for (size_t i = 0; i < blocks.size(); ++i)
     EXPECT_TRUE(h.FreeBlock(blocks[i]));
 }
 
 TEST(ZebraBlockHeapTest, BlocksHaveCorrectAlignment) {
   TestZebraBlockHeap h;
   BlockLayout layout = {};
   BlockInfo block = {};
 
   // Allocate blocks with different header, body and trailer sizes .
   for (uint32_t header_size = 0; header_size < 100; header_size += 3) {
     for (uint32_t trailer_size = 0; trailer_size < 100; trailer_size += 3) {
       for (uint32_t body_size = 0; body_size < 100; body_size += 3) {
         void* alloc = h.AllocateBlock(body_size, header_size,
                                       trailer_size, &layout);
 
         EXPECT_NE(reinterpret_cast<void*>(NULL), alloc);
         EXPECT_TRUE(IsAligned(alloc, kShadowRatio));
 
-        BlockInitialize(layout, alloc, false, &block);
+        BlockInitialize(layout, alloc, &block);
 
         // The header (== block), body and the end of the trailer must be
         // kShadowRatio aligned.
         EXPECT_TRUE(IsAligned(block.body, kShadowRatio));
         EXPECT_TRUE(IsAligned(block.header, kShadowRatio));
         EXPECT_TRUE(IsAligned(block.header, GetPageSize()));
         EXPECT_TRUE(IsAligned(block.trailer + 1, GetPageSize()));
 
         uint32_t right_redzone_size = block.TotalTrailerSize();
 
@@ skipping 38 matching lines @@
 
   const uint32_t kMaxAllowedBlockSize = static_cast<uint32_t>(GetPageSize()) -
       sizeof(BlockHeader);
 
   // Allocate all possible block sizes.
   for (uint32_t i = 0; i <= kMaxAllowedBlockSize; ++i) {
     uint8_t* alloc = reinterpret_cast<uint8_t*>(
         h.AllocateBlock(i, sizeof(BlockHeader), sizeof(BlockTrailer), &layout));
 
     EXPECT_NE(reinterpret_cast<void*>(NULL), alloc);
-    BlockInitialize(layout, alloc, false, &block);
+    BlockInitialize(layout, alloc, &block);
     EXPECT_TRUE(h.FreeBlock(block));
   }
 
   // Impossible block sizes.
   for (uint32_t delta = 1; delta < 10000; delta += 7)
     EXPECT_EQ(reinterpret_cast<uint8_t*>(NULL),
               h.AllocateBlock(kMaxAllowedBlockSize + delta, sizeof(BlockHeader),
                               sizeof(BlockTrailer), &layout));
 }
 
@@ skipping 10 matching lines @@
   EXPECT_TRUE(IsAligned(mem1, kShadowRatio));
 
   void* mem2 = h.AllocateBlock(0, sizeof(BlockHeader), sizeof(BlockTrailer),
       &layout2);
   EXPECT_NE(reinterpret_cast<void*>(NULL), mem2);
   EXPECT_TRUE(IsAligned(mem2, kShadowRatio));
 
   // Empty blocks cannot have the same address.
   EXPECT_NE(mem1, mem2);
 
-  BlockInitialize(layout1, mem1, false, &block1);
-  BlockInitialize(layout2, mem2, false, &block2);
+  BlockInitialize(layout1, mem1, &block1);
+  BlockInitialize(layout2, mem2, &block2);
 
   EXPECT_TRUE(h.FreeBlock(block1));
   EXPECT_TRUE(h.FreeBlock(block2));
 }
 
 
 TEST(ZebraBlockHeapTest, AllocateUntilFull) {
   TestZebraBlockHeap h;
   // Test maximum number of allocations.
   std::vector<uint8_t*> buffers;
@@ skipping 118 matching lines @@
         if (alloc != NULL) {
           // Check that the block is well formed.
           EXPECT_TRUE(header_size + body_size <= GetPageSize());
           EXPECT_TRUE(trailer_size <= GetPageSize());
 
           size_t body_end_offset = layout.header_size +
               layout.header_padding_size + layout.body_size;
 
           EXPECT_EQ(GetPageSize(),
                     ::common::AlignUp(body_end_offset, kShadowRatio));
-          BlockInitialize(layout, alloc, false, &block);
+          BlockInitialize(layout, alloc, &block);
           EXPECT_TRUE(h.FreeBlock(block));
         } else {
           size_t body_end_offset = layout.header_size +
               layout.header_padding_size + layout.body_size;
 
           // Check the cause of the unsuccessful allocation.
           EXPECT_TRUE(
               // Even page overflow.
               (header_size + body_size > GetPageSize()) ||
               // Odd page overflow.
@@ skipping 33 matching lines @@
   TestZebraBlockHeap h;
   BlockLayout layout = {};
   BlockInfo block = {};
 
   // Fill the heap.
   std::vector<BlockInfo> blocks;
   for (size_t i = 0; i < h.slab_count_; i++) {
     void* alloc = h.AllocateBlock(0xFF, 0, 0, &layout);
     EXPECT_NE(reinterpret_cast<void*>(NULL), alloc);
     EXPECT_TRUE(IsAligned(alloc, kShadowRatio));
-    BlockInitialize(layout, alloc, false, &block);
+    BlockInitialize(layout, alloc, &block);
     blocks.push_back(block);
     CompactBlockInfo compact = {};
     ConvertBlockInfo(block, &compact);
     EXPECT_TRUE(h.Push(compact).push_successful);
   }
 
   for (size_t i = 0; i < h.slab_count_; i++) {
     CompactBlockInfo dummy = {};
     bool old_invariant = h.QuarantineInvariantIsSatisfied();
     if (h.Pop(&dummy).pop_successful) {
@@ skipping 36 matching lines @@
 
   h.Lock();
   EXPECT_TRUE(h.TryLock());
   h.Unlock();
   h.Unlock();
 }
 
 }  // namespace heaps
 }  // namespace asan
 }  // namespace agent