Remove the is_nested bit from the BlockInfo structure.

syzygy/agent/asan/shadow_unittest.cc

 // Copyright 2012 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 299 matching lines @@
     // An overflowing range is always inaccessible.
     EXPECT_EQ(test_array + 3, test_shadow.FindFirstPoisonedByte(
                                   test_array + 3, static_cast<size_t>(-3)));
 
     for (size_t i = 0; i < size; ++i) {
       // Try valid ranges at every starting position inside the unpoisoned
       // range.
       EXPECT_EQ(nullptr,
                 test_shadow.FindFirstPoisonedByte(test_array + i, size - i));
 
-      // Try valid ranges ending at every poisition inside the unpoisoned range.
+      // Try valid ranges ending at every position inside the unpoisoned range.
       EXPECT_EQ(nullptr,
                 test_shadow.FindFirstPoisonedByte(test_array, size - i));
     }
 
     for (size_t i = 1; i < kShadowRatio; ++i) {
       // Try invalid ranges at starting positions outside the unpoisoned range.
       EXPECT_EQ(test_array - i,
                 test_shadow.FindFirstPoisonedByte(test_array - i, size));
 
       // Try invalid ranges at ending positions outside the unpoisoned range.
       EXPECT_EQ(test_array + size,
                 test_shadow.FindFirstPoisonedByte(test_array, size + i));
     }
   }
   test_shadow.Unpoison(aligned_test_array, aligned_array_length);
 }
 
 TEST_F(ShadowTest, MarkAsFreed) {
   BlockLayout l0 = {}, l1 = {};
   EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 16, 30, 30, &l1));
   EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio,
                               l1.block_size + 2 * kShadowRatio, 30, 30, &l0));
 
   uint8_t* data = new uint8_t[l0.block_size];
 
   uint8_t* d0 = data;
   BlockInfo i0 = {};
-  BlockInitialize(l0, d0, false, &i0);
+  BlockInitialize(l0, d0, &i0);
   test_shadow.PoisonAllocatedBlock(i0);
 
   uint8_t* d1 = i0.RawBody() + kShadowRatio;
   BlockInfo i1 = {};
-  BlockInitialize(l1, d1, true, &i1);
+  BlockInitialize(l1, d1, &i1);
   test_shadow.PoisonAllocatedBlock(i1);
 
   test_shadow.MarkAsFreed(i0.body, i0.body_size);
   for (uint8_t* p = i0.RawBlock(); p < i0.RawBlock() + i0.block_size; ++p) {
     if (p >= i0.RawBlock() && p < i0.RawBody()) {
       EXPECT_TRUE(test_shadow.IsLeftRedzone(p));
     } else if (p >= i0.RawBody() &&
         p < i0.RawTrailerPadding()) {
       if (p >= i1.RawBlock() && p < i1.RawBody()) {
         EXPECT_TRUE(test_shadow.IsLeftRedzone(p));
@@ skipping 16 matching lines @@
   test_shadow.Unpoison(data, l0.block_size);
   delete [] data;
 }
 
 TEST_F(ShadowTest, PoisonAllocatedBlock) {
   BlockLayout layout = {};
   EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 15, 22, 0, &layout));
 
   uint8_t* data = new uint8_t[layout.block_size];
   BlockInfo info = {};
-  BlockInitialize(layout, data, false, &info);
+  BlockInitialize(layout, data, &info);
 
   test_shadow.PoisonAllocatedBlock(info);
   EXPECT_EQ(test_shadow.GetShadowMarkerForAddress(data + 0 * 8),
             kHeapBlockStartMarker0 | 7);
   EXPECT_EQ(test_shadow.GetShadowMarkerForAddress(data + 1 * 8),
             kHeapLeftPaddingMarker);
   EXPECT_EQ(test_shadow.GetShadowMarkerForAddress(data + 2 * 8),
             kHeapLeftPaddingMarker);
   EXPECT_EQ(test_shadow.GetShadowMarkerForAddress(data + 3 * 8),
             0);
@@ skipping 22 matching lines @@
     EXPECT_FALSE(test_shadow.IsAccessible(cursor));
   test_shadow.Unpoison(info.RawBlock(), info.block_size);
 
   delete [] data;
 }
 
 TEST_F(ShadowTest, ScanLeftAndRight) {
   size_t offset = test_shadow.length() / 2;
   size_t l = 0;
   test_shadow.shadow_[offset + 0] = kHeapBlockStartMarker0;
-  test_shadow.shadow_[offset + 1] = kHeapNestedBlockStartMarker0;
-  test_shadow.shadow_[offset + 2] = kHeapAddressableMarker;
-  test_shadow.shadow_[offset + 3] = kHeapNestedBlockEndMarker;
-  test_shadow.shadow_[offset + 4] = kHeapBlockEndMarker;
+  test_shadow.shadow_[offset + 1] = kHeapAddressableMarker;
+  test_shadow.shadow_[offset + 2] = kHeapBlockEndMarker;
 
-  EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(0, offset + 0, &l));
+  EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(offset + 0, &l));
   EXPECT_EQ(offset, l);
