[MSan][MIPS] Fix for some failing tests on MIPS64

[mohit.bhakkad]

test/msan/vector_select.cc

4

Sorry, my bad, removing this double check in next revision.

[mohit.bhakkad]

Changes in this revision:

• Adding internal ptrace functionality for mips64.
• Removed XFAIL from vector_select.cc and vector_cvt.cc.
• added mips part for vector_select.cc, (will submit for vector_cvt.cc soon)

[eugenis]

LGTM

lib/msan/tests/msan_test.cc

2900

This is a path to a file that does not exist!
Just remove the x86_64 part.

[mohit.bhakkad]

lib/msan/tests/msan_test.cc

2900

Ah, OK, thought it should be similar to #L2838.
Will change it before commit.
Thanks for the review.

[mohit.bhakkad]

lib/msan/tests/msan_test.cc

2900

Took care about this while committing.

lib/msan/tests/msan_test.cc

static int dl_phdr_callback(struct dl_phdr_info *info, size_t size, void *data) {
   for (int i = 0; i < info->dlpi_phnum; ++i)
     EXPECT_NOT_POISONED(info->dlpi_phdr[i]);
   return 0;
 }
 
 // Compute the path to our loadable DSO.  We assume it's in the same
 // directory.  Only use string routines that we intercept so far to do this.
 static int PathToLoadable(char *buf, size_t sz) {
+#if defined(__x86_64__)
   const char *basename = "libmsan_loadable.x86_64.so";
+#elif defined(__MIPSEB__) || defined(MIPSEB)
+  const char *basename = "libmsan_loadable.mips64.so";
+#elif defined(__mips64)
+  const char *basename = "libmsan_loadable.mips64el.so";
+#endif
   char *argv0 = program_invocation_name;
   char *last_slash = strrchr(argv0, '/');
   assert(last_slash);
   int res =
       snprintf(buf, sz, "%.*s/%s", int(last_slash - argv0), argv0, basename);
   assert(res >= 0);
   return (size_t)res < sz ? 0 : res;
 }
for (int i = 0; i < 2; i++) {
     __msan_poison(dso_global, sizeof(*dso_global));
     EXPECT_POISONED(*dso_global);
     dlclose(lib);
   }
 }
 
 // Regression test for a crash in dlopen() interceptor.
 TEST(MemorySanitizer, dlopenFailed) {
+#if defined(__x86_64__)
   const char *path = "/libmsan_loadable_does_not_exist.x86_64.so";
+#elif defined(__MIPSEB__) || defined(MIPSEB)
+  const char *path = "/libmsan_loadable_does_not_exist.mips64.so";
+#elif defined(__mips64)
+  const char *path = "/libmsan_loadable_does_not_exist.mips64el.so";
+#endif
   void *lib = dlopen(path, RTLD_LAZY);
   ASSERT_TRUE(lib == NULL);
 }
 
 #endif // MSAN_TEST_DISABLE_DLOPEN
 
 // There's no sched_getaffinity() on FreeBSD.
 #if !defined(__FreeBSD__)

