This is an archive of the discontinued LLVM Phabricator instance.

Differential D10294

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

Authored by filcab on Jun 5 2015, 7:38 PM.

Details

Reviewers
kcc
samsonov
rnk
Commits
rG91244924cb11: [ASan] Test churn for setting ASAN_OPTIONS=symbolize_vs_style=false
rCRT239754: [ASan] Test churn for setting ASAN_OPTIONS=symbolize_vs_style=false
rL239754: [ASan] Test churn for setting ASAN_OPTIONS=symbolize_vs_style=false
Summary

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

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

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

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

Diff Detail

Repository
rL LLVM

Event Timeline

filcab updated this revision to Diff 27254.Jun 5 2015, 7:38 PM
filcab retitled this revision from to [ASan] Test churn for setting ASAN_OPTIONS=symbolize_vs_style=false.
filcab updated this object.
filcab edited the test plan for this revision. (Show Details)
filcab added reviewers: samsonov, kcc, rnk.
filcab added a subscriber: Unknown Object (MLST).
Herald added a subscriber: tberghammer. · View Herald TranscriptJun 5 2015, 7:38 PM
rnk edited edge metadata.Jun 8 2015, 1:42 PM

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

samsonov edited edge metadata.Jun 9 2015, 5:22 PM

Wait a second, why can't you set

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

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

samsonov added a comment.Jun 9 2015, 5:27 PM
In D10294#185931, @samsonov wrote:

Wait a second, why can't you set

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

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

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

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

filcab added a comment.Jun 9 2015, 5:38 PM

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

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

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

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

(llvm-env)

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

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

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

Thanks,

Filipe
filcab added a comment.Jun 9 2015, 5:41 PM

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

Will update.

Thanks,

Filipe
samsonov added a comment.Jun 9 2015, 5:43 PM

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

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

(llvm-env)

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

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

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

