This is an archive of the discontinued LLVM Phabricator instance.

Differential D12305

[ASan] More ASAN_OPTIONS churn: use %env_asan_opts where applicable.
ClosedPublic

Authored by samsonov on Aug 24 2015, 5:58 PM.

Details

Reviewers
filcab
kubamracek
rnk
Commits
rG113068171675: [ASan] More ASAN_OPTIONS churn: use %env_asan_opts where applicable.
rCRT245962: [ASan] More ASAN_OPTIONS churn: use %env_asan_opts where applicable.
rL245962: [ASan] More ASAN_OPTIONS churn: use %env_asan_opts where applicable.
Summary

I would appreciate testing on Mac OS and Windows.

Diff Detail

Repository
rL LLVM

Event Timeline

samsonov updated this revision to Diff 33032.Aug 24 2015, 5:58 PM
samsonov retitled this revision from to [ASan] More ASAN_OPTIONS churn: use %env_asan_opts where applicable..
samsonov updated this object.
samsonov added reviewers: filcab, rnk, kubamracek.
samsonov added a subscriber: llvm-commits.
Herald added subscribers: srhines, danalbert, tberghammer. · View Herald TranscriptAug 24 2015, 5:58 PM
kubamracek edited edge metadata.Aug 25 2015, 7:19 AM

This patch passes all tests on OS X.

rnk accepted this revision.Aug 25 2015, 9:19 AM
rnk edited edge metadata.

lgtm with the updated xfail. Everything else passes.

test/asan/TestCases/suppressions-interceptor.cc
8–9 ↗(On Diff #33032)

You can remove the win32 XFAIL and FIXME here, the test passes with this change. I must have misdiagnosed this issue when I was porting the test suite. =/

The good news is that it passes. :)

This revision is now accepted and ready to land.Aug 25 2015, 9:19 AM
Closed by commit rL245962: [ASan] More ASAN_OPTIONS churn: use %env_asan_opts where applicable. (authored by samsonov). · Explain WhyAug 25 2015, 11:29 AM
This revision was automatically updated to reflect the committed changes.
samsonov marked an inline comment as done.

Revision Contents

PathSize
compiler-rt/
trunk/
test/
asan/
TestCases/
Android/
12 lines
Darwin/
2 lines
4 lines
4 lines
9 lines
8 lines
2 lines
Linux/
8 lines
2 lines
12 lines
2 lines
4 lines
6 lines
6 lines
4 lines
8 lines
4 lines
18 lines
4 lines
10 lines
8 lines
2 lines
2 lines
2 lines
6 lines
Posix/
4 lines
2 lines
6 lines
4 lines
12 lines
2 lines
3 lines
5 lines
13 lines
13 lines
5 lines
4 lines
2 lines
2 lines
4 lines
4 lines
13 lines
10 lines
2 lines
Windows/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
5 lines
4 lines
2 lines

Diff 33095

compiler-rt/trunk/test/asan/TestCases/Android/coverage-android.cc

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

compiler-rt/trunk/test/asan/TestCases/Darwin/atos-symbolizer-dyld-root-path.cc

