Fix warning + death test + failing test on Windows (D39072).

[flowerhack]

Summary

Fixes https://reviews.llvm.org/D39072

[cryptoad]

lib/sanitizer_common/sanitizer_win.cc

252–253

Also use addr_as_void here (otherwise it's going to complain it's not used either).
Or remove addr_as_void and leave the cast.

lib/sanitizer_common/sanitizer_win.cc

uptr ReservedAddressRange::Map(uptr fixed_addr, uptr size,
   }
   return reinterpret_cast<uptr>(MmapFixedOrDie(fixed_addr, size));
 }
 
 void ReservedAddressRange::Unmap(uptr addr, uptr size) {
   void* addr_as_void = reinterpret_cast<void*>(addr);
   uptr base_as_uptr = reinterpret_cast<uptr>(base_);
   // Only unmap if it covers the entire range.
-  CHECK((addr_as_void == base_) && (size == size_));
-  UnmapOrDie(reinterpret_cast<void*>(addr), size);
+  CHECK((addr == base_as_uptr) && (size == size_));
+  UnmapOrDie(addr_as_void, size);
 }
 
 void *MmapFixedOrDieOnFatalError(uptr fixed_addr, uptr size) {
   void *p = VirtualAlloc((LPVOID)fixed_addr, size,
       MEM_COMMIT, PAGE_READWRITE);
   if (p == 0) {
     char mem_type[30];
     internal_snprintf(mem_type, sizeof(mem_type), "memory at address 0x%zx",

lib/sanitizer_common/tests/sanitizer_common_test.cc

TEST(SanitizerCommon, ReservedAddressRangeMap) {
 
   // Valid mappings should succeed.
   CHECK_EQ(res, address_range.Map(res, init_size));
 
   // Valid mappings should be readable.
   unsigned char buffer[init_size];
   memcpy(buffer, reinterpret_cast<void *>(res), init_size);
 
-  // Invalid mappings should fail.
-  EXPECT_DEATH(address_range.Map(res, 0), ".*");
-
   // TODO(flowerhack): Once this is switched to the "real" implementation, make
   // sure you can only mmap into offsets in the Init range.
 }
 
 TEST(SanitizerCommon, ReservedAddressRangeUnmap) {
   uptr PageSize = GetPageSizeCached();
-  uptr init_size = PageSize * 4;
+  uptr init_size = PageSize * 8;
   ReservedAddressRange address_range;
   uptr base_addr = address_range.Init(init_size);
   CHECK_NE(base_addr, (void*)-1);
   CHECK_EQ(base_addr, address_range.Map(base_addr, init_size));
 
   // Unmapping the entire range should succeed.
-  address_range.Unmap(base_addr, PageSize * 4);
+  address_range.Unmap(base_addr, init_size);
 
-  // Remap that range in.
+  // Map a new range.
+  base_addr = address_range.Init(init_size);
   CHECK_EQ(base_addr, address_range.Map(base_addr, init_size));
 
   // Windows doesn't allow partial unmappings.
   #if !SANITIZER_WINDOWS
 
   // Unmapping at the beginning should succeed.
   address_range.Unmap(base_addr, PageSize);
 
   // Unmapping at the end should succeed.
   uptr new_start = reinterpret_cast<uptr>(address_range.base()) +
                    address_range.size() - PageSize;
   address_range.Unmap(new_start, PageSize);
 
   #endif
 
   // Unmapping in the middle of the ReservedAddressRange should fail.
-  EXPECT_DEATH(address_range.Unmap(base_addr + 0xf, 0xff), ".*");
+  EXPECT_DEATH(address_range.Unmap(base_addr + (PageSize * 2), PageSize), ".*");
 }
 
 }  // namespace __sanitizer