$ grep -rnH "$.SAN_OPTIONS" projects/compiler-rt/test/*
  • change lit's shell, if we're sure that's the one that's being used.

Thanks,

Filipe
filcab updated this revision to Diff 27536.Jun 11 2015, 12:31 PM
filcab edited edge metadata.

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

samsonov added inline comments.Jun 12 2015, 11:14 AM
test/asan/TestCases/Darwin/suppressions-darwin.cc
7 ↗(On Diff #27536)

Looks like quotes should enclose the whole string here

ASAN_OPTIONS="$ASAN_OPTIONS:suppressions='%t.supp'"
test/asan/TestCases/Linux/leak.cc
6 ↗(On Diff #27536)

Huh? Why not

env ASAN_OPTIONS=$ASAN_OPTIONS

?

test/asan/TestCases/Linux/malloc_delete_mismatch.cc
33 ↗(On Diff #27536)

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

test/asan/TestCases/Posix/log_path_fork_test.cc.disabled
4 ↗(On Diff #27536)

Same note about quotes.

test/asan/TestCases/Windows/report_globals_reload_dll.cc
4 ↗(On Diff #27536)

You sure you need both?

test/asan/TestCases/atol_strict.c
4 ↗(On Diff #27536)

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

test/asan/TestCases/atoll_strict.c
4 ↗(On Diff #27536)

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

test/asan/TestCases/strcasestr-1.c
6 ↗(On Diff #27536)

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

test/asan/TestCases/strcasestr_strict.c
3 ↗(On Diff #27536)

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

test/asan/TestCases/suppressions-exec-relative-location.cc
12 ↗(On Diff #27536)

quotes (here and below)

filcab updated this revision to Diff 27622.Jun 12 2015, 5:51 PM

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

filcab added a comment.Jun 12 2015, 5:58 PM

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

Filipe

samsonov accepted this revision.Jun 13 2015, 10:22 AM
samsonov edited edge metadata.

LGTM, thanks! Single comment below.

test/asan/TestCases/stack-use-after-return.cc
15 ↗(On Diff #27622)

Extra $ASAN_OPTIONS here.

16 ↗(On Diff #27622)

And here

This revision is now accepted and ready to land.Jun 13 2015, 10:22 AM
Closed by commit rL239754: [ASan] Test churn for setting ASAN_OPTIONS=symbolize_vs_style=false (authored by filcab). · Explain WhyJun 15 2015, 1:48 PM
This revision was automatically updated to reflect the committed changes.
filcab added a comment.Jun 15 2015, 2:55 PM

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

Revision Contents

PathSize
compiler-rt/
trunk/
test/
asan/
TestCases/
Android/
12 lines
Darwin/
4 lines
2 lines
6 lines
2 lines
4 lines
8 lines
2 lines
2 lines
Linux/
2 lines
2 lines
2 lines
2 lines
14 lines
2 lines
4 lines
6 lines
6 lines
4 lines
8 lines
4 lines
18 lines
4 lines
10 lines
12 lines
2 lines
2 lines
2 lines
6 lines
Posix/
4 lines
2 lines
6 lines
4 lines
12 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
4 lines
4 lines
10 lines
2 lines
Windows/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
20 lines
2 lines
2 lines
2 lines
12 lines
12 lines
12 lines
2 lines
2 lines
2 lines
2 lines
12 lines
4 lines
16 lines
4 lines
8 lines
2 lines
16 lines
2 lines
4 lines
4 lines
2 lines
4 lines
2 lines
8 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
8 lines
8 lines
4 lines
8 lines
10 lines
4 lines
4 lines
4 lines
8 lines
4 lines
4 lines
4 lines
6 lines
4 lines
4 lines
6 lines
26 lines
4 lines
4 lines
4 lines
4 lines
8 lines
4 lines
4 lines
2 lines
2 lines
4 lines
2 lines
8 lines
2 lines
2 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
4 lines
28 lines
28 lines
6 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines

Diff 27716

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: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android/direct:verbosity=1 %run %t // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android-kill/direct:verbosity=1 not %run %t // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android/direct:verbosity=1 %run %t // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android-kill/direct:verbosity=1 not %run %t // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android/direct:verbosity=1 %run %t // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%device/coverage-android-kill/direct:verbosity=1 not %run %t // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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.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: ASAN_OPTIONS=verbosity=2 ASAN_SYMBOLIZER_PATH=$(which atos) not %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:verbosity=2 ASAN_SYMBOLIZER_PATH=$(which atos) not %run %t 2>&1 | FileCheck %s
// Check that when having a DYLD_ROOT_PATH set, the symbolizer still works. // Check that when having a DYLD_ROOT_PATH set, the symbolizer still works.
// RUN: DYLD_ROOT_PATH="/" ASAN_OPTIONS=verbosity=2 ASAN_SYMBOLIZER_PATH=$(which atos) \ // RUN: env DYLD_ROOT_PATH="/" ASAN_OPTIONS=$ASAN_OPTIONS:verbosity=2 ASAN_SYMBOLIZER_PATH=$(which atos) \
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: 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];
Show All 13 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: 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_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
#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: DYLD_INSERT_LIBRARIES=@executable_path/libclang_rt.asan_osx_dynamic.dylib \ // RUN: env DYLD_INSERT_LIBRARIES=@executable_path/libclang_rt.asan_osx_dynamic.dylib \
// RUN: ASAN_OPTIONS=verbosity=1 %run %T/dyld_insert_libraries_reexec/a.out 2>&1 \ // RUN: ASAN_OPTIONS=$ASAN_OPTIONS:verbosity=1 %run %T/dyld_insert_libraries_reexec/a.out 2>&1 \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: ASAN_OPTIONS=verbosity=1 %run %T/dyld_insert_libraries_reexec/a.out 2>&1 \ // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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
#include <stdio.h> #include <stdio.h>
int main() { int main() {
printf("Passed\n"); printf("Passed\n");
return 0; return 0;
} }
Show All 10 Lines

compiler-rt/trunk/test/asan/TestCases/Darwin/reexec-insert-libraries-env.cc

// Make sure ASan doesn't hang in an exec loop if DYLD_INSERT_LIBRARIES is set. // Make sure ASan doesn't hang in an exec loop if DYLD_INSERT_LIBRARIES is set.
// This is a regression test for // This is a regression test for
// https://code.google.com/p/address-sanitizer/issues/detail?id=159 // https://code.google.com/p/address-sanitizer/issues/detail?id=159
// RUN: %clangxx_asan %s -o %t // RUN: %clangxx_asan %s -o %t
// RUN: %clangxx -DSHARED_LIB %s \ // RUN: %clangxx -DSHARED_LIB %s \
// RUN: -dynamiclib -o darwin-dummy-shared-lib-so.dylib // RUN: -dynamiclib -o darwin-dummy-shared-lib-so.dylib
// FIXME: the following command line may hang in the case of a regression. // FIXME: the following command line may hang in the case of a regression.
// RUN: DYLD_INSERT_LIBRARIES=darwin-dummy-shared-lib-so.dylib \ // RUN: env DYLD_INSERT_LIBRARIES=darwin-dummy-shared-lib-so.dylib \
// RUN: %run %t 2>&1 | FileCheck %s || exit 1 // RUN: %run %t 2>&1 | FileCheck %s || exit 1
#if !defined(SHARED_LIB) #if !defined(SHARED_LIB)
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int main() { int main() {
const char kEnvName[] = "DYLD_INSERT_LIBRARIES"; const char kEnvName[] = "DYLD_INSERT_LIBRARIES";
printf("%s=%s\n", kEnvName, getenv(kEnvName)); printf("%s=%s\n", kEnvName, getenv(kEnvName));
// CHECK: {{DYLD_INSERT_LIBRARIES=.*darwin-dummy-shared-lib-so.dylib.*}} // CHECK: {{DYLD_INSERT_LIBRARIES=.*darwin-dummy-shared-lib-so.dylib.*}}
return 0; return 0;
} }
#else // SHARED_LIB #else // SHARED_LIB
void foo() {} void foo() {}
#endif // SHARED_LIB #endif // SHARED_LIB

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

// In a non-forking sandbox, we can't spawn an external symbolizer, but dladdr() // In a non-forking sandbox, we can't spawn an external symbolizer, but dladdr()
// should still work and provide function names. No line numbers though. // should still work and provide function names. No line numbers though.
// Second, `atos` symbolizer can't inspect a process that has an inaccessible // Second, `atos` symbolizer can't inspect a process that has an inaccessible
// task port, in which case we should again fallback to dladdr gracefully. // task port, in which case we should again fallback to dladdr gracefully.
// RUN: %clangxx_asan -O0 %s -o %t // RUN: %clangxx_asan -O0 %s -o %t
// RUN: not %run sandbox-exec -p '(version 1)(allow default)(deny process-fork)' %t 2>&1 | FileCheck %s // RUN: not %run sandbox-exec -p '(version 1)(allow default)(deny process-fork)' %t 2>&1 | FileCheck %s
// RUN: not %run sandbox-exec -p '(version 1)(allow default)(deny mach-priv-task-port)' %t 2>&1 | FileCheck %s // RUN: not %run sandbox-exec -p '(version 1)(allow default)(deny mach-priv-task-port)' %t 2>&1 | FileCheck %s
// RUN: ASAN_SYMBOLIZER_PATH="" not %run sandbox-exec -p '(version 1)(allow default)(deny mach-priv-task-port)' %t 2>&1 | FileCheck %s // RUN: env ASAN_SYMBOLIZER_PATH="" not %run sandbox-exec -p '(version 1)(allow default)(deny mach-priv-task-port)' %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -o %t // RUN: %clangxx_asan -O3 %s -o %t
// RUN: not %run sandbox-exec -p '(version 1)(allow default)(deny process-fork)' %t 2>&1 | FileCheck %s // RUN: not %run sandbox-exec -p '(version 1)(allow default)(deny process-fork)' %t 2>&1 | FileCheck %s
// RUN: not %run sandbox-exec -p '(version 1)(allow default)(deny mach-priv-task-port)' %t 2>&1 | FileCheck %s // RUN: not %run sandbox-exec -p '(version 1)(allow default)(deny mach-priv-task-port)' %t 2>&1 | FileCheck %s
// RUN: ASAN_SYMBOLIZER_PATH="" not %run sandbox-exec -p '(version 1)(allow default)(deny mach-priv-task-port)' %t 2>&1 | FileCheck %s // RUN: env ASAN_SYMBOLIZER_PATH="" not %run sandbox-exec -p '(version 1)(allow default)(deny mach-priv-task-port)' %t 2>&1 | FileCheck %s
#include <stdlib.h> #include <stdlib.h>
int main() { int main() {
char *x = (char*)malloc(10 * sizeof(char)); char *x = (char*)malloc(10 * sizeof(char));
free(x); free(x);
return x[5]; return x[5];
// CHECK: {{.*ERROR: AddressSanitizer: heap-use-after-free on address}} // CHECK: {{.*ERROR: AddressSanitizer: heap-use-after-free on address}}
// CHECK: {{READ of size 1 at 0x.* thread T0}} // CHECK: {{READ of size 1 at 0x.* thread T0}}
// CHECK: {{ #0 0x.* in main}} // CHECK: {{ #0 0x.* in main}}
// CHECK: {{freed by thread T0 here:}} // CHECK: {{freed by thread T0 here:}}
// CHECK: {{ #0 0x.* in wrap_free}} // CHECK: {{ #0 0x.* in wrap_free}}
// CHECK: {{ #1 0x.* in main}} // CHECK: {{ #1 0x.* in main}}
// CHECK: {{previously allocated by thread T0 here:}} // CHECK: {{previously allocated by thread T0 here:}}
// CHECK: {{ #0 0x.* in wrap_malloc}} // CHECK: {{ #0 0x.* in wrap_malloc}}
// CHECK: {{ #1 0x.* in main}} // CHECK: {{ #1 0x.* in main}}
} }

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: ASAN_OPTIONS="suppressions='%t.supp'" %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s // RUN: env ASAN_OPTIONS="$ASAN_OPTIONS: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: ASAN_OPTIONS="suppressions='%t.supp':symbolize=false" %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s // RUN: env ASAN_OPTIONS="$ASAN_OPTIONS: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: ASAN_OPTIONS="suppressions='%t.supp'" %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s // RUN: env ASAN_OPTIONS="$ASAN_OPTIONS: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: ASAN_OPTIONS="suppressions='%t.supp':symbolize=false" %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s // RUN: env ASAN_OPTIONS="$ASAN_OPTIONS: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: ASAN_OPTIONS=suppressions=%t.supp \ // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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/Darwin/unset-insert-libraries-on-exec.cc

// Make sure ASan removes the runtime library from DYLD_INSERT_LIBRARIES before // Make sure ASan removes the runtime library from DYLD_INSERT_LIBRARIES before
// executing other programs. // executing other programs.
// RUN: %clangxx_asan %s -o %t // RUN: %clangxx_asan %s -o %t
// RUN: %clangxx %p/../Helpers/echo-env.cc -o %T/echo-env // RUN: %clangxx %p/../Helpers/echo-env.cc -o %T/echo-env
// RUN: %clangxx -DSHARED_LIB %s \ // RUN: %clangxx -DSHARED_LIB %s \
// RUN: -dynamiclib -o %t-darwin-dummy-shared-lib-so.dylib // RUN: -dynamiclib -o %t-darwin-dummy-shared-lib-so.dylib
// Make sure DYLD_INSERT_LIBRARIES doesn't contain the runtime library before // Make sure DYLD_INSERT_LIBRARIES doesn't contain the runtime library before
// execl(). // execl().
// RUN: %run %t %T/echo-env >/dev/null 2>&1 // RUN: %run %t %T/echo-env >/dev/null 2>&1
// RUN: DYLD_INSERT_LIBRARIES=%t-darwin-dummy-shared-lib-so.dylib \ // RUN: env DYLD_INSERT_LIBRARIES=%t-darwin-dummy-shared-lib-so.dylib \
// RUN: %run %t %T/echo-env 2>&1 | FileCheck %s || exit 1 // RUN: %run %t %T/echo-env 2>&1 | FileCheck %s || exit 1
#if !defined(SHARED_LIB) #if !defined(SHARED_LIB)
#include <unistd.h> #include <unistd.h>
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
execl(argv[1], argv[1], "DYLD_INSERT_LIBRARIES", NULL); execl(argv[1], argv[1], "DYLD_INSERT_LIBRARIES", NULL);
// CHECK: {{DYLD_INSERT_LIBRARIES = .*darwin-dummy-shared-lib-so.dylib.*}} // CHECK: {{DYLD_INSERT_LIBRARIES = .*darwin-dummy-shared-lib-so.dylib.*}}
return 0; return 0;
} }
#else // SHARED_LIB #else // SHARED_LIB
void foo() {} void foo() {}
#endif // SHARED_LIB #endif // SHARED_LIB

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: ASAN_OPTIONS=verbosity=1 %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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/asan_preload_test-1.cc

// Test that non-sanitized executables work with sanitized shared libs // Test that non-sanitized executables work with sanitized shared libs
// and preloaded runtime. // and preloaded runtime.
// //
// RUN: %clangxx -DBUILD_SO=1 -fPIC -shared %s -o %t.so // RUN: %clangxx -DBUILD_SO=1 -fPIC -shared %s -o %t.so
// RUN: %clangxx %s %t.so -o %t // RUN: %clangxx %s %t.so -o %t
// //
// RUN: %clangxx_asan -DBUILD_SO=1 -fPIC -shared %s -o %t.so // RUN: %clangxx_asan -DBUILD_SO=1 -fPIC -shared %s -o %t.so
// RUN: LD_PRELOAD=%shared_libasan not %run %t 2>&1 | FileCheck %s // RUN: env LD_PRELOAD=%shared_libasan not %run %t 2>&1 | FileCheck %s
// REQUIRES: asan-dynamic-runtime // REQUIRES: asan-dynamic-runtime
// This way of setting LD_PRELOAD does not work with Android test runner. // This way of setting LD_PRELOAD does not work with Android test runner.
// REQUIRES: not-android // REQUIRES: not-android
#if BUILD_SO #if BUILD_SO
char dummy; char dummy;
Show All 14 Lines

compiler-rt/trunk/test/asan/TestCases/Linux/asan_preload_test-2.cc

// Test that preloaded runtime works with unsanitized executables. // Test that preloaded runtime works with unsanitized executables.
// //
// RUN: %clangxx %s -o %t // RUN: %clangxx %s -o %t
// RUN: LD_PRELOAD=%shared_libasan not %run %t 2>&1 | FileCheck %s // RUN: env LD_PRELOAD=%shared_libasan not %run %t 2>&1 | FileCheck %s
// REQUIRES: asan-dynamic-runtime // REQUIRES: asan-dynamic-runtime
// This way of setting LD_PRELOAD does not work with Android test runner. // This way of setting LD_PRELOAD does not work with Android test runner.
// REQUIRES: not-android // REQUIRES: not-android
#include <stdlib.h> #include <stdlib.h>
Show All 12 Lines

compiler-rt/trunk/test/asan/TestCases/Linux/asan_rt_confict_test-1.cc

// Test that preloading dynamic runtime to statically sanitized // Test that preloading dynamic runtime to statically sanitized
// executable is prohibited. // executable is prohibited.
// //
// RUN: %clangxx_asan_static %s -o %t // RUN: %clangxx_asan_static %s -o %t
// RUN: LD_PRELOAD=%shared_libasan not %run %t 2>&1 | FileCheck %s // RUN: env LD_PRELOAD=%shared_libasan not %run %t 2>&1 | FileCheck %s
// REQUIRES: asan-dynamic-runtime // REQUIRES: asan-dynamic-runtime
// XFAIL: android // XFAIL: android
#include <stdlib.h> #include <stdlib.h>
int main(int argc, char **argv) { return 0; } int main(int argc, char **argv) { return 0; }
// CHECK: Your application is linked against incompatible ASan runtimes // CHECK: Your application is linked against incompatible ASan runtimes

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

// Test for "sancov.py missing ...". // Test for "sancov.py missing ...".
// RUN: ASAN_OPTIONS=coverage=1:coverage_dir=%T/coverage-missing // RUN: env 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: ASAN_OPTIONS=$ASAN_OPTIONS %t // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS %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: ASAN_OPTIONS=$ASAN_OPTIONS %t x // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS %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: ASAN_OPTIONS=$ASAN_OPTIONS %t x x // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS %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: LIBNAME=`basename %dynamiclib` // RUN: env 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: ASAN_OPTIONS=$ASAN_OPTIONS %t x // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS %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: ASAN_OPTIONS=$ASAN_OPTIONS %t x x // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS %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=strict_init_order=true %run %t 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_init_order=true %run %t 2>&1
#if defined(SHARED_LIB) #if defined(SHARED_LIB)
#include <stdio.h> #include <stdio.h>
struct Bar { struct Bar {
Bar(int val) : val(val) { printf("Bar::Bar(%d)\n", val); } Bar(int val) : val(val) { printf("Bar::Bar(%d)\n", val); }
int val; int val;
}; };
Show All 29 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: ASAN_OPTIONS=strict_init_order=true not %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=strict_init_order=true not %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%kernel_bits // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%kernel_bits
// RUN: ASAN_OPTIONS=verbosity=1:full_address_space=0 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%kernel_bits // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:verbosity=1:full_address_space=0 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%kernel_bits
// RUN: ASAN_OPTIONS=verbosity=1:full_address_space=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-kernel-64-bits // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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 // REQUIRES: asan-32-bits
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: ASAN_OPTIONS=detect_leaks=1 not %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:detect_leaks=1 not %run %t 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS="" not %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS not %run %t 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS=detect_leaks=0 %run %t // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=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=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-FAST
// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-SLOW // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=alloc_dealloc_mismatch=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=ALLOC-STACK // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=alloc_dealloc_mismatch=0 %run %t // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:alloc_dealloc_mismatch=0 %run %t
// Also works if no malloc context is available. // Also works if no malloc context is available.
// RUN: ASAN_OPTIONS=alloc_dealloc_mismatch=1:malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s // RUN: 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: 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_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=no_huge_pages_for_shadow=1 %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=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=1 not %run %t-ODR-EXE 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0:detect_odr_violation=2 not %run %t-ODR-EXE 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:fast_unwind_on_malloc=0:detect_odr_violation=2 not %run %t-ODR-EXE 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0:detect_odr_violation=0 %run %t-ODR-EXE 2>&1 | FileCheck %s --check-prefix=DISABLED // RUN: 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: ASAN_OPTIONS=fast_unwind_on_malloc=0 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
// //
// 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: 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_OPTIONS=$ASAN_OPTIONS:fast_unwind_on_malloc=0:detect_odr_violation=1 %run %t-ODR-EXE 2>&1 | FileCheck %s --check-prefix=DISABLED
// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0:detect_odr_violation=2 not %run %t-ODR-EXE 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:fast_unwind_on_malloc=0:detect_odr_violation=2 not %run %t-ODR-EXE 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0 not %run %t-ODR-EXE 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: 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_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: echo "odr_violation:foo::G" > %t.supp // RUN: echo "odr_violation:foo::G" > %t.supp
// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0:detect_odr_violation=2:suppressions=%t.supp %run %t-ODR-EXE 2>&1 | FileCheck %s --check-prefix=DISABLED // RUN: 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: 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: ASAN_OPTIONS=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=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-FAST
// RUN: ASAN_OPTIONS=fast_unwind_on_fatal=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-SLOW // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=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=10485760:verbosity=1:hard_rss_limit_mb=50 %run %t 2>&1 | FileCheck %s --check-prefix=Q10
// RUN: ASAN_OPTIONS=quarantine_size_mb=10:verbosity=1:hard_rss_limit_mb=50 %run %t 2>&1 | FileCheck %s --check-prefix=Q10 // RUN: 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: ASAN_OPTIONS=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=10:quarantine_size=20:verbosity=1 not %run %t 2>&1 | FileCheck %s --check-prefix=BOTH
// RUN: ASAN_OPTIONS=quarantine_size_mb=1000:hard_rss_limit_mb=50 not %run %t 2>&1 | FileCheck %s --check-prefix=RSS_LIMIT // RUN: 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: ASAN_OPTIONS=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
#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: ASAN_OPTIONS=new_delete_type_mismatch=1 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: not %run %t array 2>&1 | FileCheck %s -check-prefix=ARRAY // RUN: not %run %t array 2>&1 | FileCheck %s -check-prefix=ARRAY
// RUN: ASAN_OPTIONS=new_delete_type_mismatch=1 not %run %t array 2>&1 | FileCheck %s -check-prefix=ARRAY // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:new_delete_type_mismatch=1 not %run %t array 2>&1 | FileCheck %s -check-prefix=ARRAY
// RUN: ASAN_OPTIONS=new_delete_type_mismatch=0 %run %t scalar // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:new_delete_type_mismatch=0 %run %t scalar
// RUN: ASAN_OPTIONS=new_delete_type_mismatch=0 %run %t array // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:new_delete_type_mismatch=0 %run %t array
// FIXME: the following two lines are not true after r232788. // FIXME: the following two lines are not true after r232788.
// Sized-delete is implemented with a weak delete() definition. // Sized-delete is implemented with a weak delete() definition.
// Weak symbols are kind of broken on Android. // Weak symbols are kind of broken on Android.
// XFAIL: android // XFAIL: android
#include <new> #include <new>
#include <stdio.h> #include <stdio.h>
▲ Show 20 Lines • Show All 79 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=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -o %t && env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=exitcode=0 %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=verbosity=2 %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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 // XFAIL: powerpc64
#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: ASAN_OPTIONS=verbosity=2 %run %t 10 2 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:verbosity=2 %run %t 10 2 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS=verbosity=2:intercept_tls_get_addr=1 %run %t 10 2 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:verbosity=2:intercept_tls_get_addr=1 %run %t 10 2 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS=verbosity=2:intercept_tls_get_addr=0 %run %t 10 2 2>&1 | FileCheck %s --check-prefix=CHECK0 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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=allow_user_segv_handler=true not %run %t 2>&1 | FileCheck %s // 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 -O2 %s -o %t && ASAN_OPTIONS=allow_user_segv_handler=true not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O2 %s -o %t && ASAN_OPTIONS=$ASAN_OPTIONS: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=symbolize=0 not %run %t 2>&1 | %asan_symbolize | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=coverage=1,coverage_direct=0,coverage_dir=%T/coverage-direct-activation/normal:verbosity=1 %run %t %dynamiclib // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=start_deactivated=1,coverage_direct=1,verbosity=1 \ // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=start_deactivated=1,coverage=1,coverage_direct=1,verbosity=1 \ // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=coverage=1:coverage_direct=0:verbosity=1 %run %t %dynamiclib // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=coverage=1:coverage_direct=1:verbosity=1 %run %t %dynamiclib // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=coverage=1:coverage_direct=0:coverage_dir=%T/coverage-direct/normal:verbosity=1 %run %t %dynamiclib // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%T/coverage-direct/direct:verbosity=1 %run %t %dynamiclib // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=coverage=1:coverage_direct=0:coverage_dir=%T/coverage-direct/normal:verbosity=1 %run %t %dynamiclib // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%T/coverage-direct/direct:verbosity=1 %run %t %dynamiclib // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=coverage=1:coverage_direct=0:coverage_dir=%T/coverage-direct/normal:verbosity=1 %run %t %dynamiclib // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=coverage=1:coverage_direct=1:coverage_dir=%T/coverage-direct/direct:verbosity=1 %run %t %dynamiclib // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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=coverage=1:coverage_direct=1:verbosity=1 %run %t; \ // RUN: (ASAN_OPTIONS=$ASAN_OPTIONS: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=coverage=1:coverage_direct=0:verbosity=1 // 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: %run %t 2>&1 | FileCheck %s
// //
// XFAIL: android // XFAIL: android
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
Show All 28 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=coverage=1:verbosity=1 // 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: %run %t %dynamiclib1 %dynamiclib2 2>&1 | FileCheck %s
// RUN: %run %t %dynamiclib1 %dynamiclib2 foo 2>&1 | FileCheck %s // RUN: %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
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 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=coverage=1:verbosity=1 // 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: %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: %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
▲ Show 20 Lines • Show All 74 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=coverage=1:verbosity=1 // 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: %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: %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: %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: %run %t foo bar 2>&1 | FileCheck %s --check-prefix=CHECK-foo-bar
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

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

// RUN: %clangxx_asan -O0 -g %s -o %t && ASAN_OPTIONS=handle_ioctl=1 not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 -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 && ASAN_OPTIONS=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 -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: ASAN_OPTIONS=quarantine_size_mb=0 %run %t // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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="log_path=%t.log verbosity=1" not %run %t 2> %t.out // RUN: env ASAN_OPTIONS="$ASAN_OPTIONS: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: ASAN_OPTIONS=poison_array_cookie=1 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: ASAN_OPTIONS=poison_array_cookie=0 not %run %t 2>&1 | FileCheck %s --check-prefix=NO_COOKIE // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=poison_array_cookie=1 not %run %t 2>&1 | FileCheck %s --check-prefix=COOKIE // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:poison_array_cookie=1 not %run %t 2>&1 | FileCheck %s --check-prefix=COOKIE
// RUN: ASAN_OPTIONS=poison_array_cookie=0 not %run %t 2>&1 | FileCheck %s --check-prefix=NO_COOKIE // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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/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: ASAN_OPTIONS=start_deactivated=1,allocator_may_return_null=0 \ // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=start_deactivated=1 \ // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=start_deactivated=1,verbosity=1 \ // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=start_deactivated=1 \ // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=start_deactivated=1 \ // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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: ASAN_OPTIONS=quarantine_size_mb=0 %run %t // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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_OPTIONS=$ASAN_OPTIONS: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_OPTIONS=$ASAN_OPTIONS: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_OPTIONS=$ASAN_OPTIONS: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_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_OPTIONS=$ASAN_OPTIONS: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_OPTIONS=$ASAN_OPTIONS: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_OPTIONS=$ASAN_OPTIONS: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/allocator_returns_null.cc

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

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

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

compiler-rt/trunk/test/asan/TestCases/asan_options-help.cc

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

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

// Make sure we report atexit stats. // Make sure we report atexit stats.
// RUN: %clangxx_asan -O3 %s -o %t // RUN: %clangxx_asan -O3 %s -o %t
// RUN: env ASAN_OPTIONS=atexit=1:print_stats=1 %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:atexit=1:print_stats=1 %run %t 2>&1 | FileCheck %s
// //
// No atexit output on Android due to // No atexit output on Android due to
// 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 <stdlib.h> #include <stdlib.h>
#if !defined(__APPLE__) && !defined(__FreeBSD__) #if !defined(__APPLE__) && !defined(__FreeBSD__)
#include <malloc.h> #include <malloc.h>
#endif #endif
int *p1 = (int*)malloc(900); int *p1 = (int*)malloc(900);
int *p2 = (int*)malloc(90000); int *p2 = (int*)malloc(90000);
int *p3 = (int*)malloc(9000000); int *p3 = (int*)malloc(9000000);
int main() { } int main() { }
// CHECK: AddressSanitizer exit stats: // CHECK: AddressSanitizer exit stats:

compiler-rt/trunk/test/asan/TestCases/atoi_strict.c

// Test strict_string_checks option in atoi function // Test strict_string_checks option in atoi function
// RUN: %clang_asan %s -o %t // RUN: %clang_asan %s -o %t
// RUN: %run %t test1 2>&1 // RUN: %run %t test1 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test1 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test1 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1
// RUN: %run %t test2 2>&1 // RUN: %run %t test2 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test2 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test2 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2
// RUN: %run %t test3 2>&1 // RUN: %run %t test3 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test3 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test3 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test3 2>&1 | FileCheck %s --check-prefix=CHECK3 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test3 2>&1 | FileCheck %s --check-prefix=CHECK3
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
void test1(char *array) { void test1(char *array) {
// Last symbol is non-digit // Last symbol is non-digit
memset(array, '1', 10); memset(array, '1', 10);
Show All 36 Lines

compiler-rt/trunk/test/asan/TestCases/atol_strict.c

// Test strict_string_checks option in atol function // Test strict_string_checks option in atol function
// RUN: %clang_asan %s -o %t // RUN: %clang_asan %s -o %t
// RUN: %run %t test1 2>&1 // RUN: %run %t test1 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test1 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test1 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1
// RUN: %run %t test2 2>&1 // RUN: %run %t test2 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test2 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test2 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2
// RUN: %run %t test3 2>&1 // RUN: %run %t test3 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test3 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test3 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test3 2>&1 | FileCheck %s --check-prefix=CHECK3 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test3 2>&1 | FileCheck %s --check-prefix=CHECK3
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
void test1(char *array) { void test1(char *array) {
// Last symbol is non-digit // Last symbol is non-digit
memset(array, '1', 10); memset(array, '1', 10);
Show All 36 Lines

compiler-rt/trunk/test/asan/TestCases/atoll_strict.c

// Test strict_string_checks option in atoll function // Test strict_string_checks option in atoll function
// RUN: %clang_asan %s -o %t // RUN: %clang_asan %s -o %t
// RUN: %run %t test1 2>&1 // RUN: %run %t test1 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test1 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test1 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1
// RUN: %run %t test2 2>&1 // RUN: %run %t test2 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test2 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test2 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2
// RUN: %run %t test3 2>&1 // RUN: %run %t test3 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test3 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test3 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test3 2>&1 | FileCheck %s --check-prefix=CHECK3 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test3 2>&1 | FileCheck %s --check-prefix=CHECK3
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
void test1(char *array) { void test1(char *array) {
// Last symbol is non-digit // Last symbol is non-digit
memset(array, '1', 10); memset(array, '1', 10);
Show All 36 Lines

compiler-rt/trunk/test/asan/TestCases/closed-fds.cc

// Check that when the program closed its std(in|out|err), running the external // Check that when the program closed its std(in|out|err), running the external
// symbolizer still works. // symbolizer still works.
// RUN: rm -f %t.log.* // RUN: rm -f %t.log.*
// RUN: %clangxx_asan -O0 %s -o %t 2>&1 && ASAN_OPTIONS=log_path=%t.log:verbosity=2 not %run %t 2>&1 // RUN: %clangxx_asan -O0 %s -o %t 2>&1 && ASAN_OPTIONS=$ASAN_OPTIONS:log_path=%t.log:verbosity=2 not %run %t 2>&1
// RUN: FileCheck %s --check-prefix=CHECK-FILE < %t.log.* // RUN: FileCheck %s --check-prefix=CHECK-FILE < %t.log.*
#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>
Show All 17 Lines

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

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

compiler-rt/trunk/test/asan/TestCases/coverage-and-lsan.cc

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

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

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

compiler-rt/trunk/test/asan/TestCases/coverage-caller-callee.cc

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

compiler-rt/trunk/test/asan/TestCases/coverage-disabled.cc

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

compiler-rt/trunk/test/asan/TestCases/coverage-levels.cc

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

compiler-rt/trunk/test/asan/TestCases/coverage-maybe-open-file.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 -fsanitize-coverage=func %s -o %t // RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t
// RUN: rm -rf %T/coverage-maybe-open-file // RUN: rm -rf %T/coverage-maybe-open-file
// RUN: mkdir -p %T/coverage-maybe-open-file && cd %T/coverage-maybe-open-file // RUN: mkdir -p %T/coverage-maybe-open-file && cd %T/coverage-maybe-open-file
// RUN: ASAN_OPTIONS=coverage=1 %run %t | FileCheck %s --check-prefix=CHECK-success // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:coverage=1 %run %t | FileCheck %s --check-prefix=CHECK-success
// RUN: ASAN_OPTIONS=coverage=0 %run %t | FileCheck %s --check-prefix=CHECK-fail // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:coverage=0 %run %t | FileCheck %s --check-prefix=CHECK-fail
// RUN: [ "$(cat test.sancov.packed)" == "test" ] // RUN: [ "$(cat test.sancov.packed)" == "test" ]
// RUN: cd .. && rm -rf %T/coverage-maybe-open-file // RUN: cd .. && rm -rf %T/coverage-maybe-open-file
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
#include <sanitizer/coverage_interface.h> #include <sanitizer/coverage_interface.h>
Show All 16 Lines

compiler-rt/trunk/test/asan/TestCases/coverage-order-pcs.cc

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

compiler-rt/trunk/test/asan/TestCases/coverage-reset.cc

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

compiler-rt/trunk/test/asan/TestCases/coverage-tracing.cc

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

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

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

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

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

compiler-rt/trunk/test/asan/TestCases/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=detect_stack_use_after_return=1 // 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; %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_OPTIONS=verbosity=1:use_sigaltstack=1 %run %t | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:verbosity=1:use_sigaltstack=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/deep_stack_uaf.cc

// Check that we can store lots of stack frames if asked to. // Check that we can store lots of stack frames if asked to.
// RUN: %clangxx_asan -O0 %s -o %t 2>&1 // RUN: %clangxx_asan -O0 %s -o %t 2>&1
// RUN: env ASAN_OPTIONS=malloc_context_size=120:redzone=512 not %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:malloc_context_size=120:redzone=512 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>
#include <stdio.h> #include <stdio.h>
template <int depth> template <int depth>
struct DeepFree { struct DeepFree {
static void free(char *x) { static void free(char *x) {
Show All 24 Lines

compiler-rt/trunk/test/asan/TestCases/double-free.cc

// RUN: %clangxx_asan -O0 %s -o %t 2>&1 // RUN: %clangxx_asan -O0 %s -o %t 2>&1
// RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=MALLOC-CTX // RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=MALLOC-CTX
// Also works if no malloc context is available. // Also works if no malloc context is available.
// RUN: env ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s
// RUN: env ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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>
#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);
Show All 13 Lines

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

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

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

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

compiler-rt/trunk/test/asan/TestCases/heap-overflow.cc

// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: env ASAN_OPTIONS=print_stats=1 not %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:print_stats=1 not %run %t 2>&1 | FileCheck %s
// FIXME: Fix this test under GCC. // FIXME: Fix this test under GCC.
// REQUIRES: Clang // REQUIRES: Clang
#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));
Show All 11 Lines

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

// RUN: export ASAN_OPTIONS=detect_stack_use_after_return=1 // RUN: export ASAN_OPTIONS=$ASAN_OPTIONS:detect_stack_use_after_return=1
// RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
// XFAIL: arm-linux-gnueabi // XFAIL: arm-linux-gnueabi
// FIXME: Fix this test under GCC. // FIXME: Fix this test under GCC.
// REQUIRES: Clang // REQUIRES: Clang
#include <stdio.h> #include <stdio.h>
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

compiler-rt/trunk/test/asan/TestCases/init-order-atexit.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 for the following situation: // Test for the following situation:
// (1) global A is constructed. // (1) global A is constructed.
// (2) exit() is called during construction of global B. // (2) exit() is called during construction of global B.
// (3) destructor of A reads uninitialized global C from another module. // (3) destructor of A reads uninitialized global C from another module.
// We do *not* want to report init-order bug in this case. // We do *not* want to report init-order bug in this case.
// RUN: %clangxx_asan -O0 %s %p/Helpers/init-order-atexit-extra.cc -o %t // RUN: %clangxx_asan -O0 %s %p/Helpers/init-order-atexit-extra.cc -o %t
// RUN: env ASAN_OPTIONS=strict_init_order=true not %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_init_order=true not %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
void AccessC(); void AccessC();
class A { class A {
public: public:
Show All 15 Lines

compiler-rt/trunk/test/asan/TestCases/init-order-pthread-create.cc

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

compiler-rt/trunk/test/asan/TestCases/initialization-blacklist.cc

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

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

// Test to make sure basic initialization order errors are caught. // Test to make sure basic initialization order errors are caught.
// RUN: %clangxx_asan -O0 %s %p/Helpers/initialization-bug-extra2.cc -o %t-INIT-ORDER-EXE // RUN: %clangxx_asan -O0 %s %p/Helpers/initialization-bug-extra2.cc -o %t-INIT-ORDER-EXE
// RUN: env ASAN_OPTIONS=check_initialization_order=true not %run %t-INIT-ORDER-EXE 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:check_initialization_order=true not %run %t-INIT-ORDER-EXE 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.
// FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=186 // FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=186
// XFAIL: darwin // XFAIL: darwin
#include <cstdio> #include <cstdio>
Show All 35 Lines

compiler-rt/trunk/test/asan/TestCases/initialization-constexpr.cc

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

compiler-rt/trunk/test/asan/TestCases/initialization-nobug.cc

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

compiler-rt/trunk/test/asan/TestCases/invalid-free.cc

// RUN: %clangxx_asan -O0 %s -o %t // RUN: %clangxx_asan -O0 %s -o %t
// RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=MALLOC-CTX // RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=MALLOC-CTX
// Also works if no malloc context is available. // Also works if no malloc context is available.
// RUN: env ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s
// RUN: env ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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>
#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);
Show All 9 Lines

compiler-rt/trunk/test/asan/TestCases/log-path_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
// //
// RUN: %clangxx_asan %s -o %t // RUN: %clangxx_asan %s -o %t
// Regular run. // Regular run.
// RUN: not %run %t 2> %t.out // RUN: not %run %t 2> %t.out
// RUN: FileCheck %s --check-prefix=CHECK-ERROR < %t.out // RUN: FileCheck %s --check-prefix=CHECK-ERROR < %t.out
// Good log_path. // Good log_path.
// RUN: rm -f %t.log.* // RUN: rm -f %t.log.*
// RUN: env ASAN_OPTIONS=log_path=%t.log not %run %t 2> %t.out // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:log_path=%t.log not %run %t 2> %t.out
// RUN: FileCheck %s --check-prefix=CHECK-ERROR < %t.log.* // RUN: FileCheck %s --check-prefix=CHECK-ERROR < %t.log.*
// Invalid log_path. // Invalid log_path.
// RUN: env ASAN_OPTIONS=log_path=/dev/null/INVALID not %run %t 2> %t.out // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:log_path=/dev/null/INVALID not %run %t 2> %t.out
// RUN: FileCheck %s --check-prefix=CHECK-INVALID < %t.out // RUN: FileCheck %s --check-prefix=CHECK-INVALID < %t.out
// Too long log_path. // Too long log_path.
// RUN: env ASAN_OPTIONS=log_path=`for((i=0;i<10000;i++)); do echo -n $i; done` \ // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:log_path=`for((i=0;i<10000;i++)); do echo -n $i; done` \
// RUN: not %run %t 2> %t.out // RUN: not %run %t 2> %t.out
// RUN: FileCheck %s --check-prefix=CHECK-LONG < %t.out // RUN: FileCheck %s --check-prefix=CHECK-LONG < %t.out
// Run w/o errors should not produce any log. // Run w/o errors should not produce any log.
// RUN: rm -f %t.log.* // RUN: rm -f %t.log.*
// RUN: env ASAN_OPTIONS=log_path=%t.log %run %t ARG ARG ARG // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:log_path=%t.log %run %t ARG ARG ARG
// RUN: not cat %t.log.* // RUN: not cat %t.log.*
// FIXME: log_path is not supported on Windows yet. // FIXME: log_path is not supported on Windows yet.
// XFAIL: win32 // XFAIL: win32
#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 10 Lines

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

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

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

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

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

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

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

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

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

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

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

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

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

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

compiler-rt/trunk/test/asan/TestCases/printf-1.c

// RUN: %clang_asan -O2 %s -o %t // RUN: %clang_asan -O2 %s -o %t
// RUN: env ASAN_OPTIONS=check_printf=1 %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:check_printf=1 %run %t 2>&1 | FileCheck %s
// RUN: env ASAN_OPTIONS=check_printf=0 %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:check_printf=0 %run %t 2>&1 | FileCheck %s
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#if defined(_WIN32) #if defined(_WIN32)
# define snprintf _snprintf # define snprintf _snprintf
#endif #endif
int main() { int main() {
Show All 14 Lines

compiler-rt/trunk/test/asan/TestCases/printf-2.c

// RUN: %clang_asan -O2 %s -o %t // RUN: %clang_asan -O2 %s -o %t
// We need replace_str=0 and replace_intrin=0 to avoid reporting errors in // We need replace_str=0 and replace_intrin=0 to avoid reporting errors in
// strlen() and memcpy() called by printf(). // strlen() and memcpy() called by printf().
// RUN: env ASAN_OPTIONS=replace_str=0:replace_intrin=0:check_printf=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:replace_str=0:replace_intrin=0:check_printf=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
// RUN: env ASAN_OPTIONS=replace_str=0:replace_intrin=0:check_printf=0 %run %t 2>&1 | FileCheck --check-prefix=CHECK-OFF %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:replace_str=0:replace_intrin=0:check_printf=0 %run %t 2>&1 | FileCheck --check-prefix=CHECK-OFF %s
// RUN: env ASAN_OPTIONS=replace_str=0:replace_intrin=0 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:replace_str=0:replace_intrin=0 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
// FIXME: printf is not intercepted on Windows yet. // FIXME: printf is not intercepted on Windows yet.
// XFAIL: win32 // XFAIL: win32
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
int main() { int main() {
Show All 13 Lines

compiler-rt/trunk/test/asan/TestCases/printf-3.c

// RUN: %clang_asan -O2 %s -o %t // RUN: %clang_asan -O2 %s -o %t
// RUN: env ASAN_OPTIONS=check_printf=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:check_printf=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
// RUN: env ASAN_OPTIONS=check_printf=0 %run %t 2>&1 | FileCheck --check-prefix=CHECK-OFF %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:check_printf=0 %run %t 2>&1 | FileCheck --check-prefix=CHECK-OFF %s
// RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s // RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
// FIXME: printf is not intercepted on Windows yet. // FIXME: printf is not intercepted on Windows yet.
// XFAIL: win32 // XFAIL: win32
#include <stdio.h> #include <stdio.h>
int main() { int main() {
volatile char c = '0'; volatile char c = '0';
Show All 11 Lines

compiler-rt/trunk/test/asan/TestCases/printf-4.c

// RUN: %clang_asan -O2 %s -o %t // RUN: %clang_asan -O2 %s -o %t
// We need replace_str=0 and replace_intrin=0 to avoid reporting errors in // We need replace_str=0 and replace_intrin=0 to avoid reporting errors in
// strlen() and memcpy() called by puts(). // strlen() and memcpy() called by puts().
// RUN: env ASAN_OPTIONS=replace_str=0:replace_intrin=0:check_printf=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:replace_str=0:replace_intrin=0:check_printf=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
// RUN: env ASAN_OPTIONS=replace_str=0:replace_intrin=0 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:replace_str=0:replace_intrin=0 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
// FIXME: printf is not intercepted on Windows yet. // FIXME: printf is not intercepted on Windows yet.
// XFAIL: win32 // XFAIL: win32
#include <stdio.h> #include <stdio.h>
int main() { int main() {
volatile char c = '0'; volatile char c = '0';
volatile int x = 12; volatile int x = 12;
Show All 10 Lines

compiler-rt/trunk/test/asan/TestCases/printf-5.c

// RUN: %clang_asan -O2 %s -o %t // RUN: %clang_asan -O2 %s -o %t
// We need replace_intrin=0 to avoid reporting errors in memcpy. // We need replace_intrin=0 to avoid reporting errors in memcpy.
// RUN: env ASAN_OPTIONS=replace_intrin=0:check_printf=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:replace_intrin=0:check_printf=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
// RUN: env ASAN_OPTIONS=replace_intrin=0:check_printf=0 %run %t 2>&1 | FileCheck --check-prefix=CHECK-OFF %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:replace_intrin=0:check_printf=0 %run %t 2>&1 | FileCheck --check-prefix=CHECK-OFF %s
// RUN: env ASAN_OPTIONS=replace_intrin=0 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:replace_intrin=0 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
// FIXME: printf is not intercepted on Windows yet. // FIXME: printf is not intercepted on Windows yet.
// XFAIL: win32 // XFAIL: win32
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
int main() { int main() {
volatile char c = '0'; volatile char c = '0';
Show All 12 Lines

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

// Test ASan detection of stack-overflow condition. // Test ASan detection of stack-overflow condition.
// RUN: %clangxx_asan -O0 %s -DSMALL_FRAME -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -DSMALL_FRAME -pthread -o %t && env ASAN_OPTIONS=$ASAN_OPTIONS:use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -DSMALL_FRAME -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -DSMALL_FRAME -pthread -o %t && env ASAN_OPTIONS=$ASAN_OPTIONS:use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O0 %s -DSAVE_ALL_THE_REGISTERS -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -DSAVE_ALL_THE_REGISTERS -pthread -o %t && env ASAN_OPTIONS=$ASAN_OPTIONS:use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -DSAVE_ALL_THE_REGISTERS -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -DSAVE_ALL_THE_REGISTERS -pthread -o %t && env ASAN_OPTIONS=$ASAN_OPTIONS:use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O0 %s -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -pthread -o %t && env ASAN_OPTIONS=$ASAN_OPTIONS:use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -pthread -o %t && env ASAN_OPTIONS=$ASAN_OPTIONS:use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O0 %s -DTHREAD -DSMALL_FRAME -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -DTHREAD -DSMALL_FRAME -pthread -o %t && env ASAN_OPTIONS=$ASAN_OPTIONS:use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -DTHREAD -DSMALL_FRAME -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -DTHREAD -DSMALL_FRAME -pthread -o %t && env ASAN_OPTIONS=$ASAN_OPTIONS:use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O0 %s -DTHREAD -DSAVE_ALL_THE_REGISTERS -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -DTHREAD -DSAVE_ALL_THE_REGISTERS -pthread -o %t && env ASAN_OPTIONS=$ASAN_OPTIONS:use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -DTHREAD -DSAVE_ALL_THE_REGISTERS -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -DTHREAD -DSAVE_ALL_THE_REGISTERS -pthread -o %t && env ASAN_OPTIONS=$ASAN_OPTIONS:use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O0 %s -DTHREAD -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -DTHREAD -pthread -o %t && env ASAN_OPTIONS=$ASAN_OPTIONS:use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -DTHREAD -pthread -o %t && env ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -DTHREAD -pthread -o %t && env ASAN_OPTIONS=$ASAN_OPTIONS:use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
// REQUIRES: stable-runtime // REQUIRES: stable-runtime
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>
#include <pthread.h> #include <pthread.h>
#include <unistd.h> #include <unistd.h>
#include <sys/time.h> #include <sys/time.h>
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

// RUN: export ASAN_OPTIONS=detect_stack_use_after_return=1 // RUN: export ASAN_OPTIONS=$ASAN_OPTIONS:detect_stack_use_after_return=1
// RUN: %clangxx_asan -O0 %s -pthread -o %t && 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 && not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O1 %s -pthread -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O2 %s -pthread -o %t && not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O2 %s -pthread -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -pthread -o %t && not %run %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -pthread -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %run %t // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS: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 && 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 && 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.
// //
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

compiler-rt/trunk/test/asan/TestCases/strcasestr-1.c

// Test haystack overflow in strcasestr function // Test haystack overflow in strcasestr function
// RUN: %clang_asan %s -o %t && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s // RUN: %clang_asan %s -o %t && ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t 2>&1 | FileCheck %s
// Test intercept_strstr asan option // Test intercept_strstr asan option
// Disable other interceptors because strlen may be called inside strcasestr // Disable other interceptors because strlen may be called inside strcasestr
// RUN: ASAN_OPTIONS=intercept_strstr=false:replace_str=false %run %t 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:intercept_strstr=false:replace_str=false %run %t 2>&1
// There's no interceptor for strcasestr on Windows // There's no interceptor for strcasestr on Windows
// XFAIL: win32 // XFAIL: win32
#define _GNU_SOURCE #define _GNU_SOURCE
#include <assert.h> #include <assert.h>
#include <string.h> #include <string.h>
Show All 10 Lines

compiler-rt/trunk/test/asan/TestCases/strcasestr-2.c

// Test needle overflow in strcasestr function // Test needle overflow in strcasestr function
// RUN: %clang_asan %s -o %t && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s // RUN: %clang_asan %s -o %t && ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t 2>&1 | FileCheck %s
// Test intercept_strstr asan option // Test intercept_strstr asan option
// Disable other interceptors because strlen may be called inside strcasestr // Disable other interceptors because strlen may be called inside strcasestr
// RUN: ASAN_OPTIONS=intercept_strstr=false:replace_str=false %run %t 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:intercept_strstr=false:replace_str=false %run %t 2>&1
// There's no interceptor for strcasestr on Windows // There's no interceptor for strcasestr on Windows
// XFAIL: win32 // XFAIL: win32
#define _GNU_SOURCE #define _GNU_SOURCE
#include <assert.h> #include <assert.h>
#include <string.h> #include <string.h>
Show All 10 Lines

compiler-rt/trunk/test/asan/TestCases/strcasestr_strict.c

// Test strict_string_checks option in strcasestr function // Test strict_string_checks option in strcasestr function
// RUN: %clang_asan %s -o %t && %run %t 2>&1 // RUN: %clang_asan %s -o %t && %run %t 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t 2>&1 | FileCheck %s
// There's no interceptor for strcasestr on Windows // There's no interceptor for strcasestr on Windows
// XFAIL: win32 // XFAIL: win32
#define _GNU_SOURCE #define _GNU_SOURCE
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
Show All 16 Lines

compiler-rt/trunk/test/asan/TestCases/strcat_strict.c

// Test strict_string_checks option in strcat function // Test strict_string_checks option in strcat function
// RUN: %clang_asan %s -o %t // RUN: %clang_asan %s -o %t
// RUN: not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1-NONSTRICT --check-prefix=CHECK1 // RUN: not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1-NONSTRICT --check-prefix=CHECK1
// RUN: ASAN_OPTIONS=strict_string_checks=false not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1-NONSTRICT --check-prefix=CHECK1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1-NONSTRICT --check-prefix=CHECK1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1-STRICT --check-prefix=CHECK1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1-STRICT --check-prefix=CHECK1
// RUN: not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2-NONSTRICT --check-prefix=CHECK2 // RUN: not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2-NONSTRICT --check-prefix=CHECK2
// RUN: ASAN_OPTIONS=strict_string_checks=false not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2-NONSTRICT --check-prefix=CHECK2 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2-NONSTRICT --check-prefix=CHECK2
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2-STRICT --check-prefix=CHECK2 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2-STRICT --check-prefix=CHECK2
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
void test1(char *to, int to_size, char *from) { void test1(char *to, int to_size, char *from) {
// One of arguments points to not allocated memory. // One of arguments points to not allocated memory.
char* r = strcat(to + to_size, from); char* r = strcat(to + to_size, from);
Show All 28 Lines

compiler-rt/trunk/test/asan/TestCases/strchr_strict.c

// Test strict_string_checks option in strchr function // Test strict_string_checks option in strchr function
// RUN: %clang_asan %s -o %t && %run %t 2>&1 // RUN: %clang_asan %s -o %t && %run %t 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
int main(int argc, char **argv) { int main(int argc, char **argv) {
size_t size = 100; size_t size = 100;
char fill = 'o'; char fill = 'o';
Show All 10 Lines

compiler-rt/trunk/test/asan/TestCases/strcmp_strict.c

// Test strict_string_checks option in strcmp function // Test strict_string_checks option in strcmp function
// RUN: %clang_asan %s -o %t && %run %t 2>&1 // RUN: %clang_asan %s -o %t && %run %t 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
int main(int argc, char **argv) { int main(int argc, char **argv) {
size_t size = 100; size_t size = 100;
char fill = 'o'; char fill = 'o';
Show All 14 Lines

compiler-rt/trunk/test/asan/TestCases/strcspn-1.c

// Test string s1 overflow in strcspn function // Test string s1 overflow in strcspn function
// RUN: %clang_asan %s -o %t && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s // RUN: %clang_asan %s -o %t && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
// Test intercept_strspn asan option // Test intercept_strspn asan option
// RUN: ASAN_OPTIONS=intercept_strspn=false %run %t 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:intercept_strspn=false %run %t 2>&1
#include <assert.h> #include <assert.h>
#include <string.h> #include <string.h>
int main(int argc, char **argv) { int main(int argc, char **argv) {
size_t r; size_t r;
char s2[] = "ab"; char s2[] = "ab";
char s1[] = {'c', 'a'}; char s1[] = {'c', 'a'};
char s3 = 0; char s3 = 0;
r = strcspn(s1, s2); r = strcspn(s1, s2);
// CHECK:'s{{[1|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable // CHECK:'s{{[1|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
assert(r == 1); assert(r == 1);
return 0; return 0;
} }

compiler-rt/trunk/test/asan/TestCases/strcspn-2.c

// Test stopset overflow in strcspn function // Test stopset overflow in strcspn function
// RUN: %clang_asan %s -o %t && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s // RUN: %clang_asan %s -o %t && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
// Test intercept_strcspn asan option // Test intercept_strcspn asan option
// RUN: ASAN_OPTIONS=intercept_strspn=false %run %t 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:intercept_strspn=false %run %t 2>&1
#include <assert.h> #include <assert.h>
#include <string.h> #include <string.h>
int main(int argc, char **argv) { int main(int argc, char **argv) {
size_t r; size_t r;
char s1[] = "ab"; char s1[] = "ab";
char s2[] = {'a'}; char s2[] = {'a'};
char s3 = 0; char s3 = 0;
r = strcspn(s1, s2); r = strcspn(s1, s2);
// CHECK:'s{{[2|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable // CHECK:'s{{[2|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
assert(r == 0); assert(r == 0);
return 0; return 0;
} }

compiler-rt/trunk/test/asan/TestCases/strcspn_strict.c

// Test strict_string_checks option in strcspn function // Test strict_string_checks option in strcspn function
// RUN: %clang_asan %s -o %t && %run %t 2>&1 // RUN: %clang_asan %s -o %t && %run %t 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
int main(int argc, char **argv) { int main(int argc, char **argv) {
size_t size = 100; size_t size = 100;
char fill = 'o'; char fill = 'o';
Show All 14 Lines

compiler-rt/trunk/test/asan/TestCases/strip_path_prefix.c

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

compiler-rt/trunk/test/asan/TestCases/strncat_strict.c

// Test strict_string_checks option in strncat function // Test strict_string_checks option in strncat function
// RUN: %clang_asan %s -o %t // RUN: %clang_asan %s -o %t
// RUN: not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1-NONSTRICT --check-prefix=CHECK1 // RUN: not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1-NONSTRICT --check-prefix=CHECK1
// RUN: ASAN_OPTIONS=strict_string_checks=false not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1-NONSTRICT --check-prefix=CHECK1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1-NONSTRICT --check-prefix=CHECK1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1-STRICT --check-prefix=CHECK1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1-STRICT --check-prefix=CHECK1
// RUN: not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2-NONSTRICT --check-prefix=CHECK2 // RUN: not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2-NONSTRICT --check-prefix=CHECK2
// RUN: ASAN_OPTIONS=strict_string_checks=false not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2-NONSTRICT --check-prefix=CHECK2 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2-NONSTRICT --check-prefix=CHECK2
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2-STRICT --check-prefix=CHECK2 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2-STRICT --check-prefix=CHECK2
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
void test1(char *to, int to_size, char *from) { void test1(char *to, int to_size, char *from) {
// One of arguments points to not allocated memory. // One of arguments points to not allocated memory.
char* r = strncat(to + to_size, from, 2); char* r = strncat(to + to_size, from, 2);
Show All 28 Lines

compiler-rt/trunk/test/asan/TestCases/strpbrk-1.c

// Test string s1 overflow in strpbrk function // Test string s1 overflow in strpbrk function
// RUN: %clang_asan %s -o %t && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s // RUN: %clang_asan %s -o %t && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
// Test intercept_strpbrk asan option // Test intercept_strpbrk asan option
// RUN: ASAN_OPTIONS=intercept_strpbrk=false %run %t 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:intercept_strpbrk=false %run %t 2>&1
#include <assert.h> #include <assert.h>
#include <string.h> #include <string.h>
int main(int argc, char **argv) { int main(int argc, char **argv) {
char *r; char *r;
char s2[] = "ab"; char s2[] = "ab";
char s1[] = {'c', 'a'}; char s1[] = {'c', 'a'};
char s3 = 0; char s3 = 0;
r = strpbrk(s1, s2); r = strpbrk(s1, s2);
// CHECK:'s{{[1|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable // CHECK:'s{{[1|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
assert(r == s1 + 1); assert(r == s1 + 1);
return 0; return 0;
} }

compiler-rt/trunk/test/asan/TestCases/strpbrk-2.c

// Test stopset overflow in strpbrk function // Test stopset overflow in strpbrk function
// RUN: %clang_asan %s -o %t && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s // RUN: %clang_asan %s -o %t && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
// Test intercept_strpbrk asan option // Test intercept_strpbrk asan option
// RUN: ASAN_OPTIONS=intercept_strpbrk=false %run %t 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:intercept_strpbrk=false %run %t 2>&1
#include <assert.h> #include <assert.h>
#include <string.h> #include <string.h>
int main(int argc, char **argv) { int main(int argc, char **argv) {
char *r; char *r;
char s1[] = "c"; char s1[] = "c";
char s2[] = {'b', 'c'}; char s2[] = {'b', 'c'};
char s3 = 0; char s3 = 0;
r = strpbrk(s1, s2); r = strpbrk(s1, s2);
// CHECK:'s{{[2|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable // CHECK:'s{{[2|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
assert(r == s1); assert(r == s1);
return 0; return 0;
} }

compiler-rt/trunk/test/asan/TestCases/strpbrk_strict.c

// Test strict_string_checks option in strpbrk function // Test strict_string_checks option in strpbrk function
// RUN: %clang_asan %s -o %t && %run %t 2>&1 // RUN: %clang_asan %s -o %t && %run %t 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
int main(int argc, char **argv) { int main(int argc, char **argv) {
size_t size = 100; size_t size = 100;
char fill = 'o'; char fill = 'o';
Show All 13 Lines

compiler-rt/trunk/test/asan/TestCases/strspn-1.c

// Test string s1 overflow in strspn function // Test string s1 overflow in strspn function
// RUN: %clang_asan %s -o %t && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s // RUN: %clang_asan %s -o %t && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
// Test intercept_strspn asan option // Test intercept_strspn asan option
// RUN: ASAN_OPTIONS=intercept_strspn=false %run %t 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:intercept_strspn=false %run %t 2>&1
#include <assert.h> #include <assert.h>
#include <string.h> #include <string.h>
int main(int argc, char **argv) { int main(int argc, char **argv) {
size_t r; size_t r;
char s2[] = "ab"; char s2[] = "ab";
char s1[] = {'a', 'c'}; char s1[] = {'a', 'c'};
char s3 = 0; char s3 = 0;
r = strspn(s1, s2); r = strspn(s1, s2);
// CHECK:'s{{[1|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable // CHECK:'s{{[1|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
assert(r == 1); assert(r == 1);
return 0; return 0;
} }

compiler-rt/trunk/test/asan/TestCases/strspn-2.c

// Test stopset overflow in strspn function // Test stopset overflow in strspn function
// RUN: %clang_asan %s -o %t && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s // RUN: %clang_asan %s -o %t && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
// Test intercept_strspn asan option // Test intercept_strspn asan option
// RUN: ASAN_OPTIONS=intercept_strspn=false %run %t 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:intercept_strspn=false %run %t 2>&1
#include <assert.h> #include <assert.h>
#include <string.h> #include <string.h>
int main(int argc, char **argv) { int main(int argc, char **argv) {
size_t r; size_t r;
char s1[] = "bbc"; char s1[] = "bbc";
char s2[] = {'a', 'b'}; char s2[] = {'a', 'b'};
char s3 = 0; char s3 = 0;
r = strspn(s1, s2); r = strspn(s1, s2);
// CHECK:'s{{[2|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable // CHECK:'s{{[2|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
assert(r >= 2); assert(r >= 2);
return 0; return 0;
} }

compiler-rt/trunk/test/asan/TestCases/strspn_strict.c

// Test strict_str`ing_checks option in strspn function // Test strict_str`ing_checks option in strspn function
// RUN: %clang_asan %s -o %t && %run %t 2>&1 // RUN: %clang_asan %s -o %t && %run %t 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
int main(int argc, char **argv) { int main(int argc, char **argv) {
size_t size = 100; size_t size = 100;
char fill = 'o'; char fill = 'o';
Show All 13 Lines

compiler-rt/trunk/test/asan/TestCases/strstr-1.c

// Test haystack overflow in strstr function // Test haystack overflow in strstr function
// RUN: %clang_asan %s -o %t && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s // RUN: %clang_asan %s -o %t && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
// Test intercept_strstr asan option // Test intercept_strstr asan option
// Disable other interceptors because strlen may be called inside strstr // Disable other interceptors because strlen may be called inside strstr
// RUN: ASAN_OPTIONS=intercept_strstr=false:replace_str=false %run %t 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:intercept_strstr=false:replace_str=false %run %t 2>&1
#include <assert.h> #include <assert.h>
#include <string.h> #include <string.h>
int main(int argc, char **argv) { int main(int argc, char **argv) {
char *r = 0; char *r = 0;
char s2[] = "c"; char s2[] = "c";
char s1[] = {'a', 'c'}; char s1[] = {'a', 'c'};
char s3 = 0; char s3 = 0;
r = strstr(s1, s2); r = strstr(s1, s2);
// CHECK:'s{{[1|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable // CHECK:'s{{[1|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
assert(r == s1 + 1); assert(r == s1 + 1);
return 0; return 0;
} }

compiler-rt/trunk/test/asan/TestCases/strstr-2.c

// Test needle overflow in strstr function // Test needle overflow in strstr function
// RUN: %clang_asan %s -o %t && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s // RUN: %clang_asan %s -o %t && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
// Test intercept_strstr asan option // Test intercept_strstr asan option
// Disable other interceptors because strlen may be called inside strstr // Disable other interceptors because strlen may be called inside strstr
// RUN: ASAN_OPTIONS=intercept_strstr=false:replace_str=false %run %t 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:intercept_strstr=false:replace_str=false %run %t 2>&1
#include <assert.h> #include <assert.h>
#include <string.h> #include <string.h>
int main(int argc, char **argv) { int main(int argc, char **argv) {
char *r = 0; char *r = 0;
char s1[] = "ab"; char s1[] = "ab";
char s2[] = {'c'}; char s2[] = {'c'};
char s3 = 0; char s3 = 0;
r = strstr(s1, s2); r = strstr(s1, s2);
// CHECK:'s{{[2|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable // CHECK:'s{{[2|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
assert(r == 0); assert(r == 0);
return 0; return 0;
} }

compiler-rt/trunk/test/asan/TestCases/strstr_strict.c

// Test strict_string_checks option in strstr function // Test strict_string_checks option in strstr function
// RUN: %clang_asan %s -o %t && %run %t 2>&1 // RUN: %clang_asan %s -o %t && %run %t 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
int main(int argc, char **argv) { int main(int argc, char **argv) {
size_t size = 100; size_t size = 100;
char fill = 'o'; char fill = 'o';
Show All 13 Lines

compiler-rt/trunk/test/asan/TestCases/strtol_strict.c

// Test strict_string_checks option in strtol function // Test strict_string_checks option in strtol function
// RUN: %clang_asan -DTEST1 %s -o %t // RUN: %clang_asan -DTEST1 %s -o %t
// RUN: %run %t test1 2>&1 // RUN: %run %t test1 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test1 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test1 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1
// RUN: %run %t test2 2>&1 // RUN: %run %t test2 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test2 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test2 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2
// RUN: %run %t test3 2>&1 // RUN: %run %t test3 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test3 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test3 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test3 2>&1 | FileCheck %s --check-prefix=CHECK3 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test3 2>&1 | FileCheck %s --check-prefix=CHECK3
// RUN: %run %t test4 2>&1 // RUN: %run %t test4 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test4 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test4 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test4 2>&1 | FileCheck %s --check-prefix=CHECK4 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test4 2>&1 | FileCheck %s --check-prefix=CHECK4
// RUN: %run %t test5 2>&1 // RUN: %run %t test5 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test5 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test5 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test5 2>&1 | FileCheck %s --check-prefix=CHECK5 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test5 2>&1 | FileCheck %s --check-prefix=CHECK5
// RUN: %run %t test6 2>&1 // RUN: %run %t test6 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test6 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test6 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test6 2>&1 | FileCheck %s --check-prefix=CHECK6 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test6 2>&1 | FileCheck %s --check-prefix=CHECK6
// RUN: %run %t test7 2>&1 // RUN: %run %t test7 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test7 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test7 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test7 2>&1 | FileCheck %s --check-prefix=CHECK7 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test7 2>&1 | FileCheck %s --check-prefix=CHECK7
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <sanitizer/asan_interface.h> #include <sanitizer/asan_interface.h>
void test1(char *array, char *endptr) { void test1(char *array, char *endptr) {
// Buffer overflow if there is no terminating null (depends on base) // Buffer overflow if there is no terminating null (depends on base)
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

compiler-rt/trunk/test/asan/TestCases/strtoll_strict.c

// Test strict_string_checks option in strtoll function // Test strict_string_checks option in strtoll function
// RUN: %clang_asan -DTEST1 %s -o %t // RUN: %clang_asan -DTEST1 %s -o %t
// RUN: %run %t test1 2>&1 // RUN: %run %t test1 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test1 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test1 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1
// RUN: %run %t test2 2>&1 // RUN: %run %t test2 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test2 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test2 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2
// RUN: %run %t test3 2>&1 // RUN: %run %t test3 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test3 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test3 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test3 2>&1 | FileCheck %s --check-prefix=CHECK3 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test3 2>&1 | FileCheck %s --check-prefix=CHECK3
// RUN: %run %t test4 2>&1 // RUN: %run %t test4 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test4 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test4 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test4 2>&1 | FileCheck %s --check-prefix=CHECK4 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test4 2>&1 | FileCheck %s --check-prefix=CHECK4
// RUN: %run %t test5 2>&1 // RUN: %run %t test5 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test5 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test5 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test5 2>&1 | FileCheck %s --check-prefix=CHECK5 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test5 2>&1 | FileCheck %s --check-prefix=CHECK5
// RUN: %run %t test6 2>&1 // RUN: %run %t test6 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test6 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test6 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test6 2>&1 | FileCheck %s --check-prefix=CHECK6 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test6 2>&1 | FileCheck %s --check-prefix=CHECK6
// RUN: %run %t test7 2>&1 // RUN: %run %t test7 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=false %run %t test7 2>&1 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=false %run %t test7 2>&1
// RUN: ASAN_OPTIONS=strict_string_checks=true not %run %t test7 2>&1 | FileCheck %s --check-prefix=CHECK7 // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_string_checks=true not %run %t test7 2>&1 | FileCheck %s --check-prefix=CHECK7
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <sanitizer/asan_interface.h> #include <sanitizer/asan_interface.h>
void test1(char *array, char *endptr) { void test1(char *array, char *endptr) {
// Buffer overflow if there is no terminating null (depends on base) // Buffer overflow if there is no terminating null (depends on base)
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 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: ASAN_OPTIONS="suppressions=supp.txt" \ // RUN: env ASAN_OPTIONS="$ASAN_OPTIONS: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: ASAN_OPTIONS="suppressions='/absolute/path'" not %run %t 2>&1 | \ // RUN: env ASAN_OPTIONS="$ASAN_OPTIONS: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: ASAN_OPTIONS="suppressions='folder/only/'" not %run %t 2>&1 | \ // RUN: env ASAN_OPTIONS="$ASAN_OPTIONS: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-function.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_via_fun:crash_function" > %t.supp // RUN: echo "interceptor_via_fun:crash_function" > %t.supp
// RUN: %clangxx_asan -O0 %s -o %t && ASAN_OPTIONS="suppressions='%t.supp'" %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s // RUN: %clangxx_asan -O0 %s -o %t && ASAN_OPTIONS="$ASAN_OPTIONS:suppressions='%t.supp'" %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
// RUN: %clangxx_asan -O3 %s -o %t && ASAN_OPTIONS="suppressions='%t.supp'" %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s // RUN: %clangxx_asan -O3 %s -o %t && ASAN_OPTIONS="$ASAN_OPTIONS:suppressions='%t.supp'" %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
// XFAIL: android // XFAIL: android
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
void crash_function() { void crash_function() {
Show All 14 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: ASAN_OPTIONS="suppressions='%t.supp'" %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s // RUN: env ASAN_OPTIONS="$ASAN_OPTIONS:suppressions='%t.supp'" %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
// XFAIL: android // XFAIL: android
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
int main() { int main() {
Show All 10 Lines

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

// RUN: %clangxx_asan -O0 -DSHARED_LIB %s -fPIC -shared -o %dynamiclib %ld_flags_rpath_so // RUN: %clangxx_asan -O0 -DSHARED_LIB %s -fPIC -shared -o %dynamiclib %ld_flags_rpath_so
// RUN: %clangxx_asan -O0 %s -o %t %ld_flags_rpath_exe // RUN: %clangxx_asan -O0 %s -o %t %ld_flags_rpath_exe
// Check that without suppressions, we catch the issue. // Check that without suppressions, we catch the issue.
// 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_via_lib:"`basename %dynamiclib` > %t.supp // RUN: echo "interceptor_via_lib:"`basename %dynamiclib` > %t.supp
// RUN: ASAN_OPTIONS="suppressions='%t.supp'" %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s // RUN: env ASAN_OPTIONS="$ASAN_OPTIONS:suppressions='%t.supp'" %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
// XFAIL: android // XFAIL: android
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#if !defined(SHARED_LIB) #if !defined(SHARED_LIB)
Show All 23 Lines

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=detect_stack_use_after_return=1 // export ASAN_OPTIONS=$ASAN_OPTIONS:detect_stack_use_after_return=1
// RUN: %clangxx_asan -O0 %s -o %t && %run %t // RUN: %clangxx_asan -O0 %s -o %t && %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 33 Lines

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

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

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="detect_stack_use_after_return=1" 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
// 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'
} }

compiler-rt/trunk/test/asan/TestCases/verbose-log-path_test.cc

// RUN: %clangxx_asan %s -o %T/verbose-log-path_test-binary // RUN: %clangxx_asan %s -o %T/verbose-log-path_test-binary
// Good log_path. // Good log_path.
// RUN: rm -f %T/asan.log.* // RUN: rm -f %T/asan.log.*
// RUN: env ASAN_OPTIONS=log_path=%T/asan.log:log_exe_name=1 not %run %T/verbose-log-path_test-binary 2> %t.out // RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:log_path=%T/asan.log:log_exe_name=1 not %run %T/verbose-log-path_test-binary 2> %t.out
// RUN: FileCheck %s --check-prefix=CHECK-ERROR < %T/asan.log.verbose-log-path_test-binary.* // RUN: FileCheck %s --check-prefix=CHECK-ERROR < %T/asan.log.verbose-log-path_test-binary.*
// FIXME: only FreeBSD and Linux have verbose log paths now. // FIXME: only FreeBSD and Linux have verbose log paths now.
// XFAIL: win32,android // XFAIL: win32,android
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
int main(int argc, char **argv) { int main(int argc, char **argv) {
if (argc > 2) return 0; if (argc > 2) return 0;
char *x = (char*)malloc(10); char *x = (char*)malloc(10);
memset(x, 0, 10); memset(x, 0, 10);
int res = x[argc * 10]; // BOOOM int res = x[argc * 10]; // BOOOM
free(x); free(x);
return res; return res;
} }
// CHECK-ERROR: ERROR: AddressSanitizer // CHECK-ERROR: ERROR: AddressSanitizer

compiler-rt/trunk/test/asan/lit.cfg

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