[ASAN] Add support for mips/mips64 android

[mohit.bhakkad]

Summary

Continue here from D17842

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.

Changes:
Using arch macros defined in D17881
some indentation changes

[filcab]

I have some minor nits.

lib/sanitizer_common/sanitizer_linux_libcdep.cc

160

Can you push the negation inside the parens, please?

lib/sanitizer_common/sanitizer_platform_limits_posix.cc

1059

Please push the negation inside the parens.

lib/sanitizer_common/sanitizer_platform_limits_posix.h

82

I think using the FIRST_32_SECOND_64 macro would be even more readable. Even fits on one line.

[samsonov]

lib/sanitizer_common/sanitizer_platform_limits_posix.h

521

Please don't indend #ifs

[mohit.bhakkad]

Changed indentation and some other changes.

[filcab]

lib/sanitizer_common/sanitizer_linux.cc

595

No need for parens.

611

Same as line 611

[mohit.bhakkad]

Removed parens.

[samsonov]

lib/sanitizer_common/sanitizer_platform_limits_posix.h

550–551

Maybe, just provide a separate definition whenever SANITIZER_ANDROID && SANITIZER_MIPS32 is true?

[mohit.bhakkad]

Changes in this revision:

• separate definition of __sanitizer_sigactionfor mips32 android.
• using conditional operator at sanitizer_platform_limits_posix.h:80

[samsonov]

LGTM with a nit. Thanks!

lib/sanitizer_common/sanitizer_platform_limits_posix.h

553

double space before "//"

[duanesand]

lib/sanitizer_common/sanitizer_linux_libcdep.cc

160

Sorry, my mistake; this should revert back to the original condition, without SANITIZER_MIPS

162

This #endif should be moved down around all things using this variable; either after TlsPreTcbSize, or better yet, after InitTlsSize.

173

This function is only used when the nonempty version of InitTlsSize() is used, ie when

#if !SANITIZER_FREEBSD && !SANITIZER_ANDROID && !SANITIZER_GO

This TlsPreTcbSize() function must similarly be skipped when that condition is false, otherwise there is an unresolved ref to g_tls_size during mips Android builds.

189

This condition (which must match line 159 in the original) is prone to breaking again in the future. It would be best to not duplicate it, or else give it a positive name like SANITIZER_USES_TLS.

Rather than defining it as a bunch of negatives (against what world of possible os's?), I suggest redefining it more exactly as

SANITIZER_LINUX && !SANITIZER_ANDROID

if that is indeed the current situation

207

This defines a do-nothing body for InitTlsSize for some os's including Android. That allows its callers' source to be free of os dependencies, which is good. But the current way of skipping its body requires two matching instances of a non-obvious #if. These could be combined into a single #if by repeating the entire header and body of the do-nothing function in an #else part, ie

}
#else
void InitTlsSize() { }
#endif // !SANITIZER_FREEBSD && !SANITIZER_ANDROID && !SANITIZER_GO

lib/sanitizer_common/sanitizer_platform_limits_posix.h

560

final }; is missing

[mohit.bhakkad]

Hi @samsonov, Duane suggested some changes in sanitizer_common/sanitizer_linux_libcdep.cc, could you please review it?

[samsonov]

LGTM after addressing one minor comment below. Thanks!

lib/sanitizer_common/sanitizer_linux_libcdep.cc

173

Uhm, no, this function is only used in ThreadSelf(). Let's move it away from here, and right before ThreadSelf() definition below.

[mohit.bhakkad]

Thanks!

Changed the location of TlsPreTcbSize() in commit.

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 && SANITIZER_MIPS32)
     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 && SANITIZER_MIPS32)
     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 && !SANITIZER_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
 
 #if defined(__mips__) || defined(__powerpc64__)
 // TlsPreTcbSize includes size of struct pthread_descr and size of tcb
 // head structure. It lies before the static tls blocks.
 static uptr TlsPreTcbSize() {
 # if defined(__mips__)
   const uptr kTcbHead = 16; // sizeof (tcbhead_t)
 # elif defined(__powerpc64__)
   const uptr kTcbHead = 88; // sizeof (tcbhead_t)
 # endif
   const uptr kTlsAlign = 16;
   const uptr kTlsPreTcbSize =
     (ThreadDescriptorSize() + kTcbHead + kTlsAlign - 1) & ~(kTlsAlign - 1);
   InitTlsSize();
   g_tls_size = (g_tls_size + kTlsPreTcbSize + kTlsAlign -1) & ~(kTlsAlign - 1);
   return kTlsPreTcbSize;
 }
 #endif
 
 void InitTlsSize() {
 #if !SANITIZER_FREEBSD && !SANITIZER_ANDROID && !SANITIZER_GO
 // all current supported platforms have 16 bytes stack alignment
   const size_t kStackAlign = 16;
   typedef void (*get_tls_func)(size_t*, size_t*) DL_INTERNAL_FUNCTION;
   get_tls_func get_tls;
   void *get_tls_static_info_ptr = dlsym(RTLD_NEXT, "_dl_get_tls_static_info");
   CHECK_EQ(sizeof(get_tls), sizeof(get_tls_static_info_ptr));
   internal_memcpy(&get_tls, &get_tls_static_info_ptr,
                   sizeof(get_tls_static_info_ptr));
   CHECK_NE(get_tls, 0);
   size_t tls_size = 0;
   size_t tls_align = 0;
   get_tls(&tls_size, &tls_align);
   if (tls_align < kStackAlign)
     tls_align = kStackAlign;
   g_tls_size = RoundUpTo(tls_size, tls_align);
 #endif  // !SANITIZER_FREEBSD && !SANITIZER_ANDROID && !SANITIZER_GO
 }
 
 #if (defined(__x86_64__) || defined(__i386__) || defined(__mips__) \
     || defined(__aarch64__) || defined(__powerpc64__)) \
     && SANITIZER_LINUX && !SANITIZER_ANDROID
 // sizeof(struct pthread) from glibc.
 static atomic_uintptr_t kThreadDescriptorSize;
 
 uptr ThreadDescriptorSize() {
   uptr val = atomic_load(&kThreadDescriptorSize, memory_order_relaxed);

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_WORDSIZE == 64
-  const unsigned struct_kernel_stat_sz = 216;
+  #if SANITIZER_ANDROID
+    const unsigned struct_kernel_stat_sz
+                   = (SANITIZER_WORDSIZE == 64) ? 128 : 104;
   #else
-  const unsigned struct_kernel_stat_sz = 144;
+    const unsigned struct_kernel_stat_sz
+                   = (SANITIZER_WORDSIZE == 64) ? 216 : 144;
   #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
+  #if SANITIZER_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 && ((SANITIZER_WORDSIZE == 64) || SANITIZER_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 !SANITIZER_MIPS32
     void (*sa_restorer)();
+# endif
   };
 #elif SANITIZER_ANDROID && (SANITIZER_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)();
   };
 #else // !SANITIZER_ANDROID
   struct __sanitizer_sigaction {
 #if defined(__mips__) && !SANITIZER_FREEBSD
     unsigned int sa_flags;
 #endif
     union {

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 && !(SANITIZER_MIPS32 && SANITIZER_ANDROID)
 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 && SANITIZER_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;
-#define REG_SP regs[EF_REG29]
+# 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"