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

135

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

142–159

accidental duplication?

152

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

164

Do you use symbols from dynamic runtime anywhere?

lib/asan/asan_rtl.cc

715

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

234

ASAN_BUILD_SHARED_RUNTIME

lib/asan/CMakeLists.txt

87

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 ↗

(On Diff #7936)

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

[samsonov]

lib/asan/asan_rtl.cc

647

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

234

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

87

Yeah, already done locally.

135

Right.

142–159

Most probably result of code rewrite.

152

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

164

No, probably not. I'll remove this.

lib/asan/asan_rtl.cc

647

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.

715

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 ↗

(On Diff #7936)

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

234

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

152

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

lib/asan/asan_rtl.cc

647

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 ↗

(On Diff #7936)

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

234

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

152

Ok, will check.

lib/asan/asan_rtl.cc

647

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 ↗

(On Diff #7936)

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

647

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

lib/sanitizer_common/sanitizer_internal_defs.h

151 ↗

(On Diff #7936)

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

58

Use a single call:

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

83

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

79

Use more specific name (FindFirstDynamicLibraryCallback or some such).

104

remove newline

112

Weird indentation.

117

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

50

Why do you need this?

52

and this?

[ygribov]

cmake/Modules/AddCompilerRT.cmake

83

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

112

Yeah, moved from other place.

117

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

50

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

52

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

34–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.

66

Here.

[ygribov]

lib/asan/asan_linux.cc

117

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

117

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

test/asan/CMakeLists.txt

66

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

117

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

94

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

105

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

94

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

41

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

45

Why is the default OUTPUT_NAME not suitable here?

lib/asan/asan_linux.cc

94

Yeah.

105

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

45

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

105

Sure I'll give it a try.

[samsonov]

lib/asan/asan_linux.cc

105

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

45

Ok, got it.

[ygribov]

lib/asan/asan_linux.cc

105

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

105

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

111

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

713

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_BUILD_SHARED_ASAN "Build shared version of AddressSanitizer runtime" OFF)
+
 #================================
 # Setup Compiler Flags
 #================================
 include(config-ix)
 
 if(MSVC)
   append_string_if(COMPILER_RT_HAS_W3_FLAG /W3 CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
 else()

cmake/Modules/AddCompilerRT.cmake

macro(add_compiler_rt_darwin_object_library 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 static or shared runtime for a given architecture and puts it in the
 # proper directory in the build and install trees.
 # add_compiler_rt_runtime(<name> <arch> {STATIC,SHARED}
 #                         SOURCES <source files>
 #                         CFLAGS <compile flags>
 #                         DEFS <compile definitions>)
 macro(add_compiler_rt_runtime name arch type)
   if(CAN_TARGET_${arch})
-    parse_arguments(LIB "SOURCES;CFLAGS;DEFS" "" ${ARGN})
+    parse_arguments(LIB "SOURCES;CFLAGS;DEFS;OUTPUT_NAME" "" ${ARGN})
     add_library(${name} ${type} ${LIB_SOURCES})
     # Setup compile flags and definitions.
     set_target_compile_flags(${name}
       ${TARGET_${arch}_CFLAGS} ${LIB_CFLAGS})
     set_target_link_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}
       LIBRARY_OUTPUT_DIRECTORY ${COMPILER_RT_LIBRARY_OUTPUT_DIR})
+    if (LIB_OUTPUT_NAME)
+      set_target_properties(${name} PROPERTIES
+        OUTPUT_NAME ${LIB_OUTPUT_NAME})
+    endif()
     # Add installation command.
     install(TARGETS ${name}
       ARCHIVE DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR}
       LIBRARY DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR})
   else()
     message(FATAL_ERROR "Archtecture ${arch} can't be targeted")
   endif()
 endmacro()
 
 # Same as add_compiler_rt_runtime(... STATIC), 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()

cmake/config-ix.cmake

 check_cxx_compiler_flag(-fomit-frame-pointer COMPILER_RT_HAS_FOMIT_FRAME_POINTER_FLAG)
 check_cxx_compiler_flag(-funwind-tables      COMPILER_RT_HAS_FUNWIND_TABLES_FLAG)
 check_cxx_compiler_flag(-fno-stack-protector COMPILER_RT_HAS_FNO_STACK_PROTECTOR_FLAG)
 check_cxx_compiler_flag(-fvisibility=hidden  COMPILER_RT_HAS_FVISIBILITY_HIDDEN_FLAG)
 check_cxx_compiler_flag(-fno-rtti            COMPILER_RT_HAS_FNO_RTTI_FLAG)
 check_cxx_compiler_flag(-ffreestanding       COMPILER_RT_HAS_FFREESTANDING_FLAG)
 check_cxx_compiler_flag("-Werror -fno-function-sections" COMPILER_RT_HAS_FNO_FUNCTION_SECTIONS_FLAG)
 check_cxx_compiler_flag(-std=c++11           COMPILER_RT_HAS_STD_CXX11_FLAG)
+check_cxx_compiler_flag(-ftls-model=initial-exec COMPILER_RT_HAS_FTLS_MODEL_INITIAL_EXEC)
 
 check_cxx_compiler_flag(/GR COMPILER_RT_HAS_GR_FLAG)
 check_cxx_compiler_flag(/GS COMPILER_RT_HAS_GS_FLAG)
 check_cxx_compiler_flag(/MT COMPILER_RT_HAS_MT_FLAG)
 check_cxx_compiler_flag(/Oy COMPILER_RT_HAS_Oy_FLAG)
 
 # Debug info flags.
 check_cxx_compiler_flag(-gline-tables-only COMPILER_RT_HAS_GLINE_TABLES_ONLY_FLAG)

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()
 
+set(ASAN_DYNAMIC_DEFINITIONS
+  ${ASAN_COMMON_DEFINITIONS} ASAN_DYNAMIC=1)
+
+set(ASAN_DYNAMIC_CFLAGS ${ASAN_CFLAGS})
+append_if(COMPILER_RT_HAS_FTLS_MODEL_INITIAL_EXEC -ftls-model=initial-exec ASAN_DYNAMIC_CFLAGS)
+
+set(ASAN_DYNAMIC_LIBS stdc++ m c)
+append_if(COMPILER_RT_HAS_LIBPTHREAD pthread ASAN_DYNAMIC_LIBS)
+append_if(COMPILER_RT_HAS_LIBPTHREAD dl ASAN_DYNAMIC_LIBS)
+
 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)
elseif(ANDROID)
   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}
       DEFS ${ASAN_COMMON_DEFINITIONS})
