Make syzyasan_rtl compile in 64 bit

syzygy/agent/asan/shadow.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 15 matching lines @@
 
 namespace {
 
 #ifdef _WIN64
 // A lock under which the shadow instance is modified.
 base::Lock shadow_instance_lock;
 
 // The pointer for the exception handler to know what shadow object is
 // currently used. Under shadow_instance_lock.
 // TODO(loskutov): eliminate this by enforcing Shadow to be a singleton.
-const Shadow* shadow_instance;
+const Shadow* shadow_instance = nullptr;
 
 // The exception handler, intended to map the pages for shadow and page_bits
 // on demand. When a page fault happens, the operating systems calls
 // this handler, and if the page is inside shadow or page_bits, it gets
 // commited seamlessly for the caller, and then execution continues.
 // Otherwise, the OS keeps searching for an appropriate handler.
 LONG NTAPI ShadowExceptionHandler(PEXCEPTION_POINTERS exception_pointers) {
+  DCHECK_NE(static_cast<const Shadow*>(nullptr), shadow_instance);
   // Only handle access violations.
   if (exception_pointers->ExceptionRecord->ExceptionCode !=
       EXCEPTION_ACCESS_VIOLATION) {
     return EXCEPTION_CONTINUE_SEARCH;
   }
 
   // Only handle access violations that land within the shadow memory
   // or the page bits.
 
   void* addr = reinterpret_cast<void*>(
@@ skipping 31 matching lines @@
                               size_t* index,
                               uint8_t* mask) {
   DCHECK_NE(static_cast<size_t*>(nullptr), index);
   DCHECK_NE(static_cast<uint8_t*>(nullptr), mask);
 
   size_t i = reinterpret_cast<uintptr_t>(address) / kPageSize;
   *index = i / 8;
   *mask = 1 << (i % 8);
 }
 
+// Check if |addr| is in a memory region that has been committed.
+bool AddressIsInCommittedMemory(const void* addr) {
+  MEMORY_BASIC_INFORMATION memory_info = {};
+  SIZE_T mem_status = ::VirtualQuery(addr, &memory_info, sizeof(memory_info));
+  DCHECK_GT(mem_status, 0u);
+  if (memory_info.State != MEM_COMMIT)
+    return false;
+  return true;
+}
+
 }  // namespace
 
 Shadow::Shadow() : own_memory_(false), shadow_(nullptr), length_(0) {
   Init(RequiredLength());
 }
 
 Shadow::Shadow(size_t length)
     : own_memory_(false), shadow_(nullptr), length_(0) {
   Init(length);
 }
@@ skipping 103 matching lines @@
   }
 
   auto cursor = shadow_ + i;
   MEMORY_BASIC_INFORMATION info = {};
   while (i < length_) {
     auto next_cursor = cursor;
     while (cursor < shadow_ + length_) {
       auto ret = ::VirtualQuery(cursor, &info, sizeof(info));
       DCHECK_GT(ret, 0u);
       next_cursor = static_cast<uint8_t*>(info.BaseAddress) + info.RegionSize;
-      if (info.Type == MEM_COMMIT)
+      if (info.State == MEM_COMMIT)
         break;
       cursor = next_cursor;
     }
     i = cursor - shadow_;
     next_cursor = std::min(next_cursor, shadow_ + length_);
     auto next_i = next_cursor - shadow_;
     for (; i < next_i; ++i) {
       if ((i >= shadow_begin && i < shadow_end) ||
           (i >= page_bits_begin && i < page_bits_end) ||
           (i >= this_begin && i < this_end)) {
@@ skipping 648 matching lines @@
 }
 
 bool Shadow::ScanLeftForBracketingBlockStart(
     size_t initial_nesting_depth, size_t cursor, size_t* location) const {
   DCHECK_NE(static_cast<size_t*>(NULL), location);
 
   static const size_t kLowerBound = kAddressLowerBound / kShadowRatio;
 
   size_t left = cursor;
   int nesting_depth = static_cast<int>(initial_nesting_depth);
+  if (!AddressIsInCommittedMemory((&shadow_[left])))
+    return false;
   if (ShadowMarkerHelper::IsBlockEnd(shadow_[left]))
     --nesting_depth;
   while (true) {
+    if (!AddressIsInCommittedMemory((&shadow_[left])))
+      return false;
     if (ShadowMarkerHelper::IsBlockStart(shadow_[left])) {
       if (nesting_depth == 0) {
         *location = left;
         return true;
       }
       // If this is not a nested block then there's no hope of finding a
       // block containing the original cursor.
       if (!ShadowMarkerHelper::IsNestedBlockStart(shadow_[left]))
         return false;
       --nesting_depth;
@@ skipping 142 matching lines @@
     size_t initial_nesting_depth,
     const void* addr,
     CompactBlockInfo* info) const {
   DCHECK_NE(static_cast<void*>(NULL), addr);
   DCHECK_NE(static_cast<CompactBlockInfo*>(NULL), info);
 
   // Convert the address to an offset in the shadow memory.
   size_t left = reinterpret_cast<uintptr_t>(addr) / kShadowRatio;
   size_t right = left;
 
+  if (!AddressIsInCommittedMemory(&shadow_[left]))
+    return false;
+
   if (!ScanLeftForBracketingBlockStart(initial_nesting_depth, left, &left))
     return false;
   if (!ScanRightForBracketingBlockEnd(initial_nesting_depth, right, &right))
     return false;
   ++right;
 
   uint8_t* block = reinterpret_cast<uint8_t*>(left * kShadowRatio);
   info->header = reinterpret_cast<BlockHeader*>(block);
   info->block_size = static_cast<uint32_t>((right - left) * kShadowRatio);
 
@@ skipping 153 matching lines @@
         continue;
       }
     }
   }
 
   return false;
 }
 
 }  // namespace asan
 }  // namespace agent