Optional support for dynamic Asan runtime

[ygribov]

First try on Konstantin's suggestions in ML (https://groups.google.com/forum/#!topic/address-sanitizer/XJXOrSvN8vg).

Stuff that hasn't been addressed:

• platforms other than Linux
• support for other dynamic runtimes (UBSan, MSan, etc.)
• detection of static/dynamic rt conflict
• detection of dlopen

[ygribov]

Forgot to add new files (as usual).

[ygribov]

One more thing that would be useful to verify:

• make sure that libasan is preloaded

[ygribov]

I think I found a reasonably robust way to detect that dynamic rt was either linked to exectable or preloaded (and thus can be used safely). I can simply check that it preceedes other dynamic libraries in list returned by dl_iterate_phdr. This would also prohibit dlopens.

Still not sure how to detect static/shared rt conflicts though.

[ygribov]

Still not sure how to detect static/shared rt conflicts though.

One option would be to export some marker from executable linked with static libasan (e.g. local_asan_preinit symbol) and then check if it's present via dlsym() in asan_init if ASAN_DYNAMIC is defined.

[ygribov]

Added support for

• detection of static/dynamic rt conflicts
• detection of dlopen
• make sure that libasan is preloaded

(all features have unit tests).

One huge problem is that currently Asan always starts in active mode because dlsym's in AsanCheckIncompatibleRT call dlerror, this calls malloc and malloc activates Asan. I'm not sure how to address the issue (I tried the calloc-style hack but this would cause errors when dlerror-allocated regions are freed).

As before, I haven't really checked anything besides Linux x64.

I decided to leave dynamic runtimes for UBSan, etc. for future. IMHO this would be a trivial piece of work anyway.

[ygribov]

Removed redundant code.

[ygribov]

Resolved afore-mentioned problem with deactivation tests. Dlerror now uses same preinit hack as dlsym.

[ygribov]

Improved tests.

[samsonov]

First round of comments.

cmake/Modules/AddCompilerRT.cmake

42

Can you avoid duplicating the function, and instead generalize it?

add_compiler_rt_runtime (<name> <arch> [SOURCES <sources>] [CFLAGS <cflags>] [DEFS <defs>] [SHARED]).
which would build the shared runtime if SHARED is specified, and static runtime otherwise?

lib/asan/CMakeLists.txt

132

get rid of this and ASAN_DYNAMIC_RUNTIME_OBJECTS, just write all objects you need inside add_compiler_rt_runtime.

140–161

accidental duplication?

150

ldl or lpthread may not be available, see COMPILER_RT_HAS_LIBDL for example.

166

Do you use symbols from dynamic runtime anywhere?

lib/asan/asan_rtl.cc

632

We generally assume that all ASAN_xxx compiler definitions should be defined. If they are not, we set the default value in the source file, see asan_internal.h

[samsonov]

CMakeLists.txt

233

ASAN_BUILD_SHARED_RUNTIME

lib/asan/CMakeLists.txt

77

define this right after ASAN_COMMON_DEFINITIONS

lib/asan/asan_win.cc

77

Why don't we use UNIMPLEMENTED() here?

lib/sanitizer_common/sanitizer_internal_defs.h

151

Please don't do this. We should really specfiy this for each variable instead.

[samsonov]

lib/asan/asan_rtl.cc

563

Can't you simply call __asan_init() here? It also calls AsanCheckIncompatibleRT, checks for asan_inited, and you may add a call to AsanCheckDynamicRTPrereqs under #if ASAN_DYNAMIC

[ygribov]

CMakeLists.txt

233

Hm, are you sure? I thought all compiler-rt configs should start with COMPILER_RT...

cmake/Modules/AddCompilerRT.cmake

42

Well, there is already so much code dup (e.g. compare add_compiler_rt_static_runtime against add_compiler_rt_osx_static_runtime). Perhaps it should be addressed in a separate patch?

lib/asan/CMakeLists.txt

77

Yeah, already done locally.

132

Right.

140–161

Most probably result of code rewrite.

150

Ok, I'll add checks then. What about adding these for static rt as well (in Clang driver)?

166

No, probably not. I'll remove this.

lib/asan/asan_rtl.cc

563

No, because then __asan_init may then get called twice:

1. once from .preinit_array
2. once from this ctor

which will force ASan in activated state. Actually ability to start in deactivated state greatly complicates startup.

632

Will do.

lib/asan/asan_win.cc

77

Well, they are still called from initialization code (like other empty functions in this file).

lib/sanitizer_common/sanitizer_internal_defs.h

151

This was Kostya's request and I think it makes sense. We require ASan runtime to be the first dynamic library to load so we may safely assume that initial-exec works.

[samsonov]

CMakeLists.txt

233

Alright, let's then use COMPILER_RT_BUILD_SHARED_ASAN, "include" is a bit confusing to me (yep, I know we have COMPILER_RT_INCLUDE_TESTS named after LLVM_INCLUDE_TESTS, but maybe I'll rename it soon).

cmake/Modules/AddCompilerRT.cmake

42

the diff between the two macro you mention is much larger. In your case the difference is only in: SHARED/STATIC, LIBRARY_OUTPUT_DIRECTORY/ARCHIVE_OUTPUT_DIRECTORY and LIBRARY DESTINATION / ARCHIVE DESTINATION.
The first choice may be controlled by an input parameter, the second and third may just be combined (you can set both _OUTPUT_DIRECTORY) w/o any harm.

lib/asan/CMakeLists.txt

150

We already started to add toolchain-specific logic to adding -l... flags to the Clang driver (for FreeBSD port)

lib/asan/asan_rtl.cc

563

Then we should be able to somehow use AsanInitFromRtl().

lib/asan/asan_win.cc

77

Looks like AsanCheckDynamicRTPrereqs() is called only in shared-libasan. It makes sense to print "UNIMPLEMENTED" on platforms where it's not available.

Which reminds me of Mac - we use dynamic runtime there as well. Can you make sure that your changes will play well with it? Does it make sense to build it with -DASAN_DYNAMIC=1 as well?

lib/sanitizer_common/sanitizer_internal_defs.h

151

This is still confusing. sanitizer_internal_defs.h is included not only in ASan source files, but also in sanitizer_common source files, and you don't compile the latter with -DASAN_DYNAMIC=1 (and in general you shouldn't add sanitizer-specific defines to sanitizer_common code).

[ygribov]

CMakeLists.txt

233

Ok.

cmake/Modules/AddCompilerRT.cmake

42

the diff between the two macro you mention is much larger

Ok, then take a look osx/darwin. Anyway this isn't a big deal, I can refactor my macro.

lib/asan/CMakeLists.txt

150

Ok, will check.

lib/asan/asan_rtl.cc

563

I think it makes sense to detect this error ASAP and not wait till AsanInitFromRtl() gets called. By this time rt inconsistencies may already cause mysterious jumps to NULL, etc.

lib/asan/asan_win.cc

77

It makes sense to print "UNIMPLEMENTED" on platforms where it's not available.

Makes sense.

Which reminds me of Mac - we use dynamic runtime there as well.

Yeah and it also uses a cool reexec trick which may be useful for other platforms as well (Linux, Android).

