[TSAN/AArch64/Android] Changes for AArch64/Android

[rengolin]

Summary

There are several problems getting TSAN on Android/AArch64 to work.
Android is missing TLS support with __thread keyword.

Using pthread api to emulate TLS is not going to work, because
of several reasons:

1. bionic's pthread_create calls the INTERCEPTED version of pthread_mutex_lock

2. the key cleanup code calls free() and such, but this is AFTER the main

thread has exited. This means that calling pthread_getspecific again returns
an odd address. So this means that the TLS ThreadState pointer now becomes
corrupt DURING the exit process.

So instead, I opted for a non-interceptible workaround for TLS support.

TSAN on Android also requires patches for bionic.
Please refer to https://code.google.com/p/android/issues/detail?id=179564
for details.

[rengolin]

Hi Jason,

How orthogonal this is against D11484? Have you re-based on top of that?

cheers,
--renato

cmake/config-ix.cmake

237–238

Please don't enable these yet. I know it's a pain, but there are some issues in ASAN on AArch64 that breaks the buildbot.

We need to get that problem fixed ASAP, so that other patches waiting (TSAN, DFSAN, etc.) can go in.

[rengolin]

I'm not an expert in compiler-rt, but somehow I feel that the workaround should be in bionic, not here.

Maybe it's just not possible, I'll let the experts chime in, but this patch seems odd.

cheers,
--renato

lib/sanitizer_common/sanitizer_common_interceptors.inc

3053 ↗

