[hwasan] Increase allocator space for non-android Linux

[vitalybuka]

Summary

This is max acceptable value with pow of 2 for DefaultSizeClassMap, the
same as for ASAN.

[vitalybuka]

update

compiler-rt/lib/hwasan/hwasan_allocator.h

 
 static const uptr kMaxAllowedMallocSize = 1UL << 40;  // 1T
 
 struct AP64 {
   static const uptr kSpaceBeg = ~0ULL;
 
 #if defined(HWASAN_ALIASING_MODE)
   static const uptr kSpaceSize = 1ULL << kAddressTagShift;
+  typedef __sanitizer::DefaultSizeClassMap SizeClassMap;
+#elif SANITIZER_LINUX && !SANITIZER_ANDROID
+  static const uptr kSpaceSize = 0x40000000000ULL;  // 4T.
+  typedef __sanitizer::DefaultSizeClassMap SizeClassMap;
 #else
-  static const uptr kSpaceSize = 0x2000000000ULL;
+  static const uptr kSpaceSize = 0x2000000000ULL;  // 128G.
+  typedef __sanitizer::VeryDenseSizeClassMap SizeClassMap;
 #endif
+
   static const uptr kMetadataSize = sizeof(Metadata);
-  typedef __sanitizer::VeryDenseSizeClassMap SizeClassMap;
   using AddressSpaceView = LocalAddressSpaceView;
   typedef HwasanMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;
 };
+
 typedef SizeClassAllocator64<AP64> PrimaryAllocator;
 typedef CombinedAllocator<PrimaryAllocator> Allocator;
 typedef Allocator::AllocatorCache AllocatorCache;
 
 void AllocatorSwallowThreadLocalCache(AllocatorCache *cache);
 
 class HwasanChunkView {
  public:

compiler-rt/test/hwasan/TestCases/Linux/decorate-proc-maps.c

void *ThreadFn(void *arg) {
   CopyFdToFd(fd, 2);
   close(fd);
   return NULL;
 }
 
 int main(void) {
   pthread_t t;
   void * volatile res = malloc(100);
-  void * volatile res2 = malloc(100000);
+  void * volatile res2 = malloc(1000000);
   pthread_create(&t, 0, ThreadFn, 0);
   pthread_join(t, 0);
   int ret_val = (int)(size_t)res;
   free(res);
   free(res2);
   return ret_val;
 }

compiler-rt/test/hwasan/TestCases/use-after-free.c

int main() {
   if (ISREAD) r = x[5]; else x[5] = 42;  // should be on the same line.
   // CHECK: ERROR: HWAddressSanitizer: tag-mismatch on address {{.*}} at pc {{[0x]+}}[[PC:.*]]
   // CHECK: [[TYPE]] of size 1 at {{.*}} tags: [[PTR_TAG:[0-9a-f][0-9a-f]]]/[[MEM_TAG:[0-9a-f][0-9a-f]]] (ptr/mem)
   // CHECK: #{{[0-9]}} {{[0-9]+}}{{.*}}[[PC]]
   // If we instrument using calls (default on x86), main is not the top frame
   // of the fault.
   // CHECK: in main {{.*}}use-after-free.c:[[@LINE-6]]
   // Offset is 5 or 11 depending on left/right alignment.
-  // CHECK: is a small unallocated heap chunk; size: 32 offset: {{5|11}}
+  // CHECK: is a small unallocated heap chunk; size: {{16|32}} offset: {{5|11}}
   // CHECK: Cause: use-after-free
   // CHECK: is located 5 bytes inside a 10-byte region
   //
   // CHECK: freed by thread {{.*}} here:
   // CHECK: #0 {{.*}} in {{.*}}free{{.*}} {{.*}}hwasan_allocation_functions.cpp
   // CHECK: #1 {{.*}} in main {{.*}}use-after-free.c:[[@LINE-19]]
 
   // CHECK: previously allocated here:
   // CHECK: #0 {{.*}} in {{.*}}malloc{{.*}} {{.*}}hwasan_allocation_functions.cpp
   // CHECK: #1 {{.*}} in main {{.*}}use-after-free.c:[[@LINE-24]]
   // CHECK: Memory tags around the buggy address (one tag corresponds to 16 bytes):
   // CHECK: =>{{.*}}[[MEM_TAG]]
   // CHECK: SUMMARY: HWAddressSanitizer: tag-mismatch
   return r;
 }