Can you make sure that your changes will play well with it?
Does it make sense to build it with -DASAN_DYNAMIC=1 as well?

I think there is quite some potential for unification. I could work on this but I have practically no experience with Mac so I'd prefer to do this separately to avoid huge delays.

lib/sanitizer_common/sanitizer_internal_defs.h

151

Ok,I see the point but I'd still prefer not to save performance. Do you think building runtime with -ftls-model=initial-exec would work?

[ygribov]

lib/asan/asan_rtl.cc

563

Also keep in mind that I'd like to detect dlopen.

lib/sanitizer_common/sanitizer_internal_defs.h

151

s/prefer not to save performance/prefer to save performance/

[ygribov]

Addressed Alexey's concerns. Remaining issues:

• need to test non-lit tests with shared runtime
• need to agree with Alex on where to check for incompatible runtimes

[ygribov]

Fixed based on Alexey's comments.

[samsonov]

cmake/Modules/AddCompilerRT.cmake

82

Use a single call:

set_target_properties(${name} PROPERTIES
  ARCHIVE_OUTPUT_DIRECTORY ...
  LIBRARY_OUTPUT_DIRECTORY ...)

101

Is it possible to use

install(TARGETS ${name}
  ARCHIVE DESTINATION ...
  LIBRARY DESTINATION ...)

in the add_compiler_rt_runtime above and get rid of add_compiler_rt_{static,shared}_runtime rules?

lib/asan/CMakeLists.txt

57

set(ASAN_DYNAMIC_LIBS stdc++ c m)

lib/asan/asan_linux.cc

56

Use more specific name (FindFirstDynamicLibraryCallback or some such).

81

remove newline

89

Weird indentation.

94

Consider running tools/clang/tools/clang-format/clang-format-diff.py on your patch.

lib/asan/asan_malloc_linux.cc

64 ↗