+    add_compiler_rt_object_library(RTAsan_preinit ${arch}
+      SOURCES ${ASAN_PREINIT_SOURCES} CFLAGS ${ASAN_CFLAGS}
+      DEFS ${ASAN_COMMON_DEFINITIONS})
+    if (COMPILER_RT_BUILD_SHARED_ASAN)
+      add_compiler_rt_object_library(RTAsan_dynamic ${arch}
+        SOURCES ${ASAN_SOURCES} CFLAGS ${ASAN_DYNAMIC_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})
     add_compiler_rt_darwin_dynamic_runtime(clang_rt.asan_${os}_dynamic ${os}
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()
 
     add_compiler_rt_runtime(clang_rt.asan-${arch} ${arch} STATIC
-      SOURCES ${ASAN_RUNTIME_OBJECTS}
+      SOURCES
+        $<TARGET_OBJECTS:RTAsan_preinit.${arch}>
+        $<TARGET_OBJECTS:RTAsan.${arch}>
+        ${ASAN_COMMON_RUNTIME_OBJECTS}
       CFLAGS ${ASAN_CFLAGS}
       DEFS ${ASAN_COMMON_DEFINITIONS})
     add_dependencies(asan clang_rt.asan-${arch})
+
+    if (COMPILER_RT_BUILD_SHARED_ASAN)
+      add_compiler_rt_runtime(clang_rt.asan-preinit-${arch} ${arch} STATIC
+        SOURCES $<TARGET_OBJECTS:RTAsan_preinit.${arch}>
+        CFLAGS ${ASAN_CFLAGS}
+        DEFS ${ASAN_COMMON_DEFINITIONS})
+      add_dependencies(asan clang_rt.asan-preinit-${arch})
+
+      add_compiler_rt_runtime(clang_rt.asan-dynamic-${arch} ${arch} SHARED
+        OUTPUT_NAME clang_rt.asan-${arch}
+        SOURCES $<TARGET_OBJECTS:RTAsan_dynamic.${arch}> ${ASAN_COMMON_RUNTIME_OBJECTS}
+        CFLAGS ${ASAN_DYNAMIC_CFLAGS}
+        DEFS ${ASAN_DYNAMIC_DEFINITIONS})
+      target_link_libraries(clang_rt.asan-dynamic-${arch} ${ASAN_DYNAMIC_LIBS})
+      add_dependencies(asan clang_rt.asan-dynamic-${arch})
+    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)
     endif()
 
     if (WIN32)
       add_compiler_rt_runtime(clang_rt.asan_dll_thunk-${arch} ${arch} STATIC
         SOURCES asan_dll_thunk.cc
         CFLAGS ${ASAN_CFLAGS} -DASAN_DLL_THUNK
         DEFS ${ASAN_COMMON_DEFINITIONS})
       add_dependencies(asan clang_rt.asan_dll_thunk-${arch})
     endif()
   endforeach()

