[ASAN] Add support for mips/mips64 android

[slthakur]

Summary

Patch by Duane Sand

The mips32r2 build of asan_test runs cleanly with same result as for arm/arm64/x86: 3 failed subtests.
The mips64r6 asan_test fails early on a huge_malloc subtest without trying all tests. This is a bug in mips64 malloc, not in asan.

[samsonov]

lib/sanitizer_common/sanitizer_linux.cc

595

You might introduce a separate #define that would tell you whether you're on 32-bit MIPS: it's better than
spraying defined(__mips__) && !defined(__mips64) and its negation throughout the code.

lib/sanitizer_common/sanitizer_platform_limits_posix.h

82

const unsigned struct_kernel_stat_sz = (SANITIZER_WORDSIZE == 64) ? 128 : 104;

you can use the same construct below.

527

Use #if defined() form where possible.

549

That's incredibly hard to understand. Can you keep one level of nested #if's somehow?

[eugenis]

lib/sanitizer_common/sanitizer_linux.cc

595

Yes. We don't really do that now, but we can start.
Smth like SANITIZER_MIPS (for either variant), SANITIZER_MIPS32, SANITIZER_MIPS64. In sanitizer_platform.h.

lib/sanitizer_common/sanitizer_platform_limits_posix.h

549

If mips32 is special, it could be worth duplicating the entire __sanitizer_sigaction definition just for that.

[mohit.bhakkad]

sagar is not available for a week, request you to please review this at D17883

lib/sanitizer_common/sanitizer_linux.cc

if (u_act) {
     // FIXME: most often sa_restorer is unset, however the kernel requires it
     // to point to a valid signal restorer that calls the rt_sigreturn syscall.
     // If sa_restorer passed to the kernel is NULL, the program may crash upon
     // signal delivery or fail to unwind the stack in the signal handler.
     // libc implementation of sigaction() passes its own restorer to
     // rt_sigaction, so we need to do the same (we'll need to reimplement the
     // restorers; for x86_64 the restorer address can be obtained from
     // oldact->sa_restorer upon a call to sigaction(xxx, NULL, oldact).
+#if !(SANITIZER_ANDROID && defined(__mips__) && !defined(__mips64))
     k_act.sa_restorer = u_act->sa_restorer;
+#endif
   }
 
   uptr result = internal_syscall(SYSCALL(rt_sigaction), (uptr)signum,
       (uptr)(u_act ? &k_act : nullptr),
       (uptr)(u_oldact ? &k_oldact : nullptr),
       (uptr)sizeof(__sanitizer_kernel_sigset_t));
 
   if ((result == 0) && u_oldact) {
     u_oldact->handler = k_oldact.handler;
     u_oldact->sigaction = k_oldact.sigaction;
     internal_memcpy(&u_oldact->sa_mask, &k_oldact.sa_mask,
                     sizeof(__sanitizer_kernel_sigset_t));
     u_oldact->sa_flags = k_oldact.sa_flags;
+#if !(SANITIZER_ANDROID && defined(__mips__) && !defined(__mips64))
     u_oldact->sa_restorer = k_oldact.sa_restorer;
+#endif
   }
   return result;
 }
 #endif  // SANITIZER_LINUX
 
 uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set,
     __sanitizer_sigset_t *oldset) {
 #if SANITIZER_FREEBSD

lib/sanitizer_common/sanitizer_linux_libcdep.cc

#ifdef PR_GET_NAME
   internal_strncpy(name, buff, max_len);
   name[max_len] = 0;
   return true;
 #else
   return false;
 #endif
 }
 
-#if !SANITIZER_FREEBSD && !SANITIZER_ANDROID && !SANITIZER_GO
+#if !SANITIZER_FREEBSD && !(SANITIZER_ANDROID && !defined(__mips__)) \
+  && !SANITIZER_GO
 static uptr g_tls_size;
 #endif
 
 #ifdef __i386__
 # define DL_INTERNAL_FUNCTION __attribute__((regparm(3), stdcall))
 #else
 # define DL_INTERNAL_FUNCTION
 #endif

lib/sanitizer_common/sanitizer_platform_limits_posix.h

#elif defined(__aarch64__)
   const unsigned struct_kernel_stat64_sz = 104;
 #elif defined(__powerpc__) && !defined(__powerpc64__)
   const unsigned struct_kernel_stat_sz = 72;
   const unsigned struct_kernel_stat64_sz = 104;
 #elif defined(__powerpc64__)
   const unsigned struct_kernel_stat_sz = 144;
   const unsigned struct_kernel_stat64_sz = 104;
 #elif defined(__mips__)
+  #if SANITIZER_ANDROID
+    #if SANITIZER_WORDSIZE == 64
+    const unsigned struct_kernel_stat_sz = 128;
+    #else
+    const unsigned struct_kernel_stat_sz = 104;
+    #endif
+  #else
     #if SANITIZER_WORDSIZE == 64
     const unsigned struct_kernel_stat_sz = 216;
     #else
     const unsigned struct_kernel_stat_sz = 144;
     #endif