-  EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(0, offset + 1, &l));
-  EXPECT_EQ(offset + 1, l);
-  EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(0, offset + 2, &l));
-  EXPECT_EQ(offset + 1, l);
-  EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(0, offset + 3, &l));
-  EXPECT_EQ(offset + 1, l);
-  EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(0, offset + 4, &l));
+  EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(offset + 1, &l));
+  EXPECT_EQ(offset, l);
+  EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(offset + 2, &l));
   EXPECT_EQ(offset, l);
 
-  EXPECT_FALSE(test_shadow.ScanLeftForBracketingBlockStart(1, offset + 0, &l));
-  EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(1, offset + 1, &l));
-  EXPECT_EQ(offset, l);
-  EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(1, offset + 2, &l));
-  EXPECT_EQ(offset, l);
-  EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(1, offset + 3, &l));
-  EXPECT_EQ(offset, l);
-  EXPECT_FALSE(test_shadow.ScanLeftForBracketingBlockStart(1, offset + 4, &l));
-
-  EXPECT_FALSE(test_shadow.ScanLeftForBracketingBlockStart(2, offset + 0, &l));
-  EXPECT_FALSE(test_shadow.ScanLeftForBracketingBlockStart(2, offset + 1, &l));
-  EXPECT_FALSE(test_shadow.ScanLeftForBracketingBlockStart(2, offset + 2, &l));
-  EXPECT_FALSE(test_shadow.ScanLeftForBracketingBlockStart(2, offset + 3, &l));
-  EXPECT_FALSE(test_shadow.ScanLeftForBracketingBlockStart(2, offset + 4, &l));
-
-  EXPECT_TRUE(test_shadow.ScanRightForBracketingBlockEnd(0, offset + 0, &l));
-  EXPECT_EQ(offset + 4, l);
-  EXPECT_TRUE(test_shadow.ScanRightForBracketingBlockEnd(0, offset + 1, &l));
-  EXPECT_EQ(offset + 3, l);
-  EXPECT_TRUE(test_shadow.ScanRightForBracketingBlockEnd(0, offset + 2, &l));
-  EXPECT_EQ(offset + 3, l);
-  EXPECT_TRUE(test_shadow.ScanRightForBracketingBlockEnd(0, offset + 3, &l));
-  EXPECT_EQ(offset + 3, l);
-  EXPECT_TRUE(test_shadow.ScanRightForBracketingBlockEnd(0, offset + 4, &l));
-  EXPECT_EQ(offset + 4, l);
-
-  EXPECT_FALSE(test_shadow.ScanRightForBracketingBlockEnd(1, offset + 0, &l));
-  EXPECT_TRUE(test_shadow.ScanRightForBracketingBlockEnd(1, offset + 1, &l));
-  EXPECT_EQ(offset + 4, l);
-  EXPECT_TRUE(test_shadow.ScanRightForBracketingBlockEnd(1, offset + 2, &l));
-  EXPECT_EQ(offset + 4, l);
-  EXPECT_TRUE(test_shadow.ScanRightForBracketingBlockEnd(1, offset + 3, &l));
-  EXPECT_EQ(offset + 4, l);
-  EXPECT_FALSE(test_shadow.ScanRightForBracketingBlockEnd(1, offset + 4, &l));
-
-  EXPECT_FALSE(test_shadow.ScanRightForBracketingBlockEnd(2, offset + 0, &l));
-  EXPECT_FALSE(test_shadow.ScanRightForBracketingBlockEnd(2, offset + 1, &l));
-  EXPECT_FALSE(test_shadow.ScanRightForBracketingBlockEnd(2, offset + 2, &l));
-  EXPECT_FALSE(test_shadow.ScanRightForBracketingBlockEnd(2, offset + 3, &l));
-  EXPECT_FALSE(test_shadow.ScanRightForBracketingBlockEnd(2, offset + 4, &l));
+  EXPECT_TRUE(test_shadow.ScanRightForBracketingBlockEnd(offset + 0, &l));
+  EXPECT_EQ(offset + 2, l);
+  EXPECT_TRUE(test_shadow.ScanRightForBracketingBlockEnd(offset + 1, &l));
+  EXPECT_EQ(offset + 2, l);
+  EXPECT_TRUE(test_shadow.ScanRightForBracketingBlockEnd(offset + 2, &l));
+  EXPECT_EQ(offset + 2, l);
 
   ::memset(test_shadow.shadow_ + offset, 0, 5);
 }
 
 TEST_F(ShadowTest, ScanRightPerfTest) {
   size_t offset = test_shadow.length() / 2;
   size_t length = 1 * 1024 * 1024;
 
   ::memset(test_shadow.shadow_ + offset, 0, length);
 
   test_shadow.shadow_[offset + 0] = kHeapBlockStartMarker0;
-  // A nested block with freed contents.
-  test_shadow.shadow_[offset + 50] = kHeapNestedBlockStartMarker0;
-  ::memset(test_shadow.shadow_ + offset + 51, kHeapFreedMarker, 8);
-  test_shadow.shadow_[offset + 60] = kHeapNestedBlockEndMarker;
-  // A nested block with a nested block.
-  test_shadow.shadow_[offset + 100000] = kHeapNestedBlockStartMarker0;
-  test_shadow.shadow_[offset + 100100] = kHeapNestedBlockStartMarker0;
-  test_shadow.shadow_[offset + 100400] = kHeapNestedBlockEndMarker;
-  test_shadow.shadow_[offset + 200000] = kHeapNestedBlockEndMarker;
-  // The end of the outer block.
+  // The end of the block.
   test_shadow.shadow_[offset + length - 1] = kHeapBlockEndMarker;
 
   uint64_t tnet = 0;
   for (size_t i = 0; i < 100; ++i) {
     size_t l = 0;
     uint64_t t0 = ::__rdtsc();
-    test_shadow.ScanRightForBracketingBlockEnd(0, offset + 1, &l);
+    test_shadow.ScanRightForBracketingBlockEnd(offset + 1, &l);
     uint64_t t1 = ::__rdtsc();
     tnet += t1 - t0;
   }
   testing::EmitMetric("Syzygy.Asan.Shadow.ScanRightForBracketingBlockEnd",
                       tnet);
 
   // Reset the shadow memory.
   ::memset(test_shadow.shadow_ + offset, 0, length);
 }
 
 TEST_F(ShadowTest, IsLeftOrRightRedzone) {
   BlockLayout layout = {};
   const size_t kAllocSize = 15;
   ASSERT_NE(0U, kAllocSize % kShadowRatio);
   EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, kAllocSize, 0, 0,
                               &layout));
 
   std::unique_ptr<uint8_t[]> data(new uint8_t[layout.block_size]);
   BlockInfo info = {};