lib/asan/asan_internal.h

 #  define ASAN_LOW_MEMORY 0
 # endif
 #endif
 
 #ifndef ASAN_USE_PREINIT_ARRAY
 # define ASAN_USE_PREINIT_ARRAY (SANITIZER_LINUX && !SANITIZER_ANDROID)
 #endif
 
+#ifndef ASAN_DYNAMIC
+# define ASAN_DYNAMIC 0
+#endif
+
 // All internal functions in asan reside inside the __asan namespace
 // to avoid namespace collisions with the user programs.
 // Seperate namespace also makes it simpler to distinguish the asan run-time
 // functions from the instrumented user code in a profile.
 namespace __asan {
 
 class AsanThread;
 using __sanitizer::StackTrace;
 
 void AsanInitFromRtl();
 
 // asan_rtl.cc
 void NORETURN ShowStatsAndAbort();
 
 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
 
 // x86_64 FreeBSD 9.2 and older define 64-bit register names in both 64-bit
 // and 32-bit modes.
 #if SANITIZER_FREEBSD
 #include <sys/param.h>
 # if __FreeBSD_version <= 902001  // v9.2
 #  define mc_eip mc_rip
 #  define mc_ebp mc_rbp
 #  define mc_esp mc_rsp
 # endif
 #endif
 
-extern "C" void* _DYNAMIC;
+typedef enum {
+  ASAN_RT_VERSION_UNDEFINED = 0,
+  ASAN_RT_VERSION_DYNAMIC,
+  ASAN_RT_VERSION_STATIC,
+} asan_rt_version_t;
+
+// fixme: perhaps also store abi version here?
+extern "C" {
+SANITIZER_INTERFACE_ATTRIBUTE
+asan_rt_version_t  __asan_rt_version;
+}
 
 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 FindFirstDSOCallback(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;
+}
+
+static bool IsDynamicRTName(const char *libname) {
+  return internal_strstr(libname, "libclang_rt.asan") ||
+    internal_strstr(libname, "libasan.so");
+}
+
+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_dso_name = 0;
+  dl_iterate_phdr(FindFirstDSOCallback, &first_dso_name);
+  if (first_dso_name && !IsDynamicRTName(first_dso_name)) {
+    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
+#if ASAN_DYNAMIC
+  if (__asan_rt_version == ASAN_RT_VERSION_UNDEFINED) {
+    __asan_rt_version = ASAN_RT_VERSION_DYNAMIC;
+  } else if (__asan_rt_version != ASAN_RT_VERSION_DYNAMIC) {
+    Report("Your application is linked against "
+           "incompatible ASan runtimes.\n");
+    Die();
+  }
+#else
+  MemoryMappingLayout proc_maps(/*cache_enabled*/true);
+  char filename[128];
+  while (proc_maps.Next(0, 0, 0, filename, sizeof(filename),
+         /* protection */0)) {
+    if (IsDynamicRTName(filename)) {
+      Report("Your application is linked against "
+             "incompatible ASan runtimes.\n");
+      Die();
+    }
+  }
+
+  CHECK_NE(__asan_rt_version, ASAN_RT_VERSION_DYNAMIC);
+  __asan_rt_version = ASAN_RT_VERSION_STATIC;
+#endif
+#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();
 }
 
+#if 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();
+    AsanCheckDynamicRTPrereqs();
+    if (!asan_inited)
+      __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
+#if 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() { UNIMPLEMENTED(); }
+
+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/asan/tests/CMakeLists.txt

 set(ASAN_UNITTEST_INSTRUMENTED_LINKFLAGS
   ${ASAN_UNITTEST_COMMON_LINKFLAGS})
 # On Android, we link with ASan runtime manually. On other platforms we depend
 # on Clang driver behavior, passing -fsanitize=address flag.
 if(NOT ANDROID)
   list(APPEND ASAN_UNITTEST_INSTRUMENTED_LINKFLAGS -fsanitize=address)
 endif()
 
+set(ASAN_DYNAMIC_UNITTEST_INSTRUMENTED_LINKFLAGS
+  ${ASAN_UNITTEST_INSTRUMENTED_LINKFLAGS}
+  -shared-libasan)
+
 set(ASAN_UNITTEST_NOINST_LINKFLAGS
   ${ASAN_UNITTEST_COMMON_LINKFLAGS} -lm)
 append_if(COMPILER_RT_HAS_LIBDL -ldl ASAN_UNITTEST_NOINST_LINKFLAGS)
 append_if(COMPILER_RT_HAS_LIBPTHREAD -lpthread ASAN_UNITTEST_NOINST_LINKFLAGS)
 
 # Compile source for the given architecture, using compiler
 # options in ${ARGN}, and add it to the object list.
 macro(asan_compile obj_list source arch)
macro(add_asan_tests_for_arch arch)
   if (APPLE)
     # Add Mac-specific helper.
     asan_compile(ASAN_INST_TEST_OBJECTS asan_mac_test_helpers.mm ${arch}
                  ${ASAN_UNITTEST_INSTRUMENTED_CFLAGS} -ObjC)
   endif()
   add_asan_test(AsanUnitTests "Asan-${arch}-Test" ${arch}
                 OBJECTS ${ASAN_INST_TEST_OBJECTS}
                 LINKFLAGS ${ASAN_UNITTEST_INSTRUMENTED_LINKFLAGS})
+  if(COMPILER_RT_BUILD_SHARED_ASAN)
+    add_asan_test(AsanUnitTests "Asan-${arch}-Dynamic-Test" ${arch}
+                  OBJECTS ${ASAN_INST_TEST_OBJECTS}
+                  LINKFLAGS ${ASAN_DYNAMIC_UNITTEST_INSTRUMENTED_LINKFLAGS})
+  endif()
 
   # Add static ASan runtime that will be linked with uninstrumented tests.
   set(ASAN_TEST_RUNTIME RTAsanTest.${arch})
   if(APPLE)
     set(ASAN_TEST_RUNTIME_OBJECTS
       $<TARGET_OBJECTS:RTAsan.osx>
       $<TARGET_OBJECTS:RTInterception.osx>
       $<TARGET_OBJECTS:RTSanitizerCommon.osx>
macro(add_asan_tests_for_arch arch)
   set(ASAN_BENCHMARKS_OBJECTS)
   foreach(src ${ASAN_BENCHMARKS_SOURCES})
     asan_compile(ASAN_BENCHMARKS_OBJECTS ${src} ${arch}
                  ${ASAN_UNITTEST_INSTRUMENTED_CFLAGS})
   endforeach()
   add_asan_test(AsanBenchmarks "Asan-${arch}-Benchmark" ${arch}
                 OBJECTS ${ASAN_BENCHMARKS_OBJECTS}
                 LINKFLAGS ${ASAN_UNITTEST_INSTRUMENTED_LINKFLAGS})
+  if(COMPILER_RT_BUILD_SHARED_ASAN)
+    add_asan_test(AsanBenchmarks "Asan-${arch}-Dynamic-Benchmark" ${arch}
+                  OBJECTS ${ASAN_BENCHMARKS_OBJECTS}
+                  LINKFLAGS ${ASAN_DYNAMIC_UNITTEST_INSTRUMENTED_LINKFLAGS})
+  endif()
 endmacro()
 
 if(COMPILER_RT_CAN_EXECUTE_TESTS)
   foreach(arch ${ASAN_SUPPORTED_ARCH})
     add_asan_tests_for_arch(${arch})
   endforeach()
 endif()
 

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_BUILD_SHARED_ASAN)
+    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)
+  set(ASAN_RT_SUFFIX "i386")
   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_BUILD_SHARED_ASAN)
