[SyzyAsan] Fix overflow error in ShadowWalker for 4GB 32-bit processes.

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 61 matching lines @@
         ASSERT_FALSE(internal::IsZeroBufferImpl<AccessType>(buf + i, end - j));
         buf[k] = 0;
       }
     }
   }
 }
 
 // A derived class to expose protected members for unit-testing.
 class TestShadow : public Shadow {
  public:
-  TestShadow() : Shadow(kTestShadowSize) {
+  TestShadow() : Shadow(kDefaultTestShadowSize) {
+  }
+
+  TestShadow(size_t digits, size_t power)
+      : Shadow(digits << (power - kShadowRatioLog)) {
   }
 
   // We'll simulate memory as being 1GB in size.
-  static const size_t kTestShadowSize =
+  static const size_t kDefaultTestShadowSize =
       (1 * 1024 * 1024 * 1024) >> kShadowRatioLog;
 
   // Protected functions that we want to unittest directly.
   using Shadow::Reset;
   using Shadow::ScanLeftForBracketingBlockStart;
   using Shadow::ScanRightForBracketingBlockEnd;
   using Shadow::shadow_;
 };
 
 // A fixture for shadow memory tests.
@@ skipping 645 matching lines @@
 namespace {
 
 // 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);
+  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()));
+  BlockInfo i = {};
+  EXPECT_FALSE(w.Next(&i));
+}
+
 TEST_F(ShadowWalkerTest, WalksNonNestedBlocks) {
   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;
 
@@ skipping 133 matching lines @@
   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;
 }
 
 }  // namespace asan
 }  // namespace agent