-  BlockInitialize(layout, data.get(), false, &info);
+  BlockInitialize(layout, data.get(), &info);
 
   test_shadow.PoisonAllocatedBlock(info);
   uint8_t* block = reinterpret_cast<uint8_t*>(info.header);
   uint8_t* cursor = block;
 
   for (; cursor < info.RawBody(); ++cursor) {
     EXPECT_TRUE(test_shadow.IsLeftRedzone(cursor));
     EXPECT_FALSE(test_shadow.IsRightRedzone(cursor));
   }
   for (; cursor < info.RawBody() + info.body_size; ++cursor) {
     EXPECT_FALSE(test_shadow.IsLeftRedzone(cursor));
     EXPECT_FALSE(test_shadow.IsRightRedzone(cursor));
   }
   for (; cursor < block + info.block_size; ++cursor) {
     EXPECT_FALSE(test_shadow.IsLeftRedzone(cursor));
     EXPECT_TRUE(test_shadow.IsRightRedzone(cursor));
   }
 
   test_shadow.Unpoison(block, info.block_size);
 }
 
 namespace {
 
-void TestBlockInfoFromShadow(Shadow* shadow,
-                             const BlockLayout& outer,
-                             const BlockLayout& nested) {
+void TestBlockInfoFromShadow(Shadow* shadow, const BlockLayout& block_layout) {
   ASSERT_TRUE(shadow != nullptr);
-  ASSERT_LE(nested.block_size, outer.body_size);
 
-  uint8_t* data = new uint8_t[outer.block_size];
+  uint8_t* data = new uint8_t[block_layout.block_size];
 
-  // Try recovering the block from every position within it when no nested
-  // block exists. Expect finding a nested block to fail.
   BlockInfo info = {};
-  BlockInitialize(outer, data, false, &info);
+  BlockInitialize(block_layout, data, &info);
   shadow->PoisonAllocatedBlock(info);
   BlockInfo info_recovered = {};
   for (size_t i = 0; i < info.block_size; ++i) {
     EXPECT_TRUE(shadow->BlockInfoFromShadow(
         info.RawBlock() + i, &info_recovered));
     EXPECT_EQ(0, ::memcmp(&info, &info_recovered, sizeof(info)));
-
-    // This block should have no parent block as its not nested.
-    EXPECT_FALSE(shadow->ParentBlockInfoFromShadow(
-        info, &info_recovered));
   }
 
-  // Place a nested block and try the recovery from every position again.
-  size_t padding = ::common::AlignDown(info.body_size - nested.block_size,
-                                       kShadowRatio * 2);
-  uint8_t* nested_begin = info.RawBody() + padding / 2;
-  uint8_t* nested_end = nested_begin + nested.block_size;
-  BlockInfo nested_info = {};
-  BlockInitialize(nested, nested_begin, true, &nested_info);
-  nested_info.header->is_nested = true;
-  shadow->PoisonAllocatedBlock(nested_info);
-  for (size_t i = 0; i < info.block_size; ++i) {
-    uint8_t* pos = info.RawBlock() + i;
-    EXPECT_TRUE(shadow->BlockInfoFromShadow(pos, &info_recovered));
-
-    BlockInfo parent_info = {};
-    bool found_parent = shadow->ParentBlockInfoFromShadow(
-        info_recovered, &parent_info);
-
-    if (pos >= nested_begin && pos < nested_end) {
-      EXPECT_EQ(0, ::memcmp(&nested_info, &info_recovered,
-                            sizeof(nested_info)));
-      EXPECT_TRUE(found_parent);
-      EXPECT_EQ(0, ::memcmp(&info, &parent_info, sizeof(info)));
-    } else {
-      EXPECT_EQ(0, ::memcmp(&info, &info_recovered, sizeof(info)));
-      EXPECT_FALSE(found_parent);
-    }
-  }
-  shadow->Unpoison(info.header, info.block_size);
-
   delete [] data;
 }
 
 }  // namespace
 
 TEST_F(ShadowTest, BlockInfoFromShadow) {
-  // This is a simple layout that will be nested inside of another block.
   BlockLayout layout0 = {};
   EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 6, 0, 0, &layout0));
 