+  #endif
   const unsigned struct_kernel_stat64_sz = 104;
 #endif
   struct __sanitizer_perf_event_attr {
     unsigned type;
     unsigned size;
     // More fields that vary with the kernel version.
   };
 
#endif
   // limit. Verified with a compiler assert in .cc.
   const int pthread_attr_t_max_sz = 128;
   union __sanitizer_pthread_attr_t {
     char size[pthread_attr_t_max_sz]; // NOLINT
     void *align;
   };
 
 #if SANITIZER_ANDROID
+  #ifdef __mips__
+  typedef unsigned long __sanitizer_sigset_t[16/sizeof(unsigned long)];
+  #else
   typedef unsigned long __sanitizer_sigset_t;
+  #endif
 #elif SANITIZER_MAC
   typedef unsigned __sanitizer_sigset_t;
 #elif SANITIZER_LINUX
   struct __sanitizer_sigset_t {
     // The size is determined by looking at sizeof of real sigset_t on linux.
     uptr val[128 / sizeof(uptr)];
   };
 #elif SANITIZER_FREEBSD
   struct __sanitizer_sigset_t {
      // uint32_t * 4
      unsigned int __bits[4];
   };
 #endif
 
   // Linux system headers define the 'sa_handler' and 'sa_sigaction' macros.
-#if SANITIZER_ANDROID && (SANITIZER_WORDSIZE == 64)
+
+#if SANITIZER_ANDROID
+#if SANITIZER_WORDSIZE == 64 || defined(__mips__)
   struct __sanitizer_sigaction {
     unsigned sa_flags;
     union {
       void (*sigaction)(int sig, void *siginfo, void *uctx);
       void (*handler)(int sig);
     };
     __sanitizer_sigset_t sa_mask;
+    #if !defined(__mips__) || defined(__mips64)
     void (*sa_restorer)();
+    #endif
   };
-#elif SANITIZER_ANDROID && (SANITIZER_WORDSIZE == 32)
+#else  // non-mips wordsize 32
   struct __sanitizer_sigaction {
     union {
       void (*sigaction)(int sig, void *siginfo, void *uctx);
       void (*handler)(int sig);
     };
     __sanitizer_sigset_t sa_mask;
     uptr sa_flags;
     void (*sa_restorer)();
   };
+#endif // SANITIZE_WORDSIZE
 #else // !SANITIZER_ANDROID
   struct __sanitizer_sigaction {
 #if defined(__mips__) && !SANITIZER_FREEBSD
     unsigned int sa_flags;
 #endif
     union {
       void (*sigaction)(int sig, void *siginfo, void *uctx);
       void (*handler)(int sig);

lib/sanitizer_common/sanitizer_platform_limits_posix.cc

 
 CHECK_TYPE_SIZE(sigset_t);
 
 COMPILER_CHECK(sizeof(__sanitizer_sigaction) == sizeof(struct sigaction));
 // Can't write checks for sa_handler and sa_sigaction due to them being
 // preprocessor macros.
 CHECK_STRUCT_SIZE_AND_OFFSET(sigaction, sa_mask);
 CHECK_STRUCT_SIZE_AND_OFFSET(sigaction, sa_flags);
-#if SANITIZER_LINUX
+#if SANITIZER_LINUX && (!defined(__mips__) || defined(__mips64))
 CHECK_STRUCT_SIZE_AND_OFFSET(sigaction, sa_restorer);
 #endif
 
 #if SANITIZER_LINUX
 CHECK_TYPE_SIZE(__sysctl_args);
 CHECK_SIZE_AND_OFFSET(__sysctl_args, name);
 CHECK_SIZE_AND_OFFSET(__sysctl_args, nlen);
 CHECK_SIZE_AND_OFFSET(__sysctl_args, oldval);

lib/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc

 #if SANITIZER_ANDROID && defined(__arm__)
 # include <linux/user.h>  // for pt_regs
 #else
 # ifdef __aarch64__
 // GLIBC 2.20+ sys/user does not include asm/ptrace.h
 #  include <asm/ptrace.h>
 # endif
 # include <sys/user.h>  // for user_regs_struct
+# if SANITIZER_ANDROID && defined(__mips__)
+#   include <asm/reg.h>  // for mips SP register in sys/user.h
+# endif
 #endif
 #include <sys/wait.h> // for signal-related stuff
 
 #ifdef sa_handler
 # undef sa_handler
 #endif
 
 #ifdef sa_sigaction

 #endif
 
 #elif defined(__powerpc__) || defined(__powerpc64__)
 typedef pt_regs regs_struct;
 #define REG_SP gpr[PT_R1]
 
 #elif defined(__mips__)
 typedef struct user regs_struct;
+#if SANITIZER_ANDROID
+#define REG_SP regs[EF_R29]
+#else
 #define REG_SP regs[EF_REG29]
+#endif
 
 #elif defined(__aarch64__)
 typedef struct user_pt_regs regs_struct;
 #define REG_SP sp
 #define ARCH_IOVEC_FOR_GETREGSET
 
 #else
 #error "Unsupported architecture"