Remove the is_nested bit from the BlockInfo structure.

syzygy/agent/asan/page_protection_helpers_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 158 matching lines @@
                                     uint32_t min_right_redzone_size) {
     // Create and initialize the given block.
     BlockLayout layout = {};
     EXPECT_TRUE(BlockPlanLayout(chunk_size, alignment, size,
                                 min_left_redzone_size, min_right_redzone_size,
                                 &layout));
     void* alloc =
         ::VirtualAlloc(NULL, layout.block_size, MEM_COMMIT, PAGE_READWRITE);
     ASSERT_TRUE(alloc != NULL);
     BlockInfo block_info = {};
-    BlockInitialize(layout, alloc, false, &block_info);
+    BlockInitialize(layout, alloc, &block_info);
 
     // By default the protections should be disabled for a fresh allocation.
     EXPECT_NO_FATAL_FAILURE(
         TestAccessUnderProtection(block_info, kProtectNone));
 
     // Try a full cycle of page protections. This tests all possible
     // transitions, including self transitions.
     EXPECT_NO_FATAL_FAILURE(TestProtectNone(block_info));
     EXPECT_NO_FATAL_FAILURE(TestProtectNone(block_info));
     EXPECT_NO_FATAL_FAILURE(TestProtectRedzones(block_info));
@@ skipping 20 matching lines @@
   BlockLayout layout = {};
   BlockPlanLayout(4096, 4096, 4096, 4096, 4096, &layout);
 
   void* alloc = ::VirtualAlloc(
       nullptr, layout.block_size, MEM_COMMIT, PAGE_READWRITE);
   ASSERT_TRUE(alloc != nullptr);
   ::memset(alloc, 0, layout.block_size);
 
   // Initialize the block in both memory and the shadow memory.
   BlockInfo info = {};
-  BlockInitialize(layout, alloc, false, &info);
+  BlockInitialize(layout, alloc, &info);
   shadow_.PoisonAllocatedBlock(info);
 
   // Try recovering in the usual case.
   BlockInfo info_recovered = {};
   EXPECT_TRUE(BlockInfoFromMemory(info.header, &info_recovered));
   EXPECT_TRUE(GetBlockInfo(&shadow_, info.body, &info_recovered));
   EXPECT_EQ(0, ::memcmp(&info, &info_recovered, sizeof(info)));
 
   // Muck up the header and try again.
   info.header->magic++;
@@ skipping 41 matching lines @@
 TEST_F(PageProtectionHelpersTest, BlockProtectAuto) {
   BlockLayout layout = {};
   const uint32_t kPageSize = static_cast<uint32_t>(GetPageSize());
   EXPECT_TRUE(BlockPlanLayout(kPageSize, kPageSize, kPageSize, kPageSize,
                               kPageSize, &layout));
   void* alloc = ::VirtualAlloc(NULL, layout.block_size, MEM_COMMIT,
                                PAGE_READWRITE);
   ASSERT_TRUE(alloc != NULL);
 
   BlockInfo block_info = {};
-  BlockInitialize(layout, alloc, false, &block_info);
+  BlockInitialize(layout, alloc, &block_info);
   TestAccessUnderProtection(block_info, kProtectNone);
 
   block_info.header->state = ALLOCATED_BLOCK;
   BlockProtectAuto(block_info, &shadow_);
   TestAccessUnderProtection(block_info, kProtectRedzones);
   BlockProtectNone(block_info, &shadow_);
 
   block_info.header->state = QUARANTINED_BLOCK;
   BlockProtectAuto(block_info, &shadow_);
   TestAccessUnderProtection(block_info, kProtectAll);
   BlockProtectNone(block_info, &shadow_);
 
   block_info.header->state = QUARANTINED_FLOODED_BLOCK;
   BlockProtectAuto(block_info, &shadow_);
   TestAccessUnderProtection(block_info, kProtectAll);
   BlockProtectNone(block_info, &shadow_);
 
   block_info.header->state = FREED_BLOCK;
   BlockProtectAuto(block_info, &shadow_);
   TestAccessUnderProtection(block_info, kProtectAll);
   BlockProtectNone(block_info, &shadow_);
 
   ASSERT_EQ(TRUE, ::VirtualFree(alloc, 0, MEM_RELEASE));
 }
 
 }  // namespace asan
 }  // namespace agent