(On Diff #30715)

Please, don't include commented out code.

lib/sanitizer_common/sanitizer_linux.cc

1013

Please, don't include unrelated whitespace changes with code.

lib/sanitizer_common/sanitizer_platform_limits_posix.h

740

Please, pass some clang-format on those.

[jasonk]

Sorry about the noise guys,

but I inadvertantly uploaded this before it was really ready for review.
Please ignore the noise for a bit until I get this in order.

Thanks

lib/sanitizer_common/sanitizer_common_interceptors.inc

3053 ↗

(On Diff #30715)

Sorry, this patch was uploaded "raw" form. It still needs a lot of clean up. I blame arc diff for this..

I will upload a cleaned up patch soon.

[rengolin]

lib/sanitizer_common/sanitizer_common_interceptors.inc

3053 ↗

(On Diff #30715)

:D

[jasonk]

Renato,

TSAN on Android Aarch64 needs TLS support.
Ideally, this should be supported with the __thread keyword, but that is not yet supported, and it is a much bigger chunk of work to get it integrated into the default android cross compiler.

[rengolin]

In D11532#212836, @jasonk wrote:

Ideally, this should be supported with the __thread keyword, but that is not yet supported, and it is a much bigger chunk of work to get it integrated into the default android cross compiler.

I don't know how things are layered between Android and bionic very well, but I'd be very surprised if adding a workaround in compiler-rt would be the best long-term decision for the both bionic and RT projects.

You don't want to create dependencies, and once you add the workaround, the motivation for implementing the *proper* fix disappears.

[jasonk]

In D11532#212838, @rengolin wrote:

In D11532#212836, @jasonk wrote:

Ideally, this should be supported with the __thread keyword, but that is not yet supported, and it is a much bigger chunk of work to get it integrated into the default android cross compiler.

I don't know how things are layered between Android and bionic very well, but I'd be very surprised if adding a workaround in compiler-rt would be the best long-term decision for the both bionic and RT projects.

You don't want to create dependencies, and once you add the workaround, the motivation for implementing the *proper* fix disappears.

Renato,

I absolutely agree with that sentiment.

But what are we to do for NOW when the "proper" fix is maybe months off, or possibly longer?
This patch will allow people to experiment with TSAN on their android devices. Please don't let the perfect be the enemy of "limping along for a bit" while we wait for some gcc experts to pull a rabbit out of their hat :-)

Thanks

[rengolin]

In D11532#212844, @jasonk wrote:

But what are we to do for NOW when the "proper" fix is maybe months off, or possibly longer?

I'm sorry if I'm sceptical, but from what I've seen of bionic, and indeed of the Android stack, most of it is hack-based "waiting" for the proper fix that will never come.

Leaking this mentality out of the Android project into others to help people experiment with a feature is not the kind of thing that is generally acceptable upstream.

If it was me, I'd keep this internally until the day you do have a proper fix. After all, running TSAN on Android is not stopping any release from seeing the light of day.

But these are just my personal opinions. I'll let Kostya and Eugenis argue about the viability of such a workaround.

cheers,
--renato

[jasonk]

Got rid of a lot of debugging cruft.

[jasonk]

Forgot to wrap ASAN + AArch64 under COMPILER_RT_FORCE_TSAN_AARCH64

[jasonk]

Quashed whitespace nits (hopefully)

[jasonk]

Okay, most easy nits have now been addressed.

This still needs to be reconciled with D11484

[rengolin]

lib/sanitizer_common/sanitizer_linux.cc

911–912

Is this an Android only function?

Even if it is, wouldn't that break K and older?

lib/sanitizer_common/sanitizer_platform_limits_posix.h

325

this comment is redundant

409

Is this meaning to be 32 or 64 bits? Maybe make it clearer (by using uintNN_t) in the structure above would remove the need to duplicate it?

lib/tsan/rtl/tsan_interceptors.cc

93

This is *really* the wrong place for this...

lib/tsan/rtl/tsan_platform.h

17

oops

96

Please, rebase your patch on top of Adhemerval's and you'll get this right.

[danalbert]

lib/sanitizer_common/sanitizer_linux.cc

911–912

It's actually not an API 21+ thing, but an LP64 thing. The system properties API never should have been exposed, but our time machine isn't working yet, so all we could do was hide them in the new ABIs.

We shouldn't be using this at all, and AFAICT we don't need it either (I didn't even know it was an option). Using $ASAN_OPTIONS has been sufficient for us so far.

[zatrazz]

lib/sanitizer_common/sanitizer_linux.cc

878

This version you are working with seems old, the MIPS clone has been reimplemented in assembly 86d8101714e7e8191a50189dc6c9d2001df2e930 (06/05). I would suggest you to rebase against master. Also, my port to aarch64/linux have the assembly implementation that seems to be working (I am not sure if it would be correct approach to Android).

lib/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc

17

Split to fit on 80 lines.

490

I would prefer the to not change semantics for other arches and let now only aarch64 to use PTRACE_GETREGSET. The other arches maintainers could check if it would be desirable to change as well.

Also, for linux/aarch64 afaik the PTRACE_GETREGSET should be used with iovec interface:

struct iovec regset_io;
regset_io.iov_base = &regs;
regset_io.iov_len = sizeof(regs_struct);
bool isErr = internal_iserror(internal_ptrace(PTRACE_GETREGSET, tid,
                              (void*)NT_PRSTATUS, (void*)&regset_io),
                              &pterrno);

Does this change works for linux/aarch64 besides Android?

lib/tsan/rtl/tsan_aarch64_tls_workaround.cc

27

'This' refers to the cur_thread_placeholder field (as the code suggest) or the how TSanTLSHack struct?

71

Since it will be called by each TLS access and prime division tend to be slow on modern hardware, I would suggest to change to a multiplicative hash instead (like Knuth's Multiplicative).

lib/tsan/rtl/tsan_interceptors.cc

16

What is the idea of this counter? It is initialized and incremented, but nothing else.

lib/tsan/rtl/tsan_interface.cc

34

Both '__tsan_init_count' initialization and increment should be inside SANITIZER_TLS_WORKAROUND_NEEDED.

lib/tsan/rtl/tsan_platform.h

157

Do we really need a special mapping for android/aarch64? I could get a 39-bit VMA mapping for linux/aarch64 without special handling.

[zatrazz]

lib/tsan/rtl/tsan_aarch64_tls_workaround.cc

71

My comment does not really apply here since the prime number is constant (and the compiler will optimize it out using montgomery modular multiplication).

[jasonk]

Thanks for the review guys. Updating to a recent tip broke something in TSAN.
Fixing now....
Sigh...

Once I get past this, I will rebase on top of http://reviews.llvm.org/D11484 and re-upload.

My svn revisions currently are
243502 llvm
243489 llvm/tools/clang
243494 llvm/projects/compiler-rt/

lib/tsan/rtl/tsan_platform.h

157

Well, ASLR seems to be turned off (forced?) in the recent nexus9 kernels. Therefore the existing address math does not work :-(

[eugenis]

lib/tsan/rtl/tsan_platform.h

157

This looks like the behavior described in this issue:
https://llvm.org/bugs/show_bug.cgi?id=24155
Is it still random?
On x86_64 it only affects MSan, but on AArch64 with smaller address space, I guess TSan mapping will have to altered, too.

If at all possible, we should try and come up with one mapping that works in both cases, otherwise a kernel upgrade on Linux would break TSan programs.

[jasonk]

rebased against http://reviews.llvm.org/D11484

[rengolin]

Hi Jason,

Can you reply to the many questions and comments about many parts of the patch as well? Just rebasing but keeping the code unchanged won't help much in getting the patch in good shape.

cheers,
--renato

[jasonk]

I just uploaded the first "limping along" version to http://reviews.llvm.org/D11532
It has been rebased on top of http://reviews.llvm.org/D11484

There are some 60 tests passing, with around 130 marked as UNSUPPORTED for aarch64-android
Each of those unsupported tests either fail outright (possibly differently from x86_64-linux), or are flaky.

Please take a look.

I suppose next steps are:
0. code review (please :-)

1. visit google MTV to square away the required AOSP bionic patch https://android-review.googlesource.com/#/c/162104/
2. also visit google MTV to discuss adding a new aarch64-linux buildbot labs.llvm.org as well as some oddball stuff I noticed in the existing TSAN tests.

Thanks for all your help!

[jasonk]

cmake/config-ix.cmake

237–239

guarded with new CMAKE flah COMPILER_RT_FORCE_TSAN_AARCH64

lib/sanitizer_common/sanitizer_linux.cc

881–882

newer compiler-rt already takes care of this.

lib/sanitizer_common/sanitizer_platform_limits_posix.h

409

Its for both

lib/tsan/rtl/tsan_aarch64_tls_workaround.cc

28

This struct is used to hold all of the TLS variables used in TSAN.

The cur_thread_placeholder is used originally as a plain C struct that contains the ThreadState TLS var. I just carried that notion along.

lib/tsan/rtl/tsan_interceptors.cc

93

Err. I don't know of a better place to put it.

In order to use REAL(...) I need to DECLARE_REAL()..
in the same file.

lib/tsan/rtl/tsan_platform.h

157

Not sure if https://llvm.org/bugs/show_bug.cgi?id=24155 applies.

ASLR is apparently turned OFF, as in text/data wind up with 0x55 high byte regardless of whether aslr is turned on in /proc switches...

[jasonk]

some more code review nits fixed.

[jasonk]

Wierd thing with phabricator -- my updated commit message seem to have gotten lost.
(!)

[jasonk]

lib/sanitizer_common/sanitizer_linux.cc

869–870

done

[dvyukov]

Hi Jason,

This is too huge to review as single chunk. Please split it into smaller pieces.
E.g. all test changes can go in separately.
lib/sanitizer_common/sanitizer_linux.cc changes can be factored into separate "support internal_clone on aarch64".
sanitizer_stoptheworld_linux_libcdep.cc changes into separate "support stoptheworld on aarch64"
lib/sanitizer_common/sanitizer_platform_limits_posix.h changes into separate "provide definitions of aarch64 kernel structures"
etc

I will try to do one pass over this change as is now.

[dvyukov]

lib/interception/interception_linux.cc

24 ↗

(On Diff #32189)

Please do this only #ifdef ANDROID and only for known functions (i.e. internal_strcmp(func_name, "foo") == 0).
It's better to keep such hacks in a very limited, understandable scope. Otherwise it can lead to bad failure modes for other platforms/functions.

lib/sanitizer_common/sanitizer_libc.h

101

not used, remove

lib/sanitizer_common/sanitizer_platform_limits_posix.h

731

"uptr _size" should work for both 64- and 32-bit mode, isn't it?

lib/tsan/rtl/tsan_aarch64_tls_workaround.cc

20

Place this all into __tsan namespace.

29

Constants must be prefixed with "k"

47

Both TLSHack and Count are globals, they are zero initialized already. Remove this.

53

Call this from Initialize and then you don't need TSanTLSWorkAroundHasInited check. Initialize is executed exactly once.

54

Can you move this into InitializeInterceptors where similar setup is done already?

lib/tsan/rtl/tsan_aarch64_tls_workaround.h

30

Please don't prefix names in __tsan namespace with TSan, they are all TSan-something. It is a pointless prefix that introduces clutter without any benefit.
The same for the other names here.
Also remove extern "C", it is not needed inside of TSan namespace.

33

Looks like debugging leftovers, please remove.

lib/tsan/rtl/tsan_interceptors.cc

79–80

I see that you changed pthread_yield calls to internal_sched_yield below. So I guess you can now just remove this declaration.

99

Can you move this to tsan_interceptors.cc where freebsd handles this?
That would fix both tsan_interceptors.cc and tsan_new_delete.cc

155

What's wrong with errno name?

1543

spaces around &&

1555

spaces around &&

lib/tsan/rtl/tsan_interceptors.h

26 ↗

(On Diff #32189)

I guess you added this because the existing debug print in ScopedInterceptor::ScopedInterceptor is not always executed.
If you want to commit this, please prefix it with thread id like all other debug output; change INTERCEPT to intercept and, I think, you can change it to DPrint like the current interceptor output. DPrintf2 is used mainly in memory access interceptors as they are executed _very_ frequently.

lib/tsan/rtl/tsan_interface.cc

31

This should go into Initialize function. It is called not only from __tsan_init.

39

This better go into tsan_interceptors.cc.
tsan_interceptors.cc contains system-dependent glues, while this file is more or less platform-independent and "portable".

lib/tsan/rtl/tsan_rtl.cc

343

spaces around &&

[jasonk]

Should address all of dvyukov's feedback.
This patch still needs to be split up.

[jasonk]

Okay, just uploaded a new version (pre-split).
It should address all of the feedback from dvyukov.

lib/tsan/rtl/tsan_aarch64_tls_workaround.cc

53

Actually, it turns out that Initialize() is called multiple times (!)
because __tsan_init() is also called twice.

But its a no-op because as you correctly pointed out, I don't need to memset a static var :-)

54

It turns out that my bionic patch makes this unnecessary.
removed.

lib/tsan/rtl/tsan_interceptors.cc

99

It almost works.

I can't find a nice way to move the DECLARE_REAL(...) into tsan_interceptors.h (you probably meant the header file, not the .cc, which is *this* file :-)

The #defines also is headachy to move to the header file.
Sorry :-(

155

causes a compiler error.

lib/tsan/rtl/tsan_interface.cc

31

most of this is gone -- only thing I left behind was the init count and Dprintf()

[jasonk]

Updated to r245453

[dvyukov]

lib/tsan/rtl/tsan_aarch64_tls_workaround.cc

54

Initialize already has a guard against multiple calls (it is intended to be called multiple times).
So if you need to do any init, do it in Initialize after the guard check.

lib/tsan/rtl/tsan_interceptors.cc

155

Do you mean that <errno.h> is transitively included on android and that header provides own definition of errno?

How is it get included? This file does not include any system headers (for historical reasons).

[rengolin]

Jason,

This diff still has all the other changes that you have split. Please, remove the extra stuff and leave just the delta.

Also, I though we'd agreed to base the implementation on Joerg's TLS emulation layer in RT (D12001), and this patch still mentions (and uses) the local TLS work around. Please, rebase onto Joerg's work in progress.

The TSAN for AArch64 is on, and works well on machines with 39-bits VMA, but it's still disabled because it failed the buildbot (which I believe is 42-bits). Adhemerval is getting 42-bits support upstream soon, and we'll re-enable TSAN on AArch64 (since it worked on our 42-bits machine, too).

If all goes well, you'll also be able to remove some of the logic you need for AArch64 enablement, and only leave the Android specific stuff.

cheers,
--renato

[jasonk]

In D11532#228807, @rengolin wrote:

Jason,

This diff still has all the other changes that you have split. Please, remove the extra stuff and leave just the delta.

Sorry, I don't know what you mean.

I have already split the patches out. This is hanging around just for reference. I am not expecting this patch to go in as is.

Also, I though we'd agreed to base the implementation on Joerg's TLS emulation layer in RT (D12001), and this patch still mentions (and uses) the local TLS work around. Please, rebase onto Joerg's work in progress.

The TLS emulation is wholly inappropriate for TSAN, as it uses calls that are themselves intercepted by TSAN. EVERY memory access, and every API call made in the user app (including calls to pthread mutex lock, malloc, ett al) REQUIRES TLS vars to already exist. There is a chicken-vs-egg that can't be resolved here.

Sorry, but for now at least, it doesn't look like emutls is appropriate for TSAN.

The TSAN for AArch64 is on, and works well on machines with 39-bits VMA, but it's still disabled because it failed the buildbot (which I believe is 42-bits). Adhemerval is getting 42-bits support upstream soon, and we'll re-enable TSAN on AArch64 (since it worked on our 42-bits machine, too).

Huh. I was under the impression that aarch64 kernel being limited to 39 bits was primarily for performance reasons. For 42 bits, every memory access needs to access full 3 levels of in-memory tables (as opposed to two levels for 39 bits), which would, approximately, add 33% overhead for each memory access???

Or at least that's what I was told by a local android kernel guy

I guess we'll see.

If all goes well, you'll also be able to remove some of the logic you need for AArch64 enablement, and only leave the Android specific stuff.

Errr. okay.

I am not sure what you mean, but I'll do what it takes to get this (not this patch specifically, but the work in TSAN+android+aarch64 in general) integrated.

[rengolin]

In D11532#233531, @jasonk wrote:

I have already split the patches out. This is hanging around just for reference. I am not expecting this patch to go in as is.

Right, than it's better to "abandon" this change. It'll still be here for people to look at, but the intent will be clear.

The TLS emulation is wholly inappropriate for TSAN, as it uses calls that are themselves intercepted by TSAN. EVERY memory access, and every API call made in the user app (including calls to pthread mutex lock, malloc, ett al) REQUIRES TLS vars to already exist. There is a chicken-vs-egg that can't be resolved here.

That's not what the agreement in the thread was. I'm not an expert in TLS, so I won't opine, but you should get consensus in the LLVM list before proposing a patch of this magnitude. Discussing on the sanitizer's list is not enough, as most of us don't participate in that list, so you won't hit the people that can really help you.

If the sanitizer sources were completely independent from Compiler-RT, I understand, but they're not, so you should get consensus here.

Huh. I was under the impression that aarch64 kernel being limited to 39 bits was primarily for performance reasons. For 42 bits, every memory access needs to access full 3 levels of in-memory tables (as opposed to two levels for 39 bits), which would, approximately, add 33% overhead for each memory access???

AArch64 can use 39, 42 and 48 bits VMA. For now, it was limited to 39, but some distributions are enabling 42-bits (like Fedora), and it seems that it will be a kernel default to move to 48 bits pretty soon. We have to work with all scenarios.

Or at least that's what I was told by a local android kernel guy

Android is a closed ecosystem, and the decisions are taken internally and may not be in line with the mainline kernel, Linux or BSD distributions, etc. You can't assume that the way Android works on AArch64 is AArch64's behaviour.

I am not sure what you mean, but I'll do what it takes to get this (not this patch specifically, but the work in TSAN+android+aarch64 in general) integrated.

I agree. Focus on the functionality, not an implementation. I guess it's a shame that the sanitizer discussion is happening in a different list, especially when it gets so down to the hardware behaviour. We can't assume all the hardware folks will be in all the lists, so if you want to discuss about Android/TSAN on hardware A, you should at least copy some of the folks from that community.

If I was copied, I'd have brought the discussion to the LLVM list a lot sooner, and we'd have had a lot less disagreements.

At least now we have two fast buildbots on AArch64, one on 39bits and one on 42bits, so we can be more confident once the patches start landing.

Let's more this discussion to the list, and to the specific patches that spawned, and let's abandon this one.

cheers,
--renato

CMakeLists.txt

+if(${COMPILER_RT_CROSS_COMPILING_NOANDROID})
+SET(ANDROID "0" CACHE STRING "ANDROID" FORCE)
+endif()
+
 # CMake build for CompilerRT.
 #
 # This build assumes that CompilerRT is checked out into the
 # 'projects/compiler-rt' inside of an LLVM tree.
 # Standalone build system for CompilerRT is not yet ready.
 #
 # An important constraint of the build is that it only produces libraries
 # based on the ability of the host toolchain to target various platforms.

cmake/config-ix.cmake

 
 # Generate the COMPILER_RT_SUPPORTED_ARCH list.
 if(ANDROID)
   # Can't rely on LLVM_NATIVE_ARCH in cross-compilation.
   # Examine compiler output instead.
   detect_target_arch()
   set(COMPILER_RT_OS_SUFFIX "-android")
 else()
-  if("${LLVM_NATIVE_ARCH}" STREQUAL "X86")
+  # See If the user wants cross compiling, e.g. using clang for something
+  # other than android.
+  # This is useful if we want to use CMAKE_C_FLAGS and CMAKE_C_COMPILER to
+  # pass in cross compilation args, i.e. we are using a single version of clang
+  # that has a default target other than the host to generate compiler-rt for the
+  # host (or some other platform)
+  if(${COMPILER_RT_CROSS_COMPILING})
+    detect_target_arch()
+  elseif("${LLVM_NATIVE_ARCH}" STREQUAL "X86")
     if(NOT MSVC)
       test_target_arch(x86_64 "" "-m64")
       # FIXME: We build runtimes for both i686 and i386, as "clang -m32" may
       # target different variant than "$CMAKE_C_COMPILER -m32". This part should
       # be gone after we resolve PR14109.
       test_target_arch(i686 __i686__ "-m32")
       test_target_arch(i386 __i386__ "-m32")
     else()
function(get_target_flags_for_arch arch out_var)
   else()
     set(${out_var} ${TARGET_${arch}_CFLAGS} PARENT_SCOPE)
   endif()
 endfunction()
 
 # Architectures supported by compiler-rt libraries.
 filter_available_targets(SANITIZER_COMMON_SUPPORTED_ARCH
   x86_64 i386 i686 powerpc64 powerpc64le arm aarch64 mips mips64 mipsel mips64el)
+if(${COMPILER_RT_FORCE_TSAN_AARCH64})
+filter_available_targets(ASAN_SUPPORTED_ARCH
+  x86_64 i386 i686 powerpc64 powerpc64le arm aarch64 mips mipsel mips64 mips64el)
+else()
 filter_available_targets(ASAN_SUPPORTED_ARCH
   x86_64 i386 i686 powerpc64 powerpc64le arm mips mipsel mips64 mips64el)
+endif()
 filter_available_targets(DFSAN_SUPPORTED_ARCH x86_64 mips64 mips64el)
 filter_available_targets(LSAN_SUPPORTED_ARCH x86_64 mips64 mips64el)
 # LSan common files should be available on all architectures supported
 # by other sanitizers (even if they build into dummy object files).
 filter_available_targets(LSAN_COMMON_SUPPORTED_ARCH
   ${SANITIZER_COMMON_SUPPORTED_ARCH})
 filter_available_targets(MSAN_SUPPORTED_ARCH x86_64 mips64 mips64el)
 filter_available_targets(PROFILE_SUPPORTED_ARCH x86_64 i386 i686 arm mips mips64
   mipsel mips64el aarch64 powerpc64 powerpc64le)
+if(${COMPILER_RT_FORCE_TSAN_AARCH64})
+filter_available_targets(TSAN_SUPPORTED_ARCH x86_64 mips64 mips64el aarch64)
+else()
 filter_available_targets(TSAN_SUPPORTED_ARCH x86_64 mips64 mips64el)
+endif()
 filter_available_targets(UBSAN_SUPPORTED_ARCH x86_64 i386 i686 arm aarch64 mips mipsel mips64 mips64el)
 
 if(ANDROID)
   set(OS_NAME "Android")
 else()
   set(OS_NAME "${CMAKE_SYSTEM_NAME}")
 endif()
 

 if (PROFILE_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Darwin|Linux|FreeBSD")
   set(COMPILER_RT_HAS_PROFILE TRUE)
 else()
   set(COMPILER_RT_HAS_PROFILE FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND TSAN_SUPPORTED_ARCH AND
-    OS_NAME MATCHES "Linux|FreeBSD")
+    OS_NAME MATCHES "Linux|FreeBSD|Android")
   set(COMPILER_RT_HAS_TSAN TRUE)
 else()
   set(COMPILER_RT_HAS_TSAN FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND UBSAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Darwin|Linux|FreeBSD")
   set(COMPILER_RT_HAS_UBSAN TRUE)
 else()
   set(COMPILER_RT_HAS_UBSAN FALSE)
 endif()
 

lib/sanitizer_common/sanitizer_libc.h

 void NORETURN internal__exit(int exitcode);
 uptr internal_lseek(fd_t fd, OFF_T offset, int whence);
 
 uptr internal_ptrace(int request, int pid, void *addr, void *data);
 uptr internal_waitpid(int pid, int *status, int options);
 uptr internal_getpid();
 uptr internal_getppid();
 
+void *internal_malloc(uptr s);
+void *internal_calloc(uptr s, uptr n);
+
 int internal_fork();
 
 // Threading
 uptr internal_sched_yield();
 
 // These functions call appropriate pthread_ functions directly, bypassing
 // the interceptor. They are weak and may not be present in some tools.
 SANITIZER_WEAK_ATTRIBUTE
 int real_pthread_create(void *th, void *attr, void *(*callback)(void *),

lib/sanitizer_common/sanitizer_libc.cc

if (d < s) {
     if (d > s && signed_n > 0)
       for (i = signed_n - 1; i >= 0 ; --i) {
         d[i] = s[i];
       }
   }
   return dest;
 }
 
+void *internal_malloc(uptr n) {
+  return InternalAlloc(n);
+}
+
+void *internal_calloc(uptr n, uptr s) {
+  void *rtn = InternalAlloc(n * s);
+  if (rtn) {
+    internal_memset(rtn, 0, n * s);
+  }
+  return (void*)0;
+}
+
+
 // Semi-fast bzero for 16-aligned data. Still far from peak performance.
 void internal_bzero_aligned16(void *s, uptr n) {
   struct S16 { u64 a, b; } ALIGNED(16);
   CHECK_EQ((reinterpret_cast<uptr>(s) | n) & 15, 0);
   for (S16 *p = reinterpret_cast<S16*>(s), *end = p + n / 16; p < end; p++) {
     p->a = p->b = 0;
     SanitizerBreakOptimization(0);  // Make sure this does not become memset.
   }

lib/sanitizer_common/sanitizer_linux.h

 // Linux-only syscalls.
 #if SANITIZER_LINUX
 uptr internal_prctl(int option, uptr arg2, uptr arg3, uptr arg4, uptr arg5);
 // Used only by sanitizer_stoptheworld. Signal handlers that are actually used
 // (like the process-wide error reporting SEGV handler) must use
 // internal_sigaction instead.
 int internal_sigaction_norestorer(int signum, const void *act, void *oldact);
 void internal_sigdelset(__sanitizer_sigset_t *set, int signum);
-#if defined(__x86_64__) || defined(__mips__)
+#if defined(__x86_64__) || defined(__mips__) || defined(__aarch64__)
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
                     int *parent_tidptr, void *newtls, int *child_tidptr);
 #endif
 #endif  // SANITIZER_LINUX
 
 // This class reads thread IDs from /proc/<pid>/task using only syscalls.
 class ThreadLister {
  public:

lib/sanitizer_common/sanitizer_linux.cc

__asm__ __volatile__(
                          "r"(r8),
                          "r"(r10)
                        : "rsp", "memory", "r11", "rcx");
   return res;
 }
 #elif defined(__mips__)
 // TODO(sagarthakur): clone function is to be rewritten in assembly.
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
                     int *parent_tidptr, void *newtls, int *child_tidptr) {
   return clone(fn, child_stack, flags, arg, parent_tidptr,
                newtls, child_tidptr);
 }
+#elif defined(__aarch64__)
+uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
+                    int *parent_tidptr, void *newtls, int *child_tidptr) {
+  return clone(fn, child_stack, flags, arg, parent_tidptr,
+               newtls, child_tidptr);
+}
 #endif  // defined(__x86_64__) && SANITIZER_LINUX
 
 #if SANITIZER_ANDROID
 static atomic_uint8_t android_log_initialized;
 
 void AndroidLogInit() {
   atomic_store(&android_log_initialized, 1, memory_order_release);
 }
 // This thing is not, strictly speaking, async signal safe, but it does not seem
 // to cause any issues. Alternative is writing to log devices directly, but
 // their location and message format might change in the future, so we'd really
 // like to avoid that.
do {
     __android_log_write(ANDROID_LOG_INFO, NULL, p);
     if (q) p = q + 1;
   } while (q);
   InternalFree(copy);
 }
 
 void GetExtraActivationFlags(char *buf, uptr size) {
   CHECK(size > PROP_VALUE_MAX);
-  __system_property_get("asan.options", buf);
+  // fixme: below not available in android L and onwards
+  //__system_property_get("asan.options", buf);
 }
 #endif
 
 bool IsDeadlySignal(int signum) {
   return (signum == SIGSEGV || signum == SIGBUS) && common_flags()->handle_segv;
 }
 
 #ifndef SANITIZER_GO
#elif defined(__mips__)
   *pc = ucontext->uc_mcontext.gregs[31];
   *bp = ucontext->uc_mcontext.gregs[30];
   *sp = ucontext->uc_mcontext.gregs[29];
 #else
 # error "Unsupported arch"
 #endif
 }
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_FREEBSD || SANITIZER_LINUX

lib/sanitizer_common/sanitizer_platform_interceptors.h

 #define SANITIZER_INTERCEPT_STRERROR_R SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_XPG_STRERROR_R SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_SCANDIR SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_SCANDIR64 SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_GETGROUPS SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_POLL SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_PPOLL SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_WORDEXP \
-  SI_FREEBSD || (SI_MAC && !SI_IOS) || SI_LINUX_NOT_ANDROID
+  (SI_FREEBSD || (SI_MAC && !SI_IOS) || SI_LINUX_NOT_ANDROID)
 #define SANITIZER_INTERCEPT_SIGWAIT SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_SIGWAITINFO SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_SIGTIMEDWAIT SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_SIGSETOPS \
-  SI_FREEBSD || SI_MAC || SI_LINUX_NOT_ANDROID
+  (SI_FREEBSD || SI_MAC || SI_LINUX_NOT_ANDROID || __aarch64__)
 #define SANITIZER_INTERCEPT_SIGPENDING SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_SIGPROCMASK SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_BACKTRACE SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_GETMNTENT SI_LINUX
 #define SANITIZER_INTERCEPT_GETMNTENT_R SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_STATFS SI_FREEBSD || SI_MAC || SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_STATFS64 \
   (SI_MAC && !SI_IOS) || SI_LINUX_NOT_ANDROID

lib/sanitizer_common/sanitizer_platform_limits_posix.h

struct __sanitizer_passwd {
     char *pw_name;
     char *pw_passwd;
     int pw_uid;
     int pw_gid;
 #if SANITIZER_MAC || SANITIZER_FREEBSD
     long pw_change;
     char *pw_class;
 #endif
-#if !SANITIZER_ANDROID
+#if !SANITIZER_ANDROID || (SANITIZER_ANDROID && __aarch64__)
+    // this is defined in aarch64
     char *pw_gecos;
 #endif
     char *pw_dir;
     char *pw_shell;
 #if SANITIZER_MAC || SANITIZER_FREEBSD
     long pw_expire;
 #endif
 #if SANITIZER_FREEBSD
struct __sanitizer_mntent {
     char *mnt_dir;
     char *mnt_type;
     char *mnt_opts;
     int mnt_freq;
     int mnt_passno;
   };
 #endif
 
-#if SANITIZER_ANDROID || SANITIZER_MAC || SANITIZER_FREEBSD
+#if SANITIZER_MAC || SANITIZER_FREEBSD
   struct __sanitizer_msghdr {
     void *msg_name;
     unsigned msg_namelen;
     struct __sanitizer_iovec *msg_iov;
     unsigned msg_iovlen;
     void *msg_control;
     unsigned msg_controllen;
     int msg_flags;
   };
   struct __sanitizer_cmsghdr {
     unsigned cmsg_len;
     int cmsg_level;
     int cmsg_type;
   };
+#elif SANITIZER_ANDROID
+struct __sanitizer_msghdr {
+  void* msg_name;
+  unsigned msg_namelen;
+  struct __sanitizer_iovec* msg_iov;
+  unsigned long msg_iovlen;
+  void* msg_control;
+  unsigned long msg_controllen;
+  int msg_flags;
+};
+
+struct __sanitizer_cmsghdr {
+  unsigned long cmsg_len;
+  int cmsg_level;
+  int cmsg_type;
+};
+
 #else
   struct __sanitizer_msghdr {
     void *msg_name;
     unsigned msg_namelen;
     struct __sanitizer_iovec *msg_iov;
     uptr msg_iovlen;
     void *msg_control;
     uptr msg_controllen;
#elif SANITIZER_LINUX
   };
 #elif SANITIZER_FREEBSD
   struct __sanitizer_sigset_t {
      // uint32_t * 4
      unsigned int __bits[4];
   };
 #endif
 
+#if SANITIZER_ANDROID && __aarch64__
+  struct __sanitizer_sigaction {
+    unsigned int sa_flags;
+    union {
+      void (*handler)(int);
+      void (*sigaction)(int, void*, void*);
+    };
+    __sanitizer_sigset_t sa_mask;
+    void (*sa_restorer)(void);
+  };
+
+#else
   // Linux system headers define the 'sa_handler' and 'sa_sigaction' macros.
   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);

 #endif
 #if SANITIZER_LINUX
     void (*sa_restorer)();
 #endif
 #if defined(__mips__) && (SANITIZER_WORDSIZE == 32)
     int sa_resv[1];
 #endif
   };
+#endif
 
 #if SANITIZER_FREEBSD
   typedef __sanitizer_sigset_t __sanitizer_kernel_sigset_t;
 #elif defined(__mips__)
   struct __sanitizer_kernel_sigset_t {
     u8 sig[16];
   };
 #else
struct __sanitizer_FILE {
     char *_IO_save_base;
     char *_IO_backup_base;
     char *_IO_save_end;
     void *_markers;
     __sanitizer_FILE *_chain;
     int _fileno;
   };
 # define SANITIZER_HAS_STRUCT_FILE 1
+#elif SANITIZER_ANDROID
+#if defined(__LP64__)
+  struct __sanitizer__sbuf {
+    unsigned char* _base;
+    uptr _size;
+};
+#else
+  struct __sanitizer__sbuf {
+    unsigned char *_base;
+    int _size;
+  };
+#endif
+
+  struct __sanitizer_FILE  {
+    unsigned char *_p;  /* current position in (some) buffer */
+    int         _r;     /* read space left for getc() */
+    int         _w;     /* write space left for putc() */
+#if defined(__LP64__)
+    int         _flags; /* flags, below; this FILE is free if 0 */
+    int         _file;  /* fileno, if Unix descriptor, else -1 */
+#else
+    short       _flags; /* flags, below; this FILE is free if 0 */
+    short       _file;  /* fileno, if Unix descriptor, else -1 */
+#endif
+     /* the buffer (at least 1 byte, if !NULL) */
+    struct      __sanitizer__sbuf _bf;
+    int         _lbfsize;       /* 0 or -_bf._size, for inline putc */
+
+    /* operations */
+    void        *_cookie;       /* cookie passed to io functions */
+    int         (*_close)(void *);
+    int         (*_read)(void *, char *, int);
+    uptr        (*_seek)(void *, uptr, int);
+    int         (*_write)(void *, const char *, int);
+
+    /* extension data, to avoid further ABI breakage */
+    struct      __sanitizer__sbuf _ext;
+    /* data for long sequences of ungetc() */
+    unsigned char *_up; /* saved _p when _p is doing ungetc data */
+    int           _ur;  /* saved _r when _r is counting ungetc data */
+
+    unsigned char _ubuf[3];     /* guarantee an ungetc() buffer */
+    unsigned char _nbuf[1];     /* guarantee a getc() buffer */
+
+    struct      __sanitizer__sbuf _lb;     /* buffer for fgetln() */
+
+    /* Unix stdio files get aligned to block boundaries on fseek() */
+    int         _blksize;       /* stat.st_blksize (may be != _bf._size) */
+    uptr        _offset;        /* current lseek offset */
+  };
+# define SANITIZER_HAS_STRUCT_FILE 0
 #else
   typedef void __sanitizer_FILE;
 # define SANITIZER_HAS_STRUCT_FILE 0
 #endif
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID && \
   (defined(__i386) || defined(__x86_64) || defined(__mips64))
   extern unsigned struct_user_regs_struct_sz;

lib/sanitizer_common/sanitizer_platform_limits_posix.cc

 #include <sys/ipc.h>
 #endif // SANITIZER_LINUX && !SANITIZER_ANDROID
 
 #if SANITIZER_ANDROID
 #include <linux/kd.h>
 #include <linux/mtio.h>
 #include <linux/ppp_defs.h>
 #include <linux/if_ppp.h>
+#include <sys/socket.h>
 #endif
 
 #if SANITIZER_LINUX
 #include <link.h>
 #include <sys/vfs.h>
 #include <sys/epoll.h>
 #include <linux/capability.h>
 #endif // SANITIZER_LINUX

 CHECK_TYPE_SIZE(passwd);
 CHECK_SIZE_AND_OFFSET(passwd, pw_name);
 CHECK_SIZE_AND_OFFSET(passwd, pw_passwd);
 CHECK_SIZE_AND_OFFSET(passwd, pw_uid);
 CHECK_SIZE_AND_OFFSET(passwd, pw_gid);
 CHECK_SIZE_AND_OFFSET(passwd, pw_dir);
 CHECK_SIZE_AND_OFFSET(passwd, pw_shell);
 
-#if !SANITIZER_ANDROID
+#if !SANITIZER_ANDROID || (SANITIZER_ANDROID && __aarch64__)
 CHECK_SIZE_AND_OFFSET(passwd, pw_gecos);
 #endif
 
 #if SANITIZER_MAC
 CHECK_SIZE_AND_OFFSET(passwd, pw_change);
 CHECK_SIZE_AND_OFFSET(passwd, pw_expire);
 CHECK_SIZE_AND_OFFSET(passwd, pw_class);
 #endif

lib/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc

 //===-- sanitizer_stoptheworld_linux_libcdep.cc ---------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // See sanitizer_stoptheworld.h for details.
 // This implementation was inspired by Markus Gutschke's linuxthreads.cc.
 //
 //===----------------------------------------------------------------------===//
 
 
 #include "sanitizer_platform.h"
-#if SANITIZER_LINUX && (defined(__x86_64__) || defined(__mips__))
+#if SANITIZER_LINUX && (defined(__x86_64__) || defined(__mips__) || defined(__aarch64__))
 
 #include "sanitizer_stoptheworld.h"
 
 #include "sanitizer_platform_limits_posix.h"
 #include "sanitizer_atomic.h"
 
 #include <errno.h>
 #include <sched.h> // for CLONE_* definitions

 #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]
 
+#elif defined(__aarch64__)
+typedef struct user_pt_regs regs_struct;
+#define REG_SP sp
 #else
 #error "Unsupported architecture"
 #endif // SANITIZER_ANDROID && defined(__arm__)
 
 int SuspendedThreadsList::GetRegistersAndSP(uptr index,
                                             uptr *buffer,
                                             uptr *sp) const {
   pid_t tid = GetThreadID(index);
   regs_struct regs;
   int pterrno;
-  if (internal_iserror(internal_ptrace(PTRACE_GETREGS, tid, NULL, &regs),
+  if (internal_iserror(internal_ptrace(PTRACE_GETREGSET, tid, NULL, &regs),
                        &pterrno)) {
     VReport(1, "Could not get registers from thread %d (errno %d).\n", tid,
             pterrno);
     return -1;
   }
 
   *sp = regs.REG_SP;
   internal_memcpy(buffer, &regs, sizeof(regs));
   return 0;
 }
 
 uptr SuspendedThreadsList::RegisterCount() {
   return sizeof(regs_struct) / sizeof(uptr);
 }
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_LINUX && (defined(__x86_64__) || defined(__mips__))

lib/tsan/CMakeLists.txt

 append_list_if(COMPILER_RT_HAS_MSSE3_FLAG -msse3 TSAN_RTL_CFLAGS)
 append_list_if(SANITIZER_LIMIT_FRAME_SIZE -Wframe-larger-than=512
                TSAN_RTL_CFLAGS)
 append_list_if(COMPILER_RT_HAS_WGLOBAL_CONSTRUCTORS_FLAG -Wglobal-constructors
                TSAN_RTL_CFLAGS)
 # FIXME: Add support for --sysroot=. compile flag:
 
 set(TSAN_SOURCES
+  rtl/tsan_aarch64_tls_workaround.cc
   rtl/tsan_clock.cc
   rtl/tsan_flags.cc
   rtl/tsan_fd.cc
   rtl/tsan_ignoreset.cc
   rtl/tsan_interceptors.cc
   rtl/tsan_interface_ann.cc
   rtl/tsan_interface_atomic.cc
   rtl/tsan_interface.cc
if(APPLE)
   list(APPEND TSAN_SOURCES rtl/tsan_platform_mac.cc)
 elseif(UNIX)
   # Assume Linux
   list(APPEND TSAN_SOURCES
     rtl/tsan_platform_linux.cc)
 endif()
 
 set(TSAN_HEADERS
+  rtl/tsan_aarch64_tls_workaround.h
   rtl/tsan_clock.h
   rtl/tsan_defs.h
   rtl/tsan_dense_alloc.h
   rtl/tsan_fd.h
   rtl/tsan_flags.h
   rtl/tsan_flags.inc
   rtl/tsan_ignoreset.h
   rtl/tsan_interface_ann.h

lib/tsan/rtl/tsan.syms.extra

 __tsan_init
 __tsan_read*
 __tsan_write*
 __tsan_vptr*
 __tsan_func*
 __tsan_atomic*
 __tsan_java*
 __tsan_unaligned*
 __tsan_release
 __tsan_acquire
+InitTSanWorkAround
 Annotate*
 WTFAnnotate*
 RunningOnValgrind
 ValgrindSlowdown

lib/tsan/rtl/tsan_aarch64_tls_workaround.h

+//===-- tsan_android_aarch64_tls_workaround.h -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of ThreadSanitizer (TSan), a race detector.
+//
+// This file presents some macros
+//===----------------------------------------------------------------------===//
+
+#ifndef TSAN_AARCH64_TLS_WORKAROUND_H
+#define TSAN_AARCH64_TLS_WORKAROUND_H
+
+// This file implements a few macros
+// For OSs that properly implement __thread, this will devolve to a no-op.
+// For others (notably Android on AArch64), we get around the lack of support
+// via using pthread calls internally to implement it.
+#include "sanitizer_common/sanitizer_platform.h"
+
+namespace __tsan {
+extern "C" bool InitTSanWorkAround();
+};
+
+#if defined(__aarch64__)
+#define SANITIZER_TLS_WORKAROUND_NEEDED 1
+#define GetFromTLS(tlsvar) get_from_tls_##tlsvar()
+
+// Due to chicken-vs-egg decl issues, these are the real accessor functions
+// these accessor functions are defined elsewhere
+// char &get_from_tls_cur_thread_placeholder() (used in tsan_rtl.cc)
+//  __sanitizer_sigset_t &get_from_tls_emptset() (used in tsan_interceptors.cc)
+//  __sanitizer_sigset_t &get_from_tls_oldset();
+
+#else
+#define GetFromTLS(tlsvar) tlsvar
+#endif
+
+#endif

lib/tsan/rtl/tsan_aarch64_tls_workaround.cc

+#include <cassert>
+
+#include "sanitizer_common/sanitizer_atomic.h"
+#include "sanitizer_common/sanitizer_libc.h"
+#include "sanitizer_common/sanitizer_linux.h"
+#include "sanitizer_common/sanitizer_platform_limits_posix.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+#include "interception/interception.h"
+
+#include "tsan_interface.h"
+#include "tsan_platform.h"
+#include "tsan_rtl.h"
+#include "interception/interception.h"
+#include <dlfcn.h>
+
+
+extern "C" {
+  int pthread_key_create(unsigned *key, void (*destructor)(void* v));
+  void *pthread_getspecific(unsigned key);
+  int pthread_setspecific(unsigned key, const void *v);
+};
+
+using namespace __tsan;
+
+// This needs to be aligned(64)
+struct TSanTLSHack {
+  uptr tid;
+  char cur_thread_placeholder[sizeof(ThreadState)] ALIGNED(64);
+  __sanitizer_sigset_t emptyset, oldset;
+};
+
+static const int PrimeNumber = 2053;
+static TSanTLSHack* TLSHack[PrimeNumber];
+static int Count = 0;
+
+DECLARE_REAL_AND_INTERCEPTOR(void *, memset, void *dst, int v, uptr size);
+DECLARE_REAL_AND_INTERCEPTOR(void *, memcpy, void *dst, const void *src, uptr size);
+DECLARE_REAL_AND_INTERCEPTOR(int, memcmp, const void *dst, const void *src, uptr size);
+// uhoh dlsym() uses these too!
+DECLARE_REAL_AND_INTERCEPTOR(void *, malloc, uptr size);
+DECLARE_REAL_AND_INTERCEPTOR(void *, calloc, uptr nmeb, uptr size);
+
+namespace __tsan {
+
+static bool TSanTLSWorkAroundHasInited=0;
+
+void InitTLSHack() {
+  internal_memset(TLSHack, 0, sizeof(TLSHack));
+  Count = 0;
+}
+
+bool InitTSanWorkAround() {
+  // We need to setup it early, because functions like dlsym() can call it.
+  REAL(memset) = internal_memset;
+  REAL(memcpy) = internal_memcpy;
+  REAL(memcmp) = internal_memcmp;
+  REAL(malloc) = internal_malloc;
+  REAL(calloc) = internal_calloc;
+  if (TSanTLSWorkAroundHasInited == 0)
+    InitTLSHack();
+  TSanTLSWorkAroundHasInited = 1;
+  return TSanTLSWorkAroundHasInited;
+}
+
+extern
+TSanTLSHack *GetTSanTLSHack() {
+  CHECK_EQ(TSanTLSWorkAroundHasInited, 1);
+  uptr tid = GetThreadSelf();
+  uptr hash = tid % PrimeNumber;
+
+  if (TLSHack[hash] == 0ll) {
+    TLSHack[hash] = (TSanTLSHack*)InternalAlloc(sizeof(TSanTLSHack));
+    TLSHack[hash]->tid = tid;
+    DPrintf("Thread %p at slot %p getting ThreadState %p\n",
+            tid, hash, &(TLSHack[hash]->cur_thread_placeholder[0]));
+    return TLSHack[hash];
+  }
+  CHECK_EQ(TLSHack[hash]->tid, tid);
+  return TLSHack[hash];
+}
+
+char &get_from_tls_cur_thread_placeholder() {
+  return GetTSanTLSHack()->cur_thread_placeholder[0];
+};
+
+__sanitizer_sigset_t &get_from_tls_emptyset() {
+  return GetTSanTLSHack()->emptyset;
+};
+
+__sanitizer_sigset_t &get_from_tls_oldset() {
+  return GetTSanTLSHack()->oldset;
+};
+
+}

lib/tsan/rtl/tsan_interceptors.cc

 //===-- tsan_interceptors.cc ----------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of ThreadSanitizer (TSan), a race detector.
 //
 // FIXME: move as many interceptors as possible into
 // sanitizer_common/sanitizer_common_interceptors.inc
 //===----------------------------------------------------------------------===//
 
+static unsigned long long GLOBAL_interceptor_count = 0;
+
 #include "sanitizer_common/sanitizer_atomic.h"
 #include "sanitizer_common/sanitizer_libc.h"
 #include "sanitizer_common/sanitizer_linux.h"
 #include "sanitizer_common/sanitizer_platform_limits_posix.h"
 #include "sanitizer_common/sanitizer_placement_new.h"
 #include "sanitizer_common/sanitizer_stacktrace.h"
 #include "interception/interception.h"
 #include "tsan_interface.h"

 #define __libc_malloc __malloc
 #define __libc_realloc __realloc
 #define __libc_calloc __calloc
 #define __libc_free __free
 #define stdout __stdoutp
 #define stderr __stderrp
 #endif
 
+#if SANITIZER_ANDROID
+#define __errno_location __errno
+#define fileno_unlocked fileno
+#endif
+
 #ifdef __mips__
 const int kSigCount = 129;
 #else
 const int kSigCount = 65;
 #endif
 
 struct my_siginfo_t {
   // The size is determined by looking at sizeof of real siginfo_t on linux.

 
 extern "C" int pthread_attr_init(void *attr);
 extern "C" int pthread_attr_destroy(void *attr);
 DECLARE_REAL(int, pthread_attr_getdetachstate, void *, void *)
 extern "C" int pthread_attr_setstacksize(void *attr, uptr stacksize);
 extern "C" int pthread_key_create(unsigned *key, void (*destructor)(void* v));
 extern "C" int pthread_setspecific(unsigned key, const void *v);
 DECLARE_REAL(int, pthread_mutexattr_gettype, void *, void *)
+#if !SANITIZER_ANDROID
 extern "C" int pthread_yield();
+#endif
 extern "C" int pthread_sigmask(int how, const __sanitizer_sigset_t *set,
                                __sanitizer_sigset_t *oldset);
 // REAL(sigfillset) defined in common interceptors.
 DECLARE_REAL(int, sigfillset, __sanitizer_sigset_t *set)
 DECLARE_REAL(int, fflush, __sanitizer_FILE *fp)
 extern "C" void *pthread_self();
 extern "C" void _exit(int status);
+
 extern "C" int *__errno_location();
 extern "C" int fileno_unlocked(void *stream);
+
+#if SANITIZER_ANDROID && __aarch64__
+// bionic does not have __libc_(malloc/realloc/calloc/free)
+DECLARE_REAL(void *, malloc, uptr);
+DECLARE_REAL(void *, calloc, uptr, uptr);
+DECLARE_REAL(void *, realloc, void *, uptr);
+DECLARE_REAL(void, free, void *);
+
+#define __libc_malloc  REAL(malloc)
+#define __libc_realloc REAL(realloc)
+#define __libc_calloc  REAL(calloc)
+#define __libc_free    REAL(free)
+#else
 extern "C" void *__libc_malloc(uptr size);
+extern "C" void __libc_free(void *ptr);
 extern "C" void *__libc_calloc(uptr size, uptr n);
 extern "C" void *__libc_realloc(void *ptr, uptr size);
-extern "C" void __libc_free(void *ptr);
+#endif
+
+
 extern "C" int dirfd(void *dirp);
 #if !SANITIZER_FREEBSD
 extern "C" int mallopt(int param, int value);
 #endif
+
+#if SANITIZER_ANDROID
+extern __sanitizer_FILE __sF[];
+#define         stdout  (&__sF[1])
+#define         stderr  (&__sF[2])
+#else
 extern __sanitizer_FILE *stdout, *stderr;
+#endif // SANITIZER_ANDROID
+
+
 const int PTHREAD_MUTEX_RECURSIVE = 1;
 const int PTHREAD_MUTEX_RECURSIVE_NP = 1;
 const int EINVAL = 22;
 const int EBUSY = 16;
 const int EOWNERDEAD = 130;
 const int EPOLL_CTL_ADD = 1;
 const int SIGILL = 4;
 const int SIGABRT = 6;

 typedef long long_t;  // NOLINT
 
 // From /usr/include/unistd.h
 # define F_ULOCK 0      /* Unlock a previously locked region.  */
 # define F_LOCK  1      /* Lock a region for exclusive use.  */
 # define F_TLOCK 2      /* Test and lock a region for exclusive use.  */
 # define F_TEST  3      /* Test a region for other processes locks.  */
 
-#define errno (*__errno_location())
+#define get_errno_lval (*__errno_location())
 
 typedef void (*sighandler_t)(int sig);
 typedef void (*sigactionhandler_t)(int sig, my_siginfo_t *siginfo, void *uctx);
 
 struct sigaction_t {
 #ifdef __mips__
   u32 sa_flags;
 #endif
ScopedInterceptor::~ScopedInterceptor() {
   if (!thr_->ignore_interceptors) {
     ProcessPendingSignals(thr_);
     FuncExit(thr_);
     CheckNoLocks(thr_);
   }
 }
 
 #define SCOPED_INTERCEPTOR_RAW(func, ...) \
+    ++GLOBAL_interceptor_count; \
     ThreadState *thr = cur_thread(); \
     const uptr caller_pc = GET_CALLER_PC(); \
+    DPrintf2("INTERCEPT: " #func " %s:%d:%s\n", __FILE__, __LINE__, __PRETTY_FUNCTION__); \
     ScopedInterceptor si(thr, #func, caller_pc); \
     const uptr pc = StackTrace::GetCurrentPc(); \
     (void)pc; \
 /**/
 
 #define SCOPED_TSAN_INTERCEPTOR(func, ...) \
     SCOPED_INTERCEPTOR_RAW(func, __VA_ARGS__); \
     if (REAL(func) == 0) { \

 
 TSAN_INTERCEPTOR(void*, __libc_memalign, uptr align, uptr sz) {
   SCOPED_TSAN_INTERCEPTOR(__libc_memalign, align, sz);
   return user_alloc(thr, pc, sz, align);
 }
 
 TSAN_INTERCEPTOR(void*, calloc, uptr size, uptr n) {
   if (cur_thread()->in_symbolizer)
+#if SANITIZER_ANDROID
+    return REAL(calloc)(size, n);
+#else
     return __libc_calloc(size, n);
+#endif
   void *p = 0;
   {
     SCOPED_INTERCEPTOR_RAW(calloc, size, n);
     p = user_calloc(thr, pc, size, n);
   }
   invoke_malloc_hook(p, n * size);
   return p;
 }
 
 TSAN_INTERCEPTOR(void*, realloc, void *p, uptr size) {
   if (cur_thread()->in_symbolizer)
+#if SANITIZER_ANDROID
+    return REAL(realloc)(p, size);
+#else
     return __libc_realloc(p, size);
+#endif
+
   if (p)
     invoke_free_hook(p);
   {
     SCOPED_INTERCEPTOR_RAW(realloc, p, size);
     p = user_realloc(thr, pc, p, size);
   }
   invoke_malloc_hook(p, size);
   return p;
TSAN_INTERCEPTOR(char*, strdup, const char *str) {
   // strdup will call malloc, so no instrumentation is required here.
   return REAL(strdup)(str);
 }
 
 static bool fix_mmap_addr(void **addr, long_t sz, int flags) {
   if (*addr) {
     if (!IsAppMem((uptr)*addr) || !IsAppMem((uptr)*addr + sz - 1)) {
       if (flags & MAP_FIXED) {
-        errno = EINVAL;
+        get_errno_lval = EINVAL;
         return false;
       } else {
         *addr = 0;
       }
     }
   }
   return true;
 }
int tid = 0;
     ThreadIgnoreBegin(thr, 0);
     if (pthread_setspecific(g_thread_finalize_key,
                             (void *)kPthreadDestructorIterations)) {
       Printf("ThreadSanitizer: failed to set thread key\n");
       Die();
     }
     ThreadIgnoreEnd(thr, 0);
     while ((tid = atomic_load(&p->tid, memory_order_acquire)) == 0)
-      pthread_yield();
+      internal_sched_yield();
     atomic_store(&p->tid, 0, memory_order_release);
     ThreadStart(thr, tid, GetTid());
   }
   void *res = callback(param);
   // Prevent the callback from being tail called,
   // it mixes up stack traces.
   volatile int foo = 42;
   foo++;
int res = -1;
     res = REAL(pthread_create)(th, attr, __tsan_thread_start_func, &p);
     ThreadIgnoreEnd(thr, pc);
   }
   if (res == 0) {
     int tid = ThreadCreate(thr, pc, *(uptr*)th, detached);
     CHECK_NE(tid, 0);
     atomic_store(&p.tid, tid, memory_order_release);
     while (atomic_load(&p.tid, memory_order_acquire) != 0)
-      pthread_yield();
+      internal_sched_yield();
   }
   if (attr == &myattr)
     pthread_attr_destroy(&myattr);
   return res;
 }
 
 TSAN_INTERCEPTOR(int, pthread_join, void *th, void **ret) {
   SCOPED_INTERCEPTOR_RAW(pthread_join, th, ret);
TSAN_INTERCEPTOR(int, pthread_once, void *o, void (*f)()) {
   if (v == 0 && atomic_compare_exchange_strong(a, &v, 1,
                                                memory_order_relaxed)) {
     (*f)();
     if (!thr->in_ignored_lib)
       Release(thr, pc, (uptr)o);
     atomic_store(a, 2, memory_order_release);
   } else {
     while (v != 2) {
-      pthread_yield();
+      internal_sched_yield();
       v = atomic_load(a, memory_order_acquire);
     }
     if (!thr->in_ignored_lib)
       Acquire(thr, pc, (uptr)o);
   }
   return 0;
 }
 
TSAN_INTERCEPTOR(int, lstat64, const char *path, void *buf) {
   SCOPED_TSAN_INTERCEPTOR(__lxstat64, 0, path, buf);
   return REAL(__lxstat64)(0, path, buf);
 }
 #define TSAN_MAYBE_INTERCEPT_LSTAT64 TSAN_INTERCEPT(lstat64)
 #else
 #define TSAN_MAYBE_INTERCEPT_LSTAT64
 #endif
 
-#if !SANITIZER_FREEBSD
+#if !SANITIZER_FREEBSD && ! SANITIZER_ANDROID
 TSAN_INTERCEPTOR(int, __fxstat, int version, int fd, void *buf) {
   SCOPED_TSAN_INTERCEPTOR(__fxstat, version, fd, buf);
   if (fd > 0)
     FdAccess(thr, pc, fd);
   return REAL(__fxstat)(version, fd, buf);
 }
 #define TSAN_MAYBE_INTERCEPT___FXSTAT TSAN_INTERCEPT(__fxstat)
 #else
 #define TSAN_MAYBE_INTERCEPT___FXSTAT
 #endif
 
 TSAN_INTERCEPTOR(int, fstat, int fd, void *buf) {
-#if SANITIZER_FREEBSD
+// SANITIZER_TLS_WORKAROUND_NEEDED is for ANDROID&&__aarch64__
+// ANDROID does not have fxstat and friends
+#if SANITIZER_FREEBSD||SANITIZER_TLS_WORKAROUND_NEEDED
   SCOPED_TSAN_INTERCEPTOR(fstat, fd, buf);
   if (fd > 0)
     FdAccess(thr, pc, fd);
   return REAL(fstat)(fd, buf);
 #else
   SCOPED_TSAN_INTERCEPTOR(__fxstat, 0, fd, buf);
   if (fd > 0)
     FdAccess(thr, pc, fd);
   return REAL(__fxstat)(0, fd, buf);
 #endif
 }
 
-#if !SANITIZER_FREEBSD
+#if !SANITIZER_FREEBSD&&!SANITIZER_TLS_WORKAROUND_NEEDED
 TSAN_INTERCEPTOR(int, __fxstat64, int version, int fd, void *buf) {
   SCOPED_TSAN_INTERCEPTOR(__fxstat64, version, fd, buf);
   if (fd > 0)
     FdAccess(thr, pc, fd);
   return REAL(__fxstat64)(version, fd, buf);
 }
 #define TSAN_MAYBE_INTERCEPT___FXSTAT64 TSAN_INTERCEPT(__fxstat64)
 #else
 #define TSAN_MAYBE_INTERCEPT___FXSTAT64
 #endif
 
-#if !SANITIZER_FREEBSD
+#if !SANITIZER_FREEBSD&&!SANITIZER_TLS_WORKAROUND_NEEDED
 TSAN_INTERCEPTOR(int, fstat64, int fd, void *buf) {
   SCOPED_TSAN_INTERCEPTOR(__fxstat64, 0, fd, buf);
   if (fd > 0)
     FdAccess(thr, pc, fd);
   return REAL(__fxstat64)(0, fd, buf);
 }
 #define TSAN_MAYBE_INTERCEPT_FSTAT64 TSAN_INTERCEPT(fstat64)
 #else
+#if SANITIZER_TLS_WORKAROUND_NEEDED
+TSAN_INTERCEPTOR(int, fstat64, int fd, void *buf) {
+  SCOPED_TSAN_INTERCEPTOR(fstat64, fd, buf);
+  if (fd > 0)
+    FdAccess(thr, pc, fd);
+  return REAL(fstat64)(fd, buf);
+}
+#define TSAN_MAYBE_INTERCEPT_FSTAT64 TSAN_INTERCEPT(fstat64)
+#else
 #define TSAN_MAYBE_INTERCEPT_FSTAT64
 #endif
+#endif
 
 TSAN_INTERCEPTOR(int, open, const char *name, int flags, int mode) {
   SCOPED_TSAN_INTERCEPTOR(open, name, flags, mode);
   int fd = REAL(open)(name, flags, mode);
   if (fd >= 0)
     FdFileCreate(thr, pc, fd);
   return fd;
 }

 
 namespace __tsan {
 
 static void CallUserSignalHandler(ThreadState *thr, bool sync, bool acquire,
     bool sigact, int sig, my_siginfo_t *info, void *uctx) {
   if (acquire)
     Acquire(thr, 0, (uptr)&sigactions[sig]);
   // Ensure that the handler does not spoil errno.
-  const int saved_errno = errno;
-  errno = 99;
+  const int saved_errno = get_errno_lval;
+  get_errno_lval = 99;
   // This code races with sigaction. Be careful to not read sa_sigaction twice.
   // Also need to remember pc for reporting before the call,
   // because the handler can reset it.
   volatile uptr pc = sigact ?
      (uptr)sigactions[sig].sa_sigaction :
      (uptr)sigactions[sig].sa_handler;
   if (pc != (uptr)SIG_DFL && pc != (uptr)SIG_IGN) {
     if (sigact)
       ((sigactionhandler_t)pc)(sig, info, uctx);
     else
       ((sighandler_t)pc)(sig);
   }
   // We do not detect errno spoiling for SIGTERM,
   // because some SIGTERM handlers do spoil errno but reraise SIGTERM,
   // tsan reports false positive in such case.
   // It's difficult to properly detect this situation (reraise),
   // because in async signal processing case (when handler is called directly
   // from rtl_generic_sighandler) we have not yet received the reraised
   // signal; and it looks too fragile to intercept all ways to reraise a signal.
-  if (flags()->report_bugs && !sync && sig != SIGTERM && errno != 99) {
+  if (flags()->report_bugs && !sync && sig != SIGTERM && get_errno_lval != 99) {
     VarSizeStackTrace stack;
     // StackTrace::GetNestInstructionPc(pc) is used because return address is
     // expected, OutputReport() will undo this.
     ObtainCurrentStack(thr, StackTrace::GetNextInstructionPc(pc), &stack);
     ThreadRegistryLock l(ctx->thread_registry);
     ScopedReport rep(ReportTypeErrnoInSignal);
     if (!IsFiredSuppression(ctx, rep, stack)) {
       rep.AddStack(stack, true);
       OutputReport(thr, rep);
     }
   }
-  errno = saved_errno;
+  get_errno_lval = saved_errno;
 }
 
 void ProcessPendingSignals(ThreadState *thr) {
   ThreadSignalContext *sctx = SigCtx(thr);
   if (sctx == 0 ||
       atomic_load(&sctx->have_pending_signals, memory_order_relaxed) == 0)
     return;
   atomic_store(&sctx->have_pending_signals, 0, memory_order_relaxed);
   atomic_fetch_add(&thr->in_signal_handler, 1, memory_order_relaxed);
+#if SANITIZER_TLS_WORKAROUND_NEEDED
+  extern __sanitizer_sigset_t &get_from_tls_emptyset();
+  extern __sanitizer_sigset_t &get_from_tls_oldset();
+  extern void internal_sigfillset(__sanitizer_sigset_t *);
+  //
+#else
   // These are too big for stack.
   static THREADLOCAL __sanitizer_sigset_t emptyset, oldset;
-  CHECK_EQ(0, REAL(sigfillset)(&emptyset));
-  CHECK_EQ(0, pthread_sigmask(SIG_SETMASK, &emptyset, &oldset));
+#endif
+  __sanitizer_sigset_t *P =  & GetFromTLS(emptyset);
+  CHECK_EQ(0, REAL(sigfillset)(P));
+  __sanitizer_sigset_t *E = &GetFromTLS(emptyset);
+  __sanitizer_sigset_t *O = &GetFromTLS(oldset);
+
+  CHECK_EQ(0, pthread_sigmask(SIG_SETMASK, E, O));
+
   for (int sig = 0; sig < kSigCount; sig++) {
     SignalDesc *signal = &sctx->pending_signals[sig];
     if (signal->armed) {
       signal->armed = false;
       CallUserSignalHandler(thr, false, true, signal->sigaction, sig,
           &signal->siginfo, &signal->ctx);
     }
   }
-  CHECK_EQ(0, pthread_sigmask(SIG_SETMASK, &oldset, 0));
+  CHECK_EQ(0, pthread_sigmask(SIG_SETMASK, &GetFromTLS(oldset), 0));
   atomic_fetch_add(&thr->in_signal_handler, -1, memory_order_relaxed);
 }
 
 }  // namespace __tsan
 
 static bool is_sync_signal(ThreadSignalContext *sctx, int sig) {
   return sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
       sig == SIGABRT || sig == SIGFPE || sig == SIGPIPE || sig == SIGSYS ||

 
 void InitializeInterceptors() {
   // We need to setup it early, because functions like dlsym() can call it.
   REAL(memset) = internal_memset;
   REAL(memcpy) = internal_memcpy;
   REAL(memcmp) = internal_memcmp;
 
   // Instruct libc malloc to consume less memory.
-#if !SANITIZER_FREEBSD
+#if !SANITIZER_FREEBSD && !SANITIZER_ANDROID
   mallopt(1, 0);  // M_MXFAST
   mallopt(-3, 32*1024);  // M_MMAP_THRESHOLD
 #endif
 
   InitializeCommonInterceptors();
 
   // We can not use TSAN_INTERCEPT to get setjmp addr,
   // because it does &setjmp and setjmp is not present in some versions of libc.
if (pthread_key_create(&g_thread_finalize_key, &thread_finalize)) {
     Printf("ThreadSanitizer: failed to create thread key\n");
     Die();
   }
 
   FdInit();
 }
 
 }  // namespace __tsan
+

lib/tsan/rtl/tsan_interface.h

 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_func_entry(void *call_pc);
 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_func_exit();
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void __tsan_read_range(void *addr, unsigned long size);  // NOLINT
 SANITIZER_INTERFACE_ATTRIBUTE
 void __tsan_write_range(void *addr, unsigned long size);  // NOLINT
 
+
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif
 
 #endif  // TSAN_INTERFACE_H

lib/tsan/rtl/tsan_interface.cc

 
 #define CALLERPC ((uptr)__builtin_return_address(0))
 
 using namespace __tsan;  // NOLINT
 
 typedef u16 uint16_t;
 typedef u32 uint32_t;
 typedef u64 uint64_t;
+static u64 __tsan_init_count=0;
 
 void __tsan_init() {
+  __tsan_init_count++;
+#if SANITIZER_TLS_WORKAROUND_NEEDED
+  bool C = InitTSanWorkAround(); (void)C;
+  DPrintf("__tsan_init called %lld times -- InitTSanWorkAround()  == %d\n",
+          __tsan_init_count, C);
+#endif
   Initialize(cur_thread());
 }
 
+#if SANITIZER_TLS_WORKAROUND_NEEDED
+__attribute__((section(".preinit_array"), used))
+void (*__local_tsan_preinitc)(void) = __tsan_init;
+#endif // SANITIZER_TLS_WORKAROUND_NEEDED
+
 void __tsan_read16(void *addr) {
   MemoryRead(cur_thread(), CALLERPC, (uptr)addr, kSizeLog8);
   MemoryRead(cur_thread(), CALLERPC, (uptr)addr + 8, kSizeLog8);
 }
 
 void __tsan_write16(void *addr) {
   MemoryWrite(cur_thread(), CALLERPC, (uptr)addr, kSizeLog8);
   MemoryWrite(cur_thread(), CALLERPC, (uptr)addr + 8, kSizeLog8);

lib/tsan/rtl/tsan_platform.h

 //===-- tsan_platform.h -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of ThreadSanitizer (TSan), a race detector.
 //
 // Platform-specific code.
 //===----------------------------------------------------------------------===//
 
 #ifndef TSAN_PLATFORM_H
 #define TSAN_PLATFORM_H
-
+// #define TSAN_DEBUG_OUTPUT 2
 #if !defined(__LP64__) && !defined(_WIN64)
 # error "Only 64-bit is supported"
 #endif
 
 #include "tsan_defs.h"
 #include "tsan_trace.h"
 
 namespace __tsan {

 const uptr kLoAppMemEnd   = 0x0200000000ull;
 const uptr kHiAppMemBeg   = 0xff80000000ull;
 const uptr kHiAppMemEnd   = 0xffffffffffull;
 const uptr kAppMemMsk     = 0xfc00000000ull;
 const uptr kAppMemXor     = 0x0400000000ull;
 const uptr kVdsoBeg       = 0xfffff00000ull;
 #endif
 
+#if defined(__aarch64__)
+/*
+// aarch64: -- memory maps are wierd here.
+*/
+#if !defined(__ANDROID__)
+#error "please fix for aarch64 !ANDROID"
+#endif
+
+const uptr kShadowBeg     = 0x1400000000ull;
+const uptr kShadowEnd     = 0x2400000000ull;
+const uptr kMetaShadowBeg = 0x3000000000ull;
+const uptr kMetaShadowEnd = 0x4000000000ull;
+const uptr kLoAppMemBeg   = 0x5500000000ull;
+const uptr kLoAppMemEnd   = 0x5600000000ull;
+const uptr kTraceMemBeg   = 0x6000000000ull;
+const uptr kTraceMemEnd   = 0x6200000000ull;
+const uptr kHeapMemBeg    = 0x7e00000000ull;
+const uptr kHeapMemEnd    = 0x7f00000000ull;
+const uptr kHiAppMemBeg   = 0x7f00000000ull;
+const uptr kHiAppMemEnd   = 0x8000000000ull;
+const uptr kAppMemMsk     = 0xfc00000000ull;
+const uptr kAppMemMskRtn  = 0x7c00000000ull;
+const uptr kAppMemXor     = 0x0400000000ull;
+const uptr kVdsoBeg       = 0xf000000000ull;
+#endif
+
 ALWAYS_INLINE
 bool IsAppMem(uptr mem) {
   return (mem >= kHeapMemBeg && mem < kHeapMemEnd) ||
          (mem >= kLoAppMemBeg && mem < kLoAppMemEnd) ||
          (mem >= kHiAppMemBeg && mem < kHiAppMemEnd);
 }
 
 ALWAYS_INLINE

 
 ALWAYS_INLINE
 u32 *MemToMeta(uptr x) {
   DCHECK(IsAppMem(x));
   return (u32*)(((((x) & ~(kAppMemMsk | (kMetaShadowCell - 1)))
       ^ kAppMemXor) / kMetaShadowCell * kMetaShadowSize) | kMetaShadowBeg);
 }
 
+#if defined(__aarch64__)
+ALWAYS_INLINE
+uptr ShadowToMem(uptr s) {
+  CHECK(IsShadowMem(s));
+  if (s >= MemToShadow(kLoAppMemBeg) && s <= MemToShadow(kLoAppMemEnd - 1))
+    return (s / kShadowCnt) ^ kAppMemXor | kLoAppMemBeg;
+  else
+    return ((s / kShadowCnt) ^ kAppMemXor) | kAppMemMskRtn;
+}
+#else // __mips64 and __x86_64__
 ALWAYS_INLINE
 uptr ShadowToMem(uptr s) {
   CHECK(IsShadowMem(s));
   if (s >= MemToShadow(kLoAppMemBeg) && s <= MemToShadow(kLoAppMemEnd - 1))
     return (s / kShadowCnt) ^ kAppMemXor;
   else
     return ((s / kShadowCnt) ^ kAppMemXor) | kAppMemMsk;
 }
+#endif
 
 static USED uptr UserRegions[] = {
   kLoAppMemBeg, kLoAppMemEnd,
   kHiAppMemBeg, kHiAppMemEnd,
   kHeapMemBeg,  kHeapMemEnd,
 };
 
 #elif defined(SANITIZER_GO) && !SANITIZER_WINDOWS

lib/tsan/rtl/tsan_platform_linux.cc

void InitializeShadowMemory() {
   // we see 20% memory usage reduction without huge pages for this range.
   // FIXME: don't use constants here.
 #if defined(__x86_64__)
   const uptr kMadviseRangeBeg  = 0x7f0000000000ull;
   const uptr kMadviseRangeSize = 0x010000000000ull;
 #elif defined(__mips64)
   const uptr kMadviseRangeBeg  = 0xff00000000ull;
   const uptr kMadviseRangeSize = 0x0100000000ull;
+#elif SANITIZER_TLS_WORKAROUND_NEEDED
+  const uptr kMadviseRangeBeg  = kHiAppMemBeg;
+  const uptr kMadviseRangeSize = kHiAppMemEnd - kHiAppMemBeg;
 #endif
   NoHugePagesInRegion(MemToShadow(kMadviseRangeBeg),
                       kMadviseRangeSize * kShadowMultiplier);
   if (common_flags()->use_madv_dontdump)
     DontDumpShadowMemory(kShadowBeg, kShadowEnd - kShadowBeg);
   DPrintf("memory shadow: %zx-%zx (%zuGB)\n",
       kShadowBeg, kShadowEnd,
       (kShadowEnd - kShadowBeg) >> 30);
if (p >= kHeapMemEnd &&
         p < HeapEnd())
       continue;
     if (p >= kVdsoBeg)  // vdso
       break;
     Printf("FATAL: ThreadSanitizer: unexpected memory mapping %p-%p\n", p, end);
     Die();
   }
 
+#if SANITIZER_TLS_WORKAROUND_NEEDED
+  // on aaarch64/android, the memory maps are significantly different
+  ProtectRange(kShadowEnd, kMetaShadowBeg);
+  ProtectRange(kMetaShadowEnd, kLoAppMemBeg);
+  ProtectRange(kLoAppMemEnd, kTraceMemBeg);
+
+  // Memory for traces is mapped lazily in MapThreadTrace.
+  // Protect the whole range for now, so that user does not map something here.
+  ProtectRange(kTraceMemBeg, kTraceMemEnd);
+  ProtectRange(kTraceMemEnd, kHeapMemBeg);
+  //ProtectRange(HeapEnd(), kHiAppMemBeg);
+#else
   ProtectRange(kLoAppMemEnd, kShadowBeg);
   ProtectRange(kShadowEnd, kMetaShadowBeg);
   ProtectRange(kMetaShadowEnd, kTraceMemBeg);
   // Memory for traces is mapped lazily in MapThreadTrace.
   // Protect the whole range for now, so that user does not map something here.
   ProtectRange(kTraceMemBeg, kTraceMemEnd);
   ProtectRange(kTraceMemEnd, kHeapMemBeg);
   ProtectRange(HeapEnd(), kHiAppMemBeg);
+#endif
 }
 #endif  // #ifndef SANITIZER_GO
 
 void InitializePlatform() {
   DisableCoreDumperIfNecessary();
 
   // Go maps shadow memory lazily and works fine with limited address space.
   // Unlimited stack is not a problem as well, because the executable
bool IsGlobalVar(uptr addr) {
   return g_data_start && addr >= g_data_start && addr < g_data_end;
 }
 
 #ifndef SANITIZER_GO
 // Extract file descriptors passed to glibc internal __res_iclose function.
 // This is required to properly "close" the fds, because we do not see internal
 // closes within glibc. The code is a pure hack.
 int ExtractResolvFDs(void *state, int *fds, int nfd) {
-#if SANITIZER_LINUX
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
   int cnt = 0;
   __res_state *statp = (__res_state*)state;
   for (int i = 0; i < MAXNS && cnt < nfd; i++) {
     if (statp->_u._ext.nsaddrs[i] && statp->_u._ext.nssocks[i] != -1)
       fds[cnt++] = statp->_u._ext.nssocks[i];
   }
   return cnt;
 #else

lib/tsan/rtl/tsan_rtl.h

 #include "sanitizer_common/sanitizer_allocator.h"
 #include "sanitizer_common/sanitizer_allocator_internal.h"
 #include "sanitizer_common/sanitizer_asm.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_deadlock_detector_interface.h"
 #include "sanitizer_common/sanitizer_libignore.h"
 #include "sanitizer_common/sanitizer_suppressions.h"
 #include "sanitizer_common/sanitizer_thread_registry.h"
+
+// this needs to be pulled in first
+#include "tsan_aarch64_tls_workaround.h"
 #include "tsan_clock.h"
 #include "tsan_defs.h"
 #include "tsan_flags.h"
 #include "tsan_sync.h"
 #include "tsan_trace.h"
 #include "tsan_vector.h"
 #include "tsan_report.h"
 #include "tsan_platform.h"
 #include "tsan_mutexset.h"
 #include "tsan_ignoreset.h"
 #include "tsan_stack_trace.h"
 
 #if SANITIZER_WORDSIZE != 64
 # error "ThreadSanitizer is supported only on 64-bit platforms"
 #endif
 
 namespace __tsan {
 
 #ifndef SANITIZER_GO
 struct MapUnmapCallback;
-#ifdef __mips64
+#if defined(__mips64) || defined(__aarch64__)
 static const uptr kAllocatorSpace = 0;
 static const uptr kAllocatorSize = SANITIZER_MMAP_RANGE_SIZE;
 static const uptr kAllocatorRegionSizeLog = 20;
 static const uptr kAllocatorNumRegions =
     kAllocatorSize >> kAllocatorRegionSizeLog;
 typedef TwoLevelByteMap<(kAllocatorNumRegions >> 12), 1 << 12,
     MapUnmapCallback> ByteMap;
 typedef SizeClassAllocator32<kAllocatorSpace, kAllocatorSize, 0,
#endif
 
   explicit ThreadState(Context *ctx, int tid, int unique_id, u64 epoch,
                        unsigned reuse_count,
                        uptr stk_addr, uptr stk_size,
                        uptr tls_addr, uptr tls_size);
 };
 
 #ifndef SANITIZER_GO
+#if !SANITIZER_TLS_WORKAROUND_NEEDED
 __attribute__((tls_model("initial-exec")))
 extern THREADLOCAL char cur_thread_placeholder[];
 INLINE ThreadState *cur_thread() {
-  return reinterpret_cast<ThreadState *>(&cur_thread_placeholder);
+  return reinterpret_cast<ThreadState *>(&GetFromTLS(cur_thread_placeholder));
 }
+#else
+extern char &get_from_tls_cur_thread_placeholder();
+INLINE ThreadState *cur_thread() {
+  return reinterpret_cast<ThreadState *>(&get_from_tls_cur_thread_placeholder());
+}
+#endif
 #endif
 
 class ThreadContext : public ThreadContextBase {
  public:
   explicit ThreadContext(int tid);
   ~ThreadContext();
   ThreadState *thr;
   u32 creation_stack_id;

lib/tsan/rtl/tsan_rtl.cc

 
 extern "C" void __tsan_resume() {
   __tsan_resumed = 1;
 }
 
 namespace __tsan {
 
 #ifndef SANITIZER_GO
+#if !SANITIZER_TLS_WORKAROUND_NEEDED
 THREADLOCAL char cur_thread_placeholder[sizeof(ThreadState)] ALIGNED(64);
+// these are the real accessor functions
+extern char &get_from_tls_cur_thread_placeholder();
+#endif
 #endif
 static char ctx_placeholder[sizeof(Context)] ALIGNED(64);
 Context *ctx;
 
 // Can be overriden by a front-end.
 #ifdef TSAN_EXTERNAL_HOOKS
 bool OnFinalize(bool failed);
 void OnInitialize();
for (uptr i = 0; i < ARRAY_SIZE(UserRegions); i += 2) {
     VPrintf(3, "checking shadow region %p-%p\n", beg, end);
     for (uptr p0 = beg; p0 <= end; p0 += (end - beg) / 4) {
       for (int x = -1; x <= 1; x++) {
         const uptr p = p0 + x;
         if (p < beg || p >= end)
           continue;
         const uptr s = MemToShadow(p);
         const uptr m = (uptr)MemToMeta(p);
-        VPrintf(3, "  checking pointer %p: shadow=%p meta=%p\n", p, s, m);
+        const uptr s1 = ShadowToMem(s);
+        VPrintf(3, "  checking pointer %p: shadow=%p meta=%p s2m=%p\n", p, s, m, s1);
         CHECK(IsAppMem(p));
         CHECK(IsShadowMem(s));
         CHECK_EQ(p & ~(kShadowCell - 1), ShadowToMem(s));
         CHECK(IsMetaMem(m));
       }
     }
   }
 }
#endif
   __sanitizer_set_report_path(common_flags()->log_path);
   InitializeSuppressions();
 #ifndef SANITIZER_GO
   InitializeLibIgnore();
   Symbolizer::GetOrInit()->AddHooks(EnterSymbolizer, ExitSymbolizer);
   // On MIPS, TSan initialization is run before
   // __pthread_initialize_minimal_internal() is finished, so we can not spawn
   // new threads.
-#ifndef __mips__
+#if !defined(__mips__)&&!SANITIZER_TLS_WORKAROUND_NEEDED
   StartBackgroundThread();
   SetSandboxingCallback(StopBackgroundThread);
 #endif
 #endif
   if (common_flags()->detect_deadlocks)
     ctx->dd = DDetector::Create(flags());
 
   VPrintf(1, "***** Running under ThreadSanitizer v2 (pid %d) *****\n",