-  // Plan two layouts, one with padding and another with none. The first has
-  // exactly enough space for the nested block, while the second has room to
-  // spare.
-  BlockLayout layout1 = {};
-  BlockLayout layout2 = {};
-  EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio,
-      static_cast<uint32_t>(
-          ::common::AlignUp(layout0.block_size, kShadowRatio) + 4), 0, 0,
-      &layout1));
-  ASSERT_EQ(0u, layout1.header_padding_size);
-  ASSERT_EQ(0u, layout1.trailer_padding_size);
-  EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio,
-      layout0.block_size + 2 * kShadowRatio, 32, 13, &layout2));
-  ASSERT_LT(0u, layout2.header_padding_size);
-  ASSERT_LT(0u, layout2.trailer_padding_size);
+  uint8_t* data = new uint8_t[layout0.block_size];
 
-  EXPECT_NO_FATAL_FAILURE(TestBlockInfoFromShadow(
-      &test_shadow, layout1, layout0));
-  EXPECT_NO_FATAL_FAILURE(TestBlockInfoFromShadow(
-      &test_shadow, layout2, layout0));
+  BlockInfo info = {};
+  BlockInitialize(layout0, data, &info);
+  test_shadow.PoisonAllocatedBlock(info);
+  BlockInfo info_recovered = {};
+  for (size_t i = 0; i < info.block_size; ++i) {
+    EXPECT_TRUE(
+        test_shadow.BlockInfoFromShadow(info.RawBlock() + i, &info_recovered));
+    EXPECT_EQ(0, ::memcmp(&info, &info_recovered, sizeof(info)));
+  }
+  delete[] data;
 }
 
 TEST_F(ShadowTest, IsBeginningOfBlockBody) {
   BlockLayout l = {};
   EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 7, 0, 0, &l));
 
   size_t data_size = l.block_size;
   std::unique_ptr<uint8_t[]> data(new uint8_t[data_size]);
 
   BlockInfo block_info = {};