(On Diff #8083)

Rename the variables - they are used not only in calloc now.

66 ↗

(On Diff #8083)

Use ALIGNED before the type (see comments in sanitizer_internal_defs.h)

73 ↗

(On Diff #8083)

uptr size_aligned = RoundUpTo(size, kWordSize);

76 ↗

(On Diff #8083)

CHECK_LT

115 ↗

(On Diff #8083)

This is just wrong. Is realloc() called before asan_inited or on PreinitAllocated pointers?

test/asan/CMakeLists.txt

44

Can you instead just unconditionally provide the basename of dynamic ASan runtime (for i386, x86_64, powerpc64) when configuring a dynamic test suite (and not deal with this asan_rt_suffix)?

test/asan/TestCases/Linux/interception_malloc_test.cc

13

So, how does attribute((no_sanitize_address)) help here?

test/asan/lit.cfg

43

Why do you need this?

45

and this?

[ygribov]

cmake/Modules/AddCompilerRT.cmake

101

Yeah, this failed with separate installs but cumulative one seems to work. Renaming add_compiler_rt_static_runtime is going to cause some churn though...

lib/asan/CMakeLists.txt

57

I wonder whether I need 'c' at all.

lib/asan/asan_linux.cc

89

Yeah, moved from other place.

94

Ok, good to know.

lib/asan/asan_malloc_linux.cc

115 ↗

(On Diff #8083)

AFAIR realloc() is called before asan_inited on PreinitAlloc-ated pointers (dlerror calls it to allocate string). So what's wrong exactly?

test/asan/lit.cfg

43

To make a copy of clang_asan_cflags (they are changed below).

45

Likewise.

[samsonov]

lib/asan/CMakeLists.txt

57

I believe we don't

lib/asan/asan_malloc_linux.cc

115 ↗

(On Diff #8083)

if realloc(ptr, new_size) != ptr, you have to copy the contents to the newly allocated buffer. It's so sad we need to appease dlerror() with hacks like this. Can you clarify why you need to call it in AsanCheckIncompatibleRT?

test/asan/lit.cfg

35

Can you instead rename this to clang_asan_static_cflags, and define clang_asan_cflags depending on config.asan_dynamic (so that these lists are immutable and defined in a single place)?

[ygribov]

lib/asan/asan_malloc_linux.cc

115 ↗

(On Diff #8083)

you have to copy the contents

Agreed, won't work in general case. Was enough for dlerror because I was ignoring them anyway.

Can you clarify why you need to call it in AsanCheckIncompatibleRT?

I search for __asan_static via dlsym() and this fails and calls dlerror().

It's so sad we need to appease dlerror() with hacks like this

It is. Unfortunately this seems to be the only reliable way to detect incompatible rts (which is super-important).

test/asan/TestCases/Linux/interception_malloc_test.cc

13

I think malloc's frame gets poisoned which caused segfault because shadow is not initialized (malloc is called at the beginning of asan_init in dlsym).

[samsonov]

lib/asan/asan_malloc_linux.cc

115 ↗

(On Diff #8083)

Can you search for ASan runtime (.so) in the contents of /proc/self/maps when initializing a static runtime? I think we can read it w/o calling malloc...

Or to add asan_runtime_type .bss global, and initialize it in __asan_init(). Set it to 1 if ASAN_DYNAMIC is set, and to 2 otherwise, and detect inconsistencies.

[ygribov]

test/asan/CMakeLists.txt

44

I'm not sure how to provide it for unit tests below.

64

Here.

[ygribov]

lib/asan/asan_linux.cc

94

Are you sure the tool is usable? I see some strange changes like

+extern "C" attribute((
+ no_sanitize_address)) // Malloc may be called from dlsym in __asan_init
+void *malloc(size_t size) {

and misplaced comments.

[samsonov]

lib/asan/asan_linux.cc

94

Hm. If this happens with fresh clang-format in your PATH, feel free to disregard it then.

test/asan/CMakeLists.txt

64

Yeah, running unit tests with dynamic runtime may be... challenging. Feel free to drop this part from the patch for now.

[ygribov]

lib/asan/asan_malloc_linux.cc

115 ↗

(On Diff #8083)

Can you search for ASan runtime (.so) in the contents of /proc/self/maps

No, this won't protect from dlopening dynamic rt.

Or to add asan_runtime_type .bss global

Yup, this might work. I'll see how it goes tomorrow.

[ygribov]

lib/asan/asan_linux.cc

94

I'll try to get something from it but really noise ratio is just too high.

lib/asan/asan_malloc_linux.cc

115 ↗

(On Diff #8083)

Or to add asan_runtime_type .bss global

Yup, this might work. I'll see how it goes tomorrow.

Ok, now I remember. We will get segfault instead of proper error message if we try to preload dynamic rt to statically sanitized executable. Here is what happens: interceptors in static runtime will be initialized using dlsym(RTLD_NEXT, ...) but they will find dynamic runtime's symbols instead of true libc symbols. So __interception::real_* pointers will remain NULLs. This will cause segfaults in e.g. MaybeInstallSigaction, etc.

[ygribov]

Updated based on comments. Stuff that was not addressed:

• ASAN_RT_SUFFIX
• asan_static/asan_dynamic are still there (I still don't see any alternative solution)

[ygribov]

lib/asan/asan_linux.cc

71

I could probably also use DumpListOfModules here. What's your opinion?

82

I think we can do this:

• for static rt:
  • check if dynamic rt in /proc/maps (and die if it's there)
  • set __asan_rt_version
• for dynamic rt:
  • check __asan_rt_version (and die if it's already initialized by static rt)

But all this looks too complicated compared to current approach (dlsym + preinit allocator).

[ygribov]

lib/asan/asan_linux.cc

71

Although the order of modules in address space does not necessarily match the order in which they were loaded by ld.so. Dl_iterate_phdr is probably more reliable...

[samsonov]

cmake/Modules/AddCompilerRT.cmake

73

FYI I've submitted this renaming as r205183, so you can rebase your patch to minimize the diff.

77

Why is the default OUTPUT_NAME not suitable here?

lib/asan/asan_linux.cc

71

Yeah.

82

I think this would be easier to digest than these preinit-allocator hooks. I'd try to avoid calling functions from system libraries before ASan is initialized, by all means possible. Could you please try if this approach works?

Does anyone else have other opinions about it?

[ygribov]

cmake/Modules/AddCompilerRT.cmake

77

I want to use same name for static and dynamic runtimes but default name for dynamic is clang_rt.asan-dynamic-${arch}.

lib/asan/asan_linux.cc

82

Sure I'll give it a try.

[samsonov]

lib/asan/asan_linux.cc

82

If we call AsanCheckIncompatibleRT later in initialization (after we initialized the interceptors, allocator, etc. and after we set asan_inited=1), will this still work and will it make preinit-allocator hooks unnecessary?

[samsonov]

cmake/Modules/AddCompilerRT.cmake

77

Ok, got it.

[ygribov]

lib/asan/asan_linux.cc

82

If we call AsanCheckIncompatibleRT later in initialization

We can't do this without sacrificing usability. As I pointed out in one of earlier comments this may cause segfaults long before initialization finishes.

[samsonov]

lib/asan/asan_linux.cc

82

Ah, I see, this is the comment about MaybeInstallSigaction() problems.

[ygribov]

Changes in this revision:

• rebased
• get rid of preinit allocator (yay!)
• unittests now know about dynamic runtime

[samsonov]

Awesome.

lib/asan/asan_linux.cc

88

Could you use

if (ASAN_DYNAMIC) {
  //...
else {
  //...
}

instead of #ifdef here? Also please add a comment describing why you need /proc/self/maps iteration.

lib/asan/asan_rtl.cc

630

Do you still need these?

test/asan/TestCases/Linux/interception_malloc_test.cc

13

Is this still relevant?

[ygribov]

Addressed Alexey's concerns. Now this fails two tests:

AddressSanitizer-Unit :: Asan-i386-Dynamic-Test/AddressSanitizer.asm_rw
AddressSanitizer-Unit :: Asan-i386-Dynamic-Test/AddressSanitizer.asm_rw
ThreadSanitizer :: ignore_lib0.cc

because of unrelated errors (I've filed separate issues for these: #285 and #286.

[samsonov]

LGTM

I think this looks good now. I will land this patch (maybe, in a series of commits) shortly.

[ygribov]

Cool! BTW when will the next merge to GCC happen?

[samsonov]

Landed as r205308.

[samsonov]

I've landed this change as r205308, with a few fixes/enhancements. However,
if I configure/build the tree with -DCOMPILER_RT_BUILD_SHARED_ASAN=ON and
run "make check-asan",
some of the tests fail with the following linker errors:
llvm/projects/compiler-rt/test/asan/TestCases/stack-overflow.cc:105: error:
undefined reference to 'pthread_join'

I presume, this happens because we don't explicitly provide -lpthread in
the clang invocation in RUN: line. "-lpthread" is added automatically if we
link with static ASan runtime, but in your patch
to the Clang driver you explicitly changed this behavior for
-shared-libasan. I had to add "-lpthread" to CMake rules for building
instrumented ASan unit test as well. What am I doing wrong?
Why linking with dynamic ASan runtime doesn't pulls in libpthread?

CMakeLists.txt

function(filter_available_targets out_var)
   endforeach()
   set(${out_var} ${archs} PARENT_SCOPE)
 endfunction()
 
 option(COMPILER_RT_DEBUG "Build runtimes with full debug info" OFF)
 # COMPILER_RT_DEBUG_PYBOOL is used by lit.common.configured.in.
 pythonize_bool(COMPILER_RT_DEBUG)
 
+option(COMPILER_RT_INCLUDE_ASAN_SHARED "Build shared version of AddressSanitizer runtime" OFF)
+
 #================================
 # Setup Compiler Flags
 #================================
 include(config-ix)
 
 if(COMPILER_RT_ENABLE_WERROR)
   add_definitions_if(COMPILER_RT_HAS_WERROR_FLAG -Werror)
   add_definitions_if(COMPILER_RT_HAS_WX_FLAG /WX)

cmake/Modules/AddCompilerRT.cmake

macro(add_compiler_rt_darwin_object_library name os)
   set(libname "${name}.${os}")
   add_library(${libname} OBJECT ${LIB_SOURCES})
   set_target_compile_flags(${libname} ${LIB_CFLAGS} ${DARWIN_${os}_CFLAGS})
   set_target_properties(${libname} PROPERTIES OSX_ARCHITECTURES "${LIB_ARCH}")
   set_property(TARGET ${libname} APPEND PROPERTY
     COMPILE_DEFINITIONS ${LIB_DEFS})
 endmacro()
 
+# Adds shared runtime for a given architecture and puts it in the proper
+# directory in the build and install trees.
+# add_compiler_rt_shared_runtime(<name> <arch>
+#                                SOURCES <source files>
+#                                CFLAGS <compile flags>
+#                                DEFS <compile definitions>)
+macro(add_compiler_rt_shared_runtime name arch)
+  if(CAN_TARGET_${arch})
+    parse_arguments(LIB "SOURCES;CFLAGS;DEFS" "" ${ARGN})
+    add_library(${name} SHARED ${LIB_SOURCES})
+    # Setup compile flags and definitions.
+    set_target_compile_flags(${name}
+      ${TARGET_${arch}_CFLAGS} ${LIB_CFLAGS})
+    set_property(TARGET ${name} APPEND PROPERTY
+      COMPILE_DEFINITIONS ${LIB_DEFS})
+    # Setup correct output directory in the build tree.
+    set_target_properties(${name} PROPERTIES
+      LIBRARY_OUTPUT_DIRECTORY ${COMPILER_RT_LIBRARY_OUTPUT_DIR})
+    # Add installation command.
+    install(TARGETS ${name}
+      LIBRARY DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR})
+  else()
+    message(FATAL_ERROR "Archtecture ${arch} can't be targeted")
+  endif()
+endmacro()
+
 # Adds static runtime for a given architecture and puts it in the proper
 # directory in the build and install trees.
 # add_compiler_rt_static_runtime(<name> <arch>
 #                                SOURCES <source files>
 #                                CFLAGS <compile flags>
 #                                DEFS <compile definitions>)
 macro(add_compiler_rt_static_runtime name arch)
   if(CAN_TARGET_${arch})
     parse_arguments(LIB "SOURCES;CFLAGS;DEFS" "" ${ARGN})
     add_library(${name} STATIC ${LIB_SOURCES})
     # Setup compile flags and definitions.
     set_target_compile_flags(${name}
       ${TARGET_${arch}_CFLAGS} ${LIB_CFLAGS})
     set_property(TARGET ${name} APPEND PROPERTY
       COMPILE_DEFINITIONS ${LIB_DEFS})
     # Setup correct output directory in the build tree.
     set_target_properties(${name} PROPERTIES
       ARCHIVE_OUTPUT_DIRECTORY ${COMPILER_RT_LIBRARY_OUTPUT_DIR})
     # Add installation command.
     install(TARGETS ${name}
       ARCHIVE DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR})
   else()
     message(FATAL_ERROR "Archtecture ${arch} can't be targeted")
   endif()
 endmacro()
 
 # Same as add_compiler_rt_static_runtime, but creates a universal library
 # for several architectures.
 # add_compiler_rt_osx_static_runtime(<name> ARCH <architectures>
 #                                    SOURCES <source files>
 #                                    CFLAGS <compile flags>
 #                                    DEFS <compile definitions>)
 macro(add_compiler_rt_osx_static_runtime name)
   parse_arguments(LIB "ARCH;SOURCES;CFLAGS;DEFS" "" ${ARGN})
   add_library(${name} STATIC ${LIB_SOURCES})
   set_target_compile_flags(${name} ${LIB_CFLAGS})
   set_property(TARGET ${name} APPEND PROPERTY
     COMPILE_DEFINITIONS ${LIB_DEFS})
   set_target_properties(${name} PROPERTIES
     OSX_ARCHITECTURES "${LIB_ARCH}"
     ARCHIVE_OUTPUT_DIRECTORY ${COMPILER_RT_LIBRARY_OUTPUT_DIR})
   install(TARGETS ${name}
     ARCHIVE DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR})
 endmacro()

lib/asan/CMakeLists.txt

set(ASAN_SOURCES
   asan_linux.cc
   asan_mac.cc
   asan_malloc_linux.cc
   asan_malloc_mac.cc
   asan_malloc_win.cc
   asan_new_delete.cc
   asan_poisoning.cc
   asan_posix.cc
-  asan_preinit.cc
   asan_report.cc
   asan_rtl.cc
   asan_stack.cc
   asan_stats.cc
   asan_thread.cc
   asan_win.cc)
 
+set(ASAN_PREINIT_SOURCES
+  asan_preinit.cc)
+
 include_directories(..)
 
 if(ANDROID)
   include_directories(${COMPILER_RT_EXTRA_ANDROID_HEADERS})
 endif()
 
 set(ASAN_CFLAGS ${SANITIZER_COMMON_CFLAGS})
 append_no_rtti_flag(ASAN_CFLAGS)
 
 set(ASAN_COMMON_DEFINITIONS
   ASAN_HAS_EXCEPTIONS=1)
 
 if(ANDROID)
   list(APPEND ASAN_COMMON_DEFINITIONS
     ASAN_LOW_MEMORY=1)
 endif()
 
 if (NOT MSVC)
   set(ASAN_ASM_SOURCES asan_asm_instrumentation.S)
   set_source_files_properties(${ASAN_ASM_SOURCES} PROPERTIES LANGUAGE C)
   list(APPEND ASAN_SOURCES ${ASAN_ASM_SOURCES})
 endif()
 
 # Compile ASan sources into an object library.
 if(APPLE)
   foreach(os ${SANITIZER_COMMON_SUPPORTED_DARWIN_OS})
     add_compiler_rt_darwin_object_library(RTAsan ${os}
       ARCH ${ASAN_SUPPORTED_ARCH}
       SOURCES ${ASAN_SOURCES}
       CFLAGS ${ASAN_CFLAGS}
       DEFS ${ASAN_COMMON_DEFINITIONS})
   endforeach()
 elseif(ANDROID)
   add_library(RTAsan.arm.android OBJECT ${ASAN_SOURCES})
   set_target_compile_flags(RTAsan.arm.android ${ASAN_CFLAGS})
   set_property(TARGET RTAsan.arm.android APPEND PROPERTY
     COMPILE_DEFINITIONS ${ASAN_COMMON_DEFINITIONS})
 else()
   foreach(arch ${ASAN_SUPPORTED_ARCH})
     add_compiler_rt_object_library(RTAsan ${arch}
-      SOURCES ${ASAN_SOURCES} CFLAGS ${ASAN_CFLAGS}
+      SOURCES ${ASAN_SOURCES} ${ASAN_PREINIT_SOURCES} CFLAGS ${ASAN_CFLAGS}
+      DEFS ${ASAN_COMMON_DEFINITIONS})
+    if (COMPILER_RT_INCLUDE_ASAN_DYNAMIC)
+      set(ASAN_DYNAMIC_DEFINITIONS
+        ${ASAN_COMMON_DEFINITIONS} ASAN_DYNAMIC)
+      add_compiler_rt_object_library(RTAsan_preinit ${arch}
+        SOURCES ${ASAN_PREINIT_SOURCES} CFLAGS ${ASAN_CFLAGS}
         DEFS ${ASAN_COMMON_DEFINITIONS})
+      add_compiler_rt_object_library(RTAsan_dynamic ${arch}
+        SOURCES ${ASAN_SOURCES} CFLAGS ${ASAN_CFLAGS}
+        DEFS ${ASAN_DYNAMIC_DEFINITIONS})
+    endif()
   endforeach()
 endif()
 
 # Build ASan runtimes shipped with Clang.
 add_custom_target(asan)
 if(APPLE)
   foreach (os ${SANITIZER_COMMON_SUPPORTED_DARWIN_OS})
     # Dynamic lookup is needed because shadow scale and offset are
set_target_compile_flags(clang_rt.asan-arm-android
     ${ASAN_CFLAGS})
   set_property(TARGET clang_rt.asan-arm-android APPEND PROPERTY
     COMPILE_DEFINITIONS ${ASAN_COMMON_DEFINITIONS})
   target_link_libraries(clang_rt.asan-arm-android dl log)
   add_dependencies(asan clang_rt.asan-arm-android)
 else()
   # Build separate libraries for each target.
   foreach(arch ${ASAN_SUPPORTED_ARCH})
-    set(ASAN_RUNTIME_OBJECTS
-      $<TARGET_OBJECTS:RTAsan.${arch}>
+    set(ASAN_COMMON_RUNTIME_OBJECTS
       $<TARGET_OBJECTS:RTInterception.${arch}>
       $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
       $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>)
     if (NOT WIN32)
       # We can't build Leak Sanitizer on Windows yet.
-      list(APPEND ASAN_RUNTIME_OBJECTS $<TARGET_OBJECTS:RTLSanCommon.${arch}>)
+      list(APPEND ASAN_COMMON_RUNTIME_OBJECTS $<TARGET_OBJECTS:RTLSanCommon.${arch}>)
     endif()
 
+    set(ASAN_RUNTIME_OBJECTS
+      $<TARGET_OBJECTS:RTAsan.${arch}>
+      ${ASAN_COMMON_RUNTIME_OBJECTS})
+
     add_compiler_rt_static_runtime(clang_rt.asan-${arch} ${arch}
       SOURCES ${ASAN_RUNTIME_OBJECTS}
       CFLAGS ${ASAN_CFLAGS}
       DEFS ${ASAN_COMMON_DEFINITIONS})
-    add_dependencies(asan clang_rt.asan-${arch})
+    add_dependencies(asan clang_rt.asan-${arch} clang_rt.asan-${arch})
+
+    if (COMPILER_RT_INCLUDE_ASAN_DYNAMIC)
+      set(ASAN_DYNAMIC_RUNTIME_OBJECTS
+        $<TARGET_OBJECTS:RTAsan_dynamic.${arch}>
+        ${ASAN_COMMON_RUNTIME_OBJECTS})
+      add_compiler_rt_shared_runtime(clang_rt.asan-${arch}-dynamic ${arch}
+        SOURCES ${ASAN_DYNAMIC_RUNTIME_OBJECTS}
+        CFLAGS ${ASAN_CFLAGS}
+        DEFS ${ASAN_DYNAMIC_DEFINITIONS})
+      target_link_libraries(clang_rt.asan-${arch}-dynamic pthread stdc++ dl m c)
+      add_dependencies(asan clang_rt.asan-${arch}-dynamic)
+
+      set(ASAN_PREINIT_RUNTIME_OBJECTS
+        $<TARGET_OBJECTS:RTAsan_preinit.${arch}>)
+      add_compiler_rt_static_runtime(clang_rt.asan-${arch}-preinit ${arch}
+        SOURCES ${ASAN_PREINIT_RUNTIME_OBJECTS}
+        CFLAGS ${ASAN_CFLAGS}
+        DEFS ${ASAN_DYNAMIC_DEFINITIONS})
+      add_dependencies(asan clang_rt.asan-${arch}-preinit)
+    endif()
+
     if (UNIX AND NOT ${arch} STREQUAL "i386")
       add_sanitizer_rt_symbols(clang_rt.asan-${arch} asan.syms.extra)
       add_dependencies(asan clang_rt.asan-${arch}-symbols)
+
+      if (COMPILER_RT_INCLUDE_ASAN_DYNAMIC)
+        add_sanitizer_rt_symbols(clang_rt.asan-${arch}-dynamic asan.syms.extra)
+        add_dependencies(asan clang_rt.asan-${arch}-dynamic-symbols)
+      endif()
     endif()
 
     if (WIN32)
       add_compiler_rt_static_runtime(clang_rt.asan_dll_thunk-${arch} ${arch}
       SOURCES asan_dll_thunk.cc
       CFLAGS ${ASAN_CFLAGS} -DASAN_DLL_THUNK
       DEFS ${ASAN_COMMON_DEFINITIONS})
       add_dependencies(asan clang_rt.asan_dll_thunk-${arch})

lib/asan/asan_interface_internal.h

extern "C" {
   // Everytime the asan ABI changes we also change the version number in this
   // name. Objects build with incompatible asan ABI version
   // will not link with run-time.
   // Changes between ABI versions:
   // v1=>v2: added 'module_name' to __asan_global
   // v2=>v3: stack frame description (created by the compiler)
   //         contains the function PC as the 3-rd field (see
   //         DescribeAddressIfStack).
-  SANITIZER_INTERFACE_ATTRIBUTE void __asan_init_v3();
   #define __asan_init __asan_init_v3
+  SANITIZER_INTERFACE_ATTRIBUTE void __asan_init_v3();
 
   // This structure describes an instrumented global variable.
   struct __asan_global {
     uptr beg;                // The address of the global.
     uptr size;               // The original size of the global.
     uptr size_with_redzone;  // The size with the redzone.
     const char *name;        // Name as a C string.
     const char *module_name; // Module name as a C string. This pointer is a

lib/asan/asan_internal.h

 
 void ReplaceOperatorsNewAndDelete();
 // asan_malloc_linux.cc / asan_malloc_mac.cc
 void ReplaceSystemMalloc();
 
 // asan_linux.cc / asan_mac.cc / asan_win.cc
 void *AsanDoesNotSupportStaticLinkage();
 
+// asan_linux.cc / asan_mac.cc / asan_win.cc
+void AsanCheckDynamicRTPrereqs();
+
+// asan_linux.cc / asan_mac.cc / asan_win.cc
+void AsanCheckIncompatibleRT();
+
 void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp);
 void AsanOnSIGSEGV(int, void *siginfo, void *context);
 
 void MaybeReexec();
 bool AsanInterceptsSignal(int signum);
 void ReadContextStack(void *context, uptr *stack, uptr *ssize);
 void AsanPlatformThreadInit();
 void StopInitOrderChecking();

lib/asan/asan_linux.cc

 #include <fcntl.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <unwind.h>
 
 #if SANITIZER_ANDROID
 #include <ucontext.h>
+extern "C" void* _DYNAMIC;
 #else
 #include <sys/ucontext.h>
+#include <dlfcn.h>
+#include <link.h>
 #endif
 
-extern "C" void* _DYNAMIC;
-
 namespace __asan {
 
 void MaybeReexec() {
   // No need to re-exec on Linux.
 }
 
 void *AsanDoesNotSupportStaticLinkage() {
   // This will fail to link with -static.
   return &_DYNAMIC;  // defined in link.h
 }
 
+static int DsoCallback(struct dl_phdr_info *info, size_t size,
+                       void *data) {
+  // Continue until the first dynamic library is found
+  if (!info->dlpi_name || info->dlpi_name[0] == 0)
+    return 0;
+
+  *(const char **)data = info->dlpi_name;
+  return 1;
+}
+
+void AsanCheckDynamicRTPrereqs() {
+  // FIXME: can we do something like this for Android?
+#if !SANITIZER_ANDROID
+  // Asan dynamic RT should be the first dynamic library in the list
+  const char *first_library_name = 0;
+  dl_iterate_phdr(DsoCallback, &first_library_name);
+  if (first_library_name
+      && !internal_strstr(first_library_name, "libclang_rt.asan")
+      && !internal_strstr(first_library_name, "libasan.so")) {
+    Report(
+      "ASan runtime does not come first in initial library list; "
+      "you should either link to your application or "
+      "manually preload it with LD_PRELOAD.\n");
+    Die();
+  }
+
+#endif
+}
+
+void AsanCheckIncompatibleRT() {
+#if !SANITIZER_ANDROID
+  const char *badsym;
+#if ASAN_DYNAMIC
+    badsym = "__asan_static";
+#else
+    badsym = "__asan_dynamic";
+#endif
+  if (dlsym(RTLD_DEFAULT, badsym)) {
+    Report("Your application is linked against "
+      "incompatible ASan runtimes.\n");
+    Die();
+  }
+#endif
+}
+
 void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp) {
 #if defined(__arm__)
   ucontext_t *ucontext = (ucontext_t*)context;
   *pc = ucontext->uc_mcontext.arm_pc;
   *bp = ucontext->uc_mcontext.arm_fp;
   *sp = ucontext->uc_mcontext.arm_sp;
 # elif defined(__aarch64__)
   ucontext_t *ucontext = (ucontext_t*)context;

lib/asan/asan_mac.cc

void MaybeReexec() {
   }
 }
 
 // No-op. Mac does not support static linkage anyway.
 void *AsanDoesNotSupportStaticLinkage() {
   return 0;
 }
 
+// Likewise.
+void AsanCheckDynamicRTPrereqs() {
+}
+
+// Likewise.
+void AsanCheckIncompatibleRT() {
+}
+
 bool AsanInterceptsSignal(int signum) {
   return (signum == SIGSEGV || signum == SIGBUS) &&
          common_flags()->handle_segv;
 }
 
 void AsanPlatformThreadInit() {
 }
 

lib/asan/asan_rtl.cc

 }
 
 // Initialize as requested from some part of ASan runtime library (interceptors,
 // allocator, etc).
 void AsanInitFromRtl() {
   AsanInitInternal();
 }
 
+#ifdef ASAN_DYNAMIC
+// Initialize runtime in case it's LD_PRELOAD-ed into unsanitized executable
+// (and thus normal initializer from .preinit_array haven't run).
+
+class AsanInitializer {
+public:  // NOLINT
+  AsanInitializer() {
+    AsanCheckIncompatibleRT();
+    if (!asan_inited) {
+      AsanCheckDynamicRTPrereqs();
+      __asan_init();
+    }
+  }
+};
+
+static AsanInitializer asan_initializer;
+#endif
+
 }  // namespace __asan
 
 // ---------------------- Interface ---------------- {{{1
 using namespace __asan;  // NOLINT
 
 #if !SANITIZER_SUPPORTS_WEAK_HOOKS
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE

 
 void NOINLINE __asan_set_death_callback(void (*callback)(void)) {
   death_callback = callback;
 }
 
 // Initialize as requested from instrumented application code.
 // We use this call as a trigger to wake up ASan from deactivated state.
 void __asan_init() {
+  AsanCheckIncompatibleRT();
   AsanActivate();
   AsanInitInternal();
 }
+
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE
+#ifdef ASAN_DYNAMIC
+int __asan_dynamic;
+#else
+int __asan_static;
+#endif
+};
+

lib/asan/asan_win.cc

 
 void *AsanDoesNotSupportStaticLinkage() {
 #if defined(_DEBUG)
 #error Please build the runtime with a non-debug CRT: /MD or /MT
 #endif
   return 0;
 }
 
+void AsanCheckDynamicRTPrereqs() {
+}
+
+void AsanCheckIncompatibleRT() {
+}
+
 void AsanPlatformThreadInit() {
   // Nothing here for now.
 }
 
 void ReadContextStack(void *context, uptr *stack, uptr *ssize) {
   UNIMPLEMENTED();
 }
 
 void AsanOnSIGSEGV(int, void *siginfo, void *context) {
   UNIMPLEMENTED();
 }
 
 }  // namespace __asan
 
 #endif  // _WIN32

lib/sanitizer_common/sanitizer_internal_defs.h

 # define ALWAYS_INLINE inline __attribute__((always_inline))
 # define ALIAS(x) __attribute__((alias(x)))
 // Please only use the ALIGNED macro before the type.
 // Using ALIGNED after the variable declaration is not portable!
 # define ALIGNED(x) __attribute__((aligned(x)))
 # define FORMAT(f, a)  __attribute__((format(printf, f, a)))
 # define NOINLINE __attribute__((noinline))
 # define NORETURN  __attribute__((noreturn))
-# define THREADLOCAL   __thread
+# ifdef ASAN_DYNAMIC
+#  define THREADLOCAL __thread __attribute__((tls_model("initial-exec")))
+# else
+// FIXME: mark as local-exec?
+#  define THREADLOCAL __thread
+# endif
 # define NOTHROW throw()
 # define LIKELY(x)     __builtin_expect(!!(x), 1)
 # define UNLIKELY(x)   __builtin_expect(!!(x), 0)
 # define UNUSED __attribute__((unused))
 # define USED __attribute__((used))
 # if defined(__i386__) || defined(__x86_64__)
 // __builtin_prefetch(x) generates prefetchnt0 on x86
 #  define PREFETCH(x) __asm__("prefetchnta (%0)" : : "r" (x))

test/asan/CMakeLists.txt

configure_lit_site_cfg(
     )
   list(APPEND ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/ARMAndroidConfig)
 endif()
 
 if(CAN_TARGET_x86_64 OR CAN_TARGET_powerpc64)
   set(ASAN_TEST_CONFIG_SUFFIX "64")
   set(ASAN_TEST_BITS "64")
   set(ASAN_TEST_TARGET_CFLAGS ${TARGET_64_BIT_CFLAGS})
+  set(ASAN_TEST_DYNAMIC False)
   configure_lit_site_cfg(
     ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
     ${CMAKE_CURRENT_BINARY_DIR}/64bitConfig/lit.site.cfg
     )
   list(APPEND ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/64bitConfig)
+  if(COMPILER_RT_INCLUDE_ASAN_DYNAMIC)
+    set(ASAN_TEST_DYNAMIC True)
+    configure_lit_site_cfg(
+      ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
+      ${CMAKE_CURRENT_BINARY_DIR}/64bitConfig-dynamic/lit.site.cfg)
+    list(APPEND ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/64bitConfig-dynamic)
+  endif()
 endif()
 
 if(CAN_TARGET_i386)
   set(ASAN_TEST_CONFIG_SUFFIX "32")
   set(ASAN_TEST_BITS "32")
   set(ASAN_TEST_TARGET_CFLAGS ${TARGET_32_BIT_CFLAGS})
+  set(ASAN_TEST_DYNAMIC False)
   configure_lit_site_cfg(
     ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
     ${CMAKE_CURRENT_BINARY_DIR}/32bitConfig/lit.site.cfg
     )
   list(APPEND ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/32bitConfig)
+  if(COMPILER_RT_INCLUDE_ASAN_DYNAMIC)
+    set(ASAN_TEST_DYNAMIC True)
+    configure_lit_site_cfg(
+      ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
+      ${CMAKE_CURRENT_BINARY_DIR}/32bitConfig-dynamic/lit.site.cfg)
+    list(APPEND ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/32bitConfig-dynamic)
+  endif()
 endif()
 
 if(COMPILER_RT_INCLUDE_TESTS)
+  set(ASAN_TEST_DYNAMIC False)
   configure_lit_site_cfg(
     ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.in
-  ${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg
-  )
+    ${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg)
+  if(COMPILER_RT_INCLUDE_ASAN_DYNAMIC)
+    set(ASAN_TEST_DYNAMIC True)
+    configure_lit_site_cfg(
+      ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.in
+      ${CMAKE_CURRENT_BINARY_DIR}/Unit-dynamic/lit.site.cfg)
+  endif()
 endif()
 
 set(ASAN_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
 if(NOT COMPILER_RT_STANDALONE_BUILD)
   list(APPEND ASAN_TEST_DEPS asan)
 endif()
 
 # FIXME: support unit test in the android test runner
 if(COMPILER_RT_INCLUDE_TESTS AND NOT CAN_TARGET_arm_android)
   list(APPEND ASAN_TEST_DEPS AsanUnitTests)
   list(APPEND ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/Unit)
+  if(COMPILER_RT_INCLUDE_ASAN_DYNAMIC)
+    list(APPEND ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/Unit-dynamic)
+  endif()
 endif()
 add_lit_testsuite(check-asan "Running the AddressSanitizer tests"
   ${ASAN_TESTSUITES}
   DEPENDS ${ASAN_TEST_DEPS})
 set_target_properties(check-asan PROPERTIES FOLDER "ASan tests")

test/asan/TestCases/Linux/DynamicRT/asan_dlopen_test.cc

+// Test that dlopen of runtime is detected.
+//
+// RUN: %clangxx %s -DRT=\"%shared_libasan\" -o %t -ldl
+// RUN: not %t 2>&1 | FileCheck %s
+
+#include <dlfcn.h>
+
+int main(int argc, char **argv) {
+  dlopen(RT, RTLD_LAZY);
+  return 0;
+}
+
+// CHECK: ASan runtime does not come first in initial library list
+

test/asan/TestCases/Linux/DynamicRT/asan_preload_test-1.cc

+// Test if legacy executables work with sanitized shared libs
+// and preloaded runtime.
+//
+// RUN: %clangxx -DBUILD_SO=1 -fPIC -shared %s -o %t.so
+// RUN: %clangxx %s %t.so -o %t
+//
+// RUN: %clangxx_asan -DBUILD_SO=1 -fPIC -shared %s -o %t.so
+// RUN: LD_PRELOAD=%shared_libasan not %t 2>&1 | FileCheck %s
+
+#if BUILD_SO
+char dummy;
+void do_access(const void *p) {
+  // CHECK: AddressSanitizer: heap-buffer-overflow
+  dummy = ((const char *)p)[1];
+}
+#else
+#include <stdlib.h>
+extern void do_access(const void *p);
+int main(int argc, char **argv) {
+  void *p = malloc(1);
+  do_access(p);
+  free(p);
+  return 0;
+}
+#endif

test/asan/TestCases/Linux/DynamicRT/asan_preload_test-2.cc

+// Test that preloaded runtime works with unsanitized executables.
+//
+// RUN: %clangxx %s -o %t
+// RUN: LD_PRELOAD=%shared_libasan not %t 2>&1 | FileCheck %s
+
+#include <stdlib.h>
+
+extern "C" void *memset(void *p, int val, size_t n);
+
+void do_access(void *p) {
+  // CHECK: AddressSanitizer: heap-buffer-overflow
+  memset(p, 0, 2);
+}
+
+int main(int argc, char **argv) {
+  void *p = malloc(1);
+  do_access(p);
+  return 0;
+}
+

test/asan/TestCases/Linux/DynamicRT/asan_rt_confict_test-1.cc

+// Test that incompatible runtimes are detected.
+//
+// RUN: %clangxx_asan_static %s -o %t
+// RUN: LD_PRELOAD=%shared_libasan not %t 2>&1 | FileCheck %s
+
+#include <stdlib.h>
+int main(int argc, char **argv) {
+  return 0;
+}
+
+// CHECK: Your application is linked against incompatible ASan runtimes

test/asan/TestCases/Linux/DynamicRT/lit.local.cfg

+if not config.asan_dynamic:
+  config.unsupported = True
+

test/asan/TestCases/Linux/interception_malloc_test.cc

 // ASan interceptor can be accessed with __interceptor_ prefix.
 
 // RUN: %clangxx_asan -O0 %s -o %t && not %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O1 %s -o %t && not %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O2 %s -o %t && not %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O3 %s -o %t && not %t 2>&1 | FileCheck %s
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
 
 extern "C" void *__interceptor_malloc(size_t size);
-extern "C" void *malloc(size_t size) {
+extern "C"
+__attribute__((no_sanitize_address))  // Malloc may be called from dlsym in __asan_init
+void *malloc(size_t size) {
   write(2, "malloc call\n", sizeof("malloc call\n") - 1);
   return __interceptor_malloc(size);
 }
 
 int main() {
   char *x = (char*)malloc(10 * sizeof(char));
   free(x);
   return (int)strtol(x, 0, 10);
   // CHECK: malloc call
   // CHECK: heap-use-after-free
 }

test/asan/TestCases/sanity_check_pure_c.c

 // Sanity checking a test in pure C.
 // RUN: %clang_asan -O2 %s -o %t
 // RUN: not %t 2>&1 | FileCheck %s
 
 // Sanity checking a test in pure C with -pie.
-// RUN: %clang_asan -O2 %s -pie -o %t
+// RUN: %clang_asan -O2 %s -pie -fPIE -o %t
 // RUN: not %t 2>&1 | FileCheck %s
 
 #include <stdlib.h>
 int main() {
   char *x = (char*)malloc(10 * sizeof(char));
   free(x);
   return x[5];
   // CHECK: heap-use-after-free
   // CHECK: free
   // CHECK: main{{.*}}sanity_check_pure_c.c:[[@LINE-4]]
   // CHECK: malloc
   // CHECK: main{{.*}}sanity_check_pure_c.c:[[@LINE-7]]
 }

test/asan/TestCases/start-deactivated.cc

 // Test for ASAN_OPTIONS=start_deactivated=1 mode.
 // Main executable is uninstrumented, but linked to ASan runtime. The shared
 // library is instrumented. Memory errors before dlopen are not detected.
 
 // RUN: %clangxx_asan -O0 %p/SharedLibs/start-deactivated-so.cc \
 // RUN:     -fPIC -shared -o %t-so.so
 // RUN: %clangxx -O0 %s -c -o %t.o
 // RUN: %clangxx_asan -O0 %t.o -o %t
 // RUN: ASAN_OPTIONS=start_deactivated=1 not %t 2>&1 | FileCheck %s
+//
+// dlsym's that check for __asan_static/__asan_dynamic call dlerror
+// which in turn calls malloc which activates Asan:
+// XFAIL: *
 
 #include <dlfcn.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include <string>

test/asan/Unit/lit.site.cfg.in

 ## Autogenerated by LLVM/Clang configuration.
 # Do not edit!
 
 # Load common config for all compiler-rt unit tests.
 lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/unittests/lit.common.unit.configured")
 
 # Setup config name.
 config.name = 'AddressSanitizer-Unit'
 
 # Setup test source and exec root. For unit tests, we define
 # it as build directory with ASan unit tests.
 # FIXME: De-hardcode this path.
 config.test_exec_root = "@COMPILER_RT_BINARY_DIR@/lib/asan/tests"
 config.test_source_root = config.test_exec_root
+config.asan_dynamic = @ASAN_TEST_DYNAMIC@
 
 # Enable leak detection in ASan unit tests on x86_64-linux.
 if config.host_os == 'Linux' and config.host_arch == 'x86_64':
   config.environment['ASAN_OPTIONS'] = 'detect_leaks=1'

test/asan/lit.cfg

 # -*- Python -*-
 
 import os
 
 def get_required_attr(config, attr_name):
   attr_value = getattr(config, attr_name, None)
   if not attr_value:
     lit_config.fatal(
       "No attribute %r in test configuration! You may need to run "
       "tests from your build directory or add this attribute "
       "to lit.site.cfg " % attr_name)
   return attr_value
 
+def push_ld_library_path(config, new_path):
+  new_ld_library_path = os.path.pathsep.join(
+    (new_path, config.environment['LD_LIBRARY_PATH']))
+  config.environment['LD_LIBRARY_PATH'] = new_ld_library_path
+
 # Setup config name.
 config.name = 'AddressSanitizer' + config.name_suffix
 
 # Setup source root.
 config.test_source_root = os.path.dirname(__file__)
 
 # GCC-ASan doesn't link in all the necessary libraries automatically, so
 # we have to do it ourselves.
 if config.compiler_id == 'GNU':
   extra_linkflags = ["-lpthread", "-lstdc++", "-ldl"]
 else:
   extra_linkflags = []
 # Setup default compiler flags used with -fsanitize=address option.
 # FIXME: Review the set of required flags and check if it can be reduced.
 target_cflags = [get_required_attr(config, "target_cflags")] + extra_linkflags
 target_cxxflags = config.cxx_mode_flags + target_cflags
 clang_asan_cflags = ["-fsanitize=address",
                      "-mno-omit-leaf-frame-pointer",
                      "-fno-omit-frame-pointer",
                      "-fno-optimize-sibling-calls",
                      "-g"] + target_cflags
 clang_asan_cxxflags = config.cxx_mode_flags + clang_asan_cflags
 
+if config.asan_dynamic:
+  clang_asan_static_cflags = list(clang_asan_cflags)
+  clang_asan_cflags.append('-shared-libasan')
+  clang_asan_static_cxxflags = list(clang_asan_cxxflags)
+  clang_asan_cxxflags.append('-shared-libasan')
+
 asan_lit_source_dir = get_required_attr(config, "asan_lit_source_dir")
 if config.android == "TRUE":
   config.available_features.add('android')
   clang_wrapper = os.path.join(asan_lit_source_dir,
                                "android_commands", "android_compile.py") + " "
 else:
   clang_wrapper = ""
 
 def build_invocation(compile_flags):
   return " " + " ".join([clang_wrapper, config.clang] + compile_flags) + " "
 
 config.substitutions.append( ("%clang ", build_invocation(target_cflags)) )
 config.substitutions.append( ("%clangxx ", build_invocation(target_cxxflags)) )
 config.substitutions.append( ("%clang_asan ", build_invocation(clang_asan_cflags)) )
 config.substitutions.append( ("%clangxx_asan ", build_invocation(clang_asan_cxxflags)) )
+config.substitutions.append( ("%shared_libasan", "libclang_rt.asan-%s-dynamic.so" % config.host_arch))
+if config.asan_dynamic:
+  config.substitutions.append( ("%clang_asan_static ", build_invocation(clang_asan_static_cflags)) )
+  config.substitutions.append( ("%clangxx_asan_static ", build_invocation(clang_asan_static_cxxflags)) )
 
 # FIXME: De-hardcode this path.
 asan_source_dir = os.path.join(
   get_required_attr(config, "compiler_rt_src_root"), "lib", "asan")
 # Setup path to asan_symbolize.py script.
 asan_symbolize = os.path.join(asan_source_dir, "scripts", "asan_symbolize.py")
 if not os.path.exists(asan_symbolize):
   lit_config.fatal("Can't find script on path %r" % asan_symbolize)
 python_exec = get_required_attr(config, "python_executable")
 config.substitutions.append( ("%asan_symbolize", python_exec + " " + asan_symbolize + " ") )
 
 # Define CHECK-%os to check for OS-dependent output.
 config.substitutions.append( ('CHECK-%os', ("CHECK-" + config.host_os)))
 
 config.available_features.add("asan-" + config.bits + "-bits")
 
 # Turn on leak detection on 64-bit Linux.
 if config.host_os == 'Linux' and config.bits == '64':
   config.environment['ASAN_OPTIONS'] = 'detect_leaks=1'
 
-# GCC-ASan uses dynamic runtime by default, so we have to set LD_LIBRARY_PATH
-# to pick it up properly.
+# Set LD_LIBRARY_PATH to pick dynamic runtime up properly.
+if config.asan_dynamic:
+  libasan_dir = config.compiler_rt_libdir
+  push_ld_library_path(config, libasan_dir)
+
+# GCC-ASan uses dynamic runtime by default.
 if config.compiler_id == 'GNU':
   gcc_dir = os.path.dirname(config.clang)
   libasan_dir = os.path.join(gcc_dir, "..", "lib" + config.bits)
-  new_ld_library_path = os.path.pathsep.join(
-    (libasan_dir, config.environment['LD_LIBRARY_PATH']))
-  config.environment['LD_LIBRARY_PATH'] = new_ld_library_path
+  push_ld_library_path(config, libasan_dir)
 
 # Default test suffixes.
 config.suffixes = ['.c', '.cc', '.cpp']
 
 # AddressSanitizer tests are currently supported on Linux and Darwin only.
 if config.host_os not in ['Linux', 'Darwin']:
   config.unsupported = True

test/asan/lit.site.cfg.in

 ## Autogenerated by LLVM/Clang configuration.
 # Do not edit!
 
 # Tool-specific config options.
 config.name_suffix = "@ASAN_TEST_CONFIG_SUFFIX@"
 config.asan_lit_source_dir = "@ASAN_LIT_SOURCE_DIR@"
 config.target_cflags = "@ASAN_TEST_TARGET_CFLAGS@"
 config.clang = "@ASAN_TEST_TARGET_CC@"
 config.llvm_tools_dir = "@ASAN_TEST_LLVM_TOOLS_DIR@"
 config.bits = "@ASAN_TEST_BITS@"
 config.android = "@CAN_TARGET_arm_android@"
+config.asan_dynamic = @ASAN_TEST_DYNAMIC@
 
 # Load common config for all compiler-rt lit tests.
 lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
 
 # Load tool-specific config that would do the real work.
 lit_config.load_config(config, "@ASAN_LIT_SOURCE_DIR@/lit.cfg")

test/lit.common.configured.in

 set_default("llvm_obj_root", "@LLVM_BINARY_DIR@")
 set_default("compiler_rt_src_root", "@COMPILER_RT_SOURCE_DIR@")
 set_default("llvm_tools_dir", "@LLVM_TOOLS_DIR@")
 set_default("clang", "@COMPILER_RT_TEST_COMPILER@")
 set_default("compiler_id", "@COMPILER_RT_TEST_COMPILER_ID@")
 set_default("compiler_rt_arch", "@COMPILER_RT_SUPPORTED_ARCH@")
 set_default("python_executable", "@PYTHON_EXECUTABLE@")
 set_default("compiler_rt_debug", @COMPILER_RT_DEBUG_PYBOOL@)
+set_default("compiler_rt_libdir", "@COMPILER_RT_LIBRARY_OUTPUT_DIR@")
 
 # LLVM tools dir can be passed in lit parameters, so try to
 # apply substitution.
 try:
   config.llvm_tools_dir = config.llvm_tools_dir % lit_config.params
 except KeyError,e:
   key, = e.args
   lit_config.fatal("unable to find %r parameter, use '--param=%s=VALUE'" % (key, key))
 
 # Setup attributes common for all compiler-rt projects.
 lit_config.load_config(config, "@COMPILER_RT_SOURCE_DIR@/test/lit.common.cfg")