[compiler-rt][TSan] Add TSan runtime support for Go on linux-aarch64.

[aadg]

Summary

This patch adds TSan runtime support for Go on linux-aarch64
platforms. This enables people working on golang to implement their
platform/language part of the TSan support.

Basic testing is done with lib/tsan/go/buildgo.sh. Additional testing will be
done as part of the work done in the Go project.

Patch by Fangming Fang <[e-mail]>.

[dvyukov]

Hi Fangming,

Is there a Go issue for linux/arm64 support? Please CC me on it and/or file it if it does not exist.
Are there already some designated people to do the Go part?

[dvyukov]

lib/tsan/go/buildgo.sh

144 ↗

(On Diff #165743)

Please don't duplicate all flags, and instead add arm64-specific flags below, like it is done for amd64 and ppc64le.

164 ↗

(On Diff #165743)

Please don't duplicate whole command line. If -m64 breaks arm64, create ARCHCFLAGS, populate it with -m64 for amd64 and ppc64le, add ARCHCFLAGS to FLAGS and here.

lib/tsan/rtl/tsan_platform.h

713 ↗

(On Diff #165743)

Do we plan to support more vma sizes? If not, then it can make sense to use the generic IsAppMemImpl<Mapping>(mem) version without the switch, because it's still a load and check of the global var per memory access.

[aadg]

There is a Go issue opened : https://github.com/golang/go/issues/25682

Fangming is working on adding the Go part. I (Arnaud) is helping him with upstreaming the compiler-rt part.

[aadg]

We will update this patch shortly with your comments addressed.

Thanks for reviewing !

lib/tsan/go/buildgo.sh

144 ↗

(On Diff #165743)

Sure, we will fix this.

164 ↗

(On Diff #165743)

Yes, will do.

lib/tsan/rtl/tsan_platform.h

713 ↗

(On Diff #165743)

39 can not be supported, but supporting other VMA sizes (42) is intended.

[aadg]

Address review comments.

[dvyukov]

Looks good to me

compiler-rt/trunk/lib/tsan/CMakeLists.txt

if(arch STREQUAL "x86_64")
         COMMAND env "CC=${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}"
                 IN_TMPDIR=1 SILENT=1 ${BUILDGO_SCRIPT}
         DEPENDS clang_rt.tsan-${arch} ${BUILDGO_SCRIPT}
         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/go
         COMMENT "Checking TSan Go runtime..."
         VERBATIM)
     elseif(arch STREQUAL "aarch64")
       add_asm_sources(TSAN_ASM_SOURCES rtl/tsan_rtl_aarch64.S)
+      # Sanity check for Go runtime.
+      set(BUILDGO_SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/go/buildgo.sh)
+      add_custom_target(GotsanRuntimeCheck
+  COMMAND env "CC=${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}"
+    IN_TMPDIR=1 SILENT=1 ${BUILDGO_SCRIPT}
+  DEPENDS clang_rt.tsan-${arch} ${BUILDGO_SCRIPT}
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/go
+  COMMENT "Checking TSan Go runtime..."
+  VERBATIM)
     elseif(arch MATCHES "powerpc64|powerpc64le")
       add_asm_sources(TSAN_ASM_SOURCES rtl/tsan_rtl_ppc64.S)
       # Sanity check for Go runtime.
       set(BUILDGO_SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/go/buildgo.sh)
       add_custom_target(GotsanRuntimeCheck
   COMMAND env "CC=${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_ARG1}"
     IN_TMPDIR=1 SILENT=1 ${BUILDGO_SCRIPT}
   DEPENDS clang_rt.tsan-${arch} ${BUILDGO_SCRIPT}

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

SRCS="
     ../../sanitizer_common/sanitizer_procmaps_common.cc
     ../../sanitizer_common/sanitizer_procmaps_linux.cc
     ../../sanitizer_common/sanitizer_linux.cc
     ../../sanitizer_common/sanitizer_linux_libcdep.cc
     ../../sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc
     "
   if [ "`uname -a | grep ppc64le`" != "" ]; then
     SUFFIX="linux_ppc64le"
+    ARCHCFLAGS="-m64"
   elif [ "`uname -a | grep x86_64`" != "" ]; then
     SUFFIX="linux_amd64"
+    ARCHCFLAGS="-m64"
     OSCFLAGS="$OSCFLAGS -ffreestanding -Wno-unused-const-variable -Werror -Wno-unknown-warning-option"
+  elif [ "`uname -a | grep aarch64`" != "" ]; then
+    SUFFIX="linux_arm64"
+    ARCHCFLAGS=""
   fi
 elif [ "`uname -a | grep FreeBSD`" != "" ]; then
   SUFFIX="freebsd_amd64"
   OSCFLAGS="-fno-strict-aliasing -fPIC -Werror"
+  ARCHCFLAGS="-m64"
   OSLDFLAGS="-lpthread -fPIC -fpie"
   SRCS="
     $SRCS
     ../rtl/tsan_platform_linux.cc
     ../../sanitizer_common/sanitizer_posix.cc
     ../../sanitizer_common/sanitizer_posix_libcdep.cc
     ../../sanitizer_common/sanitizer_procmaps_bsd.cc
     ../../sanitizer_common/sanitizer_procmaps_common.cc
     ../../sanitizer_common/sanitizer_linux.cc
     ../../sanitizer_common/sanitizer_linux_libcdep.cc
     ../../sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc
   "
 elif [ "`uname -a | grep NetBSD`" != "" ]; then
   SUFFIX="netbsd_amd64"
   OSCFLAGS="-fno-strict-aliasing -fPIC -Werror"
+  ARCHCFLAGS="-m64"
   OSLDFLAGS="-lpthread -fPIC -fpie"
   SRCS="
     $SRCS
     ../rtl/tsan_platform_linux.cc
     ../../sanitizer_common/sanitizer_posix.cc
     ../../sanitizer_common/sanitizer_posix_libcdep.cc
     ../../sanitizer_common/sanitizer_procmaps_bsd.cc
     ../../sanitizer_common/sanitizer_procmaps_common.cc
     ../../sanitizer_common/sanitizer_linux.cc
     ../../sanitizer_common/sanitizer_linux_libcdep.cc
     ../../sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc
   "
 elif [ "`uname -a | grep Darwin`" != "" ]; then
   SUFFIX="darwin_amd64"
   OSCFLAGS="-fPIC -Wno-unused-const-variable -Wno-unknown-warning-option -mmacosx-version-min=10.7"
+  ARCHCFLAGS="-m64"
   OSLDFLAGS="-lpthread -fPIC -fpie -mmacosx-version-min=10.7"
   SRCS="
     $SRCS
     ../rtl/tsan_platform_mac.cc
     ../../sanitizer_common/sanitizer_mac.cc
     ../../sanitizer_common/sanitizer_posix.cc
     ../../sanitizer_common/sanitizer_posix_libcdep.cc
     ../../sanitizer_common/sanitizer_procmaps_mac.cc
   "
 elif [ "`uname -a | grep MINGW`" != "" ]; then
   SUFFIX="windows_amd64"
   OSCFLAGS="-Wno-error=attributes -Wno-attributes -Wno-unused-const-variable -Wno-unknown-warning-option"
+  ARCHCFLAGS="-m64"
   OSLDFLAGS=""
   SRCS="
     $SRCS
     ../rtl/tsan_platform_windows.cc
     ../../sanitizer_common/sanitizer_win.cc
   "
 else
   echo Unknown platform

 
 SRCS="$SRCS $ADD_SRCS"
 
 rm -f $DIR/gotsan.cc
 for F in $SRCS; do
   cat $F >> $DIR/gotsan.cc
 done
 
-FLAGS=" -I../rtl -I../.. -I../../sanitizer_common -I../../../include -std=c++11 -m64 -Wall -fno-exceptions -fno-rtti -DSANITIZER_GO=1 -DSANITIZER_DEADLOCK_DETECTOR_VERSION=2 $OSCFLAGS"
+FLAGS=" -I../rtl -I../.. -I../../sanitizer_common -I../../../include -std=c++11 -Wall -fno-exceptions -fno-rtti -DSANITIZER_GO=1 -DSANITIZER_DEADLOCK_DETECTOR_VERSION=2 $OSCFLAGS $ARCHCFLAGS"
 if [ "$DEBUG" = "" ]; then
   FLAGS="$FLAGS -DSANITIZER_DEBUG=0 -O3 -fomit-frame-pointer"
   if [ "$SUFFIX" = "linux_ppc64le" ]; then
     FLAGS="$FLAGS -mcpu=power8 -fno-function-sections"
   elif [ "$SUFFIX" = "linux_amd64" ]; then
     FLAGS="$FLAGS -msse3"
   fi
 else
   FLAGS="$FLAGS -DSANITIZER_DEBUG=1 -g"
 fi
 
 if [ "$SILENT" != "1" ]; then
   echo $CC gotsan.cc -c -o $DIR/race_$SUFFIX.syso $FLAGS $CFLAGS
 fi
 $CC $DIR/gotsan.cc -c -o $DIR/race_$SUFFIX.syso $FLAGS $CFLAGS
 
-$CC $OSCFLAGS test.c $DIR/race_$SUFFIX.syso -m64 -g -o $DIR/test $OSLDFLAGS $LDFLAGS
+$CC $OSCFLAGS $ARCHCFLAGS test.c $DIR/race_$SUFFIX.syso -g -o $DIR/test $OSLDFLAGS $LDFLAGS
 
 export GORACE="exitcode=0 atexit_sleep_ms=0"
 if [ "$SILENT" != "1" ]; then
   $DIR/test
 else
   $DIR/test 2>/dev/null
 fi

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

struct Mapping47 {
   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;
 };
 
+#elif SANITIZER_GO && defined(__aarch64__)
+
+/* Go on linux/aarch64 (48-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 Mapping48 {
+  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;
+};
+
 // Indicates the runtime will define the memory regions at runtime.
 #define TSAN_RUNTIME_VMA 1
 
 #else
 # error "Unknown platform"
 #endif
 
 
#endif
     case MAPPING_TRACE_END: return Mapping::kTraceMemEnd;
   }
 }
 
 template<int Type>
 uptr MappingArchImpl(void) {
 #if defined(__aarch64__) && !defined(__APPLE__)
   switch (vmaSize) {
+#if !SANITIZER_GO
     case 39: return MappingImpl<Mapping39, Type>();
     case 42: return MappingImpl<Mapping42, Type>();
+#endif
     case 48: return MappingImpl<Mapping48, Type>();
   }
   DCHECK(0);
   return 0;
 #elif defined(__powerpc64__)
   switch (vmaSize) {
 #if !SANITIZER_GO
     case 44: return MappingImpl<Mapping44, Type>();
#else
   return mem >= Mapping::kAppMemBeg && mem < Mapping::kAppMemEnd;
 #endif
 }
 
 ALWAYS_INLINE
 bool IsAppMem(uptr mem) {
 #if defined(__aarch64__) && !defined(__APPLE__)
   switch (vmaSize) {
+#if !SANITIZER_GO
     case 39: return IsAppMemImpl<Mapping39>(mem);
     case 42: return IsAppMemImpl<Mapping42>(mem);
+#endif
     case 48: return IsAppMemImpl<Mapping48>(mem);
   }
   DCHECK(0);
   return false;
 #elif defined(__powerpc64__)
   switch (vmaSize) {
 #if !SANITIZER_GO
     case 44: return IsAppMemImpl<Mapping44>(mem);

 bool IsShadowMemImpl(uptr mem) {
   return mem >= Mapping::kShadowBeg && mem <= Mapping::kShadowEnd;
 }
 
 ALWAYS_INLINE
 bool IsShadowMem(uptr mem) {
 #if defined(__aarch64__) && !defined(__APPLE__)
   switch (vmaSize) {
+#if !SANITIZER_GO
     case 39: return IsShadowMemImpl<Mapping39>(mem);
     case 42: return IsShadowMemImpl<Mapping42>(mem);
+#endif
     case 48: return IsShadowMemImpl<Mapping48>(mem);
   }
   DCHECK(0);
   return false;
 #elif defined(__powerpc64__)
   switch (vmaSize) {
 #if !SANITIZER_GO
     case 44: return IsShadowMemImpl<Mapping44>(mem);

 bool IsMetaMemImpl(uptr mem) {
   return mem >= Mapping::kMetaShadowBeg && mem <= Mapping::kMetaShadowEnd;
 }
 
 ALWAYS_INLINE
 bool IsMetaMem(uptr mem) {
 #if defined(__aarch64__) && !defined(__APPLE__)
   switch (vmaSize) {
+#if !SANITIZER_GO
     case 39: return IsMetaMemImpl<Mapping39>(mem);
     case 42: return IsMetaMemImpl<Mapping42>(mem);
+#endif
     case 48: return IsMetaMemImpl<Mapping48>(mem);
   }
   DCHECK(0);
   return false;
 #elif defined(__powerpc64__)
   switch (vmaSize) {
 #if !SANITIZER_GO
     case 44: return IsMetaMemImpl<Mapping44>(mem);

 # endif
 #endif
 }
 
 ALWAYS_INLINE
 uptr MemToShadow(uptr x) {
 #if defined(__aarch64__) && !defined(__APPLE__)
   switch (vmaSize) {
+#if !SANITIZER_GO
     case 39: return MemToShadowImpl<Mapping39>(x);
     case 42: return MemToShadowImpl<Mapping42>(x);
+#endif
     case 48: return MemToShadowImpl<Mapping48>(x);
   }
   DCHECK(0);
   return 0;
 #elif defined(__powerpc64__)
   switch (vmaSize) {
 #if !SANITIZER_GO
     case 44: return MemToShadowImpl<Mapping44>(x);

 # endif
 #endif
 }
 
 ALWAYS_INLINE
 u32 *MemToMeta(uptr x) {
 #if defined(__aarch64__) && !defined(__APPLE__)
   switch (vmaSize) {
+#if !SANITIZER_GO
     case 39: return MemToMetaImpl<Mapping39>(x);
     case 42: return MemToMetaImpl<Mapping42>(x);
+#endif
     case 48: return MemToMetaImpl<Mapping48>(x);
   }
   DCHECK(0);
   return 0;
 #elif defined(__powerpc64__)
   switch (vmaSize) {
 #if !SANITIZER_GO
     case 44: return MemToMetaImpl<Mapping44>(x);

 # endif // SANITIZER_WINDOWS
 #endif
 }
 
 ALWAYS_INLINE
 uptr ShadowToMem(uptr s) {
 #if defined(__aarch64__) && !defined(__APPLE__)
   switch (vmaSize) {
+#if !SANITIZER_GO
     case 39: return ShadowToMemImpl<Mapping39>(s);
     case 42: return ShadowToMemImpl<Mapping42>(s);
+#endif
     case 48: return ShadowToMemImpl<Mapping48>(s);
   }
   DCHECK(0);
   return 0;
 #elif defined(__powerpc64__)
   switch (vmaSize) {
 #if !SANITIZER_GO
     case 44: return ShadowToMemImpl<Mapping44>(s);
uptr GetThreadTraceImpl(int tid) {
   DCHECK_LT(p, Mapping::kTraceMemEnd);
   return p;
 }
 
 ALWAYS_INLINE
 uptr GetThreadTrace(int tid) {
 #if defined(__aarch64__) && !defined(__APPLE__)
   switch (vmaSize) {
+#if !SANITIZER_GO
     case 39: return GetThreadTraceImpl<Mapping39>(tid);
     case 42: return GetThreadTraceImpl<Mapping42>(tid);
+#endif
     case 48: return GetThreadTraceImpl<Mapping48>(tid);
   }
   DCHECK(0);
   return 0;
 #elif defined(__powerpc64__)
   switch (vmaSize) {
 #if !SANITIZER_GO
     case 44: return GetThreadTraceImpl<Mapping44>(tid);
uptr GetThreadTraceHeaderImpl(int tid) {
   DCHECK_LT(p, Mapping::kTraceMemEnd);
   return p;
 }
 
 ALWAYS_INLINE
 uptr GetThreadTraceHeader(int tid) {
 #if defined(__aarch64__) && !defined(__APPLE__)
   switch (vmaSize) {
+#if !SANITIZER_GO
     case 39: return GetThreadTraceHeaderImpl<Mapping39>(tid);
     case 42: return GetThreadTraceHeaderImpl<Mapping42>(tid);
+#endif
     case 48: return GetThreadTraceHeaderImpl<Mapping48>(tid);
   }
   DCHECK(0);
   return 0;
 #elif defined(__powerpc64__)
   switch (vmaSize) {
 #if !SANITIZER_GO
     case 44: return GetThreadTraceHeaderImpl<Mapping44>(tid);

compiler-rt/trunk/lib/tsan/rtl/tsan_platform_linux.cc

 
 #endif  // #if !SANITIZER_GO
 
 void InitializePlatformEarly() {
 #ifdef TSAN_RUNTIME_VMA
   vmaSize =
     (MostSignificantSetBitIndex(GET_CURRENT_FRAME()) + 1);
 #if defined(__aarch64__)
+# if !SANITIZER_GO
   if (vmaSize != 39 && vmaSize != 42 && vmaSize != 48) {
     Printf("FATAL: ThreadSanitizer: unsupported VMA range\n");
     Printf("FATAL: Found %zd - Supported 39, 42 and 48\n", vmaSize);
     Die();
   }
+#else
+  if (vmaSize != 48) {
+    Printf("FATAL: ThreadSanitizer: unsupported VMA range\n");
+    Printf("FATAL: Found %zd - Supported 48\n", vmaSize);
+    Die();
+  }
+#endif
 #elif defined(__powerpc64__)
 # if !SANITIZER_GO
   if (vmaSize != 44 && vmaSize != 46 && vmaSize != 47) {
     Printf("FATAL: ThreadSanitizer: unsupported VMA range\n");
     Printf("FATAL: Found %zd - Supported 44, 46, and 47\n", vmaSize);
     Die();
   }
 # else