-  BlockInitialize(l, data.get(), false, &block_info);
+  BlockInitialize(l, data.get(), &block_info);
 
   test_shadow.PoisonAllocatedBlock(block_info);
 
   EXPECT_TRUE(test_shadow.IsBeginningOfBlockBody(block_info.body));
   EXPECT_FALSE(test_shadow.IsBeginningOfBlockBody(data.get()));
 
   block_info.header->state = QUARANTINED_BLOCK;
   test_shadow.MarkAsFreed(block_info.body, block_info.body_size);
 
   EXPECT_TRUE(test_shadow.IsBeginningOfBlockBody(block_info.body));
   EXPECT_FALSE(test_shadow.IsBeginningOfBlockBody(data.get()));
 
   test_shadow.Unpoison(data.get(), data_size);
 }
 
 TEST_F(ShadowTest, IsBeginningOfBlockBodyForBlockOfSizeZero) {
   BlockLayout l = {};
   EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 0, 0, 0, &l));
 
   size_t data_size = l.block_size;
   std::unique_ptr<uint8_t[]> data(new uint8_t[data_size]);
 
   BlockInfo block_info = {};
-  BlockInitialize(l, data.get(), false, &block_info);
+  BlockInitialize(l, data.get(), &block_info);
 
   test_shadow.PoisonAllocatedBlock(block_info);
 
   EXPECT_TRUE(test_shadow.IsBeginningOfBlockBody(block_info.body));
   EXPECT_FALSE(test_shadow.IsBeginningOfBlockBody(data.get()));
 
   block_info.header->state = QUARANTINED_FLOODED_BLOCK;
   test_shadow.MarkAsFreed(block_info.body, block_info.body_size);
 
   EXPECT_TRUE(test_shadow.IsBeginningOfBlockBody(block_info.body));