lib/sanitizer_common/sanitizer_common_syscalls.inc

 
 POST_SYSCALL(uselib)(long res, const void *library) {}
 
 PRE_SYSCALL(ni_syscall)() {}
 
 POST_SYSCALL(ni_syscall)(long res) {}
 
 PRE_SYSCALL(ptrace)(long request, long pid, long addr, long data) {
-#if !SANITIZER_ANDROID && (defined(__i386) || defined (__x86_64))
+#if !SANITIZER_ANDROID && \
+    (defined(__i386) || defined(__x86_64) || defined(__mips64))
   if (data) {
     if (request == ptrace_setregs) {
       PRE_READ((void *)data, struct_user_regs_struct_sz);
     } else if (request == ptrace_setfpregs) {
       PRE_READ((void *)data, struct_user_fpregs_struct_sz);
     } else if (request == ptrace_setfpxregs) {
       PRE_READ((void *)data, struct_user_fpxregs_struct_sz);
     } else if (request == ptrace_setsiginfo) {
       PRE_READ((void *)data, siginfo_t_sz);
     } else if (request == ptrace_setregset) {
       __sanitizer_iovec *iov = (__sanitizer_iovec *)data;
       PRE_READ(iov->iov_base, iov->iov_len);
     }
   }
 #endif
 }
 
 POST_SYSCALL(ptrace)(long res, long request, long pid, long addr, long data) {
-#if !SANITIZER_ANDROID && (defined(__i386) || defined (__x86_64))
+#if !SANITIZER_ANDROID && \
+    (defined(__i386) || defined(__x86_64) || defined(__mips64))
   if (res >= 0 && data) {
     // Note that this is different from the interceptor in
     // sanitizer_common_interceptors.inc.
     // PEEK* requests return resulting values through data pointer.
     if (request == ptrace_getregs) {
       POST_WRITE((void *)data, struct_user_regs_struct_sz);
     } else if (request == ptrace_getfpregs) {
       POST_WRITE((void *)data, struct_user_fpregs_struct_sz);

lib/sanitizer_common/sanitizer_platform_interceptors.h

 #define SANITIZER_INTERCEPT_RECVMSG SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_GETPEERNAME SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_IOCTL SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_INET_ATON SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_SYSINFO SI_LINUX
 #define SANITIZER_INTERCEPT_READDIR SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_READDIR64 SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_PTRACE SI_LINUX_NOT_ANDROID && \
-   (defined(__i386) || defined (__x86_64))  // NOLINT
+   (defined(__i386) || defined (__x86_64) || defined (__mips64))  // NOLINT
 #define SANITIZER_INTERCEPT_SETLOCALE SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_GETCWD SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_GET_CURRENT_DIR_NAME SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_STRTOIMAX SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_MBSTOWCS SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_MBSNRTOWCS SI_MAC || SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_WCSTOMBS SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_WCSNRTOMBS \

lib/sanitizer_common/sanitizer_platform_limits_posix.h

#if SANITIZER_LINUX && !SANITIZER_ANDROID
   };
 # define SANITIZER_HAS_STRUCT_FILE 1
 #else
   typedef void __sanitizer_FILE;
 # define SANITIZER_HAS_STRUCT_FILE 0
 #endif
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID && \
-    (defined(__i386) || defined(__x86_64))
+  (defined(__i386) || defined(__x86_64) || defined(__mips64))
   extern unsigned struct_user_regs_struct_sz;
   extern unsigned struct_user_fpregs_struct_sz;
   extern unsigned struct_user_fpxregs_struct_sz;
 
   extern int ptrace_peektext;
   extern int ptrace_peekdata;
   extern int ptrace_peekuser;
   extern int ptrace_getregs;

lib/sanitizer_common/sanitizer_platform_limits_posix.cc

 
 #if SANITIZER_FREEBSD || SANITIZER_IOS
 #undef IOC_DIRMASK
 #endif
 
 #if SANITIZER_LINUX || SANITIZER_FREEBSD
 # include <utime.h>
 # include <sys/ptrace.h>
+# if defined(__mips64)
+#  include <asm/ptrace.h>
+# endif
 #endif
 
 #if !SANITIZER_ANDROID
 #include <ifaddrs.h>
 #include <sys/ucontext.h>
 #include <wordexp.h>
 #endif
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
 #include <glob.h>
 #include <obstack.h>
 #include <mqueue.h>
 #include <net/if_ppp.h>
 #include <netax25/ax25.h>
 #include <netipx/ipx.h>
 #include <netrom/netrom.h>
 #include <rpc/xdr.h>
 #include <scsi/scsi.h>
 #include <sys/mtio.h>
 #include <sys/kd.h>
 #include <sys/shm.h>
 #include <sys/statvfs.h>
 #include <sys/timex.h>
+#if defined(__mips64)
+# include <sys/procfs.h>
+#endif
 #include <sys/user.h>
 #include <sys/ustat.h>
 #include <linux/cyclades.h>
 #include <linux/if_eql.h>
 #include <linux/if_plip.h>
 #include <linux/lp.h>
 #include <linux/mroute.h>
 #include <linux/mroute6.h>
#endif
   }
 
 #if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
   int glob_nomatch = GLOB_NOMATCH;
   int glob_altdirfunc = GLOB_ALTDIRFUNC;
 #endif
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID && \
-    (defined(__i386) || defined(__x86_64))
+    (defined(__i386) || defined(__x86_64) || defined(__mips64))
+#if defined(__mips64)
+  unsigned struct_user_regs_struct_sz = sizeof(struct pt_regs);
+  unsigned struct_user_fpregs_struct_sz = sizeof(elf_fpregset_t);
+#else
   unsigned struct_user_regs_struct_sz = sizeof(struct user_regs_struct);
   unsigned struct_user_fpregs_struct_sz = sizeof(struct user_fpregs_struct);
-#ifdef __x86_64
+#endif // __mips64
+#if (defined(__x86_64) || defined(__mips64))
   unsigned struct_user_fpxregs_struct_sz = 0;
 #else
   unsigned struct_user_fpxregs_struct_sz = sizeof(struct user_fpxregs_struct);
-#endif
+#endif // __x86_64 || __mips64
 
   int ptrace_peektext = PTRACE_PEEKTEXT;
   int ptrace_peekdata = PTRACE_PEEKDATA;
   int ptrace_peekuser = PTRACE_PEEKUSER;
   int ptrace_getregs = PTRACE_GETREGS;
   int ptrace_setregs = PTRACE_SETREGS;
   int ptrace_getfpregs = PTRACE_GETFPREGS;
   int ptrace_setfpregs = PTRACE_SETFPREGS;

test/msan/mmap_below_shadow.cc

 
 #include <assert.h>
 #include <errno.h>
 #include <stdint.h>
 #include <sys/mman.h>
 
 int main(void) {
   // Hint address just below shadow.
+#if defined(__x86_64__)
   uintptr_t hint = 0x4f0000000000ULL;
   const uintptr_t app_start = 0x600000000000ULL;
+#elif defined (__mips64)
+  uintptr_t hint = 0x4f00000000ULL;
+  const uintptr_t app_start = 0x6000000000ULL;
+#endif
   uintptr_t p = (uintptr_t)mmap(
       (void *)hint, 4096, PROT_WRITE,
       MAP_PRIVATE | MAP_ANONYMOUS | (FIXED ? MAP_FIXED : 0), -1, 0);
   if (FIXED)
     assert(p == (uintptr_t)-1 && errno == EINVAL);
   else
     assert(p >= app_start);
   return 0;
 }

test/msan/strlen_of_shadow.cc

 // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t
 
 // Check that strlen() and similar intercepted functions can be called on shadow
 // memory.
 
 #include <assert.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 const char *mem_to_shadow(const char *p) {
+#if defined(__x86_64__)
   return (char *)((uintptr_t)p & ~0x400000000000ULL);
+#elif defined (__mips64)
+  return (char *)((uintptr_t)p & ~0x4000000000ULL);
+#endif
 }
 
 int main(void) {
   const char *s = "abcdef";
   assert(strlen(s) == 6);
   assert(strlen(mem_to_shadow(s)) == 0);
 
   char *t = new char[42];
   t[41] = 0;
   assert(strlen(mem_to_shadow(t)) == 41);
   return 0;
 }

