[ASan] Test churn for setting ASAN_OPTIONS=symbolize_vs_style=false

[filcab]

Summary

This commit adds symbolize_vs_style=false to every instance of
ASAN_OPTIONS in the asan tests and sets
ASAN_OPTIONS=symbolize_vs_style=false in lit, for tests which don't set
it.

This way we don't need to make the tests be able to deal with both
symbolize styles.

This is the first patch in the series. I will eventually submit for the
other sanitizers too.

We need this change (or another way to deal with the different outputs) in
order to be able to default to symbolize_vs_style=true on some platforms.

[rnk]

This is verbose, it makes me think we want some llvm-env command that supports something like ASAN_OPTIONS+=foo. Let's see what Alexey says.

[samsonov]

Wait a second, why can't you set

config.environment['ASAN_OPTIONS'] = 'symbolize_vs_style=false'

in lit configs, and then use ASAN_OPTIONS+= or ASAN_OPTIONS=$ASAN_OPTIONS:<....> in the tests which set this env variable?
In this case you won't have to update all the test cases every time you want to set the default value of certain runtime flag for the test suite.

[samsonov]

In D10294#185931, @samsonov wrote:

Wait a second, why can't you set

config.environment['ASAN_OPTIONS'] = 'symbolize_vs_style=false'

OK, I see that you've already done it, my bad, but...

ASAN_OPTIONS=$ASAN_OPTIONS:<....> in the tests which set this env variable?

^^
Why can't we use this form instead?

[filcab]

