Minor changes in the RTL unittest.

syzygy/agent/asan/rtl_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 176 matching lines @@
   EXPECT_TRUE(LogContains(kAttemptingDoubleFree));
   EXPECT_TRUE(LogContains("previously allocated here"));
   EXPECT_TRUE(LogContains("freed here"));
 }
 
 TEST_F(AsanRtlTest, AsanCheckWildAccess) {
   FARPROC check_access_fn =
       ::GetProcAddress(asan_rtl_, "asan_check_4_byte_read_access");
   ASSERT_TRUE(check_access_fn != NULL);
 
+#ifndef _WIN64
+  void* addr = reinterpret_cast<void*>(0x80000000);
+#else
+  void* addr = reinterpret_cast<void*>(1ULL << 63);
+#endif
+
   MemoryAccessorTester tester;
   tester.AssertMemoryErrorIsDetected(
-      check_access_fn, reinterpret_cast<void*>(0x80000000), WILD_ACCESS);
+      check_access_fn, addr, WILD_ACCESS);
   EXPECT_TRUE(LogContains(kWildAccess));
 }
 
 #ifndef _WIN64
 // It is not possible to test the near-nullptr access with heap corruption
 // execution path since it depends on the unhandled exception filter which is
 // not installed in the rtl library.
 TEST_F(AsanRtlTest, AsanIgnoreInvalidAccess) {
   FARPROC check_access_fn =
       ::GetProcAddress(asan_rtl_, "asan_check_4_byte_read_access");
   ASSERT_TRUE(check_access_fn != NULL);
 
   // A near-nullptr access should not be reported by SyzyASAN.
   MemoryAccessorTester tester;
   tester.CheckAccessAndCompareContexts(check_access_fn, nullptr);
   EXPECT_FALSE(LogContains(kInvalidAddress));
 }
 #endif
 
 TEST_F(AsanRtlTest, AsanReportInvalidAccess) {
   FARPROC check_access_fn =
       ::GetProcAddress(asan_rtl_, "asan_check_4_byte_read_access");
   ASSERT_NE(static_cast<FARPROC>(nullptr), check_access_fn);
 
   MemoryAccessorTester tester;
   agent::asan::AsanRuntime* runtime = GetActiveRuntimeFunction();
-  ASSERT_NE(reinterpret_cast<agent::asan::AsanRuntime*>(NULL), runtime);
+  ASSERT_NE(static_cast<agent::asan::AsanRuntime*>(nullptr), runtime);
   runtime->params().report_invalid_accesses = true;
   tester.AssertMemoryErrorIsDetected(
-      check_access_fn, reinterpret_cast<void*>(0x00000000), INVALID_ADDRESS);
+      check_access_fn, static_cast<void*>(nullptr), INVALID_ADDRESS);
   EXPECT_TRUE(LogContains(kInvalidAddress));
 }
 
 TEST_F(AsanRtlTest, AsanCheckCorruptBlock) {
   void* mem = HeapAllocFunction(heap_, 0, kAllocSize);
   reinterpret_cast<uint8_t*>(mem)[-1]--;
   MemoryAccessorTester tester;
   tester.set_expected_error_type(CORRUPT_BLOCK);
   EXPECT_TRUE(HeapFreeFunction(heap_, 0, mem));
   EXPECT_TRUE(tester.memory_error_detected());
   EXPECT_TRUE(LogContains(kHeapCorruptBlock));
   EXPECT_TRUE(LogContains("previously allocated here"));
 }
 
 TEST_F(AsanRtlTest, AsanCheckCorruptHeap) {
   FARPROC check_access_fn =
       ::GetProcAddress(asan_rtl_, "asan_check_4_byte_read_access");
-  ASSERT_TRUE(check_access_fn != NULL);
+  ASSERT_TRUE(check_access_fn != nullptr);
 
   agent::asan::AsanRuntime* runtime = GetActiveRuntimeFunction();
   ASSERT_NE(reinterpret_cast<agent::asan::AsanRuntime*>(NULL), runtime);
   runtime->params().check_heap_on_failure = true;
 
   ScopedAsanAlloc<uint8_t> mem(this, kAllocSize);
   ASSERT_TRUE(mem.get() != NULL);
 
   const size_t kMaxIterations = 10;
 
@@ skipping 39 matching lines @@
     // An error should be triggered when we free this block.
     tester.set_memory_error_detected(false);
     tester.set_expected_error_type(CORRUPT_BLOCK);
     mem.reset(NULL);
     EXPECT_TRUE(tester.memory_error_detected());
 
     break;
   }
 }
 
+#ifndef _WIN64
 TEST_F(AsanRtlTest, AsanSingleSpecial1byteInstructionCheckGoodAccess) {
   static const char* function_names[] = {
       "asan_check_1_byte_movs_access",
       "asan_check_1_byte_cmps_access",
       "asan_check_1_byte_stos_access"
   };
 
   // Allocate memory space.
   AllocMemoryBuffers(kAllocSize, sizeof(uint8_t));
   uint8_t* src = reinterpret_cast<uint8_t*>(memory_src_);
@@ skipping 306 matching lines @@
 
 TEST_F(AsanRtlTest, AllocationFilterFlag) {
   agent::asan::AsanRuntime* runtime = GetActiveRuntimeFunction();
   SetAllocationFilterFlagFunction();
   EXPECT_TRUE(runtime->allocation_filter_flag());
   ClearAllocationFilterFlagFunction();
   EXPECT_FALSE(runtime->allocation_filter_flag());
   SetAllocationFilterFlagFunction();
   EXPECT_TRUE(runtime->allocation_filter_flag());
 }
+#endif
 
 namespace {
 
 using ExperimentMap = std::map<std::string, std::string>;
 
 ExperimentMap* experiment_map = nullptr;
 
 static void WINAPI
 ExperimentCallback(const char* feature_name, const char* feature_state) {
   ASSERT_TRUE(experiment_map != nullptr);
@@ skipping 22 matching lines @@
   EXPECT_EQ("Enabled", experiments["SyzyASANLargeBlockHeap"]);
   EXPECT_EQ("Disabled", experiments["SyzyASANCrashpad"]);
 
   // This implicitly asserts the full contents of the map by asserting
   // on the size after looking up the expected keys.
   EXPECT_EQ(3U, experiments.size());
 }
 
 }  // namespace asan
 }  // namespace agent