test/msan/vector_select.cc

 // RUN: %clangxx_msan -m64 -O0 %s -c -o %t
 // RUN: %clangxx_msan -m64 -O3 %s -c -o %t
 
 // Regression test for MemorySanitizer instrumentation of a select instruction
 // with vector arguments.
 
+#if defined(__x86_64__)
 #include <emmintrin.h>
 
 __m128d select(bool b, __m128d c, __m128d d)
 {
   return b ? c : d;
 }
+#elif defined (__mips64)
+typedef double __w64d __attribute__ ((vector_size(16)));
 
+__w64d select(bool b, __w64d c, __w64d d)
+{
+  return b ? c : d;
+}
+#endif

test/sanitizer_common/TestCases/Linux/ptrace.cc

 // RUN: %clangxx -O0 %s -o %t && %run %t
 
 #include <assert.h>
 #include <signal.h>
 #include <stdio.h>
 #include <sys/ptrace.h>
 #include <sys/types.h>
 #include <sys/user.h>
 #include <sys/wait.h>
 #include <unistd.h>
+#if __mips64
+ #include <asm/ptrace.h>
+ #include <sys/procfs.h>
+#endif
 
 int main(void) {
   pid_t pid;
   pid = fork();
   if (pid == 0) { // child
     ptrace(PTRACE_TRACEME, 0, NULL, NULL);
     execl("/bin/true", "true", NULL);
   } else {
#if __x86_64__
 
     user_fpregs_struct fpregs;
     res = ptrace(PTRACE_GETFPREGS, pid, NULL, &fpregs);
     assert(!res);
     if (fpregs.mxcsr)
       printf("%x\n", fpregs.mxcsr);
 #endif // __x86_64__
 
-#if __powerpc64__
+#if (__powerpc64__ || __mips64)
     struct pt_regs regs;
     res = ptrace((enum __ptrace_request)PTRACE_GETREGS, pid, NULL, &regs);
     assert(!res);
+#if (__powerpc64__)
     if (regs.nip)
       printf("%lx\n", regs.nip);
-
+#else
+    if (regs.cp0_epc)
+    printf("%lx\n", regs.cp0_epc);
+#endif
     elf_fpregset_t fpregs;
     res = ptrace((enum __ptrace_request)PTRACE_GETFPREGS, pid, NULL, &fpregs);
     assert(!res);
     if ((elf_greg_t)fpregs[32]) // fpscr
       printf("%lx\n", (elf_greg_t)fpregs[32]);
-#endif // __powerpc64__
+#endif // (__powerpc64__ || __mips64)
 
     siginfo_t siginfo;
     res = ptrace(PTRACE_GETSIGINFO, pid, NULL, &siginfo);
     assert(!res);
     assert(siginfo.si_pid == pid);
 
     ptrace(PTRACE_CONT, pid, NULL, NULL);
 
     wait(NULL);
   }
   return 0;
 }