Add mips64 support in lib/tsan/go/buildgo.sh

[mzh]

Summary

Enable mips64 support in buildgo.sh.

[mzh]

clang-format

[dvyukov]

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

41

Please upload diff with full context (-U999999) next time:
https://llvm.org/docs/Phabricator.html#requesting-a-review-via-the-web-interface
It makes it much easier to review. E.g. this block is under #if defined(__mips64) which is not visible in the diff.

compiler-rt/lib/tsan/rtl/tsan_platform.h

516

It seems that the only VM size for this arch is 47 bits, so it should not use TSAN_RUNTIME_VMA. It's slower.

In the functions below execution should go into existing cases like
IsShadowMemImpl<Mapping>(mem);
I think no added code should be needed there.

[mzh]

Thanks @dvyukov

All done.

[dvyukov]

This now looks like a patch for some other change :)

[mzh]

In D90130#2352826, @dvyukov wrote:

This now looks like a patch for some other change :)

Sorry! It's my first time with llvm patch submission.
I think it's ok now.

[dvyukov]

Looks good to me.
Do you want me to merge this change?

[mzh]

In D90130#2352831, @dvyukov wrote:

Looks good to me.
Do you want me to merge this change?

Sure, Thanks :)

[dvyukov]

Landed in https://github.com/llvm/llvm-project/commit/5cad535ccfebf9b41a57cf2788d8de7a765f7f35

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

 #include <asm/unistd.h>
 #include <sys/types.h>
 #define stat kernel_stat
+# if SANITIZER_GO
+#undef st_atime
+#undef st_mtime
+#undef st_ctime
+#define st_atime st_atim
+#define st_mtime st_mtim
+#define st_ctime st_ctim
+# endif
 #include <asm/stat.h>
 #undef stat
 #endif

 // Undefine compatibility macros from <sys/stat.h>
 // so that they would not clash with the kernel_stat
 // st_[a|m|c]time fields
+# if !SANITIZER_GO
 #undef st_atime
 #undef st_mtime
 #undef st_ctime
+# endif
 #if defined(SANITIZER_ANDROID)
 // Bionic sys/stat.h defines additional macros
 // for compatibility with the old NDKs and

compiler-rt/lib/sanitizer_common/sanitizer_platform.h

 // FIXME: this value should be different on different platforms.  Larger values
 // will still work but will consume more memory for TwoLevelByteMap.
 #if defined(__mips__)
+# if SANITIZER_GO && defined(__mips64)
+# define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 47)
+# else
 # define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 40)
+# endif
 #elif SANITIZER_RISCV64
 #define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 38)
 #elif defined(__aarch64__)

compiler-rt/lib/tsan/go/buildgo.sh

   elif [ "`uname -a | grep aarch64`" != "" ]; then
     SUFFIX="linux_arm64"
     ARCHCFLAGS=""
+  elif [ "`uname -a | grep -i mips64`" != "" ]; then
+    if [ "`lscpu | grep -i Little`" != "" ]; then
+      SUFFIX="linux_mips64le"
+      ARCHCFLAGS="-mips64 -EL"
+    else
+      SUFFIX="linux_mips64"
+      ARCHCFLAGS="-mips64 -EB"
+    fi
   fi
 elif [ "`uname -a | grep FreeBSD`" != "" ]; then
   # The resulting object still depends on libc.

compiler-rt/lib/tsan/rtl/tsan_platform.h

 // Indicates the runtime will define the memory regions at runtime.
 #define TSAN_RUNTIME_VMA 1
 