(I said on IRC, but I'll repeat to have it included in the thread)

env ASAN_OPTIONS+=blah=true
doesn't work on Windows, unfortunately.

I can change it to either (I think any of these would be preferable to the
current patch):

• use Reid's idea of making a (yet another) single purpose utility

(llvm-env)

• use expansion (ASAN_OPTIONS=$ASAN_OPTIONS:...) instead of spelling out

symbolize_vs_style=true again (I didn't think about this one)

• change lit's shell, if we're sure that's the one that's being used.

Thanks,

Filipe

[filcab]

Will do. I should have thought of that one, but something wasn't working
very well that day :-)

Will update.

Thanks,

Filipe

[samsonov]

I can change it to either (I think any of these would be preferable to the
current patch):

• use Reid's idea of making a (yet another) single purpose utility

(llvm-env)

• use expansion (ASAN_OPTIONS=$ASAN_OPTIONS:...) instead of spelling out

symbolize_vs_style=true again (I didn't think about this one)

^^
Right, let's use this one. We already use similar construct in another places

$ grep -rnH "$.SAN_OPTIONS" projects/compiler-rt/test/*

• change lit's shell, if we're sure that's the one that's being used.

Thanks,

Filipe

[filcab]

Added "env " before any run lines which set variables and call %run.

[samsonov]

test/asan/TestCases/Darwin/suppressions-darwin.cc

7

Looks like quotes should enclose the whole string here

ASAN_OPTIONS="$ASAN_OPTIONS:suppressions='%t.supp'"

test/asan/TestCases/Linux/leak.cc

6

Huh? Why not

env ASAN_OPTIONS=$ASAN_OPTIONS

?

test/asan/TestCases/Linux/malloc_delete_mismatch.cc

33

No, I don't think we need to modify this line ;)

test/asan/TestCases/Posix/log_path_fork_test.cc.disabled

4

Same note about quotes.

test/asan/TestCases/Windows/report_globals_reload_dll.cc

4

You sure you need both?

test/asan/TestCases/atol_strict.c

4 ↗

(On Diff #27536)

This test doesn't have $ASAN_OPTIONS, is it intentional?

test/asan/TestCases/atoll_strict.c

4 ↗

(On Diff #27536)

This test doesn't have $ASAN_OPTIONS, is it intentional?

test/asan/TestCases/strcasestr-1.c

6 ↗

(On Diff #27536)

This test doesn't have $ASAN_OPTIONS, is it intentional?

test/asan/TestCases/strcasestr_strict.c

3 ↗

(On Diff #27536)

This test doesn't have $ASAN_OPTIONS, is it intentional?(more cases below)

test/asan/TestCases/suppressions-exec-relative-location.cc

12

quotes (here and below)

[filcab]

Fixed problems pointed out by Alexey.
Included a bunch of tests I had missed.

[filcab]

Thanks Alexey. I missed a bunch of places that were messed up. I also tried
to make sure I got all files this time (I had missed some of them).

Filipe

[samsonov]

LGTM, thanks! Single comment below.

test/asan/TestCases/stack-use-after-return.cc

15–16

Extra $ASAN_OPTIONS here.

16

And here

[filcab]

This got committed, but Windows doesn't have the 'env' command, so I reverted that directory.
I'll try to figure out something for those.

test/asan/TestCases/Android/coverage-android.cc

 // Test for direct coverage writing with dlopen.
 
 // Test normal exit, coverage level 1.
 // RUN: %clangxx_asan -fsanitize-coverage=func -DSHARED %s -shared -o %T/libcoverage_android_test_1.so -fPIC
 // RUN: %clangxx_asan -fsanitize-coverage=func -DSO_DIR=\"%device\" %s -o %t
 
 // RUN: adb shell rm -rf %device/coverage-android
 // RUN: rm -rf %T/coverage-android
 
 // RUN: adb shell mkdir -p %device/coverage-android/direct
 // RUN: mkdir -p %T/coverage-android/direct
-// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android/direct:verbosity=1 %run %t
+// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android/direct:verbosity=1:symbolize_vs_style=false %run %t
 // RUN: adb pull %device/coverage-android/direct %T/coverage-android/direct
 // RUN: ls; pwd
 // RUN: cd %T/coverage-android/direct
 // RUN: %sancov rawunpack *.sancov.raw
 // RUN: %sancov print *.sancov |& FileCheck --check-prefix=CHECK1 %s
 
 
 // Test sudden death, coverage level 1.
 // RUN: %clangxx_asan -fsanitize-coverage=func -DSHARED -DKILL %s -shared -o %T/libcoverage_android_test_1.so -fPIC
 // RUN: %clangxx_asan -fsanitize-coverage=func -DSO_DIR=\"%device\" %s -o %t
 
 // RUN: adb shell rm -rf %device/coverage-android-kill
 // RUN: rm -rf %T/coverage-android-kill
 
 // RUN: adb shell mkdir -p %device/coverage-android-kill/direct
 // RUN: mkdir -p %T/coverage-android-kill/direct
-// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android-kill/direct:verbosity=1 not %run %t
+// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android-kill/direct:verbosity=1:symbolize_vs_style=false not %run %t
 // RUN: adb pull %device/coverage-android-kill/direct %T/coverage-android-kill/direct
 // RUN: ls; pwd
 // RUN: cd %T/coverage-android-kill/direct
 // RUN: %sancov rawunpack *.sancov.raw
 // RUN: %sancov print *.sancov |& FileCheck --check-prefix=CHECK1 %s
 
 
 // Test normal exit, coverage level 2.
 // RUN: %clangxx_asan -fsanitize-coverage=bb -DSHARED %s -shared -o %T/libcoverage_android_test_1.so -fPIC
 // RUN: %clangxx_asan -fsanitize-coverage=bb -DSO_DIR=\"%device\" %s -o %t
 
 // RUN: adb shell rm -rf %device/coverage-android
 // RUN: rm -rf %T/coverage-android
 
 // RUN: adb shell mkdir -p %device/coverage-android/direct
 // RUN: mkdir -p %T/coverage-android/direct
-// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android/direct:verbosity=1 %run %t
+// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android/direct:verbosity=1:symbolize_vs_style=false %run %t
 // RUN: adb pull %device/coverage-android/direct %T/coverage-android/direct
 // RUN: ls; pwd
 // RUN: cd %T/coverage-android/direct
 // RUN: %sancov rawunpack *.sancov.raw
 // RUN: %sancov print *.sancov |& FileCheck --check-prefix=CHECK2 %s
 
 
 // Test sudden death, coverage level 2.
 // RUN: %clangxx_asan -fsanitize-coverage=bb -DSHARED -DKILL %s -shared -o %T/libcoverage_android_test_1.so -fPIC
 // RUN: %clangxx_asan -fsanitize-coverage=bb -DSO_DIR=\"%device\" %s -o %t
 
 // RUN: adb shell rm -rf %device/coverage-android-kill
 // RUN: rm -rf %T/coverage-android-kill
 
 // RUN: adb shell mkdir -p %device/coverage-android-kill/direct
 // RUN: mkdir -p %T/coverage-android-kill/direct
-// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android-kill/direct:verbosity=1 not %run %t
+// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android-kill/direct:verbosity=1:symbolize_vs_style=false not %run %t
 // RUN: adb pull %device/coverage-android-kill/direct %T/coverage-android-kill/direct
 // RUN: ls; pwd
 // RUN: cd %T/coverage-android-kill/direct
 // RUN: %sancov rawunpack *.sancov.raw
 // RUN: %sancov print *.sancov |& FileCheck --check-prefix=CHECK2 %s
 
 
 // Test normal exit, coverage level 3.
 // RUN: %clangxx_asan -fsanitize-coverage=edge -DSHARED %s -shared -o %T/libcoverage_android_test_1.so -fPIC
 // RUN: %clangxx_asan -fsanitize-coverage=edge -DSO_DIR=\"%device\" %s -o %t
 
 // RUN: adb shell rm -rf %device/coverage-android
 // RUN: rm -rf %T/coverage-android
 
 // RUN: adb shell mkdir -p %device/coverage-android/direct
 // RUN: mkdir -p %T/coverage-android/direct
-// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android/direct:verbosity=1 %run %t
+// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android/direct:verbosity=1:symbolize_vs_style=false %run %t
 // RUN: adb pull %device/coverage-android/direct %T/coverage-android/direct
 // RUN: ls; pwd
 // RUN: cd %T/coverage-android/direct
 // RUN: %sancov rawunpack *.sancov.raw
 // RUN: %sancov print *.sancov |& FileCheck --check-prefix=CHECK3 %s
 
 
 // Test sudden death, coverage level 3.
 // RUN: %clangxx_asan -fsanitize-coverage=edge -DSHARED -DKILL %s -shared -o %T/libcoverage_android_test_1.so -fPIC
 // RUN: %clangxx_asan -fsanitize-coverage=edge -DSO_DIR=\"%device\" %s -o %t
 
 // RUN: adb shell rm -rf %device/coverage-android-kill
 // RUN: rm -rf %T/coverage-android-kill
 
 // RUN: adb shell mkdir -p %device/coverage-android-kill/direct
 // RUN: mkdir -p %T/coverage-android-kill/direct
-// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android-kill/direct:verbosity=1 not %run %t
+// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android-kill/direct:verbosity=1:symbolize_vs_style=false not %run %t
 // RUN: adb pull %device/coverage-android-kill/direct %T/coverage-android-kill/direct
 // RUN: ls; pwd
 // RUN: cd %T/coverage-android-kill/direct
 // RUN: %sancov rawunpack *.sancov.raw
 // RUN: %sancov print *.sancov |& FileCheck --check-prefix=CHECK3 %s
 
 #include <assert.h>
 #include <dlfcn.h>

test/asan/TestCases/Darwin/atos-symbolizer.cc

 // Check that the `atos` symbolizer works.
 
 // RUN: %clangxx_asan -O0 %s -o %t 
-// RUN: ASAN_OPTIONS=verbosity=2 ASAN_SYMBOLIZER_PATH=$(which atos) not %run %t 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=verbosity=2:symbolize_vs_style=false ASAN_SYMBOLIZER_PATH=$(which atos) not %run %t 2>&1 | FileCheck %s
 
 // Check that when having a DYLD_ROOT_PATH set, the symbolizer still works.
-// RUN: DYLD_ROOT_PATH="/" ASAN_OPTIONS=verbosity=2 ASAN_SYMBOLIZER_PATH=$(which atos) \
+// RUN: DYLD_ROOT_PATH="/" ASAN_OPTIONS=verbosity=2:symbolize_vs_style=false ASAN_SYMBOLIZER_PATH=$(which atos) \
 // RUN:   not %run %t 2>&1 | FileCheck %s
 
 #include <stdlib.h>
 #include <string.h>
 int main(int argc, char **argv) {
   char *x = (char*)malloc(10 * sizeof(char));
   memset(x, 0, 10);
   int res = x[argc];

test/asan/TestCases/Darwin/dladdr-demangling.cc

 // In a non-forking sandbox, we fallback to dladdr(). Test that we provide
 // properly demangled C++ names in that case.
 
 // RUN: %clangxx_asan -O0 %s -o %t 
 // RUN: not %run %t 2>&1 | FileCheck %s
-// RUN: ASAN_OPTIONS=verbosity=2 not %run sandbox-exec -p '(version 1)(allow default)(deny process-fork)' %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-DLADDR
+// RUN: ASAN_OPTIONS=verbosity=2:symbolize_vs_style=false not %run sandbox-exec -p '(version 1)(allow default)(deny process-fork)' %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-DLADDR
 
 #include <stdlib.h>
 
 class MyClass {
  public:
   int my_function(int n) {
     char *x = (char*)malloc(n * sizeof(char));
     free(x);

test/asan/TestCases/Darwin/dyld_insert_libraries_reexec.cc

 // When DYLD-inserting the ASan dylib from a different location than the
 // original, make sure we don't try to reexec.
 
 // RUN: mkdir -p %T/dyld_insert_libraries_reexec
 // RUN: cp `%clang_asan %s -fsanitize=address -### 2>&1 \
 // RUN:   | grep "libclang_rt.asan_osx_dynamic.dylib" \
 // RUN:   | sed -e 's/.*"\(.*libclang_rt.asan_osx_dynamic.dylib\)".*/\1/'` \
 // RUN:   %T/dyld_insert_libraries_reexec/libclang_rt.asan_osx_dynamic.dylib
 // RUN: %clangxx_asan %s -o %T/dyld_insert_libraries_reexec/a.out
 // RUN: DYLD_INSERT_LIBRARIES=@executable_path/libclang_rt.asan_osx_dynamic.dylib \
-// RUN:   ASAN_OPTIONS=verbosity=1 %run %T/dyld_insert_libraries_reexec/a.out 2>&1 \
+// RUN:   ASAN_OPTIONS=verbosity=1:symbolize_vs_style=false %run %T/dyld_insert_libraries_reexec/a.out 2>&1 \
 // RUN:   | FileCheck %s
-// RUN: ASAN_OPTIONS=verbosity=1 %run %T/dyld_insert_libraries_reexec/a.out 2>&1 \
+// RUN: ASAN_OPTIONS=verbosity=1:symbolize_vs_style=false %run %T/dyld_insert_libraries_reexec/a.out 2>&1 \
 // RUN:   | FileCheck --check-prefix=CHECK-NOINSERT %s
 
 #include <stdio.h>
 
 int main() {
   printf("Passed\n");
   return 0;
 }

test/asan/TestCases/Darwin/suppressions-darwin.cc

 // Check that without suppressions, we catch the issue.
 // RUN: %clangxx_asan -O0 %s -o %t -framework Foundation
 // RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-CRASH %s
 
 // Check that suppressing the interceptor by name works.
 // RUN: echo "interceptor_name:memmove" > %t.supp
-// RUN: ASAN_OPTIONS="suppressions='%t.supp'" %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+// RUN: ASAN_OPTIONS="suppressions='%t.supp'":symbolize_vs_style=false %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
 
 // Check that suppressing by interceptor name works even without the symbolizer
-// RUN: ASAN_OPTIONS="suppressions='%t.supp':symbolize=false" %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+// RUN: ASAN_OPTIONS="suppressions='%t.supp':symbolize=false":symbolize_vs_style=false %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
 
 // Check that suppressing all reports from a library works.
 // RUN: echo "interceptor_via_lib:CoreFoundation" > %t.supp
-// RUN: ASAN_OPTIONS="suppressions='%t.supp'" %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+// RUN: ASAN_OPTIONS="suppressions='%t.supp'":symbolize_vs_style=false %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
 
 // Check that suppressing library works even without the symbolizer.
-// RUN: ASAN_OPTIONS="suppressions='%t.supp':symbolize=false" %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+// RUN: ASAN_OPTIONS="suppressions='%t.supp':symbolize=false":symbolize_vs_style=false %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
 
 #include <CoreFoundation/CoreFoundation.h>
 
 int main() {
   char *a = (char *)malloc(6);
   strcpy(a, "hello");
   CFStringRef str =
       CFStringCreateWithBytes(kCFAllocatorDefault, (unsigned char *)a, 10,

test/asan/TestCases/Darwin/suppressions-sandbox.cc

 // Check that without suppressions, we catch the issue.
 // RUN: %clangxx_asan -O0 %s -o %t -framework Foundation
 // RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-CRASH %s
 
 // Check that suppressing a function name works within a no-fork sandbox
 // RUN: echo "interceptor_via_fun:CFStringCreateWithBytes" > %t.supp
-// RUN: ASAN_OPTIONS=suppressions=%t.supp \
+// RUN: ASAN_OPTIONS=suppressions=%t.supp:symbolize_vs_style=false \
 // RUN:   sandbox-exec -p '(version 1)(allow default)(deny process-fork)' \
 // RUN:   %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
 
 #include <CoreFoundation/CoreFoundation.h>
 
 int main() {
   char *a = (char *)malloc(6);
   strcpy(a, "hello");

test/asan/TestCases/Linux/asan_prelink_test.cc

 // Test if asan works with prelink.
 // It does not actually use prelink, but relies on ld's flag -Ttext-segment
 // or gold's flag -Ttext (we try the first flag first, if that fails we
 // try the second flag).
 //
 // RUN: %clangxx_asan -c %s -o %t.o
 // RUN: %clangxx_asan -DBUILD_SO=1 -fPIC -shared %s -o %t.so -Wl,-Ttext-segment=0x3600000000 ||\
 // RUN: %clangxx_asan -DBUILD_SO=1 -fPIC -shared %s -o %t.so -Wl,-Ttext=0x3600000000
 // RUN: %clangxx_asan %t.o %t.so -Wl,-R. -o %t
-// RUN: ASAN_OPTIONS=verbosity=1 %run %t 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=verbosity=1:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s
 
 // GNU driver doesn't handle .so files properly.
 // REQUIRES: x86_64-supported-target, asan-64-bits, Clang
 #if BUILD_SO
 int G;
 int *getG() {
   return &G;
 }

test/asan/TestCases/Linux/coverage-missing.cc

 // Test for "sancov.py missing ...".
 
-// RUN: ASAN_OPTIONS=coverage=1:coverage_dir=%T/coverage-missing
+// RUN: ASAN_OPTIONS=coverage=1:coverage_dir=%T/coverage-missing:symbolize_vs_style=false
 
 // First case: coverage from executable. main() is called on every code path.
 // RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t -DFOOBAR -DMAIN
 // RUN: rm -rf %T/coverage-missing
 // RUN: mkdir -p %T/coverage-missing
 // RUN: cd %T/coverage-missing
 // RUN: ASAN_OPTIONS=$ASAN_OPTIONS %t
 // RUN: %sancov print *.sancov > main.txt

test/asan/TestCases/Linux/init-order-dlopen.cc

 // Regression test for
 // https://code.google.com/p/address-sanitizer/issues/detail?id=178
 
 // RUN: %clangxx_asan -O0 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
 // RUN: %clangxx_asan -O0 %s %libdl -Wl,--export-dynamic -o %t
-// RUN: env ASAN_OPTIONS=strict_init_order=true %run %t 2>&1
+// RUN: env ASAN_OPTIONS=strict_init_order=true:symbolize_vs_style=false %run %t 2>&1
 
 #if defined(SHARED_LIB)
 #include <stdio.h>
 
 struct Bar {
   Bar(int val) : val(val) { printf("Bar::Bar(%d)\n", val); }
   int val;
 };

test/asan/TestCases/Linux/initialization-bug-any-order.cc

 // Test to make sure basic initialization order errors are caught.
 // Check that on Linux initialization order bugs are caught
 // independently on order in which we list source files (if we specify
 // strict init-order checking).
 
 // RUN: %clangxx_asan -O0 %s %p/../Helpers/initialization-bug-extra.cc -o %t
-// RUN: ASAN_OPTIONS=strict_init_order=true not %run %t 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=strict_init_order=true:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O0 %p/../Helpers/initialization-bug-extra.cc %s -o %t
-// RUN: ASAN_OPTIONS=strict_init_order=true not %run %t 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=strict_init_order=true:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
 
 // Do not test with optimization -- the error may be optimized away.
 
 #include <cstdio>
 
 // 'y' is a dynamically initialized global residing in a different TU.  This
 // dynamic initializer will read the value of 'y' before main starts.  The
 // result is undefined behavior, which should be caught by initialization order

test/asan/TestCases/Linux/kernel-area.cc

 // FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
 // XFAIL: android
 //
 // Test that kernel area is not sanitized on 32-bit machines.
 //
 // RUN: %clangxx_asan %s -o %t
-// RUN: ASAN_OPTIONS=verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%kernel_bits
-// RUN: ASAN_OPTIONS=verbosity=1:full_address_space=0 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%kernel_bits
-// RUN: ASAN_OPTIONS=verbosity=1:full_address_space=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-kernel-64-bits
+// RUN: ASAN_OPTIONS=verbosity=1:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%kernel_bits
+// RUN: ASAN_OPTIONS=verbosity=1:full_address_space=0:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%kernel_bits
+// RUN: ASAN_OPTIONS=verbosity=1:full_address_space=1:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-kernel-64-bits
 //
 // CHECK-kernel-32-bits: || `[0x38{{0+}}, 0xb{{f+}}]` || HighMem    ||
 // CHECK-kernel-32-bits: || `[0x27{{0+}}, 0x37{{f+}}]` || HighShadow ||
 // CHECK-kernel-32-bits: || `[0x24{{0+}}, 0x26{{f+}}]` || ShadowGap  ||
 //
 // CHECK-kernel-64-bits: || `[0x4{{0+}}, 0x{{f+}}]` || HighMem    ||
 // CHECK-kernel-64-bits: || `[0x28{{0+}}, 0x3{{f+}}]` || HighShadow ||
 // CHECK-kernel-64-bits: || `[0x24{{0+}}, 0x27{{f+}}]` || ShadowGap  ||
 //
 // REQUIRES: asan-32-bits
 
 int main() {
   return 0;
 }
 

test/asan/TestCases/Linux/leak.cc

 // Minimal test for LeakSanitizer+AddressSanitizer.
 // REQUIRES: leak-detection
 //
 // RUN: %clangxx_asan  %s -o %t
-// RUN: ASAN_OPTIONS=detect_leaks=1 not %run %t  2>&1 | FileCheck %s
-// RUN: ASAN_OPTIONS=""             not %run %t  2>&1 | FileCheck %s
-// RUN: ASAN_OPTIONS=detect_leaks=0     %run %t
+// RUN: ASAN_OPTIONS=detect_leaks=1:symbolize_vs_style=false not %run %t  2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=symbolize_vs_style=false             not %run %t  2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=detect_leaks=0:symbolize_vs_style=false     %run %t
 #include <stdio.h>
 int *t;
 
 int main(int argc, char **argv) {
   t = new int[argc - 1];
   printf("t: %p\n", t);
   t = 0;
 }
 // CHECK: LeakSanitizer: detected memory leaks

test/asan/TestCases/Linux/malloc-in-qsort.cc

 // RUN: %clangxx_asan -O2 %s -o %t
-// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-FAST
-// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-SLOW
+// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-FAST
+// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-SLOW
 
 // Test how well we unwind in presence of qsort in the stack
 // (i.e. if we can unwind through a function compiled w/o frame pointers).
 // https://code.google.com/p/address-sanitizer/issues/detail?id=137
 
 // Fast unwinder is only available on x86_64 and i386.
 // REQUIRES: x86_64-supported-target
 

test/asan/TestCases/Linux/malloc_delete_mismatch.cc

 // Check that we detect malloc/delete mismatch only if the approptiate flag
 // is set.
 
 // RUN: %clangxx_asan -g %s -o %t 2>&1
 
 // Find error and provide malloc context.
-// RUN: ASAN_OPTIONS=alloc_dealloc_mismatch=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=ALLOC-STACK
+// RUN: ASAN_OPTIONS=alloc_dealloc_mismatch=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=ALLOC-STACK
 
 // No error here.
-// RUN: ASAN_OPTIONS=alloc_dealloc_mismatch=0 %run %t
+// RUN: ASAN_OPTIONS=alloc_dealloc_mismatch=0:symbolize_vs_style=false %run %t
 
 // Also works if no malloc context is available.
-// RUN: ASAN_OPTIONS=alloc_dealloc_mismatch=1:malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s
-// RUN: ASAN_OPTIONS=alloc_dealloc_mismatch=1:malloc_context_size=0:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=alloc_dealloc_mismatch=1:malloc_context_size=0:fast_unwind_on_malloc=0:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=alloc_dealloc_mismatch=1:malloc_context_size=0:fast_unwind_on_malloc=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
 // XFAIL: arm-linux-gnueabi
 // XFAIL: armv7l-unknown-linux-gnueabihf
 #include <stdlib.h>
 
 static volatile char *x;
 
 int main() {
   x = (char*)malloc(10);
   x[0] = 0;
   delete x;
 }
 // CHECK: ERROR: AddressSanitizer: alloc-dealloc-mismatch (malloc vs operator delete) on 0x
 // CHECK-NEXT: #0{{.*}}operator delete
 // CHECK: #{{.*}}main
 // CHECK: is located 0 bytes inside of 10-byte region
 // CHECK-NEXT: allocated by thread T0 here:
 // ALLOC-STACK-NEXT: #0{{.*}}malloc
 // ALLOC-STACK: #{{.*}}main
-// CHECK: HINT: {{.*}} you may set ASAN_OPTIONS=alloc_dealloc_mismatch=0
+// CHECK: HINT: {{.*}} you may set ASAN_OPTIONS=alloc_dealloc_mismatch=0:symbolize_vs_style=false

test/asan/TestCases/Linux/nohugepage_test.cc

 // Regression test for
 // https://code.google.com/p/chromium/issues/detail?id=446692
 // where asan consumed too much RAM due to transparent hugetables.
 //
 // RUN: %clangxx_asan -g %s -o %t
-// RUN: ASAN_OPTIONS=no_huge_pages_for_shadow=1 %run %t 2>&1 | FileCheck %s
-// RUN:                                         %run %t 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=no_huge_pages_for_shadow=1:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s
+// RUN:                                                                  %run %t 2>&1 | FileCheck %s
 //
 // Would be great to run the test with no_huge_pages_for_shadow=0, but
 // the result will depend on the OS version and settings...
 //
 // REQUIRES: x86_64-supported-target, asan-64-bits
 //
 // WARNING: this test is very subtle and may nto work on some systems.
 // If this is the case we'll need to futher improve it or disable it.

test/asan/TestCases/Linux/odr-violation.cc

 // FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
 // XFAIL: android
 //
 // We use fast_unwind_on_malloc=0 to have full unwinding even w/o frame
 // pointers. This setting is not on by default because it's too expensive.
 //
 // Different size: detect a bug if detect_odr_violation>=1
 // RUN: %clangxx_asan -DBUILD_SO=1 -fPIC -shared %s -o %t-ODR-SO.so
 // RUN: %clangxx_asan %s %t-ODR-SO.so -Wl,-R. -o %t-ODR-EXE
-// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0:detect_odr_violation=1 not %run %t-ODR-EXE 2>&1 | FileCheck %s
-// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0:detect_odr_violation=2 not %run %t-ODR-EXE 2>&1 | FileCheck %s
-// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0:detect_odr_violation=0     %run %t-ODR-EXE 2>&1 | FileCheck %s --check-prefix=DISABLED
-// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0                        not %run %t-ODR-EXE 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0:detect_odr_violation=1:symbolize_vs_style=false not %run %t-ODR-EXE 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0:detect_odr_violation=2:symbolize_vs_style=false not %run %t-ODR-EXE 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0:detect_odr_violation=0:symbolize_vs_style=false     %run %t-ODR-EXE 2>&1 | FileCheck %s --check-prefix=DISABLED
+// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0:symbolize_vs_style=false                        not %run %t-ODR-EXE 2>&1 | FileCheck %s
 //
 // Same size: report a bug only if detect_odr_violation>=2.
 // RUN: %clangxx_asan -DBUILD_SO=1 -fPIC -shared %s -o %t-ODR-SO.so -DSZ=100
-// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0:detect_odr_violation=1     %run %t-ODR-EXE 2>&1 | FileCheck %s --check-prefix=DISABLED
-// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0:detect_odr_violation=2 not %run %t-ODR-EXE 2>&1 | FileCheck %s
-// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0                        not %run %t-ODR-EXE 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0:detect_odr_violation=1:symbolize_vs_style=false     %run %t-ODR-EXE 2>&1 | FileCheck %s --check-prefix=DISABLED
+// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0:detect_odr_violation=2:symbolize_vs_style=false not %run %t-ODR-EXE 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0:symbolize_vs_style=false                        not %run %t-ODR-EXE 2>&1 | FileCheck %s
 // RUN: echo "odr_violation:foo::ZZZ" > %t.supp
-// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0:detect_odr_violation=2:suppressions=%t.supp  not %run %t-ODR-EXE 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0:detect_odr_violation=2:suppressions=%t.supp:symbolize_vs_style=false  not %run %t-ODR-EXE 2>&1 | FileCheck %s
 // RUN: echo "odr_violation:foo::G" > %t.supp
-// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0:detect_odr_violation=2:suppressions=%t.supp      %run %t-ODR-EXE 2>&1 | FileCheck %s --check-prefix=DISABLED
+// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0:detect_odr_violation=2:suppressions=%t.supp:symbolize_vs_style=false      %run %t-ODR-EXE 2>&1 | FileCheck %s --check-prefix=DISABLED
 // RUN: rm -f %t.supp
 
 // GNU driver doesn't handle .so files properly.
 // REQUIRES: Clang
 
 #ifndef SZ
 # define SZ 4
 #endif

test/asan/TestCases/Linux/overflow-in-qsort.cc

 // RUN: %clangxx_asan -O2 %s -o %t
-// RUN: ASAN_OPTIONS=fast_unwind_on_fatal=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-FAST
-// RUN: ASAN_OPTIONS=fast_unwind_on_fatal=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-SLOW
+// RUN: ASAN_OPTIONS=fast_unwind_on_fatal=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-FAST
+// RUN: ASAN_OPTIONS=fast_unwind_on_fatal=0:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-SLOW
 
 // Test how well we unwind in presence of qsort in the stack
 // (i.e. if we can unwind through a function compiled w/o frame pointers).
 // https://code.google.com/p/address-sanitizer/issues/detail?id=137
 
 // Fast unwinder is only available on x86_64 and i386.
 // REQUIRES: x86_64-supported-target
 

test/asan/TestCases/Linux/quarantine_size_mb.cc

 // Test quarantine_size_mb (and the deprecated quarantine_size)
 // RUN: %clangxx_asan  %s -o %t
-// RUN: ASAN_OPTIONS=quarantine_size=10485760:verbosity=1:hard_rss_limit_mb=50 %run %t  2>&1  | FileCheck %s  --check-prefix=Q10
-// RUN: ASAN_OPTIONS=quarantine_size_mb=10:verbosity=1:hard_rss_limit_mb=50    %run %t  2>&1  | FileCheck %s  --check-prefix=Q10
-// RUN: ASAN_OPTIONS=quarantine_size_mb=10:quarantine_size=20:verbosity=1  not  %run %t  2>&1 | FileCheck %s  --check-prefix=BOTH
-// RUN: ASAN_OPTIONS=quarantine_size_mb=1000:hard_rss_limit_mb=50 not  %run %t           2>&1 | FileCheck %s  --check-prefix=RSS_LIMIT
-// RUN: ASAN_OPTIONS=hard_rss_limit_mb=50                         not  %run %t           2>&1 | FileCheck %s  --check-prefix=RSS_LIMIT
+// RUN: ASAN_OPTIONS=quarantine_size=10485760:verbosity=1:hard_rss_limit_mb=50:symbolize_vs_style=false %run %t  2>&1 | FileCheck %s  --check-prefix=Q10
+// RUN: ASAN_OPTIONS=quarantine_size_mb=10:verbosity=1:hard_rss_limit_mb=50:symbolize_vs_style=false    %run %t  2>&1 | FileCheck %s  --check-prefix=Q10
+// RUN: ASAN_OPTIONS=quarantine_size_mb=10:quarantine_size=20:verbosity=1:symbolize_vs_style=false  not %run %t  2>&1 | FileCheck %s  --check-prefix=BOTH
+// RUN: ASAN_OPTIONS=quarantine_size_mb=1000:hard_rss_limit_mb=50:symbolize_vs_style=false not  %run %t          2>&1 | FileCheck %s  --check-prefix=RSS_LIMIT
+// RUN: ASAN_OPTIONS=hard_rss_limit_mb=50:symbolize_vs_style=false                         not  %run %t          2>&1 | FileCheck %s  --check-prefix=RSS_LIMIT
 #include <string.h>
 char *g;
 
 static const int kNumAllocs = 1 << 11;
 static const int kAllocSize = 1 << 20;
 
 int main() {
   for (int i = 0; i < kNumAllocs; i++) {

test/asan/TestCases/Linux/sized_delete_test.cc

 // RUN: %clangxx_asan -fsized-deallocation -O0 %s -o %t
-// RUN:                                         not %run %t scalar 2>&1 | FileCheck %s -check-prefix=SCALAR
-// RUN: ASAN_OPTIONS=new_delete_type_mismatch=1 not %run %t scalar 2>&1 | FileCheck %s -check-prefix=SCALAR
-// RUN:                                         not %run %t array  2>&1 | FileCheck %s -check-prefix=ARRAY
-// RUN: ASAN_OPTIONS=new_delete_type_mismatch=1 not %run %t array  2>&1 | FileCheck %s -check-prefix=ARRAY
-// RUN: ASAN_OPTIONS=new_delete_type_mismatch=0     %run %t scalar
-// RUN: ASAN_OPTIONS=new_delete_type_mismatch=0     %run %t array
+// RUN:                                                                  not %run %t scalar 2>&1 | FileCheck %s -check-prefix=SCALAR
+// RUN: ASAN_OPTIONS=new_delete_type_mismatch=1:symbolize_vs_style=false not %run %t scalar 2>&1 | FileCheck %s -check-prefix=SCALAR
+// RUN:                                                                  not %run %t array  2>&1 | FileCheck %s -check-prefix=ARRAY
+// RUN: ASAN_OPTIONS=new_delete_type_mismatch=1:symbolize_vs_style=false not %run %t array  2>&1 | FileCheck %s -check-prefix=ARRAY
+// RUN: ASAN_OPTIONS=new_delete_type_mismatch=0:symbolize_vs_style=false     %run %t scalar
+// RUN: ASAN_OPTIONS=new_delete_type_mismatch=0:symbolize_vs_style=false     %run %t array
 
 // FIXME: the following two lines are not true after r232788.
 // Sized-delete is implemented with a weak delete() definition.
 // Weak symbols are kind of broken on Android.
 // XFAIL: android
 
 #include <new>
 #include <stdio.h>

test/asan/TestCases/Linux/stack-overflow-sigbus.cc

 // Test ASan detection of stack-overflow condition when Linux sends SIGBUS.
 
-// RUN: %clangxx_asan -O0 %s -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O0 %s -o %t && env ASAN_OPTIONS=use_sigaltstack=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
 
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <sys/mman.h>
 #include <sys/resource.h>

test/asan/TestCases/Linux/stack-trace-dlclose.cc

 // FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
 // XFAIL: android
 //
 // RUN: %clangxx_asan -DSHARED %s -shared -o %T/stack_trace_dlclose.so -fPIC
 // RUN: %clangxx_asan -DSO_DIR=\"%T\" %s %libdl -o %t
-// RUN: ASAN_OPTIONS=exitcode=0 %run %t 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=exitcode=0:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s
 // XFAIL: arm-linux-gnueabi
 // XFAIL: armv7l-unknown-linux-gnueabihf
 
 #include <assert.h>
 #include <dlfcn.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>

test/asan/TestCases/Linux/static_tls.cc

 // REQUIRES: asan-64-bits
 // Regression test: __tls_get_addr interceptor must recognize static TLS.
 //
 // RUN: %clangxx_asan -DSHARED %s -shared -o %t-so.so -fPIC
 // RUN: %clangxx_asan %s -ldl -pthread -o %t %t-so.so
-// RUN: ASAN_OPTIONS=verbosity=2 %run %t 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=verbosity=2:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s
 
 // CHECK: before
 // CHECK: __tls_get_addr: static tls
 // CHECK: after
 
 // XFAIL: powerpc64
 
 #ifndef SHARED

test/asan/TestCases/Linux/stress_dtls.c

 // REQUIRES: asan-64-bits
 // Stress test dynamic TLS + dlopen + threads.
 //
 // Note that glibc 2.15 seems utterly broken on this test,
 // it fails with ~17 DSOs dlopen-ed.
 // glibc 2.19 seems fine.
 //
 //
 // RUN: %clangxx_asan -x c -DSO_NAME=f0 %s -shared -o %t-f0.so -fPIC
 // RUN: %clangxx_asan -x c -DSO_NAME=f1 %s -shared -o %t-f1.so -fPIC
 // RUN: %clangxx_asan -x c -DSO_NAME=f2 %s -shared -o %t-f2.so -fPIC
 // RUN: %clangxx_asan %s -ldl -pthread -o %t
 // RUN: %run %t 0 3
 // RUN: %run %t 2 3
-// RUN: ASAN_OPTIONS=verbosity=2 %run %t 10 2 2>&1 | FileCheck %s
-// RUN: ASAN_OPTIONS=verbosity=2:intercept_tls_get_addr=1 %run %t 10 2 2>&1 | FileCheck %s
-// RUN: ASAN_OPTIONS=verbosity=2:intercept_tls_get_addr=0 %run %t 10 2 2>&1 | FileCheck %s --check-prefix=CHECK0
+// RUN: ASAN_OPTIONS=verbosity=2:symbolize_vs_style=false %run %t 10 2 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=verbosity=2:intercept_tls_get_addr=1:symbolize_vs_style=false %run %t 10 2 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=verbosity=2:intercept_tls_get_addr=0:symbolize_vs_style=false %run %t 10 2 2>&1 | FileCheck %s --check-prefix=CHECK0
 // CHECK: __tls_get_addr
 // CHECK: Creating thread 0
 // CHECK: __tls_get_addr
 // CHECK: Creating thread 1
 // CHECK: __tls_get_addr
 // CHECK: Creating thread 2
 // CHECK: __tls_get_addr
 // CHECK: Creating thread 3

test/asan/TestCases/Posix/allow_user_segv.cc

 // Regression test for
 // https://code.google.com/p/address-sanitizer/issues/detail?id=180
 
-// RUN: %clangxx_asan -O0 %s -o %t && ASAN_OPTIONS=allow_user_segv_handler=true not %run %t 2>&1 | FileCheck %s
-// RUN: %clangxx_asan -O2 %s -o %t && ASAN_OPTIONS=allow_user_segv_handler=true not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O0 %s -o %t && ASAN_OPTIONS=allow_user_segv_handler=true:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O2 %s -o %t && ASAN_OPTIONS=allow_user_segv_handler=true:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
 
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 struct sigaction original_sigaction_sigbus;
 struct sigaction original_sigaction_sigsegv;
 

test/asan/TestCases/Posix/asan-symbolize-sanity-test.cc

 // FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
 // XFAIL: android
 //
 // Check that asan_symbolize.py script works (for binaries, ASan RTL and
 // shared object files.
 
 // RUN: %clangxx_asan -O0 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
 // RUN: %clangxx_asan -O0 %s %libdl -o %t
-// RUN: env ASAN_OPTIONS=symbolize=0 not %run %t 2>&1 | %asan_symbolize | FileCheck %s
+// RUN: env ASAN_OPTIONS=symbolize=0:symbolize_vs_style=false not %run %t 2>&1 | %asan_symbolize | FileCheck %s
 // XFAIL: arm-linux-gnueabi
 // XFAIL: armv7l-unknown-linux-gnueabihf
 
 #if !defined(SHARED_LIB)
 #include <dlfcn.h>
 #include <stdio.h>
 #include <stdlib.h>
 

test/asan/TestCases/Posix/coverage-direct-activation.cc

 // Test for direct coverage writing enabled at activation time.
 
 // RUN: %clangxx_asan -fsanitize-coverage=func -DSHARED %s -shared -o %dynamiclib -fPIC
 // RUN: %clangxx -c -DSO_DIR=\"%T\" %s -o %t.o
 // RUN: %clangxx_asan -fsanitize-coverage=func %t.o %libdl -o %t
 
 // RUN: rm -rf %T/coverage-direct-activation
 
 // RUN: mkdir -p %T/coverage-direct-activation/normal
-// RUN: ASAN_OPTIONS=coverage=1,coverage_direct=0,coverage_dir=%T/coverage-direct-activation/normal:verbosity=1 %run %t %dynamiclib
+// RUN: ASAN_OPTIONS=coverage=1,coverage_direct=0,coverage_dir=%T/coverage-direct-activation/normal:verbosity=1:symbolize_vs_style=false %run %t %dynamiclib
 // RUN: %sancov print %T/coverage-direct-activation/normal/*.sancov >%T/coverage-direct-activation/normal/out.txt
 
 // RUN: mkdir -p %T/coverage-direct-activation/direct
-// RUN: ASAN_OPTIONS=start_deactivated=1,coverage_direct=1,verbosity=1 \
+// RUN: ASAN_OPTIONS=start_deactivated=1,coverage_direct=1,verbosity=1:symbolize_vs_style=false \
 // RUN:   ASAN_ACTIVATION_OPTIONS=coverage=1,coverage_dir=%T/coverage-direct-activation/direct %run %t %dynamiclib
 // RUN: cd %T/coverage-direct-activation/direct
 // RUN: %sancov rawunpack *.sancov.raw
 // RUN: %sancov print *.sancov >out.txt
 // RUN: cd ../..
 
 // Test start_deactivated=1,coverage=1 in ASAN_OPTIONS.
 
 // RUN: diff -u coverage-direct-activation/normal/out.txt coverage-direct-activation/direct/out.txt
 
 // RUN: mkdir -p %T/coverage-direct-activation/direct2
-// RUN: ASAN_OPTIONS=start_deactivated=1,coverage=1,coverage_direct=1,verbosity=1 \
+// RUN: ASAN_OPTIONS=start_deactivated=1,coverage=1,coverage_direct=1,verbosity=1:symbolize_vs_style=false \
 // RUN:   ASAN_ACTIVATION_OPTIONS=coverage_dir=%T/coverage-direct-activation/direct2 %run %t %dynamiclib
 // RUN: cd %T/coverage-direct-activation/direct2
 // RUN: %sancov rawunpack *.sancov.raw
 // RUN: %sancov print *.sancov >out.txt
 // RUN: cd ../..
 
 // RUN: diff -u coverage-direct-activation/normal/out.txt coverage-direct-activation/direct2/out.txt
 

test/asan/TestCases/Posix/coverage-direct-large.cc

 // Test for direct coverage writing with lots of data.
 // Current implementation maps output file in chunks of 64K. This test overflows
 // 1 chunk.
 
 // RUN: %clangxx_asan -fsanitize-coverage=func -O0 -DSHARED %s -shared -o %dynamiclib -fPIC
 // RUN: %clangxx_asan -fsanitize-coverage=func -O0 %s %libdl -o %t
 
 // RUN: rm -rf %T/coverage-direct-large
 
 // RUN: mkdir -p %T/coverage-direct-large/normal && cd %T/coverage-direct-large/normal
-// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=0:verbosity=1 %run %t %dynamiclib
+// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=0:verbosity=1:symbolize_vs_style=false %run %t %dynamiclib
 // RUN: %sancov print *.sancov >out.txt
 // RUN: cd ../..
 
 // RUN: mkdir -p %T/coverage-direct-large/direct && cd %T/coverage-direct-large/direct
-// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=1:verbosity=1 %run %t %dynamiclib
+// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=1:verbosity=1:symbolize_vs_style=false %run %t %dynamiclib
 // RUN: %sancov rawunpack *.sancov.raw
 // RUN: %sancov print *.sancov >out.txt
 // RUN: cd ../..
 
 // RUN: diff -u coverage-direct-large/normal/out.txt coverage-direct-large/direct/out.txt
 //
 // XFAIL: android
 

test/asan/TestCases/Posix/coverage-direct.cc

 // Test for direct coverage writing with dlopen at coverage level 1 to 3.
 
 // RUN: %clangxx_asan -fsanitize-coverage=func -DSHARED %s -shared -o %dynamiclib -fPIC
 // RUN: %clangxx_asan -fsanitize-coverage=func %s %libdl -o %t
 
 // RUN: rm -rf %T/coverage-direct
 
 // RUN: mkdir -p %T/coverage-direct/normal
-// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=0:coverage_dir=%T/coverage-direct/normal:verbosity=1 %run %t %dynamiclib
+// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=0:coverage_dir=%T/coverage-direct/normal:verbosity=1:symbolize_vs_style=false %run %t %dynamiclib
 // RUN: %sancov print %T/coverage-direct/normal/*.sancov >%T/coverage-direct/normal/out.txt
 
 // RUN: mkdir -p %T/coverage-direct/direct
-// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%T/coverage-direct/direct:verbosity=1 %run %t %dynamiclib
+// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%T/coverage-direct/direct:verbosity=1:symbolize_vs_style=false %run %t %dynamiclib
 // RUN: cd %T/coverage-direct/direct
 // RUN: %sancov rawunpack *.sancov.raw
 // RUN: %sancov print *.sancov >out.txt
 // RUN: cd ../..
 
 // RUN: diff -u coverage-direct/normal/out.txt coverage-direct/direct/out.txt
 
 
 // RUN: %clangxx_asan -fsanitize-coverage=bb -DSHARED %s -shared -o %dynamiclib -fPIC
 // RUN: %clangxx_asan -fsanitize-coverage=bb -DSO_DIR=\"%T\" %s %libdl -o %t
 
 // RUN: rm -rf %T/coverage-direct
 
 // RUN: mkdir -p %T/coverage-direct/normal
-// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=0:coverage_dir=%T/coverage-direct/normal:verbosity=1 %run %t %dynamiclib
+// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=0:coverage_dir=%T/coverage-direct/normal:verbosity=1:symbolize_vs_style=false %run %t %dynamiclib
 // RUN: %sancov print %T/coverage-direct/normal/*.sancov >%T/coverage-direct/normal/out.txt
 
 // RUN: mkdir -p %T/coverage-direct/direct
-// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%T/coverage-direct/direct:verbosity=1 %run %t %dynamiclib
+// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%T/coverage-direct/direct:verbosity=1:symbolize_vs_style=false %run %t %dynamiclib
 // RUN: cd %T/coverage-direct/direct
 // RUN: %sancov rawunpack *.sancov.raw
 // RUN: %sancov print *.sancov >out.txt
 // RUN: cd ../..
 
 // RUN: diff -u coverage-direct/normal/out.txt coverage-direct/direct/out.txt
 
 
 // RUN: %clangxx_asan -fsanitize-coverage=edge -DSHARED %s -shared -o %dynamiclib -fPIC
 // RUN: %clangxx_asan -fsanitize-coverage=edge -DSO_DIR=\"%T\" %s %libdl -o %t
 
 // RUN: rm -rf %T/coverage-direct
 
 // RUN: mkdir -p %T/coverage-direct/normal
-// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=0:coverage_dir=%T/coverage-direct/normal:verbosity=1 %run %t %dynamiclib
+// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=0:coverage_dir=%T/coverage-direct/normal:verbosity=1:symbolize_vs_style=false %run %t %dynamiclib
 // RUN: %sancov print %T/coverage-direct/normal/*.sancov >%T/coverage-direct/normal/out.txt
 
 // RUN: mkdir -p %T/coverage-direct/direct
-// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%T/coverage-direct/direct:verbosity=1 %run %t %dynamiclib
+// RUN: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%T/coverage-direct/direct:verbosity=1:symbolize_vs_style=false %run %t %dynamiclib
 // RUN: cd %T/coverage-direct/direct
 // RUN: %sancov rawunpack *.sancov.raw
 // RUN: %sancov print *.sancov >out.txt
 // RUN: cd ../..
 
 // RUN: diff -u coverage-direct/normal/out.txt coverage-direct/direct/out.txt
 
 // XFAIL: android

test/asan/TestCases/Posix/coverage-fork-direct.cc

 // RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t
 // RUN: rm -rf %T/coverage-fork-direct
 // RUN: mkdir -p %T/coverage-fork-direct && cd %T/coverage-fork-direct
-// RUN: (ASAN_OPTIONS=coverage=1:coverage_direct=1:verbosity=1 %run %t; \
+// RUN: (ASAN_OPTIONS=coverage=1:coverage_direct=1:verbosity=1:symbolize_vs_style=false %run %t; \
 // RUN:  %sancov rawunpack *.sancov.raw; %sancov print *.sancov) 2>&1
 //
 // XFAIL: android
 
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
 

test/asan/TestCases/Posix/coverage-fork.cc

 // RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t
-// RUN: export ASAN_OPTIONS=coverage=1:coverage_direct=0:verbosity=1
+// RUN: export ASAN_OPTIONS=coverage=1:coverage_direct=0:verbosity=1:symbolize_vs_style=false
 // RUN: rm -rf %T/coverage-fork
 // RUN: mkdir -p %T/coverage-fork && cd %T/coverage-fork
 // RUN: %run %t 2>&1 | FileCheck %s
 //
 // XFAIL: android
 
 #include <stdio.h>
 #include <string.h>

test/asan/TestCases/Posix/coverage-module-unloaded.cc

 // Check that unloading a module doesn't break coverage dumping for remaining
 // modules.
 // RUN: %clangxx_asan -fsanitize-coverage=func -DSHARED %s -shared -o %dynamiclib1 -fPIC
 // RUN: %clangxx_asan -fsanitize-coverage=func -DSHARED %s -shared -o %dynamiclib2 -fPIC
 // RUN: %clangxx_asan -fsanitize-coverage=func %s %libdl -o %t
-// RUN: export ASAN_OPTIONS=coverage=1:verbosity=1
+// RUN: export ASAN_OPTIONS=coverage=1:verbosity=1:symbolize_vs_style=false
 // RUN: mkdir -p %T/coverage-module-unloaded && cd %T/coverage-module-unloaded
 // RUN: %run %t %dynamiclib1 %dynamiclib2 2>&1        | FileCheck %s
 // RUN: %run %t %dynamiclib1 %dynamiclib2 foo 2>&1    | FileCheck %s
 // RUN: rm -r %T/coverage-module-unloaded
 //
 // https://code.google.com/p/address-sanitizer/issues/detail?id=263
 // XFAIL: android
 

test/asan/TestCases/Posix/coverage-sandboxing.cc

 // RUN: %clangxx_asan -fsanitize-coverage=bb -DSHARED %s -shared -o %dynamiclib -fPIC %ld_flags_rpath_so
 // RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t %ld_flags_rpath_exe
-// RUN: export ASAN_OPTIONS=coverage=1:verbosity=1
+// RUN: export ASAN_OPTIONS=coverage=1:verbosity=1:symbolize_vs_style=false
 // RUN: rm -rf %T/coverage_sandboxing_test
 // RUN: mkdir %T/coverage_sandboxing_test && cd %T/coverage_sandboxing_test
 // RUN: mkdir vanilla && cd vanilla
 // RUN: %run %t 2>&1         | FileCheck %s --check-prefix=CHECK-vanilla
 // RUN: mkdir ../sandbox1 && cd ../sandbox1
 // RUN: %run %t a 2>&1       | FileCheck %s --check-prefix=CHECK-sandbox
 // RUN: %sancov unpack coverage_sandboxing_test.sancov.packed 
 // RUN: mkdir ../sandbox2 && cd ../sandbox2

test/asan/TestCases/Posix/coverage.cc

 // RUN: %clangxx_asan -fsanitize-coverage=func -DSHARED %s -shared -o %dynamiclib -fPIC %ld_flags_rpath_so
 // RUN: %clangxx_asan -fsanitize-coverage=func %s %ld_flags_rpath_exe -o %t
-// RUN: export ASAN_OPTIONS=coverage=1:verbosity=1
+// RUN: export ASAN_OPTIONS=coverage=1:verbosity=1:symbolize_vs_style=false
 // RUN: rm -rf %T/coverage && mkdir -p %T/coverage && cd %T/coverage
 // RUN: %run %t 2>&1         | FileCheck %s --check-prefix=CHECK-main
 // RUN: %sancov print `ls coverage.*sancov | grep -v '.so'` 2>&1 | FileCheck %s --check-prefix=CHECK-SANCOV1
 // RUN: %run %t foo 2>&1     | FileCheck %s --check-prefix=CHECK-foo
 // RUN: %sancov print `ls coverage.*sancov | grep -v '.so'` 2>&1 | FileCheck %s --check-prefix=CHECK-SANCOV2
 // RUN: %run %t bar 2>&1     | FileCheck %s --check-prefix=CHECK-bar
 // RUN: %sancov print `ls *coverage.*sancov | grep -v '.so'` 2>&1 | FileCheck %s --check-prefix=CHECK-SANCOV2
 // RUN: %run %t foo bar 2>&1 | FileCheck %s --check-prefix=CHECK-foo-bar

test/asan/TestCases/Posix/ioctl.cc

-// RUN: %clangxx_asan -O0 -g %s -o %t && ASAN_OPTIONS=handle_ioctl=1 not %run %t 2>&1 | FileCheck %s
-// RUN: %clangxx_asan -O3 -g %s -o %t && ASAN_OPTIONS=handle_ioctl=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O0 -g %s -o %t && ASAN_OPTIONS=handle_ioctl=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 -g %s -o %t && ASAN_OPTIONS=handle_ioctl=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
 
 // RUN: %clangxx_asan -O0 -g %s -o %t && %run %t
 // RUN: %clangxx_asan -O3 -g %s -o %t && %run %t
 
 #include <assert.h>
 #include <stdlib.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>

test/asan/TestCases/Posix/large_allocator_unpoisons_on_free.cc

 // Test that LargeAllocator unpoisons memory before releasing it to the OS.
 // RUN: %clangxx_asan %s -o %t
 // The memory is released only when the deallocated chunk leaves the quarantine,
 // otherwise the mmap(p, ...) call overwrites the malloc header.
-// RUN: ASAN_OPTIONS=quarantine_size_mb=0 %run %t
+// RUN: ASAN_OPTIONS=quarantine_size_mb=0:symbolize_vs_style=false %run %t
 
 #include <assert.h>
 #include <string.h>
 #include <sys/mman.h>
 #include <stdlib.h>
 #include <unistd.h>
 
 #ifdef __ANDROID__

test/asan/TestCases/Posix/log_path_fork_test.cc.disabled

 // RUN: %clangxx_asan  %s -o %t
 // RUN: rm -f %t.log.*
 // Set verbosity to 1 so that the log files are opened prior to fork().
-// RUN: env ASAN_OPTIONS="log_path=%t.log verbosity=1" not %run %t 2> %t.out
+// RUN: env ASAN_OPTIONS="log_path=%t.log:symbolize_vs_style=false verbosity=1" not %run %t 2> %t.out
 // RUN: for f in %t.log.* ; do FileCheck %s < $f; done
 // RUN: [ `ls %t.log.* | wc -l` == 2 ]
 
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 int main(int argc, char **argv) {

test/asan/TestCases/Posix/new_array_cookie_test.cc

 // REQUIRES: asan-64-bits
 // RUN: %clangxx_asan -O3 %s -o %t
 // RUN:                                    not %run %t 2>&1  | FileCheck %s
-// RUN: ASAN_OPTIONS=poison_array_cookie=1 not %run %t 2>&1  | FileCheck %s
-// RUN: ASAN_OPTIONS=poison_array_cookie=0 not %run %t 2>&1  | FileCheck %s --check-prefix=NO_COOKIE
+// RUN: ASAN_OPTIONS=poison_array_cookie=1:symbolize_vs_style=false not %run %t 2>&1  | FileCheck %s
+// RUN: ASAN_OPTIONS=poison_array_cookie=0:symbolize_vs_style=false not %run %t 2>&1  | FileCheck %s --check-prefix=NO_COOKIE
 #include <stdio.h>
 #include <stdlib.h>
 struct C {
   int x;
   ~C() {
     fprintf(stderr, "ZZZZZZZZ\n");
     exit(1);
   }

test/asan/TestCases/Posix/new_array_cookie_uaf_test.cc

 // REQUIRES: asan-64-bits
 // RUN: %clangxx_asan -O3 %s -o %t
-// RUN: ASAN_OPTIONS=poison_array_cookie=1 not %run %t 2>&1  | FileCheck %s --check-prefix=COOKIE
-// RUN: ASAN_OPTIONS=poison_array_cookie=0 not %run %t 2>&1  | FileCheck %s --check-prefix=NO_COOKIE
+// RUN: ASAN_OPTIONS=poison_array_cookie=1:symbolize_vs_style=false not %run %t 2>&1  | FileCheck %s --check-prefix=COOKIE
+// RUN: ASAN_OPTIONS=poison_array_cookie=0:symbolize_vs_style=false not %run %t 2>&1  | FileCheck %s --check-prefix=NO_COOKIE
 #include <stdio.h>
 #include <stdlib.h>
 #include <assert.h>
 int dtor_counter;
 struct C {
   int x;
   ~C() {
     dtor_counter++;

test/asan/TestCases/Posix/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 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
 // RUN: %clangxx -O0 %s -c -o %t.o
 // RUN: %clangxx_asan -O0 %t.o %libdl -o %t
-// RUN: ASAN_OPTIONS=start_deactivated=1,allocator_may_return_null=0 \
+// RUN: ASAN_OPTIONS=start_deactivated=1,allocator_may_return_null=0:symbolize_vs_style=false \
 // RUN:   ASAN_ACTIVATION_OPTIONS=allocator_may_return_null=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK
-// RUN: ASAN_OPTIONS=start_deactivated=1 \
+// RUN: ASAN_OPTIONS=start_deactivated=1:symbolize_vs_style=false \
 // RUN:   ASAN_ACTIVATION_OPTIONS=help=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-HELP
-// RUN: ASAN_OPTIONS=start_deactivated=1,verbosity=1 \
+// RUN: ASAN_OPTIONS=start_deactivated=1,verbosity=1:symbolize_vs_style=false \
 // RUN:   ASAN_ACTIVATION_OPTIONS=help=1,handle_segv=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-UNSUPPORTED
-// RUN: ASAN_OPTIONS=start_deactivated=1 \
+// RUN: ASAN_OPTIONS=start_deactivated=1:symbolize_vs_style=false \
 // RUN:   ASAN_ACTIVATION_OPTIONS=help=1,handle_segv=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-UNSUPPORTED-V0
 
 // Check that verbosity=1 in activation flags affects reporting of unrecognized activation flags.
-// RUN: ASAN_OPTIONS=start_deactivated=1 \
+// RUN: ASAN_OPTIONS=start_deactivated=1:symbolize_vs_style=false \
 // RUN:   ASAN_ACTIVATION_OPTIONS=help=1,handle_segv=0,verbosity=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-UNSUPPORTED
 
 // XFAIL: arm-linux-gnueabi
 
 #if !defined(SHARED_LIB)
 #include <assert.h>
 #include <dlfcn.h>
 #include <stdio.h>

test/asan/TestCases/Posix/tsd_dtor_leak.cc

 // Regression test for a leak in tsd:
 // https://code.google.com/p/address-sanitizer/issues/detail?id=233
 // RUN: %clangxx_asan -O1 %s -pthread -o %t
-// RUN: ASAN_OPTIONS=quarantine_size_mb=0 %run %t
+// RUN: ASAN_OPTIONS=quarantine_size_mb=0:symbolize_vs_style=false %run %t
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <assert.h>
 #include <sanitizer/allocator_interface.h>
 
 static pthread_key_t tsd_key;
 

test/asan/TestCases/Windows/coverage-basic.cc

 // RUN: rm -rf %T/coverage-basic
 // RUN: mkdir %T/coverage-basic && cd %T/coverage-basic
 // RUN: %clangxx_asan -fsanitize-coverage=func %s -o test.exe
-// RUN: env ASAN_OPTIONS=coverage=1 %run ./test.exe
+// RUN: env ASAN_OPTIONS=coverage=1:symbolize_vs_style=false %run ./test.exe
 //
 // RUN: %sancov print *.sancov | FileCheck %s
 #include <stdio.h>
 
 void foo() { fprintf(stderr, "FOO\n"); }
 void bar() { fprintf(stderr, "BAR\n"); }
 
 int main(int argc, char **argv) {

test/asan/TestCases/Windows/dll_report_globals_symbolization_at_startup.cc

 // RUN: %clang_cl_asan -LD -O0 -DDLL %s -Fe%t.dll
 // RUN: %clang_cl_asan -O0 -DEXE %s %t.lib -Fe%te.exe
-// RUN: env ASAN_OPTIONS=report_globals=2 %run %te.exe 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS=report_globals=2:symbolize_vs_style=false %run %te.exe 2>&1 | FileCheck %s
 
 // FIXME: Currently, the MT runtime build crashes on startup due to dbghelp.dll
 // initialization failure.
 // REQUIRES: asan-dynamic-runtime
 
 #include <windows.h>
 #include <stdio.h>
 

test/asan/TestCases/Windows/dll_stack_use_after_return.cc

 // RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
 // RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll
-// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=1 not %run %t %t.dll 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=1:symbolize_vs_style=false not %run %t %t.dll 2>&1 | FileCheck %s
 
 #include <malloc.h>
 
 char *x;
 
 void foo() {
   char stack_buffer[42];
   x = &stack_buffer[13];

test/asan/TestCases/Windows/report_globals_reload_dll.cc

 // Make sure we can handle reloading the same DLL multiple times.
 // RUN: %clang_cl_asan -LD -O0 -DDLL %s -Fe%t.dll
 // RUN: %clang_cl_asan -O0 -DEXE %s -Fe%te.exe
-// RUN: env ASAN_OPTIONS=report_globals=1 %run %te.exe %t.dll 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS=report_globals=1:symbolize_vs_style=false:symbolize_vs_style=false %run %te.exe %t.dll 2>&1 | FileCheck %s
 
 #include <windows.h>
 #include <stdio.h>
 #include <string.h>
 
 extern "C" {
 #if defined(EXE)
 int main(int argc, char **argv) {

test/asan/TestCases/Windows/report_globals_vs_freelibrary.cc

 // RUN: %clang_cl_asan -LD -O0 -DDLL %s -Fe%t.dll
 // RUN: %clang_cl_asan -O0 -DEXE %s -Fe%te.exe
-// RUN: env ASAN_OPTIONS=report_globals=2 %run %te.exe %t.dll 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS=report_globals=2:symbolize_vs_style=false %run %te.exe %t.dll 2>&1 | FileCheck %s
 
 #include <windows.h>
 #include <stdio.h>
 #include <string.h>
 
 extern "C" {
 #if defined(EXE)
 int main(int argc, char **argv) {

test/asan/TestCases/Windows/stack_use_after_return.cc

 // RUN: %clang_cl_asan -O0 %s -Fe%t
-// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=1 not %run %t 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
 
 char *x;
 
 void foo() {
   char stack_buffer[42];
   x = &stack_buffer[13];
 }
 

test/asan/TestCases/allocator_returns_null.cc

 // Test the behavior of malloc/calloc/realloc when the allocation size is huge.
 // By default (allocator_may_return_null=0) the process should crash.
 // With allocator_may_return_null=1 the allocator should return 0.
 //
 // RUN: %clangxx_asan -O0 %s -o %t
 // RUN: not %run %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mCRASH
-// RUN: env ASAN_OPTIONS=allocator_may_return_null=0 not %run %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mCRASH
-// RUN: env ASAN_OPTIONS=allocator_may_return_null=1     %run %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mNULL
-// RUN: env ASAN_OPTIONS=allocator_may_return_null=0 not %run %t calloc 2>&1 | FileCheck %s --check-prefix=CHECK-cCRASH
-// RUN: env ASAN_OPTIONS=allocator_may_return_null=1     %run %t calloc 2>&1 | FileCheck %s --check-prefix=CHECK-cNULL
-// RUN: env ASAN_OPTIONS=allocator_may_return_null=0 not %run %t calloc-overflow 2>&1 | FileCheck %s --check-prefix=CHECK-coCRASH
-// RUN: env ASAN_OPTIONS=allocator_may_return_null=1     %run %t calloc-overflow 2>&1 | FileCheck %s --check-prefix=CHECK-coNULL
-// RUN: env ASAN_OPTIONS=allocator_may_return_null=0 not %run %t realloc 2>&1 | FileCheck %s --check-prefix=CHECK-rCRASH
-// RUN: env ASAN_OPTIONS=allocator_may_return_null=1     %run %t realloc 2>&1 | FileCheck %s --check-prefix=CHECK-rNULL
-// RUN: env ASAN_OPTIONS=allocator_may_return_null=0 not %run %t realloc-after-malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mrCRASH
-// RUN: env ASAN_OPTIONS=allocator_may_return_null=1     %run %t realloc-after-malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mrNULL
+// RUN: env ASAN_OPTIONS=allocator_may_return_null=0:symbolize_vs_style=false not %run %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mCRASH
+// RUN: env ASAN_OPTIONS=allocator_may_return_null=1:symbolize_vs_style=false     %run %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mNULL
+// RUN: env ASAN_OPTIONS=allocator_may_return_null=0:symbolize_vs_style=false not %run %t calloc 2>&1 | FileCheck %s --check-prefix=CHECK-cCRASH
+// RUN: env ASAN_OPTIONS=allocator_may_return_null=1:symbolize_vs_style=false     %run %t calloc 2>&1 | FileCheck %s --check-prefix=CHECK-cNULL
+// RUN: env ASAN_OPTIONS=allocator_may_return_null=0:symbolize_vs_style=false not %run %t calloc-overflow 2>&1 | FileCheck %s --check-prefix=CHECK-coCRASH
+// RUN: env ASAN_OPTIONS=allocator_may_return_null=1:symbolize_vs_style=false     %run %t calloc-overflow 2>&1 | FileCheck %s --check-prefix=CHECK-coNULL
+// RUN: env ASAN_OPTIONS=allocator_may_return_null=0:symbolize_vs_style=false not %run %t realloc 2>&1 | FileCheck %s --check-prefix=CHECK-rCRASH
+// RUN: env ASAN_OPTIONS=allocator_may_return_null=1:symbolize_vs_style=false     %run %t realloc 2>&1 | FileCheck %s --check-prefix=CHECK-rNULL
+// RUN: env ASAN_OPTIONS=allocator_may_return_null=0:symbolize_vs_style=false not %run %t realloc-after-malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mrCRASH
+// RUN: env ASAN_OPTIONS=allocator_may_return_null=1:symbolize_vs_style=false     %run %t realloc-after-malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mrNULL
 
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <assert.h>
 #include <limits>
 int main(int argc, char **argv) {

test/asan/TestCases/asan_and_llvm_coverage_test.cc

 // RUN: %clangxx_asan -coverage -O0 %s -o %t
-// RUN: env ASAN_OPTIONS=check_initialization_order=1 %run %t 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS=check_initialization_order=1:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s
 // XFAIL: android
 #include <stdio.h>
 int foo() { return 1; }
 int XXX = foo();
 int main() {
   printf("PASS\n");
 // CHECK: PASS
 }

test/asan/TestCases/asan_options-help.cc

 // RUN: %clangxx_asan -O0 %s -o %t
-// RUN: ASAN_OPTIONS=help=1 %run %t 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=help=1:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s
 
 int main() {
 }
 
 // CHECK: Available flags for AddressSanitizer:
 // CHECK-DAG: handle_segv
 // CHECK-DAG: check_initialization_order

test/asan/TestCases/atexit_stats.cc

 // Make sure we report atexit stats.
 // RUN: %clangxx_asan -O3 %s -o %t
-// RUN: env ASAN_OPTIONS=atexit=1:print_stats=1 %run %t 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS=atexit=1:print_stats=1:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s
 //
 // No atexit output on Android due to
 // https://code.google.com/p/address-sanitizer/issues/detail?id=263
 // XFAIL: android
 
 #include <stdlib.h>
 #if !defined(__APPLE__) && !defined(__FreeBSD__)
 #include <malloc.h>
 #endif
 int *p1 = (int*)malloc(900);
 int *p2 = (int*)malloc(90000);
 int *p3 = (int*)malloc(9000000);
 int main() { }
 
 // CHECK: AddressSanitizer exit stats:

test/asan/TestCases/closed-fds.cc

 // Check that when the program closed its std(in|out|err), running the external
 // symbolizer still works.
 
 // RUN: rm -f %t.log.*
-// RUN: %clangxx_asan -O0 %s -o %t 2>&1 && ASAN_OPTIONS=log_path=%t.log:verbosity=2 not %run %t 2>&1
+// RUN: %clangxx_asan -O0 %s -o %t 2>&1 && ASAN_OPTIONS=log_path=%t.log:verbosity=2:symbolize_vs_style=false not %run %t 2>&1
 // RUN: FileCheck %s --check-prefix=CHECK-FILE < %t.log.*
 
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 

test/asan/TestCases/contiguous_container_crash.cc

 // RUN: %clangxx_asan -O %s -o %t
 // RUN: not %run %t crash 2>&1 | FileCheck --check-prefix=CHECK-CRASH %s
 // RUN: not %run %t bad-bounds 2>&1 | FileCheck --check-prefix=CHECK-BAD-BOUNDS %s
 // RUN: not %run %t bad-alignment 2>&1 | FileCheck --check-prefix=CHECK-BAD-ALIGNMENT %s
-// RUN: env ASAN_OPTIONS=detect_container_overflow=0 %run %t crash
+// RUN: env ASAN_OPTIONS=detect_container_overflow=0:symbolize_vs_style=false %run %t crash
 //
 // Test crash due to __sanitizer_annotate_contiguous_container.
 
 #include <assert.h>
 #include <string.h>
 
 extern "C" {
 void __sanitizer_annotate_contiguous_container(const void *beg, const void *end,

test/asan/TestCases/coverage-and-lsan.cc

 // Make sure coverage is dumped even if there are reported leaks.
 //
 // RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t
 //
 // RUN: rm -rf %T/coverage-and-lsan
 //
 // RUN: mkdir -p %T/coverage-and-lsan/normal
-// RUN: ASAN_OPTIONS=coverage=1:coverage_dir=%T/coverage-and-lsan:verbosity=1 not %run %t 2>&1 | FileCheck %s
+// RUN: ASAN_OPTIONS=coverage=1:coverage_dir=%T/coverage-and-lsan:verbosity=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
 // RUN: %sancov print %T/coverage-and-lsan/*.sancov 2>&1
 //
 // REQUIRES: leak-detection
 
 int *g = new int;
 int main(int argc, char **argv) {
   g = 0;
   return 0;
 }
 
 // CHECK: LeakSanitizer: detected memory leaks
 // CHECK: CovDump:

test/asan/TestCases/coverage-caller-callee-total-count.cc

 // Test __sanitizer_get_total_unique_coverage for caller-callee coverage
 
 // RUN: %clangxx_asan -fsanitize-coverage=edge,indirect-calls %s -o %t
-// RUN: ASAN_OPTIONS=coverage=1 %run %t
+// RUN: ASAN_OPTIONS=coverage=1:symbolize_vs_style=false %run %t
 // RUN: rm -f caller-callee*.sancov
 //
 // REQUIRES: asan-64-bits
 
 #include <sanitizer/coverage_interface.h>
 #include <stdio.h>
 #include <assert.h>
 int P = 0;

test/asan/TestCases/coverage-caller-callee.cc

 // Test caller-callee coverage with large number of threads
 // and various numbers of callers and callees.
 
 // RUN: %clangxx_asan -fsanitize-coverage=edge,indirect-calls %s -o %t
-// RUN: ASAN_OPTIONS=coverage=1:verbosity=1 %run %t 10 1 2>&1 | FileCheck %s --check-prefix=CHECK-10-1
-// RUN: ASAN_OPTIONS=coverage=1:verbosity=1 %run %t 9  2 2>&1 | FileCheck %s --check-prefix=CHECK-9-2
-// RUN: ASAN_OPTIONS=coverage=1:verbosity=1 %run %t 7  3 2>&1 | FileCheck %s --check-prefix=CHECK-7-3
-// RUN: ASAN_OPTIONS=coverage=1:verbosity=1 %run %t 17 1 2>&1 | FileCheck %s --check-prefix=CHECK-17-1
-// RUN: ASAN_OPTIONS=coverage=1:verbosity=1 %run %t 15 2 2>&1 | FileCheck %s --check-prefix=CHECK-15-2
-// RUN: ASAN_OPTIONS=coverage=1:verbosity=1 %run %t 18 3 2>&1 | FileCheck %s --check-prefix=CHECK-18-3
+// RUN: ASAN_OPTIONS=coverage=1:verbosity=1:symbolize_vs_style=false %run %t 10 1 2>&1 | FileCheck %s --check-prefix=CHECK-10-1
+// RUN: ASAN_OPTIONS=coverage=1:verbosity=1:symbolize_vs_style=false %run %t 9  2 2>&1 | FileCheck %s --check-prefix=CHECK-9-2
+// RUN: ASAN_OPTIONS=coverage=1:verbosity=1:symbolize_vs_style=false %run %t 7  3 2>&1 | FileCheck %s --check-prefix=CHECK-7-3
+// RUN: ASAN_OPTIONS=coverage=1:verbosity=1:symbolize_vs_style=false %run %t 17 1 2>&1 | FileCheck %s --check-prefix=CHECK-17-1
+// RUN: ASAN_OPTIONS=coverage=1:verbosity=1:symbolize_vs_style=false %run %t 15 2 2>&1 | FileCheck %s --check-prefix=CHECK-15-2
+// RUN: ASAN_OPTIONS=coverage=1:verbosity=1:symbolize_vs_style=false %run %t 18 3 2>&1 | FileCheck %s --check-prefix=CHECK-18-3
 // RUN: rm -f caller-callee*.sancov
 //
 // REQUIRES: asan-64-bits
 //
 // CHECK-10-1: CovDump: 10 caller-callee pairs written
 // CHECK-9-2: CovDump: 18 caller-callee pairs written
 // CHECK-7-3: CovDump: 21 caller-callee pairs written
 // CHECK-17-1: CovDump: 14 caller-callee pairs written

test/asan/TestCases/coverage-disabled.cc

 // Test that no data is collected without a runtime flag.
 //
 // RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t
 //
 // RUN: rm -rf %T/coverage-disabled
 //
 // RUN: mkdir -p %T/coverage-disabled/normal
-// RUN: ASAN_OPTIONS=coverage_direct=0:coverage_dir=%T/coverage-disabled/normal:verbosity=1 %run %t
+// RUN: ASAN_OPTIONS=coverage_direct=0:coverage_dir=%T/coverage-disabled/normal:verbosity=1:symbolize_vs_style=false %run %t
 // RUN: not %sancov print %T/coverage-disabled/normal/*.sancov 2>&1
 //
 // RUN: mkdir -p %T/coverage-disabled/direct
-// RUN: ASAN_OPTIONS=coverage_direct=1:coverage_dir=%T/coverage-disabled/direct:verbosity=1 %run %t
+// RUN: ASAN_OPTIONS=coverage_direct=1:coverage_dir=%T/coverage-disabled/direct:verbosity=1:symbolize_vs_style=false %run %t
 // RUN: cd %T/coverage-disabled/direct
 // RUN: not %sancov rawunpack *.sancov
 //
 // XFAIL: android
 
 int main(int argc, char **argv) {
   return 0;
 }

test/asan/TestCases/coverage-levels.cc

 // Test various levels of coverage
 //
 // RUN: %clangxx_asan -O1 -fsanitize-coverage=func  %s -o %t
-// RUN: ASAN_OPTIONS=coverage=1:coverage_bitset=1:verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK1
+// RUN: ASAN_OPTIONS=coverage=1:coverage_bitset=1:verbosity=1:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s --check-prefix=CHECK1
 // RUN: %clangxx_asan -O1 -fsanitize-coverage=bb  %s -o %t
-// RUN: ASAN_OPTIONS=coverage=1:coverage_bitset=1:verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK2
+// RUN: ASAN_OPTIONS=coverage=1:coverage_bitset=1:verbosity=1:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s --check-prefix=CHECK2
 // RUN: %clangxx_asan -O1 -fsanitize-coverage=edge  %s -o %t
-// RUN: ASAN_OPTIONS=coverage=1:coverage_bitset=1:verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK3
+// RUN: ASAN_OPTIONS=coverage=1:coverage_bitset=1:verbosity=1:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s --check-prefix=CHECK3
 // RUN: %clangxx_asan -O1 -fsanitize-coverage=edge -mllvm -sanitizer-coverage-block-threshold=0 %s -o %t
-// RUN: ASAN_OPTIONS=coverage=1:coverage_bitset=1:verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK3
+// RUN: ASAN_OPTIONS=coverage=1:coverage_bitset=1:verbosity=1:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s --check-prefix=CHECK3
 // RUN: %clangxx_asan -O1 -fsanitize-coverage=edge,8bit-counters %s -o %t
-// RUN: ASAN_OPTIONS=coverage=1:coverage_counters=1:verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK_COUNTERS
+// RUN: ASAN_OPTIONS=coverage=1:coverage_counters=1:verbosity=1:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s --check-prefix=CHECK_COUNTERS
 
-// RUN: ASAN_OPTIONS=coverage=1:coverage_bitset=0:verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK3_NOBITSET
-// RUN: ASAN_OPTIONS=coverage=1:verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK3_NOBITSET
-// RUN: ASAN_OPTIONS=coverage=1:coverage_pcs=0:verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK3_NOPCS
+// RUN: ASAN_OPTIONS=coverage=1:coverage_bitset=0:verbosity=1:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s --check-prefix=CHECK3_NOBITSET
+// RUN: ASAN_OPTIONS=coverage=1:verbosity=1:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s --check-prefix=CHECK3_NOBITSET
+// RUN: ASAN_OPTIONS=coverage=1:coverage_pcs=0:verbosity=1:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s --check-prefix=CHECK3_NOPCS
 //
 // REQUIRES: asan-64-bits
 
 volatile int sink;
 int main(int argc, char **argv) {
   if (argc == 0)
     sink = 0;
 }

test/asan/TestCases/coverage-maybe-open-file.cc

 // FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
 // XFAIL: android
 //
 // RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t
 // RUN: rm -rf %T/coverage-maybe-open-file
 // RUN: mkdir -p %T/coverage-maybe-open-file && cd %T/coverage-maybe-open-file
-// RUN: ASAN_OPTIONS=coverage=1 %run %t | FileCheck %s --check-prefix=CHECK-success
-// RUN: ASAN_OPTIONS=coverage=0 %run %t | FileCheck %s --check-prefix=CHECK-fail
+// RUN: ASAN_OPTIONS=coverage=1:symbolize_vs_style=false %run %t | FileCheck %s --check-prefix=CHECK-success
+// RUN: ASAN_OPTIONS=coverage=0:symbolize_vs_style=false %run %t | FileCheck %s --check-prefix=CHECK-fail
 // RUN: [ "$(cat test.sancov.packed)" == "test" ]
 // RUN: cd .. && rm -rf %T/coverage-maybe-open-file
 
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
 
 #include <sanitizer/coverage_interface.h>

test/asan/TestCases/coverage-order-pcs.cc

 // Test coverage_order_pcs=1 flag which orders the PCs by their appearance.
 // RUN: DIR=%T/coverage-order-pcs
 // RUN: rm -rf $DIR
 // RUN: mkdir $DIR
 // RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t
-// RUN: ASAN_OPTIONS=coverage_dir=$DIR:coverage=1:coverage_order_pcs=0 %run %t
+// RUN: ASAN_OPTIONS=coverage_dir=$DIR:coverage=1:coverage_order_pcs=0:symbolize_vs_style=false %run %t
 // RUN: mv $DIR/*sancov $DIR/A
 
-// RUN: ASAN_OPTIONS=coverage_dir=$DIR:coverage=1:coverage_order_pcs=0 %run %t 1
+// RUN: ASAN_OPTIONS=coverage_dir=$DIR:coverage=1:coverage_order_pcs=0:symbolize_vs_style=false %run %t 1
 // RUN: mv $DIR/*sancov $DIR/B
 
-// RUN: ASAN_OPTIONS=coverage_dir=$DIR:coverage=1:coverage_order_pcs=1 %run %t
+// RUN: ASAN_OPTIONS=coverage_dir=$DIR:coverage=1:coverage_order_pcs=1:symbolize_vs_style=false %run %t
 // RUN: mv $DIR/*sancov $DIR/C
 
-// RUN: ASAN_OPTIONS=coverage_dir=$DIR:coverage=1:coverage_order_pcs=1 %run %t 1
+// RUN: ASAN_OPTIONS=coverage_dir=$DIR:coverage=1:coverage_order_pcs=1:symbolize_vs_style=false %run %t 1
 // RUN: mv $DIR/*sancov $DIR/D
 //
 // RUN: (%sancov print $DIR/A; %sancov print $DIR/B; %sancov print $DIR/C; %sancov print $DIR/D) | FileCheck %s
 //
 // RUN: rm -rf $DIR
 // Ordering works only in 64-bit mode for now.
 // REQUIRES: asan-64-bits
 #include <stdio.h>

test/asan/TestCases/coverage-reset.cc

 // Test __sanitizer_reset_coverage().
 
 // RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t
-// RUN: ASAN_OPTIONS=coverage=1 %run %t
+// RUN: ASAN_OPTIONS=coverage=1:symbolize_vs_style=false %run %t
 
 #include <sanitizer/coverage_interface.h>
 #include <stdio.h>
 #include <assert.h>
 static volatile int sink;
 __attribute__((noinline)) void bar() { sink = 2; }
 __attribute__((noinline)) void foo() { sink = 1; }
 

test/asan/TestCases/coverage-tracing.cc

 // Test -fsanitize-coverage=trace-bb
 //
 // RUN: %clangxx_asan -O1 -fsanitize-coverage=func,trace-bb %s -o %t
 // RUN: rm -rf   %T/coverage-tracing
 // RUN: mkdir %T/coverage-tracing
 // RUN: cd %T/coverage-tracing
-// RUN:  A=x;   ASAN_OPTIONS=coverage=1:verbosity=1 %run %t $A 1   2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK1; mv trace-points.*.sancov $A.points
-// RUN:  A=f;   ASAN_OPTIONS=coverage=1:verbosity=1 %run %t $A 1   2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK2; mv trace-points.*.sancov $A.points
-// RUN:  A=b;   ASAN_OPTIONS=coverage=1:verbosity=1 %run %t $A 1   2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK2; mv trace-points.*.sancov $A.points
-// RUN:  A=bf;  ASAN_OPTIONS=coverage=1:verbosity=1 %run %t $A 1   2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK3; mv trace-points.*.sancov $A.points
-// RUN:  A=fb;  ASAN_OPTIONS=coverage=1:verbosity=1 %run %t $A 1   2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK3; mv trace-points.*.sancov $A.points
-// RUN:  A=ffb; ASAN_OPTIONS=coverage=1:verbosity=1 %run %t $A 1   2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK4; mv trace-points.*.sancov $A.points
-// RUN:  A=fff; ASAN_OPTIONS=coverage=1:verbosity=1 %run %t $A 1   2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK4; mv trace-points.*.sancov $A.points
-// RUN:  A=bbf; ASAN_OPTIONS=coverage=1:verbosity=1 %run %t $A 100 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK301; mv trace-points.*.sancov $A.points
+// RUN:  A=x;   ASAN_OPTIONS=coverage=1:verbosity=1:symbolize_vs_style=false %run %t $A 1   2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK1; mv trace-points.*.sancov $A.points
+// RUN:  A=f;   ASAN_OPTIONS=coverage=1:verbosity=1:symbolize_vs_style=false %run %t $A 1   2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK2; mv trace-points.*.sancov $A.points
+// RUN:  A=b;   ASAN_OPTIONS=coverage=1:verbosity=1:symbolize_vs_style=false %run %t $A 1   2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK2; mv trace-points.*.sancov $A.points
+// RUN:  A=bf;  ASAN_OPTIONS=coverage=1:verbosity=1:symbolize_vs_style=false %run %t $A 1   2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK3; mv trace-points.*.sancov $A.points
+// RUN:  A=fb;  ASAN_OPTIONS=coverage=1:verbosity=1:symbolize_vs_style=false %run %t $A 1   2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK3; mv trace-points.*.sancov $A.points
+// RUN:  A=ffb; ASAN_OPTIONS=coverage=1:verbosity=1:symbolize_vs_style=false %run %t $A 1   2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK4; mv trace-points.*.sancov $A.points
+// RUN:  A=fff; ASAN_OPTIONS=coverage=1:verbosity=1:symbolize_vs_style=false %run %t $A 1   2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK4; mv trace-points.*.sancov $A.points
+// RUN:  A=bbf; ASAN_OPTIONS=coverage=1:verbosity=1:symbolize_vs_style=false %run %t $A 100 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK301; mv trace-points.*.sancov $A.points
 // RUN: diff f.points fff.points
 // RUN: diff bf.points fb.points
 // RUN: diff bf.points ffb.points
 // RUN: diff bf.points bbf.points
 // RUN: not diff x.points f.points
 // RUN: not diff x.points b.points
 // RUN: not diff x.points bf.points
 // RUN: not diff f.points b.points

test/asan/TestCases/debug_mapping.cc

 // Checks that the debugging API returns correct shadow scale and offset.
 // RUN: %clangxx_asan -O %s -o %t
-// RUN: env ASAN_OPTIONS=verbosity=1 %run %t 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS=verbosity=1:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s
 
 #include <sanitizer/asan_interface.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 // printed because of verbosity=1
 // CHECK: SHADOW_SCALE: [[SCALE:[0-9]+]]
 // CHECK: SHADOW_OFFSET: [[OFFSET:0x[0-9a-f]+]]

test/asan/TestCases/debug_ppc64_mapping.cc

 // RUN: %clang_asan -O0 %s -o %t
-// RUN: env ASAN_OPTIONS=verbosity=0 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-PPC64-V0
-// RUN: env ASAN_OPTIONS=verbosity=2 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-PPC64
+// RUN: env ASAN_OPTIONS=verbosity=0:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-PPC64-V0
+// RUN: env ASAN_OPTIONS=verbosity=2:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-PPC64
 // REQUIRES: powerpc64-supported-target
 
 #include <stdio.h>
 
 int main() {
 // CHECK-PPC64: || `[{{0x0a0|0x040}}000000000, {{0x3ff|0x0ff}}fffffffff]` || HighMem    ||
 // CHECK-PPC64: || `[{{0x034|0x028}}000000000, {{0x09f|0x03f}}fffffffff]` || HighShadow ||
 // CHECK-PPC64: || `[{{0x024|0x024}}000000000, {{0x033|0x027}}fffffffff]` || ShadowGap  ||

test/asan/TestCases/deep_call_stack.cc

 // Check that UAR mode can handle very deep recusrion.
-// RUN: export ASAN_OPTIONS=detect_stack_use_after_return=1
+// RUN: export ASAN_OPTIONS=detect_stack_use_after_return=1:symbolize_vs_style=false
 // RUN: %clangxx_asan -O2 %s -o %t && \
 // RUN:   (ulimit -s 4096; %run %t) 2>&1 | FileCheck %s
 
 // Also check that use_sigaltstack+verbosity doesn't crash.
-// RUN: env ASAN_OPTIONS=verbosity=1:use_sigaltstack=1 %run %t  | FileCheck %s
+// RUN: env ASAN_OPTIONS=verbosity=1:use_sigaltstack=1:symbolize_vs_style=false %run %t  | FileCheck %s
 #include <stdio.h>
 
 __attribute__((noinline))
 void RecursiveFunc(int depth, int *ptr) {
   if ((depth % 1000) == 0)
     printf("[%05d] ptr: %p\n", depth, ptr);
   if (depth == 0)
     return;

test/asan/TestCases/deep_stack_uaf.cc

 // Check that we can store lots of stack frames if asked to.
 
 // RUN: %clangxx_asan -O0 %s -o %t 2>&1
-// RUN: env ASAN_OPTIONS=malloc_context_size=120:redzone=512 not %run %t 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS=malloc_context_size=120:redzone=512:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
 // XFAIL: arm-linux-gnueabi
 // XFAIL: armv7l-unknown-linux-gnueabihf
 #include <stdlib.h>
 #include <stdio.h>
 
 template <int depth>
 struct DeepFree {
   static void free(char *x) {

test/asan/TestCases/double-free.cc

 // RUN: %clangxx_asan -O0 %s -o %t 2>&1
 // RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=MALLOC-CTX
 
 // Also works if no malloc context is available.
-// RUN: env ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s
-// RUN: env ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=0:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
 // XFAIL: arm-linux-gnueabi
 // XFAIL: armv7l-unknown-linux-gnueabihf
 
 #include <stdlib.h>
 #include <string.h>
 int main(int argc, char **argv) {
   char *x = (char*)malloc(10 * sizeof(char));
   memset(x, 0, 10);

test/asan/TestCases/dump_instruction_bytes.cc

 // Check that ASan prints the faulting instruction bytes on
 // dump_instruction_bytes=1
 // RUN: %clangxx_asan  %s -o %t
-// RUN: env ASAN_OPTIONS=dump_instruction_bytes=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-DUMP
+// RUN: env ASAN_OPTIONS=dump_instruction_bytes=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-DUMP
 // RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-NODUMP
 //
 // REQUIRES: x86_64-supported-target,i386-supported-target
 
 int main() {
 #if defined(__x86_64__)
   asm("movq $0, %rax");
   asm("movl $0xcafebabe, 0x0(%rax)");
 #elif defined(i386)
   asm("movl $0, %eax");
   asm("movl $0xcafebabe, 0x0(%eax)");
 #endif
   // CHECK-DUMP: First 16 instruction bytes at pc: c7 00 be ba fe ca
   // CHECK-NODUMP-NOT: First 16 instruction bytes
   return 0;
 }

test/asan/TestCases/gc-test.cc

 // RUN: %clangxx_asan %s -pthread -o %t
-// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK1
-// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK0
+// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=1:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s --check-prefix=CHECK1
+// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s --check-prefix=CHECK0
 // RUN: %clangxx_asan -O3 %s -pthread -o %t
-// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK1
-// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK0
+// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=1:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s --check-prefix=CHECK1
+// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0:symbolize_vs_style=false %run %t 2>&1 | FileCheck %s --check-prefix=CHECK0
 // REQUIRES: stable-runtime
 
 #include <assert.h>
 #include <stdio.h>
 #include <pthread.h>
 #include <sanitizer/asan_interface.h>
 
 static const int kNumThreads = 2;

test/asan/TestCases/heap-overflow.cc

 // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
-// RUN: env ASAN_OPTIONS=print_stats=1 not %run %t 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS=print_stats=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
 
 // FIXME: Fix this test under GCC.
 // REQUIRES: Clang
 
 #include <stdlib.h>
 #include <string.h>
 int main(int argc, char **argv) {
   char *x = (char*)malloc(10 * sizeof(char));

test/asan/TestCases/heavy_uar_test.cc

-// RUN: export ASAN_OPTIONS=detect_stack_use_after_return=1
+// RUN: export ASAN_OPTIONS=detect_stack_use_after_return=1:symbolize_vs_style=false
 // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // XFAIL: arm-linux-gnueabi
 
 // FIXME: Fix this test under GCC.
 // REQUIRES: Clang
 
 #include <stdio.h>

test/asan/TestCases/init-order-atexit.cc

 // FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
 // XFAIL: android
 //
 // Test for the following situation:
 // (1) global A is constructed.
 // (2) exit() is called during construction of global B.
 // (3) destructor of A reads uninitialized global C from another module.
 // We do *not* want to report init-order bug in this case.
 
 // RUN: %clangxx_asan -O0 %s %p/Helpers/init-order-atexit-extra.cc -o %t
-// RUN: env ASAN_OPTIONS=strict_init_order=true not %run %t 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS=strict_init_order=true:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
 
 #include <stdio.h>
 #include <stdlib.h>
 
 void AccessC();
 
 class A {
  public:

test/asan/TestCases/init-order-pthread-create.cc

 // Check that init-order checking is properly disabled if pthread_create is
 // called.
 
 // RUN: %clangxx_asan %s %p/Helpers/init-order-pthread-create-extra.cc -pthread -o %t
-// RUN: env ASAN_OPTIONS=strict_init_order=true %run %t
+// RUN: env ASAN_OPTIONS=strict_init_order=true:symbolize_vs_style=false %run %t
 
 #include <stdio.h>
 #include <pthread.h>
 #include <unistd.h>
 
 void *bar(void *input, bool sleep_before_init) {
   if (sleep_before_init)
     usleep(500000);

test/asan/TestCases/initialization-blacklist.cc

 // Test for blacklist functionality of initialization-order checker.
 
 // RUN: %clangxx_asan -O0 %s %p/Helpers/initialization-blacklist-extra.cc\
 // RUN:   %p/Helpers/initialization-blacklist-extra2.cc \
 // RUN:   -fsanitize-blacklist=%p/Helpers/initialization-blacklist.txt -o %t
-// RUN: env ASAN_OPTIONS=check_initialization_order=true %run %t 2>&1
+// RUN: env ASAN_OPTIONS=check_initialization_order=true:symbolize_vs_style=false %run %t 2>&1
 // RUN: %clangxx_asan -O1 %s %p/Helpers/initialization-blacklist-extra.cc\
 // RUN:   %p/Helpers/initialization-blacklist-extra2.cc \
 // RUN:   -fsanitize-blacklist=%p/Helpers/initialization-blacklist.txt -o %t
-// RUN: env ASAN_OPTIONS=check_initialization_order=true %run %t 2>&1
+// RUN: env ASAN_OPTIONS=check_initialization_order=true:symbolize_vs_style=false %run %t 2>&1
 // RUN: %clangxx_asan -O2 %s %p/Helpers/initialization-blacklist-extra.cc\
 // RUN:   %p/Helpers/initialization-blacklist-extra2.cc \
 // RUN:   -fsanitize-blacklist=%p/Helpers/initialization-blacklist.txt -o %t
-// RUN: env ASAN_OPTIONS=check_initialization_order=true %run %t 2>&1
+// RUN: env ASAN_OPTIONS=check_initialization_order=true:symbolize_vs_style=false %run %t 2>&1
 
 // Function is defined in another TU.
 int readBadGlobal();
 int x = readBadGlobal();  // init-order bug.
 
 // Function is defined in another TU.
 int accessBadObject();
 int y = accessBadObject();  // init-order bug.
 
 int readBadSrcGlobal();
 int z = readBadSrcGlobal();  // init-order bug.
 
 int main(int argc, char **argv) {
   return argc + x + y + z - 1;
 }

test/asan/TestCases/initialization-bug.cc

 // Test to make sure basic initialization order errors are caught.
 
 // RUN: %clangxx_asan -O0 %s %p/Helpers/initialization-bug-extra2.cc -o %t-INIT-ORDER-EXE
-// RUN: env ASAN_OPTIONS=check_initialization_order=true not %run %t-INIT-ORDER-EXE 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS=check_initialization_order=true:symbolize_vs_style=false not %run %t-INIT-ORDER-EXE 2>&1 | FileCheck %s
 
 // Do not test with optimization -- the error may be optimized away.
 
 // FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=186
 // XFAIL: darwin
 
 #include <cstdio>
 

test/asan/TestCases/initialization-constexpr.cc

 // Constexpr:
 // We need to check that a global variable initialized with a constexpr
 // constructor can be accessed during dynamic initialization (as a constexpr
 // constructor implies that it was initialized during constant initialization,
 // not dynamic initialization).
 
 // RUN: %clangxx_asan -O0 %s %p/Helpers/initialization-constexpr-extra.cc --std=c++11 -o %t
-// RUN: env ASAN_OPTIONS=check_initialization_order=true %run %t 2>&1
+// RUN: env ASAN_OPTIONS=check_initialization_order=true:symbolize_vs_style=false %run %t 2>&1
 // RUN: %clangxx_asan -O1 %s %p/Helpers/initialization-constexpr-extra.cc --std=c++11 -o %t
-// RUN: env ASAN_OPTIONS=check_initialization_order=true %run %t 2>&1
+// RUN: env ASAN_OPTIONS=check_initialization_order=true:symbolize_vs_style=false %run %t 2>&1
 // RUN: %clangxx_asan -O2 %s %p/Helpers/initialization-constexpr-extra.cc --std=c++11 -o %t
-// RUN: env ASAN_OPTIONS=check_initialization_order=true %run %t 2>&1
+// RUN: env ASAN_OPTIONS=check_initialization_order=true:symbolize_vs_style=false %run %t 2>&1
 // RUN: %clangxx_asan -O3 %s %p/Helpers/initialization-constexpr-extra.cc --std=c++11 -o %t
-// RUN: env ASAN_OPTIONS=check_initialization_order=true %run %t 2>&1
+// RUN: env ASAN_OPTIONS=check_initialization_order=true:symbolize_vs_style=false %run %t 2>&1
 
 class Integer {
   private:
   int value;
 
   public:
   constexpr Integer(int x = 0) : value(x) {}
   int getValue() {return value;}
 };
 Integer coolestInteger(42);
 int getCoolestInteger() { return coolestInteger.getValue(); }
 
 int main() { return 0; }

test/asan/TestCases/initialization-nobug.cc

 // A collection of various initializers which shouldn't trip up initialization
 // order checking.  If successful, this will just return 0.
 
 // RUN: %clangxx_asan -O0 %s %p/Helpers/initialization-nobug-extra.cc -o %t
-// RUN: env ASAN_OPTIONS=check_initialization_order=true %run %t 2>&1
+// RUN: env ASAN_OPTIONS=check_initialization_order=true:symbolize_vs_style=false %run %t 2>&1
 // RUN: %clangxx_asan -O1 %s %p/Helpers/initialization-nobug-extra.cc -o %t
-// RUN: env ASAN_OPTIONS=check_initialization_order=true %run %t 2>&1
+// RUN: env ASAN_OPTIONS=check_initialization_order=true:symbolize_vs_style=false %run %t 2>&1
 // RUN: %clangxx_asan -O2 %s %p/Helpers/initialization-nobug-extra.cc -o %t
-// RUN: env ASAN_OPTIONS=check_initialization_order=true %run %t 2>&1
+// RUN: env ASAN_OPTIONS=check_initialization_order=true:symbolize_vs_style=false %run %t 2>&1
 // RUN: %clangxx_asan -O3 %s %p/Helpers/initialization-nobug-extra.cc -o %t
-// RUN: env ASAN_OPTIONS=check_initialization_order=true %run %t 2>&1
+// RUN: env ASAN_OPTIONS=check_initialization_order=true:symbolize_vs_style=false %run %t 2>&1
 
 // Simple access:
 // Make sure that accessing a global in the same TU is safe
 
 bool condition = true;
 int initializeSameTU() {
   return condition ? 0x2a : 052;
 }

test/asan/TestCases/invalid-free.cc

 // RUN: %clangxx_asan -O0 %s -o %t
 // RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=MALLOC-CTX
 
 // Also works if no malloc context is available.
-// RUN: env ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s
-// RUN: env ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=0:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
 // XFAIL: arm-linux-gnueabi
 // XFAIL: armv7l-unknown-linux-gnueabihf
 
 #include <stdlib.h>
 #include <string.h>
 int main(int argc, char **argv) {
   char *x = (char*)malloc(10 * sizeof(char));
   memset(x, 0, 10);

test/asan/TestCases/log-path_test.cc

 // FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
 // XFAIL: android
 //
 // RUN: %clangxx_asan  %s -o %t
 
 // Regular run.
 // RUN: not %run %t 2> %t.out
 // RUN: FileCheck %s --check-prefix=CHECK-ERROR < %t.out
 
 // Good log_path.
 // RUN: rm -f %t.log.*
-// RUN: env ASAN_OPTIONS=log_path=%t.log not %run %t 2> %t.out
+// RUN: env ASAN_OPTIONS=log_path=%t.log:symbolize_vs_style=false not %run %t 2> %t.out
 // RUN: FileCheck %s --check-prefix=CHECK-ERROR < %t.log.*
 
 // Invalid log_path.
-// RUN: env ASAN_OPTIONS=log_path=/dev/null/INVALID not %run %t 2> %t.out
+// RUN: env ASAN_OPTIONS=log_path=/dev/null/INVALID:symbolize_vs_style=false not %run %t 2> %t.out
 // RUN: FileCheck %s --check-prefix=CHECK-INVALID < %t.out
 
 // Too long log_path.
-// RUN: env ASAN_OPTIONS=log_path=`for((i=0;i<10000;i++)); do echo -n $i; done` \
+// RUN: env ASAN_OPTIONS=log_path=`for((i=0;i<10000;i++)); do echo -n $i; done`:symbolize_vs_style=false \
 // RUN:   not %run %t 2> %t.out
 // RUN: FileCheck %s --check-prefix=CHECK-LONG < %t.out
 
 // Run w/o errors should not produce any log.
 // RUN: rm -f %t.log.*
-// RUN: env ASAN_OPTIONS=log_path=%t.log  %run %t ARG ARG ARG
+// RUN: env ASAN_OPTIONS=log_path=%t.log:symbolize_vs_style=false  %run %t ARG ARG ARG
 // RUN: not cat %t.log.*
 
 // FIXME: log_path is not supported on Windows yet.
 // XFAIL: win32
 
 #include <stdlib.h>
 #include <string.h>
 int main(int argc, char **argv) {

test/asan/TestCases/malloc_context_size.cc

 // RUN: %clangxx_asan -O0 %s -o %t
-// RUN: env ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s
-// RUN: env ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s
-// RUN: env ASAN_OPTIONS=malloc_context_size=1:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s
-// RUN: env ASAN_OPTIONS=malloc_context_size=1:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s
-// RUN: env ASAN_OPTIONS=malloc_context_size=2 not %run %t 2>&1 | FileCheck %s --check-prefix=TWO
+// RUN: env ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=0:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS=malloc_context_size=1:fast_unwind_on_malloc=0:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS=malloc_context_size=1:fast_unwind_on_malloc=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS=malloc_context_size=2:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s --check-prefix=TWO
 
 int main() {
   char *x = new char[20];
   delete[] x;
   return x[0];
 
   // CHECK: freed by thread T{{.*}} here:
   // CHECK-NEXT: #0 0x{{.*}} in {{operator delete( )?\[\]|wrap__ZdaPv}}

test/asan/TestCases/malloc_fill.cc

 // Check that we fill malloc-ed memory correctly.
 // RUN: %clangxx_asan %s -o %t
 // RUN: %run %t | FileCheck %s
-// RUN: env ASAN_OPTIONS=max_malloc_fill_size=10:malloc_fill_byte=8 %run %t | FileCheck %s --check-prefix=CHECK-10-8
-// RUN: env ASAN_OPTIONS=max_malloc_fill_size=20:malloc_fill_byte=171 %run %t | FileCheck %s --check-prefix=CHECK-20-ab
+// RUN: env ASAN_OPTIONS=max_malloc_fill_size=10:malloc_fill_byte=8:symbolize_vs_style=false %run %t | FileCheck %s --check-prefix=CHECK-10-8
+// RUN: env ASAN_OPTIONS=max_malloc_fill_size=20:malloc_fill_byte=171:symbolize_vs_style=false %run %t | FileCheck %s --check-prefix=CHECK-20-ab
 
 #include <stdio.h>
 int main(int argc, char **argv) {
   // With asan allocator this makes sure we get memory from mmap.
   static const int kSize = 1 << 25;
   unsigned char *x = new unsigned char[kSize];
   printf("-");
   for (int i = 0; i <= 32; i++) {

test/asan/TestCases/max_redzone.cc

 // Test max_redzone runtime option.
 
-// RUN: %clangxx_asan -O0 %s -o %t && env ASAN_OPTIONS=max_redzone=16 %run %t 0 2>&1
+// RUN: %clangxx_asan -O0 %s -o %t && env ASAN_OPTIONS=max_redzone=16:symbolize_vs_style=false %run %t 0 2>&1
 // RUN: %clangxx_asan -O0 %s -o %t && %run %t 1 2>&1
-// RUN: %clangxx_asan -O3 %s -o %t && env ASAN_OPTIONS=max_redzone=16 %run %t 0 2>&1
+// RUN: %clangxx_asan -O3 %s -o %t && env ASAN_OPTIONS=max_redzone=16:symbolize_vs_style=false %run %t 0 2>&1
 // RUN: %clangxx_asan -O3 %s -o %t && %run %t 1 2>&1
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
 #include <sanitizer/allocator_interface.h>
 
 int main(int argc, char **argv) {

test/asan/TestCases/memcmp_strict_test.cc

-// RUN: %clangxx_asan -O0 %s -o %t && env ASAN_OPTIONS=strict_memcmp=0 %run %t
-// RUN: %clangxx_asan -O0 %s -o %t && env ASAN_OPTIONS=strict_memcmp=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O0 %s -o %t && env ASAN_OPTIONS=strict_memcmp=0:symbolize_vs_style=false %run %t
+// RUN: %clangxx_asan -O0 %s -o %t && env ASAN_OPTIONS=strict_memcmp=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
 // Default to strict_memcmp=1.
 // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
 
 #include <stdio.h>
 #include <string.h>
 int main() {
   char kFoo[] = "foo";
   char kFubar[] = "fubar";
   int res = memcmp(kFoo, kFubar, strlen(kFubar));
   printf("res: %d\n", res);
   // CHECK: AddressSanitizer: stack-buffer-overflow
   return 0;
 }

test/asan/TestCases/mmap_limit_mb.cc

 // Test the mmap_limit_mb flag.
 //
 // RUN: %clangxx_asan -O2 %s -o %t
 // RUN: %run %t 20 16
 // RUN: %run %t 30 1000000
-// RUN: env ASAN_OPTIONS=mmap_limit_mb=300 %run %t 20 16
-// RUN: env ASAN_OPTIONS=mmap_limit_mb=300 %run %t 20 1000000
-// RUN: env ASAN_OPTIONS=mmap_limit_mb=300 not %run %t 500 16 2>&1 | FileCheck %s
-// RUN: env ASAN_OPTIONS=mmap_limit_mb=300 not %run %t 500 1000000 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS=mmap_limit_mb=300:symbolize_vs_style=false %run %t 20 16
+// RUN: env ASAN_OPTIONS=mmap_limit_mb=300:symbolize_vs_style=false %run %t 20 1000000
+// RUN: env ASAN_OPTIONS=mmap_limit_mb=300:symbolize_vs_style=false not %run %t 500 16 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS=mmap_limit_mb=300:symbolize_vs_style=false not %run %t 500 1000000 2>&1 | FileCheck %s
 // XFAIL: arm-linux-gnueabi
 
 #include <assert.h>
 #include <stdlib.h>
 #include <stdio.h>
 
 #include <algorithm>
 #include <vector>

test/asan/TestCases/poison_partial.cc

 // RUN: %clangxx_asan -O0 %s -o %t
 // RUN: not %run %t      2>&1 | FileCheck %s
 // RUN: not %run %t heap 2>&1 | FileCheck %s
-// RUN: env ASAN_OPTIONS=poison_partial=0 %run %t
-// RUN: env ASAN_OPTIONS=poison_partial=0 %run %t heap
+// RUN: env ASAN_OPTIONS=poison_partial=0:symbolize_vs_style=false %run %t
+// RUN: env ASAN_OPTIONS=poison_partial=0:symbolize_vs_style=false %run %t heap
 #include <string.h>
 char g[21];
 char *x;
 
 int main(int argc, char **argv) {
   if (argc >= 2)
     x = new char[21];
   else
     x = &g[0];
   memset(x, 0, 21);
   int *y = (int*)x;
   return y[5];
 }
 // CHECK: 0 bytes to the right

test/asan/TestCases/print_summary.cc

 // RUN: %clangxx_asan -O0 %s -o %t
 // RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=SOURCE
-// RUN: env ASAN_OPTIONS=symbolize=false not %run %t 2>&1 | FileCheck %s --check-prefix=MODULE
-// RUN: env ASAN_OPTIONS=print_summary=false not %run %t 2>&1 | FileCheck %s --check-prefix=MISSING
+// RUN: env ASAN_OPTIONS=symbolize=false:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s --check-prefix=MODULE
+// RUN: env ASAN_OPTIONS=print_summary=false:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s --check-prefix=MISSING
 
 int main() {
   char *x = new char[20];
   delete[] x;
   return x[0];
   // SOURCE: ERROR: AddressSanitizer: heap-use-after-free
   // SOURCE: SUMMARY: AddressSanitizer: heap-use-after-free {{.*}}print_summary.cc:[[@LINE-2]]{{.*}} main
   // MODULE: ERROR: AddressSanitizer: heap-use-after-free
   // MODULE: SUMMARY: AddressSanitizer: heap-use-after-free ({{.*}}+0x{{.*}})
   // MISSING: ERROR: AddressSanitizer: heap-use-after-free
   // MISSING-NOT: SUMMARY
 }

test/asan/TestCases/stack-overflow.cc

 // Test ASan detection of stack-overflow condition.
 
-// RUN: %clangxx_asan -O0 %s -DSMALL_FRAME -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
-// RUN: %clangxx_asan -O3 %s -DSMALL_FRAME -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
-// RUN: %clangxx_asan -O0 %s -DSAVE_ALL_THE_REGISTERS -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
-// RUN: %clangxx_asan -O3 %s -DSAVE_ALL_THE_REGISTERS -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
-// RUN: %clangxx_asan -O0 %s -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
-// RUN: %clangxx_asan -O3 %s -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
-
-// RUN: %clangxx_asan -O0 %s -DTHREAD -DSMALL_FRAME -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
-// RUN: %clangxx_asan -O3 %s -DTHREAD -DSMALL_FRAME -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
-// RUN: %clangxx_asan -O0 %s -DTHREAD -DSAVE_ALL_THE_REGISTERS -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
-// RUN: %clangxx_asan -O3 %s -DTHREAD -DSAVE_ALL_THE_REGISTERS -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
-// RUN: %clangxx_asan -O0 %s -DTHREAD -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
-// RUN: %clangxx_asan -O3 %s -DTHREAD -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O0 %s -DSMALL_FRAME -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -DSMALL_FRAME -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O0 %s -DSAVE_ALL_THE_REGISTERS -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -DSAVE_ALL_THE_REGISTERS -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O0 %s -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
+
+// RUN: %clangxx_asan -O0 %s -DTHREAD -DSMALL_FRAME -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -DTHREAD -DSMALL_FRAME -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O0 %s -DTHREAD -DSAVE_ALL_THE_REGISTERS -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -DTHREAD -DSAVE_ALL_THE_REGISTERS -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O0 %s -DTHREAD -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O3 %s -DTHREAD -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
 // RUN: not %run %t 2>&1 | FileCheck %s
 // REQUIRES: stable-runtime
 
 #include <assert.h>
 #include <stdlib.h>
 #include <pthread.h>
 #include <unistd.h>
 #include <sys/time.h>

test/asan/TestCases/stack-use-after-return.cc

-// RUN: export ASAN_OPTIONS=detect_stack_use_after_return=1
+// RUN: export ASAN_OPTIONS=detect_stack_use_after_return=1:symbolize_vs_style=false
 // RUN: %clangxx_asan  -O0 %s -pthread -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan  -O1 %s -pthread -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan  -O2 %s -pthread -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan  -O3 %s -pthread -o %t && not %run %t 2>&1 | FileCheck %s
-// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %run %t
+// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0:symbolize_vs_style=false %run %t
 // Regression test for a CHECK failure with small stack size and large frame.
 // RUN: %clangxx_asan  -O3 %s -pthread -o %t -DkSize=10000 -DUseThread -DkStackSize=65536 && not %run %t 2>&1 | FileCheck --check-prefix=THREAD %s
 //
 // Test that we can find UAR in a thread other than main:
 // RUN: %clangxx_asan  -DUseThread -O2 %s -pthread -o %t && not %run %t 2>&1 | FileCheck --check-prefix=THREAD %s
 //
 // Test the max_uar_stack_size_log/min_uar_stack_size_log flag.
 //
-// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:max_uar_stack_size_log=20:verbosity=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-20 %s
-// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:min_uar_stack_size_log=24:max_uar_stack_size_log=24:verbosity=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-24 %s
+// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:max_uar_stack_size_log=20:verbosity=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck --check-prefix=CHECK-20 %s
+// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:min_uar_stack_size_log=24:max_uar_stack_size_log=24:verbosity=1:symbolize_vs_style=false not %run %t 2>&1 | FileCheck --check-prefix=CHECK-24 %s
 
 #include <stdio.h>
 #include <pthread.h>
 
 #ifndef kSize
 # define kSize 1
 #endif
 

test/asan/TestCases/strip_path_prefix.c

 // RUN: %clang_asan -O2 %s -o %t
-// RUN: env ASAN_OPTIONS="strip_path_prefix='%S/'" not %run %t 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS="strip_path_prefix='%S/':symbolize_vs_style=false" not %run %t 2>&1 | FileCheck %s
 
 #include <stdlib.h>
 int main() {
   char *x = (char*)malloc(10 * sizeof(char));
   free(x);
   return x[5];
   // Check that paths in error report don't start with slash.
   // CHECK: heap-use-after-free
   // CHECK: #0 0x{{.*}} in main strip_path_prefix.c:[[@LINE-3]]
 }

test/asan/TestCases/suppressions-exec-relative-location.cc

 // Check that without suppressions, we catch the issue.
 // RUN: %clangxx_asan -O0 %s -o %t
 // RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-CRASH %s
 
 // If the executable is started from a different location, we should still
 // find the suppression file located relative to the location of the executable.
 // RUN: rm -rf %T/suppressions-exec-relative-location
 // RUN: mkdir -p %T/suppressions-exec-relative-location
 // RUN: %clangxx_asan -O0 %s -o %T/suppressions-exec-relative-location/exec
 // RUN: echo "interceptor_via_fun:crash_function" > \
 // RUN:   %T/suppressions-exec-relative-location/supp.txt
-// RUN: ASAN_OPTIONS="suppressions=supp.txt" \
+// RUN: ASAN_OPTIONS="suppressions=supp.txt":symbolize_vs_style=false \
 // RUN:   %run %T/suppressions-exec-relative-location/exec 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-IGNORE %s
 // RUN: rm -rf %T/suppressions-exec-relative-location
 
 // If the wrong absolute path is given, we don't try to construct
 // a relative path with it.
-// RUN: ASAN_OPTIONS="suppressions='/absolute/path'" not %run %t 2>&1 | \
+// RUN: ASAN_OPTIONS="suppressions='/absolute/path'":symbolize_vs_style=false not %run %t 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-WRONG-FILE-NAME %s
 
 // Test that we reject directory as filename.
-// RUN: ASAN_OPTIONS="suppressions='folder/only/'" not %run %t 2>&1 | \
+// RUN: ASAN_OPTIONS="suppressions='folder/only/'":symbolize_vs_style=false not %run %t 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-WRONG-FILE-NAME %s
 
 // XFAIL: android
 // XFAIL: win32
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

test/asan/TestCases/suppressions-function.cc

 // Check that without suppressions, we catch the issue.
 // RUN: %clangxx_asan -O0 %s -o %t
 // RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-CRASH %s
 
 // RUN: echo "interceptor_via_fun:crash_function" > %t.supp
-// RUN: %clangxx_asan -O0 %s -o %t && ASAN_OPTIONS="suppressions='%t.supp'" %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
-// RUN: %clangxx_asan -O3 %s -o %t && ASAN_OPTIONS="suppressions='%t.supp'" %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+// RUN: %clangxx_asan -O0 %s -o %t && ASAN_OPTIONS="suppressions='%t.supp'":symbolize_vs_style=false %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+// RUN: %clangxx_asan -O3 %s -o %t && ASAN_OPTIONS="suppressions='%t.supp'":symbolize_vs_style=false %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
 
 // XFAIL: android
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 void crash_function() {

test/asan/TestCases/suppressions-interceptor.cc

 // Check that without suppressions, we catch the issue.
 // RUN: %clangxx_asan -O0 %s -o %t
 // RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-CRASH %s
 
 // RUN: echo "interceptor_name:strlen" > %t.supp
-// RUN: ASAN_OPTIONS="suppressions='%t.supp'" %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+// RUN: ASAN_OPTIONS="suppressions='%t.supp'":symbolize_vs_style=false %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
 
 // XFAIL: android
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 int main() {

test/asan/TestCases/suppressions-library.cc

 // RUN: %clangxx_asan -O0 -DSHARED_LIB %s -fPIC -shared -o %dynamiclib %ld_flags_rpath_so
 // RUN: %clangxx_asan -O0 %s -o %t %ld_flags_rpath_exe
 
 // Check that without suppressions, we catch the issue.
 // RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-CRASH %s
 
 // RUN: echo "interceptor_via_lib:"`basename %dynamiclib` > %t.supp
-// RUN: ASAN_OPTIONS="suppressions='%t.supp'" %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
+// RUN: ASAN_OPTIONS="suppressions='%t.supp'":symbolize_vs_style=false %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
 
 // XFAIL: android
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #if !defined(SHARED_LIB)

test/asan/TestCases/uar_and_exceptions.cc

 // Test that use-after-return works with exceptions.
-// export ASAN_OPTIONS=detect_stack_use_after_return=1
+// export ASAN_OPTIONS=detect_stack_use_after_return=1:symbolize_vs_style=false
 // RUN: %clangxx_asan  -O0 %s -o %t && %run %t
 
 // Clang doesn't support exceptions on Windows yet.
 // XFAIL: win32
 
 #include <stdio.h>
 
 volatile char *g;

test/asan/TestCases/use-after-poison.cc

 // Check that __asan_poison_memory_region works.
 // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
 //
 // Check that we can disable it
-// RUN: env ASAN_OPTIONS=allow_user_poisoning=0 %run %t
+// RUN: env ASAN_OPTIONS=allow_user_poisoning=0:symbolize_vs_style=false %run %t
 
 #include <stdlib.h>
 
 extern "C" void __asan_poison_memory_region(void *, size_t);
 
 int main(int argc, char **argv) {
   char *x = new char[16];
   x[10] = 0;
   __asan_poison_memory_region(x, 16);
   int res = x[argc * 10];  // BOOOM
   // CHECK: ERROR: AddressSanitizer: use-after-poison
   // CHECK: main{{.*}}use-after-poison.cc:[[@LINE-2]]
   delete [] x;
   return res;
 }

test/asan/TestCases/use-after-scope.cc

 // RUN: %clangxx_asan -O0 -fsanitize=use-after-scope %s -o %t && \
 // RUN: not %run %t 2>&1 | FileCheck %s
-// RUN: env ASAN_OPTIONS="detect_stack_use_after_return=1" not %run %t 2>&1 | FileCheck %s
+// RUN: env ASAN_OPTIONS="detect_stack_use_after_return=1":symbolize_vs_style=false not %run %t 2>&1 | FileCheck %s
 // XFAIL: *
 
 int main() {
   int *p = 0;
   {
     int x = 0;
     p = &x;
   }
   return *p;  // BOOM
   // CHECK: ERROR: AddressSanitizer: stack-use-after-scope
   // CHECK:  #0 0x{{.*}} in main {{.*}}use-after-scope.cc:[[@LINE-2]]
   // CHECK: Address 0x{{.*}} is located in stack of thread T{{.*}} at offset [[OFFSET:[^ ]+]] in frame
   // {{\[}}[[OFFSET]], {{[0-9]+}}) 'x'
 }

test/asan/lit.cfg

def push_dynamic_library_lookup_path(config, new_path):
 
   new_ld_library_path = os.path.pathsep.join(
     (new_path, config.environment.get(dynamic_library_lookup_var, '')))
   config.environment[dynamic_library_lookup_var] = new_ld_library_path
 
 # Setup config name.
 config.name = 'AddressSanitizer' + config.name_suffix
 
+# Setup default ASAN_OPTIONS
+config.environment['ASAN_OPTIONS'] = 'symbolize_vs_style=false'
+
 # testFormat: The test format to use to interpret tests.
 external_bash = (not sys.platform in ['win32'])
 config.test_format = lit.formats.ShTest(external_bash)
 
 # Setup source root.
 config.test_source_root = os.path.dirname(__file__)
 
 # There is no libdl on FreeBSD.