Remove the is_nested bit from the BlockInfo structure.

syzygy/agent/asan/heap_checker_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 68 matching lines @@
 
   // Restore the checksum to make sure that the corruption gets detected.
   fake_block.block_info.header->checksum = header_checksum;
 
   EXPECT_TRUE(heap_checker.IsHeapCorrupt(&corrupt_ranges));
   ASSERT_EQ(1, corrupt_ranges.size());
   AsanCorruptBlockRange range_info = *corrupt_ranges.begin();
 
   EXPECT_EQ(1, range_info.block_count);
   ShadowWalker shadow_walker(
-      runtime_->shadow(), false,
-      reinterpret_cast<const uint8_t*>(range_info.address),
+      runtime_->shadow(), reinterpret_cast<const uint8_t*>(range_info.address),
       reinterpret_cast<const uint8_t*>(range_info.address) + range_info.length);
   BlockInfo block_info = {};
   EXPECT_TRUE(shadow_walker.Next(&block_info));
   EXPECT_EQ(fake_block.block_info.header, block_info.header);
   EXPECT_FALSE(shadow_walker.Next(&block_info));
 
   fake_block.block_info.header->checksum = header_checksum;
   fake_block.block_info.RawBody(0) = original_value;
   EXPECT_FALSE(heap_checker.IsHeapCorrupt(&corrupt_ranges));
 }
@@ skipping 12 matching lines @@
 
   // Corrupt the header of the block and ensure that the heap corruption gets
   // detected.
   fake_block.block_info.header->magic = ~fake_block.block_info.header->magic;
   EXPECT_TRUE(heap_checker.IsHeapCorrupt(&corrupt_ranges));
   ASSERT_EQ(1, corrupt_ranges.size());
   AsanCorruptBlockRange range_info = *corrupt_ranges.begin();
 
   EXPECT_EQ(1, range_info.block_count);
   ShadowWalker shadow_walker(
-      runtime_->shadow(), false,
-      reinterpret_cast<const uint8_t*>(range_info.address),
+      runtime_->shadow(), reinterpret_cast<const uint8_t*>(range_info.address),
       reinterpret_cast<const uint8_t*>(range_info.address) + range_info.length);
   BlockInfo block_info = {};
   EXPECT_TRUE(shadow_walker.Next(&block_info));
   EXPECT_EQ(fake_block.block_info.header, block_info.header);
   EXPECT_FALSE(shadow_walker.Next(&block_info));
 
   fake_block.block_info.header->magic = ~fake_block.block_info.header->magic;
   EXPECT_FALSE(heap_checker.IsHeapCorrupt(&corrupt_ranges));
 }
 
 TEST_F(HeapCheckerTest, IsHeapCorrupt) {
   const size_t kAllocSize = 100;
 
   BlockLayout block_layout = {};
   EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, kAllocSize, 0, 0,
                               &block_layout));
 
   const size_t kNumberOfBlocks = 4;
   size_t total_alloc_size = block_layout.block_size * kNumberOfBlocks;
   uint8_t* global_alloc =
       reinterpret_cast<uint8_t*>(::malloc(total_alloc_size));
 
   uint8_t* blocks[kNumberOfBlocks];
   BlockHeader* block_headers[kNumberOfBlocks];
 
   for (size_t i = 0; i < kNumberOfBlocks; ++i) {
     blocks[i] = global_alloc + i * block_layout.block_size;
     BlockInfo block_info = {};
-    BlockInitialize(block_layout, blocks[i], false, &block_info);
+    BlockInitialize(block_layout, blocks[i], &block_info);
     runtime_->shadow()->PoisonAllocatedBlock(block_info);
     BlockSetChecksum(block_info);
     block_headers[i] = block_info.header;
     EXPECT_EQ(block_headers[i], reinterpret_cast<BlockHeader*>(blocks[i]));
   }
 
   HeapChecker heap_checker(runtime_->shadow());
   HeapChecker::CorruptRangesVector corrupt_ranges;
   EXPECT_FALSE(heap_checker.IsHeapCorrupt(&corrupt_ranges));
 
   // Corrupt the header of the first two blocks and of the last one.
   block_headers[0]->magic++;
   block_headers[1]->magic++;
   block_headers[kNumberOfBlocks - 1]->magic++;
 
   EXPECT_TRUE(heap_checker.IsHeapCorrupt(&corrupt_ranges));
 
   // We expect the heap to contain 2 ranges of corrupt blocks, the first one
   // containing the 2 first blocks and the second one containing the last block.
 
   EXPECT_EQ(2, corrupt_ranges.size());
 
   BlockInfo block_info = {};
   ShadowWalker shadow_walker_1(
-      runtime_->shadow(), false,
+      runtime_->shadow(),
       reinterpret_cast<const uint8_t*>(corrupt_ranges[0].address),
       reinterpret_cast<const uint8_t*>(corrupt_ranges[0].address) +
           corrupt_ranges[0].length);
   EXPECT_TRUE(shadow_walker_1.Next(&block_info));
   EXPECT_EQ(reinterpret_cast<const BlockHeader*>(block_info.header),
             block_headers[0]);
   EXPECT_TRUE(shadow_walker_1.Next(&block_info));
   EXPECT_EQ(reinterpret_cast<const BlockHeader*>(block_info.header),
             block_headers[1]);
   EXPECT_FALSE(shadow_walker_1.Next(&block_info));
 
   ShadowWalker shadow_walker_2(
-      runtime_->shadow(), false,
+      runtime_->shadow(),
       reinterpret_cast<const uint8_t*>(corrupt_ranges[1].address),
       reinterpret_cast<const uint8_t*>(corrupt_ranges[1].address) +
           corrupt_ranges[1].length);
   EXPECT_TRUE(shadow_walker_2.Next(&block_info));
   EXPECT_EQ(reinterpret_cast<const BlockHeader*>(block_info.header),
             block_headers[kNumberOfBlocks - 1]);
   EXPECT_FALSE(shadow_walker_2.Next(&block_info));
 
   // Restore the checksum of the blocks.
   block_headers[0]->magic--;
   block_headers[1]->magic--;
   block_headers[kNumberOfBlocks - 1]->magic--;
 
   runtime_->shadow()->Unpoison(global_alloc, total_alloc_size);
   ::free(global_alloc);
 }
 
 }  // namespace asan
 }  // namespace agent