+#elif SANITIZER_GO && defined(__mips64)
+/*
+Go on linux/mips64 (47-bit VMA)
+0000 0000 1000 - 0000 1000 0000: executable
+0000 1000 0000 - 00c0 0000 0000: -
+00c0 0000 0000 - 00e0 0000 0000: heap
+00e0 0000 0000 - 2000 0000 0000: -
[phone] - 3000 0000 0000: shadow
[phone] - 3000 0000 0000: -
[phone] - 4000 0000 0000: metainfo (memory blocks and sync objects)
[phone] - 6000 0000 0000: -
[phone] - 6200 0000 0000: traces
[phone] - 8000 0000 0000: -
+*/
+struct Mapping47 {
+  static const uptr kMetaShadowBeg = 0x300000000000ull;
+  static const uptr kMetaShadowEnd = 0x400000000000ull;
+  static const uptr kTraceMemBeg   = 0x600000000000ull;
+  static const uptr kTraceMemEnd   = 0x620000000000ull;
+  static const uptr kShadowBeg     = 0x200000000000ull;
+  static const uptr kShadowEnd     = 0x300000000000ull;
+  static const uptr kAppMemBeg     = 0x000000001000ull;
+  static const uptr kAppMemEnd     = 0x00e000000000ull;
+};
+
+#define TSAN_RUNTIME_VMA 1
+
 #else
 # error "Unknown platform"
 #endif

   }
   DCHECK(0);
   return 0;
+#elif defined(__mips64) && SANITIZER_GO
+  switch (vmaSize) {
+    case 47: return MappingImpl<Mapping47, Type>();
+  }
+  DCHECK(0);
+  return 0;
 #else
   return MappingImpl<Mapping, Type>();
 #endif

   }
   DCHECK(0);
   return false;
+#elif defined(__mips64) && SANITIZER_GO
+  switch (vmaSize) {
+    case 47: return IsAppMemImpl<Mapping47>(mem);
+  }
+  DCHECK(0);
+  return false;
 #else
   return IsAppMemImpl<Mapping>(mem);
 #endif

   }
   DCHECK(0);
   return false;
+#elif defined(__mips64) && SANITIZER_GO
+  switch (vmaSize) {
+    case 47: return IsShadowMemImpl<Mapping47>(mem);
+  }
+  DCHECK(0);
+  return false;
 #else
   return IsShadowMemImpl<Mapping>(mem);
 #endif

   }
   DCHECK(0);
   return false;
+#elif defined(__mips64) && SANITIZER_GO
+  switch (vmaSize) {
+    case 47: return IsMetaMemImpl<Mapping47>(mem);
+  }
+  DCHECK(0);
+  return false;
 #else
   return IsMetaMemImpl<Mapping>(mem);
 #endif

   }
   DCHECK(0);
   return 0;
+  }
+#elif defined(__mips64) && SANITIZER_GO
+  switch (vmaSize) {
+    case 47: return MemToShadowImpl<Mapping47>(x);
+  }
+  DCHECK(0);
+  return false;
 #else
   return MemToShadowImpl<Mapping>(x);
 #endif

   }
   DCHECK(0);
   return 0;
+#elif defined(__mips64) && SANITIZER_GO
+  switch (vmaSize) {
+    case 47: return MemToMetaImpl<Mapping47>(x);
+  }
+  DCHECK(0);
+  return 0;
 #else
   return MemToMetaImpl<Mapping>(x);
 #endif

   }
   DCHECK(0);
   return 0;
+#elif defined(__mips64) && SANITIZER_GO
+  switch (vmaSize) {
+    case 47: return ShadowToMemImpl<Mapping47>(s);
+  }
+  DCHECK(0);
+  return 0;
 #else
   return ShadowToMemImpl<Mapping>(s);
 #endif

   }
   DCHECK(0);
   return 0;
+#elif defined(__mips64) && SANITIZER_GO
+  switch (vmaSize) {
+    case 47: return GetThreadTraceImpl<Mapping47>(tid);
+  }
+  DCHECK(0);
+  return 0;
 #else
   return GetThreadTraceImpl<Mapping>(tid);
 #endif

   }
   DCHECK(0);
   return 0;
+#elif defined(__mips64) && SANITIZER_GO
+  switch (vmaSize) {
+    case 47: return GetThreadTraceHeaderImpl<Mapping47>(tid);
+  }
+  DCHECK(0);
+  return 0;
 #else
   return GetThreadTraceHeaderImpl<Mapping>(tid);
 #endif

compiler-rt/lib/tsan/rtl/tsan_platform_linux.cpp

   }
 # endif
 #endif
+#elif defined(__mips64) && SANITIZER_GO
+  if (vmaSize != 47) {
+    Printf("FATAL: ThreadSanitizer: unsupported VMA range\n");
+    Printf("FATAL: Found %zd - Supported 47\n", vmaSize);
+    Die();
 #endif
 }