+    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()
+  unset(ASAN_RT_SUFFIX)
 endif()
 
 if(COMPILER_RT_INCLUDE_TESTS)
+  if(COMPILER_RT_BUILD_SHARED_ASAN)
+    set(ASAN_TEST_DYNAMIC True)
+  else()
+    set(ASAN_TEST_DYNAMIC False)
+  endif()
   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)
+  unset(ASAN_TEST_DYNAMIC)
 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_BUILD_SHARED_ASAN)
+    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 dynamic runtime is prohibited.
+//
+// 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 that non-sanitized 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 preloading dynamic runtime to statically sanitized
+// executable is prohibited.
+//
+// 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/asan_rt_confict_test-2.cc

+// Test that mixed static/dynamic sanitization of program objects
+// is prohibited.
+//
+// RUN: %clangxx_asan -DBUILD_SO=1 -fPIC -shared %s -o %t.so
+// RUN: %clangxx_asan_static %s %t.so -o %t
+// RUN: not %t 2>&1 | FileCheck %s
+
+#if BUILD_SO
+char dummy;
+void do_access(const void *p) { 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
+
+// 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/StaticRT/interface_symbols_linux.c

+// Check the presense of interface symbols in compiled file.
+
+// RUN: %clang_asan -O2 %s -o %t.exe
+// RUN: nm -D %t.exe | grep " T " | sed "s/.* T //" \
+// RUN:    | grep "__asan_" | sed "s/___asan_/__asan_/" \
+// RUN:    | grep -v "__asan_malloc_hook" \
+// RUN:    | grep -v "__asan_free_hook" \
+// RUN:    | grep -v "__asan_default_options" \
+// RUN:    | grep -v "__asan_stack_" \
+// RUN:    | grep -v "__asan_on_error" > %t.symbols
+// RUN: cat %p/../../../../../lib/asan/asan_interface_internal.h \
+// RUN:    | sed "s/\/\/.*//" | sed "s/typedef.*//" \
+// RUN:    | grep -v "OPTIONAL" \
+// RUN:    | grep "__asan_.*(" | sed "s/.* __asan_/__asan_/;s/(.*//" \
+// RUN:    > %t.interface
+// RUN: echo __asan_report_load1 >> %t.interface
+// RUN: echo __asan_report_load2 >> %t.interface
+// RUN: echo __asan_report_load4 >> %t.interface
+// RUN: echo __asan_report_load8 >> %t.interface
+// RUN: echo __asan_report_load16 >> %t.interface
+// RUN: echo __asan_report_store1 >> %t.interface
+// RUN: echo __asan_report_store2 >> %t.interface
+// RUN: echo __asan_report_store4 >> %t.interface
+// RUN: echo __asan_report_store8 >> %t.interface
+// RUN: echo __asan_report_store16 >> %t.interface
+// RUN: echo __asan_report_load_n >> %t.interface
+// RUN: echo __asan_report_store_n >> %t.interface
+// RUN: echo __asan_get_current_fake_stack >> %t.interface
+// RUN: echo __asan_addr_is_in_fake_stack >> %t.interface
+// RUN: cat %t.interface | sort -u | diff %t.symbols -
+
+// FIXME: nm -D on powerpc somewhy shows ASan interface symbols residing
+// in "initialized data section".
+// REQUIRES: x86_64-supported-target,i386-supported-target
+
+int main() { return 0; }

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

+if 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/Linux/interface_symbols_linux.c

-// Check the presense of interface symbols in compiled file.
-
-// RUN: %clang_asan -O2 %s -o %t.exe
-// RUN: nm -D %t.exe | grep " T " | sed "s/.* T //" \
-// RUN:    | grep "__asan_" | sed "s/___asan_/__asan_/" \
-// RUN:    | grep -v "__asan_malloc_hook" \
-// RUN:    | grep -v "__asan_free_hook" \
-// RUN:    | grep -v "__asan_default_options" \
-// RUN:    | grep -v "__asan_stack_" \
-// RUN:    | grep -v "__asan_on_error" > %t.symbols
-// RUN: cat %p/../../../../lib/asan/asan_interface_internal.h \
-// RUN:    | sed "s/\/\/.*//" | sed "s/typedef.*//" \
-// RUN:    | grep -v "OPTIONAL" \
-// RUN:    | grep "__asan_.*(" | sed "s/.* __asan_/__asan_/;s/(.*//" \
-// RUN:    > %t.interface
-// RUN: echo __asan_report_load1 >> %t.interface
-// RUN: echo __asan_report_load2 >> %t.interface
-// RUN: echo __asan_report_load4 >> %t.interface
-// RUN: echo __asan_report_load8 >> %t.interface
-// RUN: echo __asan_report_load16 >> %t.interface
-// RUN: echo __asan_report_store1 >> %t.interface
-// RUN: echo __asan_report_store2 >> %t.interface
-// RUN: echo __asan_report_store4 >> %t.interface
-// RUN: echo __asan_report_store8 >> %t.interface
-// RUN: echo __asan_report_store16 >> %t.interface
-// RUN: echo __asan_report_load_n >> %t.interface
-// RUN: echo __asan_report_store_n >> %t.interface
-// RUN: echo __asan_get_current_fake_stack >> %t.interface
-// RUN: echo __asan_addr_is_in_fake_stack >> %t.interface
-// RUN: cat %t.interface | sort -u | diff %t.symbols -
-
-// FIXME: nm -D on powerpc somewhy shows ASan interface symbols residing
-// in "initialized data section".
-// REQUIRES: x86_64-supported-target,i386-supported-target
-
-int main() { return 0; }

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/Unit/lit.site.cfg.in

 ## Autogenerated by LLVM/Clang configuration.
 # Do not edit!
 
+import os
+
 # Load common config for all compiler-rt unit tests.
 lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/unittests/lit.common.unit.configured")
 
+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-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@
+config.compiler_rt_libdir = "@COMPILER_RT_LIBRARY_OUTPUT_DIR@"
+
+# Set LD_LIBRARY_PATH to pick dynamic runtime up properly.
+push_ld_library_path(config, config.compiler_rt_libdir)
 
 # 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",
+clang_asan_static_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
+clang_asan_static_cxxflags = config.cxx_mode_flags + clang_asan_static_cflags
+
+if config.asan_dynamic:
+  clang_asan_cflags = clang_asan_static_cflags + ['-shared-libasan']
+  clang_asan_cxxflags = clang_asan_static_cxxflags + ['-shared-libasan']
+else:
+  clang_asan_cflags = clang_asan_static_cflags
+  clang_asan_cxxflags = clang_asan_static_cxxflags
 
 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) + " "
 
+asan_rt_suffix = config.asan_rt_suffix
+if not asan_rt_suffix:
+  asan_rt_suffix = config.host_arch
+
 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.so" % asan_rt_suffix))
+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)

 config.substitutions.append( ('CHECK-%kernel_bits', ("CHECK-kernel-" + kernel_bits + "-bits")))
 
 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.
+push_ld_library_path(config, config.compiler_rt_libdir)
+
+# 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']
 
 if config.host_os == 'Darwin':
   config.suffixes.append('.mm')
 
 # 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@
+config.asan_rt_suffix = "@ASAN_RT_SUFFIX@"
 
 # 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")