// Check that when having a DYLD_ROOT_PATH set, the symbolizer still works. // Check that when having a DYLD_ROOT_PATH set, the symbolizer still works.
// RUN: env DYLD_ROOT_PATH="/" ASAN_OPTIONS=$ASAN_OPTIONS:verbosity=2 ASAN_SYMBOLIZER_PATH=$(which atos) \ // RUN: %env_asan_opts=verbosity=2 DYLD_ROOT_PATH="/" ASAN_SYMBOLIZER_PATH=$(which atos) \
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
// //
// Due to a bug in atos, this only works on x86_64. // Due to a bug in atos, this only works on x86_64.
// REQUIRES: x86_64 // REQUIRES: x86_64
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
int main(int argc, char **argv) { int main(int argc, char **argv) {
Show All 16 Lines

compiler-rt/trunk/test/asan/TestCases/Darwin/atos-symbolizer.cc

// Check that the `atos` symbolizer works. // Check that the `atos` symbolizer works.
// RUN: %clangxx_asan -O0 %s -o %t // RUN: %clangxx_asan -O0 %s -o %t
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:verbosity=2 ASAN_SYMBOLIZER_PATH=$(which atos) not %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=verbosity=2 ASAN_SYMBOLIZER_PATH=$(which atos) not %run %t 2>&1 | FileCheck %s
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
int main(int argc, char **argv) { int main(int argc, char **argv) {
char *x = (char*)malloc(10 * sizeof(char)); char *x = (char*)malloc(10 * sizeof(char));
memset(x, 0, 10); memset(x, 0, 10);
int res = x[argc]; int res = x[argc];
free(x); free(x);
Show All 12 Lines

compiler-rt/trunk/test/asan/TestCases/Darwin/dladdr-demangling.cc

// In a non-forking sandbox, we fallback to dladdr(). Test that we provide // In a non-forking sandbox, we fallback to dladdr(). Test that we provide
// properly demangled C++ names in that case. // properly demangled C++ names in that case.
// RUN: %clangxx_asan -O0 %s -o %t // RUN: %clangxx_asan -O0 %s -o %t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
// RUN: env ASAN_OPTIONS=$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: %env_asan_opts=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
#include <stdlib.h> #include <stdlib.h>
class MyClass { class MyClass {
public: public:
int my_function(int n) { int my_function(int n) {
char *x = (char*)malloc(n * sizeof(char)); char *x = (char*)malloc(n * sizeof(char));
free(x); free(x);
Show All 19 Lines

compiler-rt/trunk/test/asan/TestCases/Darwin/dyld_insert_libraries_reexec.cc

// When DYLD-inserting the ASan dylib from a different location than the // When DYLD-inserting the ASan dylib from a different location than the
// original, make sure we don't try to reexec. // original, make sure we don't try to reexec.
// RUN: mkdir -p %T/dyld_insert_libraries_reexec // RUN: mkdir -p %T/dyld_insert_libraries_reexec
// RUN: cp `%clang_asan %s -fsanitize=address -### 2>&1 \ // RUN: cp `%clang_asan %s -fsanitize=address -### 2>&1 \
// RUN: | grep "libclang_rt.asan_osx_dynamic.dylib" \ // RUN: | grep "libclang_rt.asan_osx_dynamic.dylib" \
// RUN: | sed -e 's/.*"\(.*libclang_rt.asan_osx_dynamic.dylib\)".*/\1/'` \ // RUN: | sed -e 's/.*"\(.*libclang_rt.asan_osx_dynamic.dylib\)".*/\1/'` \
// RUN: %T/dyld_insert_libraries_reexec/libclang_rt.asan_osx_dynamic.dylib // 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: %clangxx_asan %s -o %T/dyld_insert_libraries_reexec/a.out
// RUN: env DYLD_INSERT_LIBRARIES=@executable_path/libclang_rt.asan_osx_dynamic.dylib \ // RUN: %env_asan_opts=verbosity=1 \
// RUN: ASAN_OPTIONS=$ASAN_OPTIONS:verbosity=1 %run %T/dyld_insert_libraries_reexec/a.out 2>&1 \ // RUN: DYLD_INSERT_LIBRARIES=@executable_path/libclang_rt.asan_osx_dynamic.dylib \
// RUN: %run %T/dyld_insert_libraries_reexec/a.out 2>&1 \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: IS_OSX_10_11_OR_HIGHER=$([ `sw_vers -productVersion | cut -d'.' -f2` -lt 11 ]; echo $?) // RUN: IS_OSX_10_11_OR_HIGHER=$([ `sw_vers -productVersion | cut -d'.' -f2` -lt 11 ]; echo $?)
// On OS X 10.10 and lower, if the dylib is not DYLD-inserted, ASan will re-exec. // On OS X 10.10 and lower, if the dylib is not DYLD-inserted, ASan will re-exec.
// RUN: if [ $IS_OSX_10_11_OR_HIGHER == 0 ]; then \ // RUN: if [ $IS_OSX_10_11_OR_HIGHER == 0 ]; then \
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:verbosity=1 %run %T/dyld_insert_libraries_reexec/a.out 2>&1 \ // RUN: %env_asan_opts=verbosity=1 %run %T/dyld_insert_libraries_reexec/a.out 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NOINSERT %s; \ // RUN: | FileCheck --check-prefix=CHECK-NOINSERT %s; \
// RUN: fi // RUN: fi
// On OS X 10.11 and higher, we don't need to DYLD-insert anymore, and the interceptors // On OS X 10.11 and higher, we don't need to DYLD-insert anymore, and the interceptors
// still installed correctly. Let's just check that things work and we don't try to re-exec. // still installed correctly. Let's just check that things work and we don't try to re-exec.
// RUN: if [ $IS_OSX_10_11_OR_HIGHER == 1 ]; then \ // RUN: if [ $IS_OSX_10_11_OR_HIGHER == 1 ]; then \
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:verbosity=1 %run %T/dyld_insert_libraries_reexec/a.out 2>&1 \ // RUN: %env_asan_opts=verbosity=1 %run %T/dyld_insert_libraries_reexec/a.out 2>&1 \
// RUN: | FileCheck %s; \ // RUN: | FileCheck %s; \
// RUN: fi // RUN: fi
#include <stdio.h> #include <stdio.h>
int main() { int main() {
printf("Passed\n"); printf("Passed\n");
return 0; return 0;
Show All 11 Lines

compiler-rt/trunk/test/asan/TestCases/Darwin/suppressions-darwin.cc

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

compiler-rt/trunk/test/asan/TestCases/Darwin/suppressions-sandbox.cc

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

compiler-rt/trunk/test/asan/TestCases/Linux/activation-options.cc

// Test for ASAN_OPTIONS=start_deactivated=1 mode. // Test for ASAN_OPTIONS=start_deactivated=1 mode.
// Main executable is uninstrumented, but linked to ASan runtime. The shared // Main executable is uninstrumented, but linked to ASan runtime. The shared
// library is instrumented. // library is instrumented.
// RUN: %clangxx_asan -O0 -DSHARED_LIB %s -fPIC -shared -o %t-so.so // RUN: %clangxx_asan -O0 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
// RUN: %clangxx -O0 %s -c -o %t.o // RUN: %clangxx -O0 %s -c -o %t.o
// RUN: %clangxx_asan -O0 %t.o %libdl -o %t // RUN: %clangxx_asan -O0 %t.o %libdl -o %t
// RUN: rm -f %t.asan.options.activation-options.cc.tmp // RUN: rm -f %t.asan.options.activation-options.cc.tmp
// RUN: rm -f %t.asan.options.ABCDE // RUN: rm -f %t.asan.options.ABCDE
// RUN: echo "help=1" >%t.asan.options.activation-options.cc.tmp // RUN: echo "help=1" >%t.asan.options.activation-options.cc.tmp
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:start_deactivated=1 \ // RUN: %env_asan_opts=start_deactivated=1 \
// RUN: ASAN_ACTIVATION_OPTIONS=include=%t.asan.options.%b %run %t 2>&1 | \ // RUN: ASAN_ACTIVATION_OPTIONS=include=%t.asan.options.%b %run %t 2>&1 | \
// RUN: FileCheck %s --check-prefix=CHECK-HELP --check-prefix=CHECK-FOUND // RUN: FileCheck %s --check-prefix=CHECK-HELP --check-prefix=CHECK-FOUND
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:start_deactivated=1 \ // RUN: %env_asan_opts=start_deactivated=1 \
// RUN: ASAN_ACTIVATION_OPTIONS=include=%t.asan.options not %run %t 2>&1 | \ // RUN: ASAN_ACTIVATION_OPTIONS=include=%t.asan.options not %run %t 2>&1 | \
// RUN: FileCheck %s --check-prefix=CHECK-NO-HELP --check-prefix=CHECK-MISSING // RUN: FileCheck %s --check-prefix=CHECK-NO-HELP --check-prefix=CHECK-MISSING
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:start_deactivated=1 \ // RUN: %env_asan_opts=start_deactivated=1 \
// RUN: ASAN_ACTIVATION_OPTIONS=include=%t.asan.options.%b not %run %t --fix-name 2>&1 | \ // RUN: ASAN_ACTIVATION_OPTIONS=include=%t.asan.options.%b not %run %t --fix-name 2>&1 | \
// RUN: FileCheck %s --check-prefix=CHECK-NO-HELP --check-prefix=CHECK-MISSING // RUN: FileCheck %s --check-prefix=CHECK-NO-HELP --check-prefix=CHECK-MISSING
// RUN: echo "help=1" >%t.asan.options.ABCDE // RUN: echo "help=1" >%t.asan.options.ABCDE
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:start_deactivated=1 \ // RUN: %env_asan_opts=start_deactivated=1 \
// RUN: ASAN_ACTIVATION_OPTIONS=include=%t.asan.options.%b %run %t --fix-name 2>&1 | \ // RUN: ASAN_ACTIVATION_OPTIONS=include=%t.asan.options.%b %run %t --fix-name 2>&1 | \
// RUN: FileCheck %s --check-prefix=CHECK-HELP --check-prefix=CHECK-FOUND // RUN: FileCheck %s --check-prefix=CHECK-HELP --check-prefix=CHECK-FOUND
// XFAIL: arm-linux-gnueabi // XFAIL: arm-linux-gnueabi
// XFAIL: android // XFAIL: android
#if !defined(SHARED_LIB) #if !defined(SHARED_LIB)
#include <assert.h> #include <assert.h>
Show All 36 Lines

compiler-rt/trunk/test/asan/TestCases/Linux/asan_prelink_test.cc

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

compiler-rt/trunk/test/asan/TestCases/Linux/coverage-missing.cc

// Test for "sancov.py missing ...". // Test for "sancov.py missing ...".
// RUN: export ASAN_OPTIONS=$ASAN_OPTIONS:coverage=1:coverage_dir=%T/coverage-missing
// First case: coverage from executable. main() is called on every code path. // First case: coverage from executable. main() is called on every code path.
// RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t -DFOOBAR -DMAIN // RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t -DFOOBAR -DMAIN
// RUN: rm -rf %T/coverage-missing // RUN: rm -rf %T/coverage-missing
// RUN: mkdir -p %T/coverage-missing // RUN: mkdir -p %T/coverage-missing
// RUN: cd %T/coverage-missing // RUN: cd %T/coverage-missing
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS %t // RUN: %env_asan_opts=coverage=1:coverage_dir=%T/coverage-missing %run %t
// RUN: %sancov print *.sancov > main.txt // RUN: %sancov print *.sancov > main.txt
// RUN: rm *.sancov // RUN: rm *.sancov
// RUN: [ $(cat main.txt | wc -l) == 1 ] // RUN: [ $(cat main.txt | wc -l) == 1 ]
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS %t x // RUN: %env_asan_opts=coverage=1:coverage_dir=%T/coverage-missing %run %t x
// RUN: %sancov print *.sancov > foo.txt // RUN: %sancov print *.sancov > foo.txt
// RUN: rm *.sancov // RUN: rm *.sancov
// RUN: [ $(cat foo.txt | wc -l) == 3 ] // RUN: [ $(cat foo.txt | wc -l) == 3 ]
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS %t x x // RUN: %env_asan_opts=coverage=1:coverage_dir=%T/coverage-missing %run %t x x
// RUN: %sancov print *.sancov > bar.txt // RUN: %sancov print *.sancov > bar.txt
// RUN: rm *.sancov // RUN: rm *.sancov
// RUN: [ $(cat bar.txt | wc -l) == 4 ] // RUN: [ $(cat bar.txt | wc -l) == 4 ]
// RUN: %sancov missing %t < foo.txt > foo-missing.txt // RUN: %sancov missing %t < foo.txt > foo-missing.txt
// RUN: sort main.txt foo-missing.txt -o foo-missing-with-main.txt // RUN: sort main.txt foo-missing.txt -o foo-missing-with-main.txt
// The "missing from foo" set may contain a few bogus PCs from the sanitizer // The "missing from foo" set may contain a few bogus PCs from the sanitizer
// runtime, but it must include the entire "bar" code path as a subset. Sorted // runtime, but it must include the entire "bar" code path as a subset. Sorted
// lists can be tested for set inclusion with diff + grep. // lists can be tested for set inclusion with diff + grep.
// RUN: ( diff bar.txt foo-missing-with-main.txt || true ) | not grep "^<" // RUN: ( diff bar.txt foo-missing-with-main.txt || true ) | not grep "^<"
// Second case: coverage from DSO. // Second case: coverage from DSO.
// cd %T // cd %T
// RUN: %clangxx_asan -fsanitize-coverage=func %s -o %dynamiclib -DFOOBAR -shared -fPIC // RUN: %clangxx_asan -fsanitize-coverage=func %s -o %dynamiclib -DFOOBAR -shared -fPIC
// RUN: %clangxx_asan -fsanitize-coverage=func %s %dynamiclib -o %t -DMAIN // RUN: %clangxx_asan -fsanitize-coverage=func %s %dynamiclib -o %t -DMAIN
// RUN: export LIBNAME=`basename %dynamiclib` // RUN: export LIBNAME=`basename %dynamiclib`
// RUN: rm -rf %T/coverage-missing // RUN: rm -rf %T/coverage-missing
// RUN: mkdir -p %T/coverage-missing // RUN: mkdir -p %T/coverage-missing
// RUN: cd %T/coverage-missing // RUN: cd %T/coverage-missing
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS %t x // RUN: %env_asan_opts=coverage=1:coverage_dir=%T/coverage-missing %run %t x
// RUN: %sancov print $LIBNAME.*.sancov > foo.txt // RUN: %sancov print $LIBNAME.*.sancov > foo.txt
// RUN: rm *.sancov // RUN: rm *.sancov
// RUN: [ $(cat foo.txt | wc -l) == 2 ] // RUN: [ $(cat foo.txt | wc -l) == 2 ]
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS %t x x // RUN: %env_asan_opts=coverage=1:coverage_dir=%T/coverage-missing %run %t x x
// RUN: %sancov print $LIBNAME.*.sancov > bar.txt // RUN: %sancov print $LIBNAME.*.sancov > bar.txt
// RUN: rm *.sancov // RUN: rm *.sancov
// RUN: [ $(cat bar.txt | wc -l) == 3 ] // RUN: [ $(cat bar.txt | wc -l) == 3 ]
// RUN: %sancov missing %dynamiclib < foo.txt > foo-missing.txt // RUN: %sancov missing %dynamiclib < foo.txt > foo-missing.txt
// RUN: ( diff bar.txt foo-missing.txt || true ) | not grep "^<" // RUN: ( diff bar.txt foo-missing.txt || true ) | not grep "^<"
// REQUIRES: x86_64-supported-target, i386-supported-target // REQUIRES: x86_64-supported-target, i386-supported-target
// XFAIL: android // XFAIL: android
Show All 35 Lines

compiler-rt/trunk/test/asan/TestCases/Linux/init-order-dlopen.cc

// Regression test for // Regression test for
// https://code.google.com/p/address-sanitizer/issues/detail?id=178 // 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 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
// RUN: %clangxx_asan -O0 %s %libdl -Wl,--export-dynamic -o %t // RUN: %clangxx_asan -O0 %s %libdl -Wl,--export-dynamic -o %t
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_init_order=true %run %t 2>&1 // RUN: %env_asan_opts=strict_init_order=true %run %t 2>&1
// dlopen() can not be intercepted on Android, making strict_init_order nearly // dlopen() can not be intercepted on Android, making strict_init_order nearly
// useless there. // useless there.
// UNSUPPORTED: android // UNSUPPORTED: android
#if defined(SHARED_LIB) #if defined(SHARED_LIB)
#include <stdio.h> #include <stdio.h>
Show All 33 Lines

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

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

compiler-rt/trunk/test/asan/TestCases/Linux/kernel-area.cc

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

compiler-rt/trunk/test/asan/TestCases/Linux/leak.cc

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

compiler-rt/trunk/test/asan/TestCases/Linux/malloc-in-qsort.cc

// RUN: %clangxx_asan -O2 %s -o %t // RUN: %clangxx_asan -O2 %s -o %t
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-FAST // RUN: %env_asan_opts=fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-FAST
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-SLOW // RUN: %env_asan_opts=fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-SLOW
// Test how well we unwind in presence of qsort in the stack // 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). // (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 // https://code.google.com/p/address-sanitizer/issues/detail?id=137
// Fast unwinder is only available on x86_64 and i386. // Fast unwinder is only available on x86_64 and i386.
// REQUIRES: x86_64-supported-target // REQUIRES: x86_64-supported-target
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

compiler-rt/trunk/test/asan/TestCases/Linux/malloc_delete_mismatch.cc

// Check that we detect malloc/delete mismatch only if the approptiate flag // Check that we detect malloc/delete mismatch only if the approptiate flag
// is set. // is set.
// RUN: %clangxx_asan -g %s -o %t 2>&1 // RUN: %clangxx_asan -g %s -o %t 2>&1
// Find error and provide malloc context. // Find error and provide malloc context.
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:alloc_dealloc_mismatch=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=ALLOC-STACK // RUN: %env_asan_opts=alloc_dealloc_mismatch=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=ALLOC-STACK
// No error here. // No error here.
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:alloc_dealloc_mismatch=0 %run %t // RUN: %env_asan_opts=alloc_dealloc_mismatch=0 %run %t
// Also works if no malloc context is available. // Also works if no malloc context is available.
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:alloc_dealloc_mismatch=1:malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=alloc_dealloc_mismatch=1:malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:alloc_dealloc_mismatch=1:malloc_context_size=0:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=alloc_dealloc_mismatch=1:malloc_context_size=0:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s
// XFAIL: arm-linux-gnueabi // XFAIL: arm-linux-gnueabi
// XFAIL: armv7l-unknown-linux-gnueabihf // XFAIL: armv7l-unknown-linux-gnueabihf
#include <stdlib.h> #include <stdlib.h>
static volatile char *x; static volatile char *x;
int main() { int main() {
x = (char*)malloc(10); x = (char*)malloc(10);
Show All 11 Lines

compiler-rt/trunk/test/asan/TestCases/Linux/nohugepage_test.cc

// Regression test for // Regression test for
// https://code.google.com/p/chromium/issues/detail?id=446692 // https://code.google.com/p/chromium/issues/detail?id=446692
// where asan consumed too much RAM due to transparent hugetables. // where asan consumed too much RAM due to transparent hugetables.
// //
// RUN: %clangxx_asan -g %s -o %t // RUN: %clangxx_asan -g %s -o %t
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:no_huge_pages_for_shadow=1 %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=no_huge_pages_for_shadow=1 %run %t 2>&1 | FileCheck %s
// RUN: %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 // 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... // the result will depend on the OS version and settings...
// //
// REQUIRES: x86_64-supported-target, asan-64-bits // REQUIRES: x86_64-supported-target, asan-64-bits
// //
// WARNING: this test is very subtle and may nto work on some systems. // 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. // If this is the case we'll need to futher improve it or disable it.
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

compiler-rt/trunk/test/asan/TestCases/Linux/odr-violation.cc

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

compiler-rt/trunk/test/asan/TestCases/Linux/overflow-in-qsort.cc

// RUN: %clangxx_asan -O2 %s -o %t // RUN: %clangxx_asan -O2 %s -o %t
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:fast_unwind_on_fatal=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-FAST // RUN: %env_asan_opts=fast_unwind_on_fatal=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-FAST
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:fast_unwind_on_fatal=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-SLOW // RUN: %env_asan_opts=fast_unwind_on_fatal=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-SLOW
// Test how well we unwind in presence of qsort in the stack // 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). // (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 // https://code.google.com/p/address-sanitizer/issues/detail?id=137
// Fast unwinder is only available on x86_64 and i386. // Fast unwinder is only available on x86_64 and i386.
// REQUIRES: x86_64-supported-target // REQUIRES: x86_64-supported-target
Show All 38 Lines

compiler-rt/trunk/test/asan/TestCases/Linux/quarantine_size_mb.cc

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

compiler-rt/trunk/test/asan/TestCases/Linux/sized_delete_test.cc

// RUN: %clangxx_asan -fsized-deallocation -O0 %s -o %t // RUN: %clangxx_asan -fsized-deallocation -O0 %s -o %t
// RUN: not %run %t scalar 2>&1 | FileCheck %s -check-prefix=SCALAR // RUN: not %run %t scalar 2>&1 | FileCheck %s -check-prefix=SCALAR
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:new_delete_type_mismatch=1 not %run %t scalar 2>&1 | FileCheck %s -check-prefix=SCALAR // RUN: %env_asan_opts=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: not %run %t array 2>&1 | FileCheck %s -check-prefix=ARRAY
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:new_delete_type_mismatch=1 not %run %t array 2>&1 | FileCheck %s -check-prefix=ARRAY // RUN: %env_asan_opts=new_delete_type_mismatch=1 not %run %t array 2>&1 | FileCheck %s -check-prefix=ARRAY
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:new_delete_type_mismatch=0 %run %t scalar // RUN: %env_asan_opts=new_delete_type_mismatch=0 %run %t scalar
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:new_delete_type_mismatch=0 %run %t array // RUN: %env_asan_opts=new_delete_type_mismatch=0 %run %t array
#include <new> #include <new>
#include <stdio.h> #include <stdio.h>
#include <string> #include <string>
inline void break_optimization(void *arg) { inline void break_optimization(void *arg) {
__asm__ __volatile__("" : : "r" (arg) : "memory"); __asm__ __volatile__("" : : "r" (arg) : "memory");
} }
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

compiler-rt/trunk/test/asan/TestCases/Linux/stack-overflow-sigbus.cc

// Test ASan detection of stack-overflow condition when Linux sends SIGBUS. // Test ASan detection of stack-overflow condition when Linux sends SIGBUS.
// RUN: %clangxx_asan -O0 %s -o %t && env ASAN_OPTIONS=$ASAN_OPTIONS:use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -o %t && %env_asan_opts=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
#include <sys/mman.h> #include <sys/mman.h>
#include <sys/resource.h> #include <sys/resource.h>
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

compiler-rt/trunk/test/asan/TestCases/Linux/stack-trace-dlclose.cc

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

compiler-rt/trunk/test/asan/TestCases/Linux/static_tls.cc

// REQUIRES: asan-64-bits // REQUIRES: asan-64-bits
// Regression test: __tls_get_addr interceptor must recognize static TLS. // Regression test: __tls_get_addr interceptor must recognize static TLS.
// //
// RUN: %clangxx_asan -DSHARED %s -shared -o %t-so.so -fPIC // RUN: %clangxx_asan -DSHARED %s -shared -o %t-so.so -fPIC
// RUN: %clangxx_asan %s -ldl -pthread -o %t %t-so.so // RUN: %clangxx_asan %s -ldl -pthread -o %t %t-so.so
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:verbosity=2 %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=verbosity=2 %run %t 2>&1 | FileCheck %s
// CHECK: before // CHECK: before
// CHECK: __tls_get_addr: static tls // CHECK: __tls_get_addr: static tls
// CHECK: after // CHECK: after
// XFAIL: powerpc64, aarch64 // XFAIL: powerpc64, aarch64
#ifndef SHARED #ifndef SHARED
Show All 15 Lines

compiler-rt/trunk/test/asan/TestCases/Linux/stress_dtls.c

// REQUIRES: asan-64-bits // REQUIRES: asan-64-bits
// Stress test dynamic TLS + dlopen + threads. // Stress test dynamic TLS + dlopen + threads.
// //
// Note that glibc 2.15 seems utterly broken on this test, // Note that glibc 2.15 seems utterly broken on this test,
// it fails with ~17 DSOs dlopen-ed. // it fails with ~17 DSOs dlopen-ed.
// glibc 2.19 seems fine. // 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=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=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 -x c -DSO_NAME=f2 %s -shared -o %t-f2.so -fPIC
// RUN: %clangxx_asan %s -ldl -pthread -o %t // RUN: %clangxx_asan %s -ldl -pthread -o %t
// RUN: %run %t 0 3 // RUN: %run %t 0 3
// RUN: %run %t 2 3 // RUN: %run %t 2 3
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:verbosity=2 %run %t 10 2 2>&1 | FileCheck %s // RUN: %env_asan_opts=verbosity=2 %run %t 10 2 2>&1 | FileCheck %s
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:verbosity=2:intercept_tls_get_addr=1 %run %t 10 2 2>&1 | FileCheck %s // RUN: %env_asan_opts=verbosity=2:intercept_tls_get_addr=1 %run %t 10 2 2>&1 | FileCheck %s
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:verbosity=2:intercept_tls_get_addr=0 %run %t 10 2 2>&1 | FileCheck %s --check-prefix=CHECK0 // RUN: %env_asan_opts=verbosity=2:intercept_tls_get_addr=0 %run %t 10 2 2>&1 | FileCheck %s --check-prefix=CHECK0
// CHECK: __tls_get_addr // CHECK: __tls_get_addr
// CHECK: Creating thread 0 // CHECK: Creating thread 0
// CHECK: __tls_get_addr // CHECK: __tls_get_addr
// CHECK: Creating thread 1 // CHECK: Creating thread 1
// CHECK: __tls_get_addr // CHECK: __tls_get_addr
// CHECK: Creating thread 2 // CHECK: Creating thread 2
// CHECK: __tls_get_addr // CHECK: __tls_get_addr
// CHECK: Creating thread 3 // CHECK: Creating thread 3
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

compiler-rt/trunk/test/asan/TestCases/Posix/allow_user_segv.cc

// Regression test for // Regression test for
// https://code.google.com/p/address-sanitizer/issues/detail?id=180 // https://code.google.com/p/address-sanitizer/issues/detail?id=180
// RUN: %clangxx_asan -O0 %s -o %t && ASAN_OPTIONS=$ASAN_OPTIONS:allow_user_segv_handler=true not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -o %t && %env_asan_opts=allow_user_segv_handler=true not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O2 %s -o %t && ASAN_OPTIONS=$ASAN_OPTIONS:allow_user_segv_handler=true not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O2 %s -o %t && %env_asan_opts=allow_user_segv_handler=true not %run %t 2>&1 | FileCheck %s
#include <signal.h> #include <signal.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
struct sigaction original_sigaction_sigbus; struct sigaction original_sigaction_sigbus;
struct sigaction original_sigaction_sigsegv; struct sigaction original_sigaction_sigsegv;
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

compiler-rt/trunk/test/asan/TestCases/Posix/asan-symbolize-sanity-test.cc

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

compiler-rt/trunk/test/asan/TestCases/Posix/coverage-direct-activation.cc

// Test for direct coverage writing enabled at activation time. // Test for direct coverage writing enabled at activation time.
// RUN: %clangxx_asan -fsanitize-coverage=func -DSHARED %s -shared -o %dynamiclib -fPIC // RUN: %clangxx_asan -fsanitize-coverage=func -DSHARED %s -shared -o %dynamiclib -fPIC
// RUN: %clangxx -c -DSO_DIR=\"%T\" %s -o %t.o // RUN: %clangxx -c -DSO_DIR=\"%T\" %s -o %t.o
// RUN: %clangxx_asan -fsanitize-coverage=func %t.o %libdl -o %t // RUN: %clangxx_asan -fsanitize-coverage=func %t.o %libdl -o %t
// RUN: rm -rf %T/coverage-direct-activation // RUN: rm -rf %T/coverage-direct-activation
// RUN: mkdir -p %T/coverage-direct-activation/normal // RUN: mkdir -p %T/coverage-direct-activation/normal
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:coverage=1,coverage_direct=0,coverage_dir=%T/coverage-direct-activation/normal:verbosity=1 %run %t %dynamiclib // RUN: %env_asan_opts=coverage=1,coverage_direct=0,coverage_dir=%T/coverage-direct-activation/normal:verbosity=1 %run %t %dynamiclib
// RUN: %sancov print %T/coverage-direct-activation/normal/*.sancov >%T/coverage-direct-activation/normal/out.txt // 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: mkdir -p %T/coverage-direct-activation/direct
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:start_deactivated=1,coverage_direct=1,verbosity=1 \ // RUN: %env_asan_opts=start_deactivated=1,coverage_direct=1,verbosity=1 \
// RUN: ASAN_ACTIVATION_OPTIONS=coverage=1,coverage_dir=%T/coverage-direct-activation/direct %run %t %dynamiclib // RUN: ASAN_ACTIVATION_OPTIONS=coverage=1,coverage_dir=%T/coverage-direct-activation/direct %run %t %dynamiclib
// RUN: cd %T/coverage-direct-activation/direct // RUN: cd %T/coverage-direct-activation/direct
// RUN: %sancov rawunpack *.sancov.raw // RUN: %sancov rawunpack *.sancov.raw
// RUN: %sancov print *.sancov >out.txt // RUN: %sancov print *.sancov >out.txt
// RUN: cd ../.. // RUN: cd ../..
// Test start_deactivated=1,coverage=1 in ASAN_OPTIONS. // 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: diff -u coverage-direct-activation/normal/out.txt coverage-direct-activation/direct/out.txt
// RUN: mkdir -p %T/coverage-direct-activation/direct2 // RUN: mkdir -p %T/coverage-direct-activation/direct2
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:start_deactivated=1,coverage=1,coverage_direct=1,verbosity=1 \ // RUN: %env_asan_opts=start_deactivated=1,coverage=1,coverage_direct=1,verbosity=1 \
// RUN: ASAN_ACTIVATION_OPTIONS=coverage_dir=%T/coverage-direct-activation/direct2 %run %t %dynamiclib // RUN: ASAN_ACTIVATION_OPTIONS=coverage_dir=%T/coverage-direct-activation/direct2 %run %t %dynamiclib
// RUN: cd %T/coverage-direct-activation/direct2 // RUN: cd %T/coverage-direct-activation/direct2
// RUN: %sancov rawunpack *.sancov.raw // RUN: %sancov rawunpack *.sancov.raw
// RUN: %sancov print *.sancov >out.txt // RUN: %sancov print *.sancov >out.txt
// RUN: cd ../.. // RUN: cd ../..
// RUN: diff -u coverage-direct-activation/normal/out.txt coverage-direct-activation/direct2/out.txt // RUN: diff -u coverage-direct-activation/normal/out.txt coverage-direct-activation/direct2/out.txt
Show All 25 Lines

compiler-rt/trunk/test/asan/TestCases/Posix/coverage-direct-large.cc

// Test for direct coverage writing with lots of data. // Test for direct coverage writing with lots of data.
// Current implementation maps output file in chunks of 64K. This test overflows // Current implementation maps output file in chunks of 64K. This test overflows
// 1 chunk. // 1 chunk.
// RUN: %clangxx_asan -fsanitize-coverage=func -O0 -DSHARED %s -shared -o %dynamiclib -fPIC // 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: %clangxx_asan -fsanitize-coverage=func -O0 %s %libdl -o %t
// RUN: rm -rf %T/coverage-direct-large // RUN: rm -rf %T/coverage-direct-large
// RUN: mkdir -p %T/coverage-direct-large/normal && cd %T/coverage-direct-large/normal // RUN: mkdir -p %T/coverage-direct-large/normal && cd %T/coverage-direct-large/normal
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:coverage=1:coverage_direct=0:verbosity=1 %run %t %dynamiclib // RUN: %env_asan_opts=coverage=1:coverage_direct=0:verbosity=1 %run %t %dynamiclib
// RUN: %sancov print *.sancov >out.txt // RUN: %sancov print *.sancov >out.txt
// RUN: cd ../.. // RUN: cd ../..
// RUN: mkdir -p %T/coverage-direct-large/direct && cd %T/coverage-direct-large/direct // RUN: mkdir -p %T/coverage-direct-large/direct && cd %T/coverage-direct-large/direct
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:coverage=1:coverage_direct=1:verbosity=1 %run %t %dynamiclib // RUN: %env_asan_opts=coverage=1:coverage_direct=1:verbosity=1 %run %t %dynamiclib
// RUN: %sancov rawunpack *.sancov.raw // RUN: %sancov rawunpack *.sancov.raw
// RUN: %sancov print *.sancov >out.txt // RUN: %sancov print *.sancov >out.txt
// RUN: cd ../.. // RUN: cd ../..
// RUN: diff -u coverage-direct-large/normal/out.txt coverage-direct-large/direct/out.txt // RUN: diff -u coverage-direct-large/normal/out.txt coverage-direct-large/direct/out.txt
// //
// XFAIL: android // XFAIL: android
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

compiler-rt/trunk/test/asan/TestCases/Posix/coverage-direct.cc

// Test for direct coverage writing with dlopen at coverage level 1 to 3. // 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 -DSHARED %s -shared -o %dynamiclib -fPIC
// RUN: %clangxx_asan -fsanitize-coverage=func %s %libdl -o %t // RUN: %clangxx_asan -fsanitize-coverage=func %s %libdl -o %t
// RUN: rm -rf %T/coverage-direct // RUN: rm -rf %T/coverage-direct
// RUN: mkdir -p %T/coverage-direct/normal // RUN: mkdir -p %T/coverage-direct/normal
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:coverage=1:coverage_direct=0:coverage_dir=%T/coverage-direct/normal:verbosity=1 %run %t %dynamiclib // RUN: %env_asan_opts=coverage=1:coverage_direct=0:coverage_dir=%T/coverage-direct/normal:verbosity=1 %run %t %dynamiclib
// RUN: %sancov print %T/coverage-direct/normal/*.sancov >%T/coverage-direct/normal/out.txt // RUN: %sancov print %T/coverage-direct/normal/*.sancov >%T/coverage-direct/normal/out.txt
// RUN: mkdir -p %T/coverage-direct/direct // RUN: mkdir -p %T/coverage-direct/direct
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:coverage=1:coverage_direct=1:coverage_dir=%T/coverage-direct/direct:verbosity=1 %run %t %dynamiclib // RUN: %env_asan_opts=coverage=1:coverage_direct=1:coverage_dir=%T/coverage-direct/direct:verbosity=1 %run %t %dynamiclib
// RUN: cd %T/coverage-direct/direct // RUN: cd %T/coverage-direct/direct
// RUN: %sancov rawunpack *.sancov.raw // RUN: %sancov rawunpack *.sancov.raw
// RUN: %sancov print *.sancov >out.txt // RUN: %sancov print *.sancov >out.txt
// RUN: cd ../.. // RUN: cd ../..
// RUN: diff -u coverage-direct/normal/out.txt coverage-direct/direct/out.txt // 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 -DSHARED %s -shared -o %dynamiclib -fPIC
// RUN: %clangxx_asan -fsanitize-coverage=bb -DSO_DIR=\"%T\" %s %libdl -o %t // RUN: %clangxx_asan -fsanitize-coverage=bb -DSO_DIR=\"%T\" %s %libdl -o %t
// RUN: rm -rf %T/coverage-direct // RUN: rm -rf %T/coverage-direct
// RUN: mkdir -p %T/coverage-direct/normal // RUN: mkdir -p %T/coverage-direct/normal
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:coverage=1:coverage_direct=0:coverage_dir=%T/coverage-direct/normal:verbosity=1 %run %t %dynamiclib // RUN: %env_asan_opts=coverage=1:coverage_direct=0:coverage_dir=%T/coverage-direct/normal:verbosity=1 %run %t %dynamiclib
// RUN: %sancov print %T/coverage-direct/normal/*.sancov >%T/coverage-direct/normal/out.txt // RUN: %sancov print %T/coverage-direct/normal/*.sancov >%T/coverage-direct/normal/out.txt
// RUN: mkdir -p %T/coverage-direct/direct // RUN: mkdir -p %T/coverage-direct/direct
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:coverage=1:coverage_direct=1:coverage_dir=%T/coverage-direct/direct:verbosity=1 %run %t %dynamiclib // RUN: %env_asan_opts=coverage=1:coverage_direct=1:coverage_dir=%T/coverage-direct/direct:verbosity=1 %run %t %dynamiclib
// RUN: cd %T/coverage-direct/direct // RUN: cd %T/coverage-direct/direct
// RUN: %sancov rawunpack *.sancov.raw // RUN: %sancov rawunpack *.sancov.raw
// RUN: %sancov print *.sancov >out.txt // RUN: %sancov print *.sancov >out.txt
// RUN: cd ../.. // RUN: cd ../..
// RUN: diff -u coverage-direct/normal/out.txt coverage-direct/direct/out.txt // 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 -DSHARED %s -shared -o %dynamiclib -fPIC
// RUN: %clangxx_asan -fsanitize-coverage=edge -DSO_DIR=\"%T\" %s %libdl -o %t // RUN: %clangxx_asan -fsanitize-coverage=edge -DSO_DIR=\"%T\" %s %libdl -o %t
// RUN: rm -rf %T/coverage-direct // RUN: rm -rf %T/coverage-direct
// RUN: mkdir -p %T/coverage-direct/normal // RUN: mkdir -p %T/coverage-direct/normal
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:coverage=1:coverage_direct=0:coverage_dir=%T/coverage-direct/normal:verbosity=1 %run %t %dynamiclib // RUN: %env_asan_opts=coverage=1:coverage_direct=0:coverage_dir=%T/coverage-direct/normal:verbosity=1 %run %t %dynamiclib
// RUN: %sancov print %T/coverage-direct/normal/*.sancov >%T/coverage-direct/normal/out.txt // RUN: %sancov print %T/coverage-direct/normal/*.sancov >%T/coverage-direct/normal/out.txt
// RUN: mkdir -p %T/coverage-direct/direct // RUN: mkdir -p %T/coverage-direct/direct
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:coverage=1:coverage_direct=1:coverage_dir=%T/coverage-direct/direct:verbosity=1 %run %t %dynamiclib // RUN: %env_asan_opts=coverage=1:coverage_direct=1:coverage_dir=%T/coverage-direct/direct:verbosity=1 %run %t %dynamiclib
// RUN: cd %T/coverage-direct/direct // RUN: cd %T/coverage-direct/direct
// RUN: %sancov rawunpack *.sancov.raw // RUN: %sancov rawunpack *.sancov.raw
// RUN: %sancov print *.sancov >out.txt // RUN: %sancov print *.sancov >out.txt
// RUN: cd ../.. // RUN: cd ../..
// RUN: diff -u coverage-direct/normal/out.txt coverage-direct/direct/out.txt // RUN: diff -u coverage-direct/normal/out.txt coverage-direct/direct/out.txt
// XFAIL: android // XFAIL: android
Show All 24 Lines

compiler-rt/trunk/test/asan/TestCases/Posix/coverage-fork-direct.cc

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

compiler-rt/trunk/test/asan/TestCases/Posix/coverage-fork.cc

// RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t // RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t
// RUN: export ASAN_OPTIONS=$ASAN_OPTIONS:coverage=1:coverage_direct=0:verbosity=1
// RUN: rm -rf %T/coverage-fork // RUN: rm -rf %T/coverage-fork
// RUN: mkdir -p %T/coverage-fork && cd %T/coverage-fork // RUN: mkdir -p %T/coverage-fork && cd %T/coverage-fork
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=coverage=1:coverage_direct=0:verbosity=1 %run %t 2>&1 | FileCheck %s
// //
// XFAIL: android // XFAIL: android
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
__attribute__((noinline)) __attribute__((noinline))
Show All 25 Lines

compiler-rt/trunk/test/asan/TestCases/Posix/coverage-module-unloaded.cc

// Check that unloading a module doesn't break coverage dumping for remaining // Check that unloading a module doesn't break coverage dumping for remaining
// modules. // modules.
// RUN: %clangxx_asan -fsanitize-coverage=func -DSHARED %s -shared -o %dynamiclib1 -fPIC // 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 -DSHARED %s -shared -o %dynamiclib2 -fPIC
// RUN: %clangxx_asan -fsanitize-coverage=func %s %libdl -o %t // RUN: %clangxx_asan -fsanitize-coverage=func %s %libdl -o %t
// RUN: export ASAN_OPTIONS=$ASAN_OPTIONS:coverage=1:verbosity=1
// RUN: mkdir -p %T/coverage-module-unloaded && cd %T/coverage-module-unloaded // RUN: mkdir -p %T/coverage-module-unloaded && cd %T/coverage-module-unloaded
// RUN: %run %t %dynamiclib1 %dynamiclib2 2>&1 | FileCheck %s // RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t %dynamiclib1 %dynamiclib2 2>&1 | FileCheck %s
// RUN: %run %t %dynamiclib1 %dynamiclib2 foo 2>&1 | FileCheck %s // RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t %dynamiclib1 %dynamiclib2 foo 2>&1 | FileCheck %s
// RUN: rm -r %T/coverage-module-unloaded // RUN: rm -r %T/coverage-module-unloaded
// //
// https://code.google.com/p/address-sanitizer/issues/detail?id=263 // https://code.google.com/p/address-sanitizer/issues/detail?id=263
// XFAIL: android // XFAIL: android
#include <assert.h> #include <assert.h>
#include <dlfcn.h> #include <dlfcn.h>
#include <stdio.h> #include <stdio.h>
Show All 38 Lines

compiler-rt/trunk/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=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: %clangxx_asan -fsanitize-coverage=func %s -o %t %ld_flags_rpath_exe
// RUN: export ASAN_OPTIONS=$ASAN_OPTIONS:coverage=1:verbosity=1
// RUN: rm -rf %T/coverage_sandboxing_test // RUN: rm -rf %T/coverage_sandboxing_test
// RUN: mkdir %T/coverage_sandboxing_test && cd %T/coverage_sandboxing_test // RUN: mkdir %T/coverage_sandboxing_test && cd %T/coverage_sandboxing_test
// RUN: mkdir vanilla && cd vanilla // RUN: mkdir vanilla && cd vanilla
// RUN: %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-vanilla // RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-vanilla
// RUN: mkdir ../sandbox1 && cd ../sandbox1 // RUN: mkdir ../sandbox1 && cd ../sandbox1
// RUN: %run %t a 2>&1 | FileCheck %s --check-prefix=CHECK-sandbox // RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t a 2>&1 | FileCheck %s --check-prefix=CHECK-sandbox
// RUN: %sancov unpack coverage_sandboxing_test.sancov.packed // RUN: %sancov unpack coverage_sandboxing_test.sancov.packed
// RUN: mkdir ../sandbox2 && cd ../sandbox2 // RUN: mkdir ../sandbox2 && cd ../sandbox2
// RUN: %run %t a b 2>&1 | FileCheck %s --check-prefix=CHECK-sandbox // RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t a b 2>&1 | FileCheck %s --check-prefix=CHECK-sandbox
// RUN: %sancov unpack coverage_sandboxing_test.sancov.packed // RUN: %sancov unpack coverage_sandboxing_test.sancov.packed
// RUN: cd .. // RUN: cd ..
// RUN: %sancov print vanilla/`basename %dynamiclib`*.sancov > vanilla.txt // RUN: %sancov print vanilla/`basename %dynamiclib`*.sancov > vanilla.txt
// RUN: %sancov print sandbox1/`basename %dynamiclib`*.sancov > sandbox1.txt // RUN: %sancov print sandbox1/`basename %dynamiclib`*.sancov > sandbox1.txt
// RUN: %sancov print sandbox2/`basename %dynamiclib`*.sancov > sandbox2.txt // RUN: %sancov print sandbox2/`basename %dynamiclib`*.sancov > sandbox2.txt
// RUN: diff vanilla.txt sandbox1.txt // RUN: diff vanilla.txt sandbox1.txt
// RUN: diff vanilla.txt sandbox2.txt // RUN: diff vanilla.txt sandbox2.txt
// RUN: rm -r %T/coverage_sandboxing_test // RUN: rm -r %T/coverage_sandboxing_test
// https://code.google.com/p/address-sanitizer/issues/detail?id=263 // https://code.google.com/p/address-sanitizer/issues/detail?id=263
// XFAIL: android // XFAIL: android
#include <assert.h> #include <assert.h>
#include <fcntl.h> #include <fcntl.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

compiler-rt/trunk/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 -DSHARED %s -shared -o %dynamiclib -fPIC %ld_flags_rpath_so
// RUN: %clangxx_asan -fsanitize-coverage=func %s %ld_flags_rpath_exe -o %t // RUN: %clangxx_asan -fsanitize-coverage=func %s %ld_flags_rpath_exe -o %t
// RUN: export ASAN_OPTIONS=$ASAN_OPTIONS:coverage=1:verbosity=1
// RUN: rm -rf %T/coverage && mkdir -p %T/coverage && cd %T/coverage // RUN: rm -rf %T/coverage && mkdir -p %T/coverage && cd %T/coverage
// RUN: %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-main // RUN: %env_asan_opts=coverage=1:verbosity=1 %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: %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: %env_asan_opts=coverage=1:verbosity=1 %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: %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: %env_asan_opts=coverage=1:verbosity=1 %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: %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 // RUN: %env_asan_opts=coverage=1:verbosity=1 %run %t foo bar 2>&1 | FileCheck %s --check-prefix=CHECK-foo-bar
// RUN: %sancov print `ls *coverage.*sancov | grep -v '.so'` 2>&1 | FileCheck %s --check-prefix=CHECK-SANCOV2 // RUN: %sancov print `ls *coverage.*sancov | grep -v '.so'` 2>&1 | FileCheck %s --check-prefix=CHECK-SANCOV2
// RUN: %sancov print `ls *coverage.*sancov | grep '.so'` 2>&1 | FileCheck %s --check-prefix=CHECK-SANCOV1 // RUN: %sancov print `ls *coverage.*sancov | grep '.so'` 2>&1 | FileCheck %s --check-prefix=CHECK-SANCOV1
// RUN: %sancov merge `ls *coverage.*sancov | grep -v '.so'` > merged-cov // RUN: %sancov merge `ls *coverage.*sancov | grep -v '.so'` > merged-cov
// RUN: %sancov print merged-cov 2>&1 | FileCheck %s --check-prefix=CHECK-SANCOV2 // RUN: %sancov print merged-cov 2>&1 | FileCheck %s --check-prefix=CHECK-SANCOV2
// RUN: not %run %t foo bar 4 2>&1 | FileCheck %s --check-prefix=CHECK-report // RUN: %env_asan_opts=coverage=1:verbosity=1 not %run %t foo bar 4 2>&1 | FileCheck %s --check-prefix=CHECK-report
// RUN: not %run %t foo bar 4 5 2>&1 | FileCheck %s --check-prefix=CHECK-segv // RUN: %env_asan_opts=coverage=1:verbosity=1 not %run %t foo bar 4 5 2>&1 | FileCheck %s --check-prefix=CHECK-segv
// RUN: rm -r %T/coverage // RUN: rm -r %T/coverage
// //
// https://code.google.com/p/address-sanitizer/issues/detail?id=263 // https://code.google.com/p/address-sanitizer/issues/detail?id=263
// XFAIL: android // XFAIL: android
#include <sanitizer/coverage_interface.h> #include <sanitizer/coverage_interface.h>
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

compiler-rt/trunk/test/asan/TestCases/Posix/deep_call_stack.cc

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

compiler-rt/trunk/test/asan/TestCases/Posix/ioctl.cc

// RUN: %clangxx_asan -O0 -g %s -o %t && ASAN_OPTIONS=$ASAN_OPTIONS:handle_ioctl=1 not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 -g %s -o %t && %env_asan_opts=handle_ioctl=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 -g %s -o %t && ASAN_OPTIONS=$ASAN_OPTIONS:handle_ioctl=1 not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 -g %s -o %t && %env_asan_opts=handle_ioctl=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O0 -g %s -o %t && %run %t // RUN: %clangxx_asan -O0 -g %s -o %t && %run %t
// RUN: %clangxx_asan -O3 -g %s -o %t && %run %t // RUN: %clangxx_asan -O3 -g %s -o %t && %run %t
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>
#include <sys/ioctl.h> #include <sys/ioctl.h>
#include <sys/socket.h> #include <sys/socket.h>
Show All 14 Lines

compiler-rt/trunk/test/asan/TestCases/Posix/large_allocator_unpoisons_on_free.cc

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

compiler-rt/trunk/test/asan/TestCases/Posix/log_path_fork_test.cc.disabled

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

compiler-rt/trunk/test/asan/TestCases/Posix/new_array_cookie_test.cc

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

compiler-rt/trunk/test/asan/TestCases/Posix/new_array_cookie_uaf_test.cc

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

compiler-rt/trunk/test/asan/TestCases/Posix/stack-use-after-return.cc

// RUN: export ASAN_OPTIONS=$ASAN_OPTIONS:detect_stack_use_after_return=1 // RUN: %clangxx_asan -O0 %s -pthread -o %t && %env_asan_opts=detect_stack_use_after_return=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O0 %s -pthread -o %t && not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O1 %s -pthread -o %t && %env_asan_opts=detect_stack_use_after_return=1 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 && %env_asan_opts=detect_stack_use_after_return=1 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 && %env_asan_opts=detect_stack_use_after_return=1 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_opts=detect_stack_use_after_return=0 %run %t // RUN: %env_asan_opts=detect_stack_use_after_return=0 %run %t
// Regression test for a CHECK failure with small stack size and large frame. // 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 // RUN: %clangxx_asan -O3 %s -pthread -o %t -DkSize=10000 -DUseThread -DkStackSize=65536 && %env_asan_opts=detect_stack_use_after_return=1 not %run %t 2>&1 | FileCheck --check-prefix=THREAD %s
// //
// Test that we can find UAR in a thread other than main: // 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 // RUN: %clangxx_asan -DUseThread -O2 %s -pthread -o %t && %env_asan_opts=detect_stack_use_after_return=1 not %run %t 2>&1 | FileCheck --check-prefix=THREAD %s
// //
// Test the max_uar_stack_size_log/min_uar_stack_size_log flag. // Test the max_uar_stack_size_log/min_uar_stack_size_log flag.
// //
// RUN: %env_asan_opts=detect_stack_use_after_return=1:max_uar_stack_size_log=20:verbosity=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-20 %s // RUN: %env_asan_opts=detect_stack_use_after_return=1:max_uar_stack_size_log=20:verbosity=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-20 %s
// RUN: %env_asan_opts=detect_stack_use_after_return=1: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_opts=detect_stack_use_after_return=1: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
#include <stdio.h> #include <stdio.h>
#include <pthread.h> #include <pthread.h>
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

compiler-rt/trunk/test/asan/TestCases/Posix/start-deactivated.cc

// Test for ASAN_OPTIONS=start_deactivated=1 mode. // Test for ASAN_OPTIONS=start_deactivated=1 mode.
// Main executable is uninstrumented, but linked to ASan runtime. The shared // Main executable is uninstrumented, but linked to ASan runtime. The shared
// library is instrumented. Memory errors before dlopen are not detected. // 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_asan -O0 -DSHARED_LIB %s -fPIC -shared -o %t-so.so
// RUN: %clangxx -O0 %s -c -o %t.o // RUN: %clangxx -O0 %s -c -o %t.o
// RUN: %clangxx_asan -O0 %t.o %libdl -o %t // RUN: %clangxx_asan -O0 %t.o %libdl -o %t
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:start_deactivated=1,allocator_may_return_null=0 \ // RUN: %env_asan_opts=start_deactivated=1,allocator_may_return_null=0 \
// RUN: ASAN_ACTIVATION_OPTIONS=allocator_may_return_null=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK // RUN: ASAN_ACTIVATION_OPTIONS=allocator_may_return_null=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:start_deactivated=1 \ // RUN: %env_asan_opts=start_deactivated=1 \
// RUN: ASAN_ACTIVATION_OPTIONS=help=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-HELP // RUN: ASAN_ACTIVATION_OPTIONS=help=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-HELP
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:start_deactivated=1,verbosity=1 \ // RUN: %env_asan_opts=start_deactivated=1,verbosity=1 \
// RUN: ASAN_ACTIVATION_OPTIONS=help=1,handle_segv=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-UNSUPPORTED // RUN: ASAN_ACTIVATION_OPTIONS=help=1,handle_segv=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-UNSUPPORTED
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:start_deactivated=1 \ // RUN: %env_asan_opts=start_deactivated=1 \
// RUN: ASAN_ACTIVATION_OPTIONS=help=1,handle_segv=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-UNSUPPORTED-V0 // 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. // Check that verbosity=1 in activation flags affects reporting of unrecognized activation flags.
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:start_deactivated=1 \ // RUN: %env_asan_opts=start_deactivated=1 \
// RUN: ASAN_ACTIVATION_OPTIONS=help=1,handle_segv=0,verbosity=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-UNSUPPORTED // 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 // XFAIL: arm-linux-gnueabi
#if !defined(SHARED_LIB) #if !defined(SHARED_LIB)
#include <assert.h> #include <assert.h>
#include <dlfcn.h> #include <dlfcn.h>
#include <stdio.h> #include <stdio.h>
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

compiler-rt/trunk/test/asan/TestCases/Posix/tsd_dtor_leak.cc

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

compiler-rt/trunk/test/asan/TestCases/Windows/coverage-basic.cc

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

compiler-rt/trunk/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 -LD -O0 -DDLL %s -Fe%t.dll
// RUN: %clang_cl_asan -O0 -DEXE %s %t.lib -Fe%te.exe // 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_opts=report_globals=2 %run %te.exe 2>&1 | FileCheck %s
// FIXME: Currently, the MT runtime build crashes on startup due to dbghelp.dll // FIXME: Currently, the MT runtime build crashes on startup due to dbghelp.dll
// initialization failure. // initialization failure.
// REQUIRES: asan-dynamic-runtime // REQUIRES: asan-dynamic-runtime
#include <windows.h> #include <windows.h>
#include <stdio.h> #include <stdio.h>
Show All 29 Lines

compiler-rt/trunk/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 -O0 %p/dll_host.cc -Fe%t
// RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll // 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_opts=detect_stack_use_after_return=1 not %run %t %t.dll 2>&1 | FileCheck %s
#include <malloc.h> #include <malloc.h>
char *x; char *x;
void foo() { void foo() {
char stack_buffer[42]; char stack_buffer[42];
x = &stack_buffer[13]; x = &stack_buffer[13];
Show All 17 Lines

compiler-rt/trunk/test/asan/TestCases/Windows/report_after_syminitialize.cc

// RUN: %clangxx_asan -O0 %s -o %t // RUN: %clangxx_asan -O0 %s -o %t
// RUN: env ASAN_OPTIONS=external_symbolizer_path=asdf not %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=external_symbolizer_path=asdf not %run %t 2>&1 | FileCheck %s
#include <windows.h> #include <windows.h>
#include <dbghelp.h> #include <dbghelp.h>
int main() { int main() {
// Make sure the RTL recovers from "no options enabled" dbghelp setup. // Make sure the RTL recovers from "no options enabled" dbghelp setup.
SymSetOptions(0); SymSetOptions(0);
Show All 11 Lines

compiler-rt/trunk/test/asan/TestCases/Windows/report_globals_reload_dll.cc

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

compiler-rt/trunk/test/asan/TestCases/Windows/report_globals_vs_freelibrary.cc

// RUN: %clang_cl_asan -LD -O0 -DDLL %s -Fe%t.dll // RUN: %clang_cl_asan -LD -O0 -DDLL %s -Fe%t.dll
// RUN: %clang_cl_asan -O0 -DEXE %s -Fe%te.exe // 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_opts=report_globals=2 %run %te.exe %t.dll 2>&1 | FileCheck %s
#include <windows.h> #include <windows.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
extern "C" { extern "C" {
#if defined(EXE) #if defined(EXE)
int main(int argc, char **argv) { int main(int argc, char **argv) {
Show All 36 Lines

compiler-rt/trunk/test/asan/TestCases/Windows/stack_use_after_return.cc

// RUN: %clang_cl_asan -O0 %s -Fe%t // 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_opts=detect_stack_use_after_return=1 not %run %t 2>&1 | FileCheck %s
char *x; char *x;
void foo() { void foo() {
char stack_buffer[42]; char stack_buffer[42];
x = &stack_buffer[13]; x = &stack_buffer[13];
} }
Show All 12 Lines

compiler-rt/trunk/test/asan/TestCases/suppressions-exec-relative-location.cc

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

compiler-rt/trunk/test/asan/TestCases/suppressions-interceptor.cc

// Check that without suppressions, we catch the issue. // Check that without suppressions, we catch the issue.
// RUN: %clangxx_asan -O0 %s -o %t // RUN: %clangxx_asan -O0 %s -o %t
// RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-CRASH %s // RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-CRASH %s
// RUN: echo "interceptor_name:strlen" > %t.supp // RUN: echo "interceptor_name:strlen" > %t.supp
// RUN: env ASAN_OPTIONS="$ASAN_OPTIONS:suppressions='%t.supp'" %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s // RUN: %env_asan_opts=suppressions='"%t.supp"' %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
// FIXME: Windows symbolizer needs work to make this pass. // XFAIL: android
// XFAIL: android,win32
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
int main() { int main() {
char *a = (char *)malloc(6); char *a = (char *)malloc(6);
free(a); free(a);
size_t len = strlen(a); // BOOM size_t len = strlen(a); // BOOM
fprintf(stderr, "strlen ignored, len = %zu\n", len); fprintf(stderr, "strlen ignored, len = %zu\n", len);
} }
// CHECK-CRASH: AddressSanitizer: heap-use-after-free // CHECK-CRASH: AddressSanitizer: heap-use-after-free
// CHECK-CRASH-NOT: strlen ignored // CHECK-CRASH-NOT: strlen ignored
// CHECK-IGNORE-NOT: AddressSanitizer: heap-use-after-free // CHECK-IGNORE-NOT: AddressSanitizer: heap-use-after-free
// CHECK-IGNORE: strlen ignored // CHECK-IGNORE: strlen ignored

compiler-rt/trunk/test/asan/TestCases/uar_and_exceptions.cc

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

compiler-rt/trunk/test/asan/TestCases/use-after-scope.cc

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