[asan] [mips] added support of asan for mips64/mips64el

[sdkie]

Summary

just done few architecture dependent code
Corresponding LLVM patch - http://reviews.llvm.org/D6165

[samsonov]

Again, I'll let Kostya sign this off. I'm generally fine with this change as long as it really fixes MIPS and you plan to support MIPS port.

[kcc]

lib/asan/asan_allocator.h

107 ↗

(On Diff #15545)

Is this enough?
As I've asked in http://reviews.llvm.org/D5906, did you verify that this works on
applications that allocate 8Gb of RAM with the same size class?
Or mips machines are not expected to be used with that much RAM?
What is the maximal amount of physical RAM in a mips machine for a foreseeable future?

lib/sanitizer_common/sanitizer_printf.cc

115

I'd like to move this logic to sanitizer_common/sanitizer_platform.h.

Define something like SANITIZER_POINTER_FORMAT_LENGTH there and
please use FIRST_32_SECOND_64

[dsanders]

lib/asan/asan_allocator.h

107 ↗

(On Diff #15545)

As I've asked in http://reviews.llvm.org/D5906, did you verify that this works on applications that allocate 8Gb of RAM with the same size class?
Or mips machines are not expected to be used with that much RAM?
What is the maximal amount of physical RAM in a mips machine for a foreseeable future?

I can't answer the 'Is this enough?' question but at the moment the biggest machines we have available to test on have 8GB RAM. It seems reasonable to predict that there will be >32GB machines in the not too distant future though.

One other thing to mention is that I've just found out that MIPS64r1 is limited to 36-bit physical addresses (64GB). MIPS64r2 added an extension to provide (up to) 59-bit physical addresses. On both architectures, there is a 64-bit virtual address space of which half is for the kernel and half is for user applications.

[kcc]

lib/asan/asan_allocator.h

107 ↗

(On Diff #15545)

The way SanitizerAllocator64 is designed it will not work with 36-bit physical addresses.
It will appear to work on small tests, but as soon as you try to allocate Gigs of RAM with e.g. 32-byte chunks it will run out of space.
So, for 36-bit space just use SanitizerAllocator32

59-bit physical addresses should be more than enough to use SanitizerAllocator64

[sdkie]

added SANITIZER_POINTER_FORMAT_LENGTH variable

[sdkie]

@kcc: As mentioned here[1], whether 16TB of memory is must for asan64 ?
Because test-cases in compiler-rt are working fine.
Now I am planning to build some big application with asan which require GBs of memory.

[1] http://clang.llvm.org/docs/AddressSanitizer.html#limitations

[kcc]

In D6024#13, @kumarsukhani wrote:

@kcc: As mentioned here[1], whether 16TB of memory is must for asan64 ?

16Tb is the limit for the 47-bit address space in x86_64 -- asan requires that much AS for the shadow.
It also requires 4Tb for the allocator, so on x86_64 the current requirement is 20Tb.

With another address space the limits will be different.

Because test-cases in compiler-rt are working fine.
Now I am planning to build some big application with asan which require GBs of memory.

No need to try a large app.
Write a test that allocates (and does not deallocate) 32-byte chunks in an infinite loop and see how much RAM it can allocate.

[1] http://clang.llvm.org/docs/AddressSanitizer.html#limitations

[sdkie]

@kcc: with top command I can see that address sanitized application can allocate VIRT(virtual memory) upto 1TB before exiting .

[kcc]

In D6024#15, @kumarsukhani wrote:

@kcc: with top command I can see that address sanitized application can allocate VIRT(virtual memory) upto 1TB before exiting .

This is not what I suggested. Please run the following program:
#include <stdio.h>
volatile void *sink;
int main() {

const size_t kSize = 24;
for (size_t i = 0; ; i++) {
  if ((i & (i - 1)) == 0)
    printf("Allocated %zd chunks of %zd bytes, total %zd Mb\n", 
           i, kSize, (i * kSize) >> 20);
  char *x = new char[kSize];
  x[i % kSize] = 42;
  sink = x;
}

}

clang++ -fsanitize=address malloc_loop.cc && ./a.out

With the current settings on x86_64 it will exhaust all RAM on my machine before dying.
If I set kAllocatorSize to 0x4000000000ULL (minimal allowed) the program will fail like this:
...
Allocated 33554432 chunks of 24 bytes, total 768 Mb
Allocated 67108864 chunks of 24 bytes, total 1536 Mb
AddressSanitizer: Out of memory. Dying. The process has exhausted 4096MB for size class 48.

You don't want you program to die after allocating ~3Gb of memory.

Yet again, SanitizerAllocator64 is not designed to support 36-bit address space, just use SanitizerAllocator32

[sdkie]

I got same output as you posted above. I tested it on mips64.

...
Allocated 16777216 chunks of 24 bytes, total 384 Mb
Allocated 33554432 chunks of 24 bytes, total 768 Mb
Allocated 67108864 chunks of 24 bytes, total 1536 Mb
AddressSanitizer: Out of memory. Dying. The process has exhausted 4096MB for size class 48.

[kcc]

In D6024#18, @kumarsukhani wrote:

I got same output as you posted above. I tested it on mips64.

...
Allocated 16777216 chunks of 24 bytes, total 384 Mb
Allocated 33554432 chunks of 24 bytes, total 768 Mb
Allocated 67108864 chunks of 24 bytes, total 1536 Mb
AddressSanitizer: Out of memory. Dying. The process has exhausted 4096MB for size class 48.

Which proves my point. Don't use SanitizerAllocator64 unless you have at least ~46 bits of address space.
Check SANITIZER_CAN_USE_ALLOCATOR64 in sanitizer_common/sanitizer_platform.h

[sdkie]

using SanitizerAllocator32 instead of SanitizerAllocator64 for mips64 as its address space is just 40-bit

[sdkie]

The output of malloc_loop.cc:
...
Allocated 16777216 chunks of 24 bytes, total 384 Mb
Allocated 33554432 chunks of 24 bytes, total 768 Mb
Allocated 67108864 chunks of 24 bytes, total 1536 Mb
Killed

[kcc]

LGTM

[kcc]

r221800.

lib/sanitizer_common/sanitizer_platform.h

115

This needs to be "8,12", not "12,8"
Please make sure your patches pass testing (check-all) on x86_64 Linux:

[sdkie]

Sorry for that mistake.
I will make sure my patch doesn't break anything on x86_64.

cmake/config-ix.cmake

if (NOT MSVC)
       test_target_arch(x86_64 ${TARGET_64_BIT_CFLAGS})
     endif()
     test_target_arch(i386 ${TARGET_32_BIT_CFLAGS})
   elseif("${LLVM_NATIVE_ARCH}" STREQUAL "PowerPC")
     test_target_arch(powerpc64 ${TARGET_64_BIT_CFLAGS})
     test_target_arch(powerpc64le ${TARGET_64_BIT_CFLAGS})
   elseif("${LLVM_NATIVE_ARCH}" STREQUAL "Mips")
     if("${COMPILER_RT_TEST_TARGET_ARCH}" MATCHES "mipsel|mips64el")
-      # regex for mipsel, mips64el                                                                                                                                                                                 
+      # regex for mipsel, mips64el
       test_target_arch(mipsel ${TARGET_32_BIT_CFLAGS})
       test_target_arch(mips64el ${TARGET_64_BIT_CFLAGS})
     else()
       test_target_arch(mips ${TARGET_32_BIT_CFLAGS})
       test_target_arch(mips64 ${TARGET_64_BIT_CFLAGS})
     endif()
   elseif("${COMPILER_RT_TEST_TARGET_ARCH}" MATCHES "arm")
     test_target_arch(arm "-march=armv7-a")
function(filter_available_targets out_var)
   endforeach()
   set(${out_var} ${archs} PARENT_SCOPE)
 endfunction()
 
 # Arhcitectures supported by compiler-rt libraries.
 filter_available_targets(SANITIZER_COMMON_SUPPORTED_ARCH
   x86_64 i386 i686 powerpc64 powerpc64le arm aarch64 mips mips64 mipsel mips64el)
 filter_available_targets(ASAN_SUPPORTED_ARCH
-  x86_64 i386 i686 powerpc64 powerpc64le arm mips mipsel)
+  x86_64 i386 i686 powerpc64 powerpc64le arm mips mipsel mips64 mips64el)
 filter_available_targets(DFSAN_SUPPORTED_ARCH x86_64)
 filter_available_targets(LSAN_SUPPORTED_ARCH x86_64)
 # LSan common files should be available on all architectures supported
 # by other sanitizers (even if they build into dummy object files).
 filter_available_targets(LSAN_COMMON_SUPPORTED_ARCH
   ${SANITIZER_COMMON_SUPPORTED_ARCH})
 filter_available_targets(MSAN_SUPPORTED_ARCH x86_64)
 filter_available_targets(PROFILE_SUPPORTED_ARCH x86_64 i386 i686 arm mips mips64 mipsel mips64el aarch64)

lib/asan/asan_mapping.h

 
 static const u64 kDefaultShadowScale = 3;
 static const u64 kDefaultShadowOffset32 = 1ULL << 29;  // 0x20000000
 static const u64 kIosShadowOffset32 = 1ULL << 30;  // 0x40000000
 static const u64 kDefaultShadowOffset64 = 1ULL << 44;
 static const u64 kDefaultShort64bitShadowOffset = 0x7FFF8000;  // < 2G.
 static const u64 kAArch64_ShadowOffset64 = 1ULL << 36;
 static const u64 kMIPS32_ShadowOffset32 = 0x0aaa0000;
+static const u64 kMIPS64_ShadowOffset64 = 1ULL << 36;
 static const u64 kPPC64_ShadowOffset64 = 1ULL << 41;
 static const u64 kFreeBSD_ShadowOffset32 = 1ULL << 30;  // 0x40000000
 static const u64 kFreeBSD_ShadowOffset64 = 1ULL << 46;  // 0x400000000000
 
 #define SHADOW_SCALE kDefaultShadowScale
 #if SANITIZER_ANDROID
 # define SHADOW_OFFSET (0)
 #else

 #  if defined(__aarch64__)
 #    define SHADOW_OFFSET kAArch64_ShadowOffset64
 #  elif defined(__powerpc64__)
 #    define SHADOW_OFFSET kPPC64_ShadowOffset64
 #  elif SANITIZER_FREEBSD
 #    define SHADOW_OFFSET kFreeBSD_ShadowOffset64
 #  elif SANITIZER_MAC
 #   define SHADOW_OFFSET kDefaultShadowOffset64
+#  elif defined(__mips64)
+#   define SHADOW_OFFSET kMIPS64_ShadowOffset64
 #  else
 #   define SHADOW_OFFSET kDefaultShort64bitShadowOffset
 #  endif
 # endif
 #endif
 
 #define SHADOW_GRANULARITY (1ULL << SHADOW_SCALE)
 #define MEM_TO_SHADOW(mem) (((mem) >> SHADOW_SCALE) + (SHADOW_OFFSET))

lib/sanitizer_common/sanitizer_platform.h

 #endif
 
 // By default we allow to use SizeClassAllocator64 on 64-bit platform.
 // But in some cases (e.g. AArch64's 39-bit address space) SizeClassAllocator64
 // does not work well and we need to fallback to SizeClassAllocator32.
 // For such platforms build this code with -DSANITIZER_CAN_USE_ALLOCATOR64=0 or
 // change the definition of SANITIZER_CAN_USE_ALLOCATOR64 here.
 #ifndef SANITIZER_CAN_USE_ALLOCATOR64
-# if defined(__aarch64__)
+# if defined(__aarch64__) || defined(__mips64)
 #  define SANITIZER_CAN_USE_ALLOCATOR64 0
 # else
 #  define SANITIZER_CAN_USE_ALLOCATOR64 (SANITIZER_WORDSIZE == 64)
 # endif
 #endif
 
 // The range of addresses which can be returned my mmap.
 // FIXME: this value should be different on different platforms,

 #ifndef SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
 # if defined(__aarch64__) && SANITIZER_LINUX
 # define SANITIZER_USES_CANONICAL_LINUX_SYSCALLS 1
 # else
 # define SANITIZER_USES_CANONICAL_LINUX_SYSCALLS 0
 # endif
 #endif
 
+#ifdef __mips__
+# define SANITIZER_POINTER_FORMAT_LENGTH FIRST_32_SECOND_64(10, 8)
+#else
+# define SANITIZER_POINTER_FORMAT_LENGTH FIRST_32_SECOND_64(12, 8)
+#endif
+
 #endif // SANITIZER_PLATFORM_H

lib/sanitizer_common/sanitizer_posix.cc

# if defined(__powerpc64__)
   // We somehow need to figure out which one we are using now and choose
   // one of 0x00000fffffffffffUL and 0x00003fffffffffffUL.
   // Note that with 'ulimit -s unlimited' the stack is moved away from the top
   // of the address space, so simply checking the stack address is not enough.
   // This should (does) work for both PowerPC64 Endian modes.
   return (1ULL << (MostSignificantSetBitIndex(GET_CURRENT_FRAME()) + 1)) - 1;
 # elif defined(__aarch64__)
   return (1ULL << 39) - 1;
+# elif defined(__mips64)
+  return (1ULL << 40) - 1;
 # else
   return (1ULL << 47) - 1;  // 0x00007fffffffffffUL;
 # endif
 #else  // SANITIZER_WORDSIZE == 32
   uptr res = (1ULL << 32) - 1;  // 0xffffffff;
   if (!common_flags()->full_address_space)
     res -= GetKernelAreaSize();
   CHECK_LT(reinterpret_cast<uptr>(&res), res);

lib/sanitizer_common/sanitizer_printf.cc

for (; *s; s++) {
     result += AppendChar(buff, buff_end, *s);
   }
   return result;
 }
 
 static int AppendPointer(char **buff, const char *buff_end, u64 ptr_value) {
   int result = 0;
   result += AppendString(buff, buff_end, -1, "0x");
   result += AppendUnsigned(buff, buff_end, ptr_value, 16,
-                           (SANITIZER_WORDSIZE == 64) ? 12 : 8, true);
+                           SANITIZER_POINTER_FORMAT_LENGTH, true);
   return result;
 }
 
 int VSNPrintf(char *buff, int buff_length,
               const char *format, va_list args) {
   static const char *kPrintfFormatsHelp =
     "Supported Printf formats: %([0-9]*)?(z|ll)?{d,u,x}; %p; %(\\.\\*)?s; %c\n";
   RAW_CHECK(format);

test/asan/CMakeLists.txt

if(CAN_TARGET_aarch64)
     set(ASAN_TEST_DYNAMIC False)
     configure_lit_site_cfg(
       ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
       ${CMAKE_CURRENT_BINARY_DIR}/AArch64LinuxConfig/lit.site.cfg
       )
     list(APPEND ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/AArch64LinuxConfig)
   endif()
 
-  if(CAN_TARGET_x86_64 OR CAN_TARGET_powerpc64)
+  if(CAN_TARGET_x86_64 OR CAN_TARGET_powerpc64 OR CAN_TARGET_mips64 OR CAN_TARGET_mips64el)
     set(ASAN_TEST_CONFIG_SUFFIX "64")
     set(ASAN_TEST_BITS "64")
     set(ASAN_TEST_TARGET_CFLAGS ${TARGET_64_BIT_CFLAGS})
     set(ASAN_TEST_DYNAMIC False)
     configure_lit_site_cfg(
       ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
       ${CMAKE_CURRENT_BINARY_DIR}/64bitConfig/lit.site.cfg
       )