[sanitizer] Revert D50940

[cryptoad]

Summary

The previous version of the patch makes some code unable to distinguish
failure to map address 0 and error.
Revert to turn the bots back to green while figuring out a new approach.

[eugenis]

LGTM

lib/asan/asan_linux.cc

#endif
 
   uptr granularity = GetMmapGranularity();
   uptr alignment = granularity * 8;
   uptr left_padding = granularity;
   uptr shadow_size = RoundUpTo(kHighShadowEnd, granularity);
   uptr map_size = shadow_size + left_padding + alignment;
 
   uptr map_start = (uptr)MmapNoAccess(map_size);
-  CHECK(map_start);
+  CHECK_NE(map_start, ~(uptr)0);
 
   uptr shadow_start = RoundUpTo(map_start + left_padding, alignment);
   UnmapFromTo(map_start, shadow_start - left_padding);
   UnmapFromTo(shadow_start + shadow_size, map_start + map_size);
 
   return shadow_start;
 }
 

lib/asan/asan_premap_shadow.cc

 uptr PremapShadow() {
   uptr granularity = GetMmapGranularity();
   uptr alignment = granularity * 8;
   uptr left_padding = granularity;
   uptr shadow_size = PremapShadowSize();
   uptr map_size = shadow_size + left_padding + alignment;
 
   uptr map_start = (uptr)MmapNoAccess(map_size);
-  CHECK(map_start);
+  CHECK_NE(map_start, ~(uptr)0);
 
   uptr shadow_start = RoundUpTo(map_start + left_padding, alignment);
   uptr shadow_end = shadow_start + shadow_size;
   internal_munmap(reinterpret_cast<void *>(map_start),
                   shadow_start - left_padding - map_start);
   internal_munmap(reinterpret_cast<void *>(shadow_end),
                   map_start + map_size - shadow_end);
   return shadow_start;

lib/hwasan/hwasan_dynamic_shadow.cc

static uptr MapDynamicShadow(uptr shadow_size_bytes) {
   const uptr granularity = GetMmapGranularity();
   const uptr alignment = granularity * SHADOW_GRANULARITY;
   const uptr left_padding = granularity;
   const uptr shadow_size =
       RoundUpTo(shadow_size_bytes, granularity);
   const uptr map_size = shadow_size + left_padding + alignment;
 
   const uptr map_start = (uptr)MmapNoAccess(map_size);
-  CHECK(map_start);
+  CHECK_NE(map_start, ~(uptr)0);
 
   const uptr shadow_start = RoundUpTo(map_start + left_padding, alignment);
 
   UnmapFromTo(map_start, shadow_start - left_padding);
   UnmapFromTo(shadow_start + shadow_size, map_start + map_size);
 
   return shadow_start;
 }

lib/sanitizer_common/sanitizer_allocator_primary64.h

public:
   void Init(s32 release_to_os_interval_ms) {
     uptr TotalSpaceSize = kSpaceSize + AdditionalSize();
     if (kUsingConstantSpaceBeg) {
       CHECK_EQ(kSpaceBeg, address_range.Init(TotalSpaceSize,
                                              PrimaryAllocatorName, kSpaceBeg));
     } else {
       NonConstSpaceBeg = address_range.Init(TotalSpaceSize,
                                             PrimaryAllocatorName);
-      CHECK(NonConstSpaceBeg);
+      CHECK_NE(NonConstSpaceBeg, ~(uptr)0);
     }
     SetReleaseToOSIntervalMs(release_to_os_interval_ms);
     MapWithCallbackOrDie(SpaceEnd(), AdditionalSize());
     // Check that the RegionInfo array is aligned on the CacheLine size.
     DCHECK_EQ(SpaceEnd() % kCacheLineSize, 0);
   }
 
   s32 ReleaseToOSIntervalMs() const {

lib/sanitizer_common/sanitizer_mac_libcdep.cc

 // This file is shared between various sanitizers' runtime libraries and
 // implements OSX-specific functions.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
 #if SANITIZER_MAC
 #include "sanitizer_mac.h"
 
+#include <sys/mman.h>
+
 namespace __sanitizer {
 
 void RestrictMemoryToMaxAddress(uptr max_address) {
   uptr size_to_mmap = GetMaxUserVirtualAddress() + 1 - max_address;
   void *res = MmapFixedNoAccess(max_address, size_to_mmap, "high gap");
-  CHECK(res);
+  CHECK(res != MAP_FAILED);
 }
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_MAC

lib/sanitizer_common/sanitizer_posix_libcdep.cc

void ReservedAddressRange::Unmap(uptr addr, uptr size) {
   UnmapOrDie(reinterpret_cast<void*>(addr), size);
 }
 
 void *MmapFixedNoAccess(uptr fixed_addr, uptr size, const char *name) {
   int fd = name ? GetNamedMappingFd(name, size) : -1;
   unsigned flags = MAP_PRIVATE | MAP_FIXED | MAP_NORESERVE;
   if (fd == -1) flags |= MAP_ANON;
 
-  uptr p = internal_mmap((void *)fixed_addr, size, PROT_NONE, flags, fd, 0);
-  if (internal_iserror(p))
-    return nullptr;
-  return (void *)p;
+  return (void *)internal_mmap((void *)fixed_addr, size, PROT_NONE, flags, fd,
+                               0);
 }
 
 void *MmapNoAccess(uptr size) {
   unsigned flags = MAP_PRIVATE | MAP_ANON | MAP_NORESERVE;
-  uptr p = internal_mmap(nullptr, size, PROT_NONE, flags, -1, 0);
-  if (internal_iserror(p))
-    return nullptr;
-  return (void *)p;
+  return (void *)internal_mmap(nullptr, size, PROT_NONE, flags, -1, 0);
 }
 
 // This function is defined elsewhere if we intercepted pthread_attr_getstack.
 extern "C" {
 SANITIZER_WEAK_ATTRIBUTE int
 real_pthread_attr_getstack(void *attr, void **addr, size_t *size);
 } // extern "C"
 

lib/scudo/scudo_allocator_secondary.h

if (UNLIKELY(Alignment > MinAlignment))
       ReservedSize += Alignment;
     const uptr PageSize = GetPageSizeCached();
     ReservedSize = RoundUpTo(ReservedSize, PageSize);
     // Account for 2 guard pages, one before and one after the chunk.
     ReservedSize += 2 * PageSize;
 
     ReservedAddressRange AddressRange;
     uptr ReservedBeg = AddressRange.Init(ReservedSize, SecondaryAllocatorName);
-    if (UNLIKELY(!ReservedBeg))
+    if (UNLIKELY(ReservedBeg == ~static_cast<uptr>(0)))
       return nullptr;
     // A page-aligned pointer is assumed after that, so check it now.
     DCHECK(IsAligned(ReservedBeg, PageSize));
     uptr ReservedEnd = ReservedBeg + ReservedSize;
     // The beginning of the user area for that allocation comes after the
     // initial guard page, and both headers. This is the pointer that has to
     // abide by alignment requirements.
     uptr CommittedBeg = ReservedBeg + PageSize;