@@ skipping 63 matching lines @@
 
 // A fixture for shadow walker tests.
 class ShadowWalkerTest : public testing::Test {
  public:
   TestShadow test_shadow;
 };
 
 }  // namespace
 
 TEST_F(ShadowWalkerTest, WalkEmptyRange) {
-  ShadowWalker w(&test_shadow, true, &test_shadow, &test_shadow);
+  ShadowWalker w(&test_shadow, &test_shadow, &test_shadow);
   BlockInfo i = {};
   EXPECT_FALSE(w.Next(&i));
 }
 
 TEST_F(ShadowWalkerTest, WalkRangeAtEndOfAddressSpace) {
   TestShadow ts1(4, 30);  // 4GB.
-  ShadowWalker w(
-      &ts1, true,
-      reinterpret_cast<const void*>(ts1.memory_size() - 100),
-      reinterpret_cast<const void*>(ts1.memory_size()));
+  ShadowWalker w(&ts1, reinterpret_cast<const void*>(ts1.memory_size() - 100),
+                 reinterpret_cast<const void*>(ts1.memory_size()));
   BlockInfo i = {};
   EXPECT_FALSE(w.Next(&i));
 }
 
-TEST_F(ShadowWalkerTest, WalksNonNestedBlocks) {
+TEST_F(ShadowWalkerTest, WalksBlocks) {
   BlockLayout l = {};
   EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 7, 0, 0, &l));
 
   size_t data_size = l.block_size * 3 + kShadowRatio;
   uint8_t* data = new uint8_t[data_size];
   uint8_t* data0 = data;
   uint8_t* data1 = data0 + l.block_size + kShadowRatio;
   uint8_t* data2 = data1 + l.block_size;
 
   BlockInfo i0 = {}, i1 = {}, i2 = {};
-  BlockInitialize(l, data0, false, &i0);
-  BlockInitialize(l, data1, false, &i1);
-  BlockInitialize(l, data2, false, &i2);
+  BlockInitialize(l, data0, &i0);
+  BlockInitialize(l, data1, &i1);
+  BlockInitialize(l, data2, &i2);
 
   test_shadow.PoisonAllocatedBlock(i0);
   test_shadow.PoisonAllocatedBlock(i1);
   test_shadow.PoisonAllocatedBlock(i2);
 
   i2.header->state = QUARANTINED_BLOCK;
   test_shadow.MarkAsFreed(i2.body, i2.body_size);
 
   // Do a non-recursive walk through the shadow.
   BlockInfo i = {};
-  ShadowWalker w0(&test_shadow, false, data, data + data_size);
-  EXPECT_EQ(-1, w0.nesting_depth());
+  ShadowWalker w0(&test_shadow, data, data + data_size);
   EXPECT_TRUE(w0.Next(&i));
-  EXPECT_EQ(0, w0.nesting_depth());
   EXPECT_TRUE(w0.Next(&i));
-  EXPECT_EQ(0, w0.nesting_depth());
   EXPECT_TRUE(w0.Next(&i));
-  EXPECT_EQ(0, w0.nesting_depth());
   EXPECT_FALSE(w0.Next(&i));
-  EXPECT_EQ(-1, w0.nesting_depth());
-
-  // Walk recursively through the shadow and expect the same results.
-  ShadowWalker w1(&test_shadow, true, data, data + data_size);
-  EXPECT_EQ(-1, w1.nesting_depth());
-  EXPECT_TRUE(w1.Next(&i));
-  EXPECT_EQ(0, w1.nesting_depth());
-  EXPECT_EQ(0, ::memcmp(&i, &i0, sizeof(i)));
-  EXPECT_TRUE(w1.Next(&i));
-  EXPECT_EQ(0, w1.nesting_depth());
-  EXPECT_EQ(0, ::memcmp(&i, &i1, sizeof(i)));
-  EXPECT_TRUE(w1.Next(&i));
-  EXPECT_EQ(0, w1.nesting_depth());
-  EXPECT_EQ(0, ::memcmp(&i, &i2, sizeof(i)));
-  EXPECT_FALSE(w1.Next(&i));
-  EXPECT_EQ(-1, w1.nesting_depth());
 
   test_shadow.Unpoison(data, data_size);
   delete [] data;
