Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(189)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: syzygy/agent/asan/shadow_unittest.cc

Issue 2508333002: Remove the is_nested bit from the BlockInfo structure. (Closed)
Patch Set: Created 4 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« syzygy/agent/asan/shadow_marker.cc ('K') | « syzygy/agent/asan/shadow_marker_unittest.cc ('k') | syzygy/agent/asan/unittest_util.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: syzygy/agent/asan/shadow_unittest.cc
diff --git a/syzygy/agent/asan/shadow_unittest.cc b/syzygy/agent/asan/shadow_unittest.cc
index a8f2851cf41df065372b7008f7ef9f542c48b9be..8af6ace88df424187076fa59e6e8dd2e330118ae 100644
--- a/syzygy/agent/asan/shadow_unittest.cc
+++ b/syzygy/agent/asan/shadow_unittest.cc
@@ -317,7 +317,7 @@ TEST_F(ShadowTest, FindFirstPoisonedByte) {
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));
}
@@ -345,12 +345,12 @@ TEST_F(ShadowTest, MarkAsFreed) {
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);
@@ -387,7 +387,7 @@ TEST_F(ShadowTest, PoisonAllocatedBlock) {
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),
@@ -430,62 +430,22 @@ 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_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 + 0, &l));
EXPECT_EQ(offset, l);
-
- EXPECT_FALSE(test_shadow.ScanLeftForBracketingBlockStart(1, offset + 0, &l));
- EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(1, offset + 1, &l));
+ EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(offset + 1, &l));
EXPECT_EQ(offset, l);
- EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(1, offset + 2, &l));
+ EXPECT_TRUE(test_shadow.ScanLeftForBracketingBlockStart(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);
}
@@ -497,15 +457,6 @@ TEST_F(ShadowTest, ScanRightPerfTest) {
::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.
test_shadow.shadow_[offset + length - 1] = kHeapBlockEndMarker;
@@ -513,7 +464,7 @@ TEST_F(ShadowTest, ScanRightPerfTest) {
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;
}
@@ -533,7 +484,7 @@ TEST_F(ShadowTest, IsLeftOrRightRedzone) {
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);
@@ -557,58 +508,20 @@ TEST_F(ShadowTest, IsLeftOrRightRedzone) {
namespace {
-void TestBlockInfoFromShadow(Shadow* shadow,
- const BlockLayout& outer,
- const BlockLayout& nested) {
+void TestBlockInfoFromShadow(Shadow* shadow, const BlockLayout& outer) {
Sigurður Ásgeirsson 2016/11/22 19:15:37 nit: rename outer to something more descriptive?
Sébastien Marchand 2016/11/22 22:12:23 Done.
ASSERT_TRUE(shadow != nullptr);
- ASSERT_LE(nested.block_size, outer.body_size);
uint8_t* data = new uint8_t[outer.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(outer, 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;
}
@@ -616,30 +529,21 @@ void TestBlockInfoFromShadow(Shadow* shadow,
} // 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);
-
- EXPECT_NO_FATAL_FAILURE(TestBlockInfoFromShadow(
- &test_shadow, layout1, layout0));
- EXPECT_NO_FATAL_FAILURE(TestBlockInfoFromShadow(
- &test_shadow, layout2, layout0));
+ uint8_t* data = new uint8_t[layout0.block_size];
+
+ 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) {
@@ -650,7 +554,7 @@ TEST_F(ShadowTest, IsBeginningOfBlockBody) {
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);
@@ -674,7 +578,7 @@ TEST_F(ShadowTest, IsBeginningOfBlockBodyForBlockOfSizeZero) {
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);
@@ -758,22 +662,20 @@ class ShadowWalkerTest : public testing::Test {
} // 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));
@@ -784,9 +686,9 @@ TEST_F(ShadowWalkerTest, WalksNonNestedBlocks) {
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);
@@ -797,128 +699,11 @@ TEST_F(ShadowWalkerTest, WalksNonNestedBlocks) {
// 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_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());
+ ShadowWalker w0(&test_shadow, data, data + data_size);
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;
@@ -967,7 +752,7 @@ TEST_F(ShadowWalkerTest, WalkShadowWithUncommittedRanges) {
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.
@@ -975,7 +760,7 @@ TEST_F(ShadowWalkerTest, WalkShadowWithUncommittedRanges) {
}
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());
« syzygy/agent/asan/shadow_marker.cc ('K') | « syzygy/agent/asan/shadow_marker_unittest.cc ('k') | syzygy/agent/asan/unittest_util.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698