-}
-
-TEST_F(ShadowWalkerTest, WalksNestedBlocks) {
-  BlockLayout b0 = {}, b1 = {}, b2 = {}, b00 = {}, b01 = {}, b10 = {},
-      b100 = {};
-  EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 15, 30, 30, &b00));
-  EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 7, 0, 0, &b01));
-  EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio,
-      b00.block_size + b01.block_size + kShadowRatio, 0, 0, &b0));
-  EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 7, 0, 0, &b100));
-  EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, b100.block_size, 0, 0,
-                              &b10));
-  EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, b10.block_size, 0, 0,
-                              &b1));
-  EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 100, 0, 0, &b2));
-
-  size_t data_size = b0.block_size + b1.block_size + kShadowRatio +
-      b2.block_size;
-  uint8_t* data = new uint8_t[data_size];
-
-  // Initialize the depth 0 blocks.
-  uint8_t* d0 = data;
-  uint8_t* d1 = d0 + b0.block_size;
-  uint8_t* d2 = d1 + b1.block_size + kShadowRatio;
-  BlockInfo i0 = {}, i1 = {}, i2 = {};
-  BlockInitialize(b0, d0, false, &i0);
-  BlockInitialize(b1, d1, false, &i1);
-  BlockInitialize(b2, d2, false, &i2);
-  test_shadow.PoisonAllocatedBlock(i0);
-  test_shadow.PoisonAllocatedBlock(i1);
-  test_shadow.PoisonAllocatedBlock(i2);
-
-  // Initialize depth 1 blocks.
-  uint8_t* d00 = i0.RawBody();
-  uint8_t* d01 = d00 + b00.block_size + kShadowRatio;
-  uint8_t* d10 = i1.RawBody();
-  BlockInfo i00 = {}, i01 = {}, i10 = {};
-  BlockInitialize(b00, d00, true, &i00);
-  BlockInitialize(b01, d01, true, &i01);
-  BlockInitialize(b10, d10, true, &i10);
-  test_shadow.PoisonAllocatedBlock(i00);
-  test_shadow.PoisonAllocatedBlock(i01);
-  test_shadow.PoisonAllocatedBlock(i10);
-
-  // Initialize depth 2 blocks.
-  uint8_t* d100 = i10.RawBody();
-  BlockInfo i100 = {};
-  BlockInitialize(b100, d100, true, &i100);
-  test_shadow.PoisonAllocatedBlock(i100);
-  i100.header->state = QUARANTINED_FLOODED_BLOCK;
-  test_shadow.MarkAsFreed(i100.body, i100.body_size);
-
-  // Do a non-recursive walk through the shadow.
-  BlockInfo i = {};
-  ShadowWalker w0(&test_shadow, false, data, data + data_size);
-  EXPECT_EQ(-1, w0.nesting_depth());
-  EXPECT_TRUE(w0.Next(&i));
-  EXPECT_EQ(0, w0.nesting_depth());
-  EXPECT_EQ(0, ::memcmp(&i, &i0, sizeof(i)));
-  EXPECT_TRUE(w0.Next(&i));
-  EXPECT_EQ(0, w0.nesting_depth());
-  EXPECT_EQ(0, ::memcmp(&i, &i1, sizeof(i)));
-  EXPECT_TRUE(w0.Next(&i));
-  EXPECT_EQ(0, w0.nesting_depth());
-  EXPECT_EQ(0, ::memcmp(&i, &i2, sizeof(i)));
-  EXPECT_FALSE(w0.Next(&i));
-  EXPECT_EQ(-1, w0.nesting_depth());
-
-  // Walk recursively through the shadow.
-  ShadowWalker w1(&test_shadow, true, data, data + data_size);
-  EXPECT_EQ(-1, w1.nesting_depth());
-  EXPECT_TRUE(w1.Next(&i));
-  EXPECT_EQ(0, w1.nesting_depth());
-  EXPECT_EQ(0, ::memcmp(&i, &i0, sizeof(i)));
-  EXPECT_TRUE(w1.Next(&i));
-  EXPECT_EQ(1, w1.nesting_depth());
-  EXPECT_EQ(0, ::memcmp(&i, &i00, sizeof(i)));
-  EXPECT_TRUE(w1.Next(&i));
-  EXPECT_EQ(1, w1.nesting_depth());
-  EXPECT_EQ(0, ::memcmp(&i, &i01, sizeof(i)));
-  EXPECT_TRUE(w1.Next(&i));
-  EXPECT_EQ(0, w1.nesting_depth());
-  EXPECT_EQ(0, ::memcmp(&i, &i1, sizeof(i)));
-  EXPECT_TRUE(w1.Next(&i));
-  EXPECT_EQ(1, w1.nesting_depth());
-  EXPECT_EQ(0, ::memcmp(&i, &i10, sizeof(i)));
-  EXPECT_TRUE(w1.Next(&i));
-  EXPECT_EQ(2, w1.nesting_depth());
-  EXPECT_EQ(0, ::memcmp(&i, &i100, sizeof(i)));
-  EXPECT_TRUE(w1.Next(&i));
-  EXPECT_EQ(0, w1.nesting_depth());
-  EXPECT_EQ(0, ::memcmp(&i, &i2, sizeof(i)));
-  EXPECT_FALSE(w1.Next(&i));
-  EXPECT_EQ(-1, w1.nesting_depth());
-
-  test_shadow.Unpoison(data, data_size);
-  delete [] data;
 }
 
 TEST_F(ShadowWalkerTest, WalkShadowWithUncommittedRanges) {
   // Create a 512k memory block.
   const size_t kMemorySize = 512 * 1024;
   uint8_t memory_block[kMemorySize];
   const size_t shadow_size = Shadow::RequiredLength();
 
   // Allocate the shadow memory, only reserve the memory.
   uint8_t* shadow_memory = static_cast<uint8_t*>(
@@ skipping 25 matching lines @@
         ::common::AlignDown(shadow_address, GetPageSize());
     // Commit the shadow memory for this block.
     EXPECT_EQ(static_cast<void*>(shadow_address_page_begin),
               ::VirtualAlloc(shadow_address, GetPageSize(), MEM_COMMIT,
                              PAGE_READWRITE));
 
     // Address of the memory for this block.
     uint8_t* page_address = ::common::AlignUp(
         memory_block + i * GetPageSize() * kShadowRatio, kShadowRatio);
     BlockInfo block_info = {};
-    BlockInitialize(l, page_address, false, &block_info);
+    BlockInitialize(l, page_address, &block_info);
     block_info_vec.push_back(block_info);
 
     // Poison the block.
     ts1.PoisonAllocatedBlock(block_info);
   }
 
   size_t block_count = 0;
-  ShadowWalker w(&ts1, true, memory_block, memory_block + kMemorySize);
+  ShadowWalker w(&ts1, memory_block, memory_block + kMemorySize);
   BlockInfo i = {};
   while (w.Next(&i)) {
     EXPECT_LT(block_count, block_info_vec.size());
     EXPECT_EQ(block_info_vec[block_count].header, i.header);
     EXPECT_EQ(block_info_vec[block_count].body, i.body);
     EXPECT_EQ(block_info_vec[block_count].trailer, i.trailer);
     block_count++;
   }
   EXPECT_EQ(block_info_vec.size(), block_count);
   EXPECT_FALSE(w.Next(&i));
 
   EXPECT_GT(::VirtualFree(shadow_memory, 0, MEM_RELEASE), 0U);
 }
 
 }  // namespace asan
 }  // namespace agent