This is an archive of the discontinued LLVM Phabricator instance.

Differential D3553

Add %run to all compiler-rt lit tests
ClosedPublic

Authored by garious on Apr 29 2014, 2:16 PM.

Details

Reviewers
rengolin
samsonov
eugenis
Summary

This patch adds %run before invoking any executables. In conjunction with http://reviews.llvm.org/D3425, this allows us to test the sanitizers in cross-compiled environments by setting COMPILER_RT_EMULATOR to qemu-arm. Alternatively, the user may point COMPILER_RT_EMULATOR to a custom script that uploads the executable to a device and executes it remotely.

Diff Detail

Event Timeline

garious updated this revision to Diff 8942.Apr 29 2014, 2:16 PM
garious retitled this revision from to Add %run to all compiler-rt lit tests.
garious updated this object.
garious edited the test plan for this revision. (Show Details)
garious added reviewers: samsonov, rengolin, eugenis.
Herald added a subscriber: aemerson. · View Herald TranscriptApr 29 2014, 2:16 PM
garious added a subscriber: Unknown Object (MLST).Apr 29 2014, 5:16 PM
samsonov edited edge metadata.Apr 29 2014, 5:33 PM

I defer to Evgeniy's opinion here.

eugenis accepted this revision.Apr 30 2014, 1:18 AM
eugenis edited edge metadata.

LGTM

This does not solve the issue of shared libraries (ex. in test/asan/TestCases/shared-lib-test.cc %t-so.so won't be copied to the device). I guess that's not an issue for qemu?

This revision is now accepted and ready to land.Apr 30 2014, 1:18 AM
rengolin edited edge metadata.Apr 30 2014, 1:23 AM

IIRC, if the binaries are linked statically, qemu-user works fine, otherwise you need sysroots and co.

garious added a comment.Apr 30 2014, 2:46 PM

Committed in r207709

rengolin closed this revision.May 2 2014, 3:39 AM

Revision Contents

PathSize
test/
asan/
TestCases/
Darwin/
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
Linux/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 lines
10 lines
2 lines
4 lines
6 lines
4 lines
4 lines
2 lines
8 lines
8 lines
16 lines
8 lines
2 lines
6 lines
4 lines
8 lines
12 lines
4 lines
2 lines
4 lines
2 lines
2 lines
10 lines
8 lines
4 lines
2 lines
2 lines
2 lines
22 lines
4 lines
2 lines
2 lines
2 lines
8 lines
2 lines
6 lines
4 lines
4 lines
2 lines
8 lines
8 lines
2 lines
8 lines
6 lines
4 lines
2 lines
4 lines
2 lines
8 lines
8 lines
4 lines
2 lines
2 lines
2 lines
6 lines
2 lines
8 lines
8 lines
2 lines
8 lines
6 lines
8 lines
2 lines
8 lines
10 lines
2 lines
4 lines
10 lines
6 lines
2 lines
8 lines
6 lines
8 lines
26 lines
12 lines
8 lines
2 lines
8 lines
8 lines
4 lines
4 lines
6 lines
6 lines
6 lines
6 lines
6 lines
4 lines
4 lines
8 lines
2 lines
28 lines
8 lines
2 lines
8 lines
26 lines
18 lines
2 lines
8 lines
2 lines
2 lines
8 lines
4 lines
2 lines
4 lines
2 lines
2 lines
20 lines
8 lines
8 lines
8 lines
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
24 lines
4 lines
dfsan/
4 lines
8 lines
6 lines
4 lines
4 lines
4 lines
4 lines
lsan/
TestCases/
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 lines
4 lines
2 lines
2 lines
8 lines
6 lines
4 lines
2 lines
4 lines
4 lines
6 lines
6 lines
6 lines
4 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
4 lines
msan/
Linux/
6 lines
6 lines
6 lines
4 lines
12 lines
4 lines
4 lines
4 lines
2 lines
6 lines
22 lines
2 lines
8 lines
4 lines
4 lines
2 lines
16 lines
2 lines
8 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
16 lines
2 lines
16 lines
4 lines
6 lines
6 lines
2 lines
2 lines
4 lines
4 lines
8 lines
4 lines
12 lines
16 lines
2 lines
2 lines
4 lines
8 lines
16 lines
8 lines
4 lines
4 lines
2 lines
2 lines
4 lines
16 lines
6 lines
6 lines
8 lines
6 lines
2 lines
2 lines
2 lines
2 lines
16 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
16 lines
4 lines
10 lines
2 lines
2 lines
tsan/
2 lines
12 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
10 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
ubsan/
TestCases/
Float/
20 lines
Integer/
6 lines
2 lines
8 lines
8 lines
2 lines
4 lines
6 lines
20 lines
6 lines
6 lines
8 lines
2 lines
6 lines
Misc/
2 lines
6 lines
2 lines
2 lines
6 lines
TypeCheck/
Function/
2 lines
14 lines
10 lines
22 lines

Diff 8942

test/asan/TestCases/Darwin/cstring_literals_regtest.mm

Context not available.
// https://code.google.com/p/address-sanitizer/issues/detail?id=274. // https://code.google.com/p/address-sanitizer/issues/detail?id=274.
// RUN: %clang_asan %s -framework Foundation -o %t // RUN: %clang_asan %s -framework Foundation -o %t
// RUN: %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
#include <stdio.h> #include <stdio.h>
Context not available.

test/asan/TestCases/Darwin/interception-in-shared-lib-test.cc

Context not available.
// TODO(glider): figure out how to set rpath in a more portable way and unite // TODO(glider): figure out how to set rpath in a more portable way and unite
// this test with ../Linux/interception-in-shared-lib-test.cc. // this test with ../Linux/interception-in-shared-lib-test.cc.
// RUN: %clangxx_asan -O0 %s -o %t -Wl,-rpath,@executable-path -L%T -linterception-in-shared-lib-test && \ // RUN: %clangxx_asan -O0 %s -o %t -Wl,-rpath,@executable-path -L%T -linterception-in-shared-lib-test && \
// RUN: not %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
Context not available.

test/asan/TestCases/Darwin/malloc_set_zone_name-mprotect.cc

Context not available.
// page-aligned address, so we can only test on a best-effort basis. // page-aligned address, so we can only test on a best-effort basis.
// RUN: %clangxx_asan %s -o %t // RUN: %clangxx_asan %s -o %t
// RUN: %t 2>&1 // RUN: %run %t 2>&1
#include <malloc/malloc.h> #include <malloc/malloc.h>
#include <stdlib.h> #include <stdlib.h>
Context not available.

test/asan/TestCases/Darwin/malloc_zone-protected.cc

Context not available.
#include <stdio.h> #include <stdio.h>
// RUN: %clangxx_asan %s -o %t // RUN: %clangxx_asan %s -o %t
// RUN: not %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
void *pwn(malloc_zone_t *unused_zone, size_t unused_size) { void *pwn(malloc_zone_t *unused_zone, size_t unused_size) {
Context not available.

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

Context not available.
// 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: DYLD_INSERT_LIBRARIES=darwin-dummy-shared-lib-so.dylib \
// RUN: %t 2>&1 | FileCheck %s || exit 1 // RUN: %run %t 2>&1 | FileCheck %s || exit 1
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
Context not available.

test/asan/TestCases/Darwin/unset-insert-libraries-on-exec.cc

Context not available.
// 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: %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: DYLD_INSERT_LIBRARIES=%t-darwin-dummy-shared-lib-so.dylib \
// RUN: %t %T/echo-env 2>&1 | FileCheck %s || exit 1 // RUN: %run %t %T/echo-env 2>&1 | FileCheck %s || exit 1
#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);
Context not available.

test/asan/TestCases/Linux/asan_dlopen_test.cc

// Test that dlopen of dynamic runtime is prohibited. // Test that dlopen of dynamic runtime is prohibited.
// //
// RUN: %clangxx %s -DRT=\"%shared_libasan\" -o %t -ldl // RUN: %clangxx %s -DRT=\"%shared_libasan\" -o %t -ldl
// RUN: not %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
// REQUIRES: asan-dynamic-runtime // REQUIRES: asan-dynamic-runtime
#include <dlfcn.h> #include <dlfcn.h>

test/asan/TestCases/Linux/asan_prelink_test.cc

Context not available.
// 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 %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=verbosity=1 %run %t 2>&1 | FileCheck %s
// REQUIRES: x86_64-supported-target, asan-64-bits // REQUIRES: x86_64-supported-target, asan-64-bits
#if BUILD_SO #if BUILD_SO
Context not available.

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

Context not available.
// 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 %t 2>&1 | FileCheck %s // RUN: LD_PRELOAD=%shared_libasan not %run %t 2>&1 | FileCheck %s
// REQUIRES: asan-dynamic-runtime // REQUIRES: asan-dynamic-runtime
Context not available.

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 %t 2>&1 | FileCheck %s // RUN: LD_PRELOAD=%shared_libasan not %run %t 2>&1 | FileCheck %s
// REQUIRES: asan-dynamic-runtime // REQUIRES: asan-dynamic-runtime

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

Context not available.
// 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 %t 2>&1 | FileCheck %s // RUN: LD_PRELOAD=%shared_libasan not %run %t 2>&1 | FileCheck %s
// REQUIRES: asan-dynamic-runtime // REQUIRES: asan-dynamic-runtime
Context not available.

test/asan/TestCases/Linux/asan_rt_confict_test-2.cc

Context not available.
// //
// 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: %clangxx_asan_static %s %t.so -o %t // RUN: %clangxx_asan_static %s %t.so -o %t
// RUN: not %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
// REQUIRES: asan-dynamic-runtime // REQUIRES: asan-dynamic-runtime
Context not available.

test/asan/TestCases/Linux/clone_test.cc

// Regression test for: // Regression test for:
// http://code.google.com/p/address-sanitizer/issues/detail?id=37 // http://code.google.com/p/address-sanitizer/issues/detail?id=37
// RUN: %clangxx_asan -O0 %s -o %t && %t | FileCheck %s // RUN: %clangxx_asan -O0 %s -o %t && %run %t | FileCheck %s
// RUN: %clangxx_asan -O1 %s -o %t && %t | FileCheck %s // RUN: %clangxx_asan -O1 %s -o %t && %run %t | FileCheck %s
// RUN: %clangxx_asan -O2 %s -o %t && %t | FileCheck %s // RUN: %clangxx_asan -O2 %s -o %t && %run %t | FileCheck %s
// RUN: %clangxx_asan -O3 %s -o %t && %t | FileCheck %s // RUN: %clangxx_asan -O3 %s -o %t && %run %t | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <sched.h> #include <sched.h>

test/asan/TestCases/Linux/coverage.cc

// RUN: %clangxx_asan -mllvm -asan-coverage=1 -DSHARED %s -shared -o %T/libcoverage_test.so -fPIC // RUN: %clangxx_asan -mllvm -asan-coverage=1 -DSHARED %s -shared -o %T/libcoverage_test.so -fPIC
// RUN: %clangxx_asan -mllvm -asan-coverage=1 %s -o %t -Wl,-R,\$ORIGIN -L%T -lcoverage_test // RUN: %clangxx_asan -mllvm -asan-coverage=1 %s -o %t -Wl,-R,\$ORIGIN -L%T -lcoverage_test
// RUN: export ASAN_OPTIONS=coverage=1:verbosity=1 // RUN: export ASAN_OPTIONS=coverage=1:verbosity=1
// RUN: %t 2>&1 | FileCheck %s --check-prefix=CHECK-main // RUN: %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-main
// RUN: %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-foo // RUN: %run %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-foo
// RUN: %t bar 2>&1 | FileCheck %s --check-prefix=CHECK-bar // RUN: %run %t bar 2>&1 | FileCheck %s --check-prefix=CHECK-bar
// 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
// RUN: not %t foo bar 1 2 2>&1 | FileCheck %s --check-prefix=CHECK-report // RUN: not %run %t foo bar 1 2 2>&1 | FileCheck %s --check-prefix=CHECK-report
// //
// 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

test/asan/TestCases/Linux/function-sections-are-bad.cc

Context not available.
// interface. // interface.
// RUN: %clang_asan %s -Wl,--gc-sections -ldl -o %t // RUN: %clang_asan %s -Wl,--gc-sections -ldl -o %t
// RUN: %clang_asan %s -DBUILD_SO -fPIC -o %t-so.so -shared // RUN: %clang_asan %s -DBUILD_SO -fPIC -o %t-so.so -shared
// RUN: %t 2>&1 // RUN: %run %t 2>&1
// REQUIRES: asan-64-bits // REQUIRES: asan-64-bits
Context not available.

test/asan/TestCases/Linux/glob.cc

// RUN: %clangxx_asan -O0 %s -o %t && %t %p 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -o %t && %run %t %p 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -o %t && %t %p 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -o %t && %run %t %p 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <glob.h> #include <glob.h>

test/asan/TestCases/Linux/heap-overflow-large.cc

Context not available.
// https://code.google.com/p/address-sanitizer/issues/detail?id=183 // https://code.google.com/p/address-sanitizer/issues/detail?id=183
// RUN: %clangxx_asan -O2 %s -o %t // RUN: %clangxx_asan -O2 %s -o %t
// RUN: not %t 12 2>&1 | FileCheck %s // RUN: not %run %t 12 2>&1 | FileCheck %s
// RUN: not %t 100 2>&1 | FileCheck %s // RUN: not %run %t 100 2>&1 | FileCheck %s
// RUN: not %t 10000 2>&1 | FileCheck %s // RUN: not %run %t 10000 2>&1 | FileCheck %s
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
Context not available.

test/asan/TestCases/Linux/heavy_uar_test.cc

// RUN: export ASAN_OPTIONS=detect_stack_use_after_return=1 // RUN: export ASAN_OPTIONS=detect_stack_use_after_return=1
// RUN: %clangxx_asan -O0 %s -o %t && \ // RUN: %clangxx_asan -O0 %s -o %t && \
// RUN: not %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O2 %s -o %t && \ // RUN: %clangxx_asan -O2 %s -o %t && \
// RUN: not %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>

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

Context not available.
// 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 %t 2>&1 | FileCheck %s // RUN: 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 %t 2>&1 | FileCheck %s // RUN: 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.
Context not available.

test/asan/TestCases/Linux/interception-in-shared-lib-test.cc

Context not available.
// TODO(glider): figure out how to set rpath in a more portable way and unite // TODO(glider): figure out how to set rpath in a more portable way and unite
// this test with ../Darwin/interception-in-shared-lib-test.cc. // this test with ../Darwin/interception-in-shared-lib-test.cc.
// RUN: %clangxx_asan -O0 %s -o %t -Wl,-R,\$ORIGIN -L%T -linterception-in-shared-lib-test && \ // RUN: %clangxx_asan -O0 %s -o %t -Wl,-R,\$ORIGIN -L%T -linterception-in-shared-lib-test && \
// RUN: not %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
Context not available.

test/asan/TestCases/Linux/interception_failure_test.cc

// If user provides his own libc functions, ASan doesn't // If user provides his own libc functions, ASan doesn't
// intercept these functions. // intercept these functions.
// RUN: %clangxx_asan -O0 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O2 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O2 %s -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>

test/asan/TestCases/Linux/interception_malloc_test.cc

// ASan interceptor can be accessed with __interceptor_ prefix. // ASan interceptor can be accessed with __interceptor_ prefix.
// RUN: %clangxx_asan -O0 %s -o %t && not %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 %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 %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 %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/asan/TestCases/Linux/interception_readdir_r_test.cc

// RUN: %clangxx_asan -O0 %s -DTEMP_DIR='"'"%T"'"' -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -DTEMP_DIR='"'"%T"'"' -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O1 %s -DTEMP_DIR='"'"%T"'"' -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O1 %s -DTEMP_DIR='"'"%T"'"' -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O2 %s -DTEMP_DIR='"'"%T"'"' -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O2 %s -DTEMP_DIR='"'"%T"'"' -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -DTEMP_DIR='"'"%T"'"' -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -DTEMP_DIR='"'"%T"'"' -o %t && %run %t 2>&1 | FileCheck %s
// //
// RUN: %clangxx_asan -O0 %s -D_FILE_OFFSET_BITS=64 -DTEMP_DIR='"'"%T"'"' -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -D_FILE_OFFSET_BITS=64 -DTEMP_DIR='"'"%T"'"' -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O1 %s -D_FILE_OFFSET_BITS=64 -DTEMP_DIR='"'"%T"'"' -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O1 %s -D_FILE_OFFSET_BITS=64 -DTEMP_DIR='"'"%T"'"' -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O2 %s -D_FILE_OFFSET_BITS=64 -DTEMP_DIR='"'"%T"'"' -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O2 %s -D_FILE_OFFSET_BITS=64 -DTEMP_DIR='"'"%T"'"' -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -D_FILE_OFFSET_BITS=64 -DTEMP_DIR='"'"%T"'"' -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -D_FILE_OFFSET_BITS=64 -DTEMP_DIR='"'"%T"'"' -o %t && %run %t 2>&1 | FileCheck %s
#include <dirent.h> #include <dirent.h>
#include <memory.h> #include <memory.h>

test/asan/TestCases/Linux/interception_test.cc

// ASan interceptor can be accessed with __interceptor_ prefix. // ASan interceptor can be accessed with __interceptor_ prefix.
// RUN: %clangxx_asan -O0 %s -o %t && not %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 %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 %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 %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>

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

// 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 %t 2>&1 | FileCheck %s --check-prefix=CHECK-%kernel_bits // RUN: ASAN_OPTIONS=verbosity=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%kernel_bits
// //
// CHECK-kernel-32-bits: || `[0x38000000, 0xbfffffff]` || HighMem || // CHECK-kernel-32-bits: || `[0x38000000, 0xbfffffff]` || HighMem ||
// CHECK-kernel-32-bits: || `[0x27000000, 0x37ffffff]` || HighShadow || // CHECK-kernel-32-bits: || `[0x27000000, 0x37ffffff]` || HighShadow ||

test/asan/TestCases/Linux/leak.cc

Context not available.
// REQUIRES: asan-64-bits // REQUIRES: asan-64-bits
// //
// RUN: %clangxx_asan %s -o %t // RUN: %clangxx_asan %s -o %t
// RUN: ASAN_OPTIONS=detect_leaks=1 not %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=detect_leaks=1 not %run %t 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS="" %t // RUN: ASAN_OPTIONS="" %run %t
// RUN: ASAN_OPTIONS=detect_leaks=0 %t // RUN: ASAN_OPTIONS=detect_leaks=0 %run %t
#include <stdio.h> #include <stdio.h>
int *t; int *t;
Context not available.

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 %t 2>&1 | FileCheck %s --check-prefix=CHECK-FAST // RUN: ASAN_OPTIONS=fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-FAST
// RUN: ASAN_OPTIONS=fast_unwind_on_malloc=0 not %t 2>&1 | FileCheck %s --check-prefix=CHECK-SLOW // RUN: 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).

test/asan/TestCases/Linux/malloc_delete_mismatch.cc

Context not available.
// 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 %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=ALLOC-STACK // RUN: 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 %t // RUN: 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 %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=alloc_dealloc_mismatch=1:malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS=alloc_dealloc_mismatch=1:malloc_context_size=0:fast_unwind_on_malloc=1 not %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
#include <stdlib.h> #include <stdlib.h>
static volatile char *x; static volatile char *x;
Context not available.

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

// 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.so // RUN: %clangxx_asan -DBUILD_SO=1 -fPIC -shared %s -o %t.so
// RUN: %clangxx_asan %s %t.so -Wl,-R. -o %t // RUN: %clangxx_asan %s %t.so -Wl,-R. -o %t
// RUN: ASAN_OPTIONS=detect_odr_violation=1 not %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=detect_odr_violation=1 not %run %t 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS=detect_odr_violation=2 not %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=detect_odr_violation=2 not %run %t 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS=detect_odr_violation=0 %t 2>&1 | FileCheck %s --check-prefix=DISABLED // RUN: ASAN_OPTIONS=detect_odr_violation=0 %run %t 2>&1 | FileCheck %s --check-prefix=DISABLED
// RUN: %t 2>&1 | FileCheck %s --check-prefix=DISABLED // RUN: %run %t 2>&1 | FileCheck %s --check-prefix=DISABLED
// //
// 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.so -DSZ=100 // RUN: %clangxx_asan -DBUILD_SO=1 -fPIC -shared %s -o %t.so -DSZ=100
// RUN: ASAN_OPTIONS=detect_odr_violation=1 %t 2>&1 | FileCheck %s --check-prefix=DISABLED // RUN: ASAN_OPTIONS=detect_odr_violation=1 %run %t 2>&1 | FileCheck %s --check-prefix=DISABLED
// RUN: ASAN_OPTIONS=detect_odr_violation=2 not %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=detect_odr_violation=2 not %run %t 2>&1 | FileCheck %s
#ifndef SZ #ifndef SZ
# define SZ 4 # define SZ 4

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 %t 2>&1 | FileCheck %s --check-prefix=CHECK-FAST // RUN: ASAN_OPTIONS=fast_unwind_on_fatal=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-FAST
// RUN: ASAN_OPTIONS=fast_unwind_on_fatal=0 not %t 2>&1 | FileCheck %s --check-prefix=CHECK-SLOW // RUN: 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).

test/asan/TestCases/Linux/preinit_test.cc

// RUN: %clangxx -DFUNC=zzzz %s -shared -o %t.so -fPIC // RUN: %clangxx -DFUNC=zzzz %s -shared -o %t.so -fPIC
// RUN: %clangxx_asan -DFUNC=main %s -o %t -Wl,-R. %t.so // RUN: %clangxx_asan -DFUNC=main %s -o %t -Wl,-R. %t.so
// RUN: %t // RUN: %run %t
// This test ensures that we call __asan_init early enough. // This test ensures that we call __asan_init early enough.
// We build a shared library w/o asan instrumentation // We build a shared library w/o asan instrumentation

test/asan/TestCases/Linux/ptrace.cc

// RUN: %clangxx_asan -O0 %s -o %t && %t // RUN: %clangxx_asan -O0 %s -o %t && %run %t
// RUN: %clangxx_asan -DPOSITIVE -O0 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -DPOSITIVE -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>

test/asan/TestCases/Linux/rlimit_mmap_test.cc

// Check that we properly report mmap failure. // Check that we properly report mmap failure.
// RUN: %clangxx_asan %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <stdlib.h> #include <stdlib.h>
#include <assert.h> #include <assert.h>
#include <sys/time.h> #include <sys/time.h>

test/asan/TestCases/Linux/shmctl.cc

// RUN: %clangxx_asan -O1 %s -o %t && %t 2>&1 // RUN: %clangxx_asan -O1 %s -o %t && %run %t 2>&1
// Regression test for // Regression test for
// https://code.google.com/p/address-sanitizer/issues/detail?id=250 // https://code.google.com/p/address-sanitizer/issues/detail?id=250
#include <stdio.h> #include <stdio.h>

test/asan/TestCases/Linux/stress_dtls.c

Context not available.
// 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 -lpthread -o %t // RUN: %clangxx_asan %s -ldl -lpthread -o %t
// RUN: %t 0 3 // RUN: %run %t 0 3
// RUN: %t 2 3 // RUN: %run %t 2 3
// RUN: ASAN_OPTIONS=verbosity=2 %t 10 2 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=verbosity=2 %run %t 10 2 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS=verbosity=2:intercept_tls_get_addr=1 %t 10 2 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=verbosity=2:intercept_tls_get_addr=1 %run %t 10 2 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS=verbosity=2:intercept_tls_get_addr=0 %t 10 2 2>&1 | FileCheck %s --check-prefix=CHECK0 // RUN: 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
Context not available.

test/asan/TestCases/Linux/swapcontext_test.cc

// Check that ASan plays well with easy cases of makecontext/swapcontext. // Check that ASan plays well with easy cases of makecontext/swapcontext.
// RUN: %clangxx_asan -O0 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O2 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O2 %s -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -o %t && %run %t 2>&1 | FileCheck %s
// //
// This test is too sublte to try on non-x86 arch for now. // This test is too sublte to try on non-x86 arch for now.
// REQUIRES: x86_64-supported-target,i386-supported-target // REQUIRES: x86_64-supported-target,i386-supported-target

test/asan/TestCases/Linux/syscalls.cc

// RUN: %clangxx_asan -O0 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <errno.h> #include <errno.h>

test/asan/TestCases/Linux/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 -lpthread -o %t // RUN: %clangxx_asan -O1 %s -lpthread -o %t
// RUN: ASAN_OPTIONS=quarantine_size=1 %t // RUN: ASAN_OPTIONS=quarantine_size=1 %run %t
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/asan/TestCases/Linux/uar_signals.cc

// This test checks that the implementation of use-after-return // This test checks that the implementation of use-after-return
// is async-signal-safe. // is async-signal-safe.
// RUN: %clangxx_asan -O1 %s -o %t -lpthread && %t // RUN: %clangxx_asan -O1 %s -o %t -lpthread && %run %t
#include <signal.h> #include <signal.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>

test/asan/TestCases/Linux/unpoison_tls.cc

// Test that TLS is unpoisoned on thread death. // Test that TLS is unpoisoned on thread death.
// REQUIRES: x86_64-supported-target,i386-supported-target // REQUIRES: x86_64-supported-target,i386-supported-target
// RUN: %clangxx_asan -O1 %s -lpthread -o %t && %t 2>&1 // RUN: %clangxx_asan -O1 %s -lpthread -o %t && %run %t 2>&1
#include <assert.h> #include <assert.h>
#include <pthread.h> #include <pthread.h>

test/asan/TestCases/allocator_returns_null.cc

Context not available.
// 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 %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mCRASH // RUN: not %run %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mCRASH
// RUN: ASAN_OPTIONS=allocator_may_return_null=0 not %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mCRASH // RUN: ASAN_OPTIONS=allocator_may_return_null=0 not %run %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mCRASH
// RUN: ASAN_OPTIONS=allocator_may_return_null=1 %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mNULL // RUN: ASAN_OPTIONS=allocator_may_return_null=1 %run %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mNULL
// RUN: ASAN_OPTIONS=allocator_may_return_null=0 not %t calloc 2>&1 | FileCheck %s --check-prefix=CHECK-cCRASH // RUN: ASAN_OPTIONS=allocator_may_return_null=0 not %run %t calloc 2>&1 | FileCheck %s --check-prefix=CHECK-cCRASH
// RUN: ASAN_OPTIONS=allocator_may_return_null=1 %t calloc 2>&1 | FileCheck %s --check-prefix=CHECK-cNULL // RUN: ASAN_OPTIONS=allocator_may_return_null=1 %run %t calloc 2>&1 | FileCheck %s --check-prefix=CHECK-cNULL
// RUN: ASAN_OPTIONS=allocator_may_return_null=0 not %t calloc-overflow 2>&1 | FileCheck %s --check-prefix=CHECK-coCRASH // RUN: ASAN_OPTIONS=allocator_may_return_null=0 not %run %t calloc-overflow 2>&1 | FileCheck %s --check-prefix=CHECK-coCRASH
// RUN: ASAN_OPTIONS=allocator_may_return_null=1 %t calloc-overflow 2>&1 | FileCheck %s --check-prefix=CHECK-coNULL // RUN: ASAN_OPTIONS=allocator_may_return_null=1 %run %t calloc-overflow 2>&1 | FileCheck %s --check-prefix=CHECK-coNULL
// RUN: ASAN_OPTIONS=allocator_may_return_null=0 not %t realloc 2>&1 | FileCheck %s --check-prefix=CHECK-rCRASH // RUN: ASAN_OPTIONS=allocator_may_return_null=0 not %run %t realloc 2>&1 | FileCheck %s --check-prefix=CHECK-rCRASH
// RUN: ASAN_OPTIONS=allocator_may_return_null=1 %t realloc 2>&1 | FileCheck %s --check-prefix=CHECK-rNULL // RUN: ASAN_OPTIONS=allocator_may_return_null=1 %run %t realloc 2>&1 | FileCheck %s --check-prefix=CHECK-rNULL
// RUN: ASAN_OPTIONS=allocator_may_return_null=0 not %t realloc-after-malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mrCRASH // RUN: ASAN_OPTIONS=allocator_may_return_null=0 not %run %t realloc-after-malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mrCRASH
// RUN: ASAN_OPTIONS=allocator_may_return_null=1 %t realloc-after-malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mrNULL // RUN: 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>
Context not available.

test/asan/TestCases/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 %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -o %t && ASAN_OPTIONS=allow_user_segv_handler=true not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O2 %s -o %t && ASAN_OPTIONS=allow_user_segv_handler=true not %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
#include <signal.h> #include <signal.h>
#include <stdio.h> #include <stdio.h>

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

Context not available.
// RUN: %clangxx_asan -O0 %p/SharedLibs/shared-lib-test-so.cc -fPIC -shared -o %t-so.so // RUN: %clangxx_asan -O0 %p/SharedLibs/shared-lib-test-so.cc -fPIC -shared -o %t-so.so
// RUN: %clangxx_asan -O0 %s -ldl -o %t // RUN: %clangxx_asan -O0 %s -ldl -o %t
// RUN: ASAN_OPTIONS=symbolize=0 not %t 2>&1 | %asan_symbolize | FileCheck %s // RUN: ASAN_OPTIONS=symbolize=0 not %run %t 2>&1 | %asan_symbolize | FileCheck %s
#include <dlfcn.h> #include <dlfcn.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
Context not available.

test/asan/TestCases/assign_large_valloc_to_global.cc

// Make sure we don't report a leak nor hang. // Make sure we don't report a leak nor hang.
// RUN: %clangxx_asan -O3 %s -o %t && %t // RUN: %clangxx_asan -O3 %s -o %t && %run %t
#include <stdlib.h> #include <stdlib.h>
#ifndef __APPLE__ #ifndef __APPLE__
#include <malloc.h> #include <malloc.h>

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: ASAN_OPTIONS=atexit=1:print_stats=1 %t 2>&1 | FileCheck %s // RUN: 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

test/asan/TestCases/blacklist.cc

Context not available.
// RUN: echo "global:*badGlobal*" >> %tmp // RUN: echo "global:*badGlobal*" >> %tmp
// RUN: echo "src:*blacklist-extra.cc" >> %tmp // RUN: echo "src:*blacklist-extra.cc" >> %tmp
// RUN: %clangxx_asan -fsanitize-blacklist=%tmp -O0 %s -o %t \ // RUN: %clangxx_asan -fsanitize-blacklist=%tmp -O0 %s -o %t \
// RUN: %p/Helpers/blacklist-extra.cc && %t 2>&1 // RUN: %p/Helpers/blacklist-extra.cc && %run %t 2>&1
// RUN: %clangxx_asan -fsanitize-blacklist=%tmp -O1 %s -o %t \ // RUN: %clangxx_asan -fsanitize-blacklist=%tmp -O1 %s -o %t \
// RUN: %p/Helpers/blacklist-extra.cc && %t 2>&1 // RUN: %p/Helpers/blacklist-extra.cc && %run %t 2>&1
// RUN: %clangxx_asan -fsanitize-blacklist=%tmp -O2 %s -o %t \ // RUN: %clangxx_asan -fsanitize-blacklist=%tmp -O2 %s -o %t \
// RUN: %p/Helpers/blacklist-extra.cc && %t 2>&1 // RUN: %p/Helpers/blacklist-extra.cc && %run %t 2>&1
// RUN: %clangxx_asan -fsanitize-blacklist=%tmp -O3 %s -o %t \ // RUN: %clangxx_asan -fsanitize-blacklist=%tmp -O3 %s -o %t \
// RUN: %p/Helpers/blacklist-extra.cc && %t 2>&1 // RUN: %p/Helpers/blacklist-extra.cc && %run %t 2>&1
// badGlobal is accessed improperly, but we blacklisted it. Align // badGlobal is accessed improperly, but we blacklisted it. Align
// it to make sure memory past the end of badGlobal will be in // it to make sure memory past the end of badGlobal will be in
Context not available.

test/asan/TestCases/contiguous_container.cc

// RUN: %clangxx_asan -O %s -o %t && %t // RUN: %clangxx_asan -O %s -o %t && %run %t
// //
// Test __sanitizer_annotate_contiguous_container. // Test __sanitizer_annotate_contiguous_container.

test/asan/TestCases/contiguous_container_crash.cc

// RUN: %clangxx_asan -O %s -o %t // RUN: %clangxx_asan -O %s -o %t
// RUN: not %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 %t bad-bounds 2>&1 | FileCheck --check-prefix=CHECK-BAD %s // RUN: not %run %t bad-bounds 2>&1 | FileCheck --check-prefix=CHECK-BAD %s
// RUN: ASAN_OPTIONS=detect_container_overflow=0 %t crash // RUN: 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.

test/asan/TestCases/current_allocated_bytes.cc

// RUN: %clangxx_asan -O0 %s -lpthread -o %t && %t // RUN: %clangxx_asan -O0 %s -lpthread -o %t && %run %t
// RUN: %clangxx_asan -O2 %s -lpthread -o %t && %t // RUN: %clangxx_asan -O2 %s -lpthread -o %t && %run %t
#include <assert.h> #include <assert.h>
#include <pthread.h> #include <pthread.h>

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.
// export ASAN_OPTIONS=detect_stack_use_after_return=1 // export ASAN_OPTIONS=detect_stack_use_after_return=1
// RUN: %clangxx_asan -O2 %s -o %t && \ // RUN: %clangxx_asan -O2 %s -o %t && \
// RUN: %t 2>&1 | FileCheck %s // RUN: %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: ASAN_OPTIONS=verbosity=1:use_sigaltstack=1 %t | FileCheck %s // RUN: ASAN_OPTIONS=verbosity=1:use_sigaltstack=1 %run %t | FileCheck %s
#include <stdio.h> #include <stdio.h>
__attribute__((noinline)) __attribute__((noinline))

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: ASAN_OPTIONS=malloc_context_size=120:redzone=512 not %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=malloc_context_size=120:redzone=512 not %run %t 2>&1 | FileCheck %s
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>

test/asan/TestCases/deep_tail_call.cc

// RUN: %clangxx_asan -O0 %s -o %t && not %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 %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 %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 %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
// CHECK: AddressSanitizer: global-buffer-overflow // CHECK: AddressSanitizer: global-buffer-overflow
int global[10]; int global[10];

test/asan/TestCases/deep_thread_stack.cc

// RUN: %clangxx_asan -O0 %s -lpthread -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -lpthread -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O1 %s -lpthread -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O1 %s -lpthread -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O2 %s -lpthread -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O2 %s -lpthread -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -lpthread -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -lpthread -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>

test/asan/TestCases/default_options.cc

// RUN: %clangxx_asan -O2 %s -o %t // RUN: %clangxx_asan -O2 %s -o %t
// RUN: %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
const char *kAsanDefaultOptions="verbosity=1 foo=bar"; const char *kAsanDefaultOptions="verbosity=1 foo=bar";

test/asan/TestCases/dlclose-test.cc

Context not available.
// REQUIRES: x86_64-supported-target,i386-supported-target // REQUIRES: x86_64-supported-target,i386-supported-target
// RUN: %clangxx_asan -O0 %p/SharedLibs/dlclose-test-so.cc -fPIC -shared -o %t-so.so // RUN: %clangxx_asan -O0 %p/SharedLibs/dlclose-test-so.cc -fPIC -shared -o %t-so.so
// RUN: %clangxx_asan -O0 %s -ldl -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -ldl -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O1 %p/SharedLibs/dlclose-test-so.cc -fPIC -shared -o %t-so.so // RUN: %clangxx_asan -O1 %p/SharedLibs/dlclose-test-so.cc -fPIC -shared -o %t-so.so
// RUN: %clangxx_asan -O1 %s -ldl -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O1 %s -ldl -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O2 %p/SharedLibs/dlclose-test-so.cc -fPIC -shared -o %t-so.so // RUN: %clangxx_asan -O2 %p/SharedLibs/dlclose-test-so.cc -fPIC -shared -o %t-so.so
// RUN: %clangxx_asan -O2 %s -ldl -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O2 %s -ldl -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %p/SharedLibs/dlclose-test-so.cc -fPIC -shared -o %t-so.so // RUN: %clangxx_asan -O3 %p/SharedLibs/dlclose-test-so.cc -fPIC -shared -o %t-so.so
// RUN: %clangxx_asan -O3 %s -ldl -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -ldl -o %t && %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <dlfcn.h> #include <dlfcn.h>
Context not available.

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 %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: ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=0 not %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=1 not %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>

test/asan/TestCases/force_inline_opt0.cc

// This test checks that we are no instrumenting a memory access twice // This test checks that we are no instrumenting a memory access twice
// (before and after inlining) // (before and after inlining)
// RUN: %clangxx_asan -O1 %s -o %t && %t // RUN: %clangxx_asan -O1 %s -o %t && %run %t
// RUN: %clangxx_asan -O0 %s -o %t && %t // RUN: %clangxx_asan -O0 %s -o %t && %run %t
__attribute__((always_inline)) __attribute__((always_inline))
void foo(int *x) { void foo(int *x) {
*x = 0; *x = 0;

test/asan/TestCases/free_hook_realloc.cc

// Check that free hook doesn't conflict with Realloc. // Check that free hook doesn't conflict with Realloc.
// RUN: %clangxx_asan -O2 %s -o %t // RUN: %clangxx_asan -O2 %s -o %t
// RUN: %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h> #include <unistd.h>

test/asan/TestCases/gc-test.cc

// RUN: %clangxx_asan %s -lpthread -o %t // RUN: %clangxx_asan %s -lpthread -o %t
// RUN: ASAN_OPTIONS=detect_stack_use_after_return=1 %t 2>&1 | FileCheck %s --check-prefix=CHECK1 // RUN: ASAN_OPTIONS=detect_stack_use_after_return=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK1
// RUN: ASAN_OPTIONS=detect_stack_use_after_return=0 %t 2>&1 | FileCheck %s --check-prefix=CHECK0 // RUN: ASAN_OPTIONS=detect_stack_use_after_return=0 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK0
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>

test/asan/TestCases/global-demangle.cc

// RUN: %clangxx_asan -O0 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
namespace XXX { namespace XXX {
class YYY { class YYY {

test/asan/TestCases/global-overflow.cc

// RUN: %clangxx_asan -O0 %s -o %t && not %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 %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 %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 %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <string.h> #include <string.h>
int main(int argc, char **argv) { int main(int argc, char **argv) {

test/asan/TestCases/heap-overflow.cc

// RUN: %clangxx_asan -O0 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// RUN: %clangxx_asan -O1 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// RUN: %clangxx_asan -O2 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// RUN: %clangxx_asan -O3 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>

test/asan/TestCases/huge_negative_hea_oob.cc

// RUN: %clangxx_asan %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan %s -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O %s -o %t && not %run %t 2>&1 | FileCheck %s
// Check that we can find huge buffer overflows to the left. // Check that we can find huge buffer overflows to the left.
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>

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

Context not available.
// 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: ASAN_OPTIONS=strict_init_order=true not %t 2>&1 | FileCheck %s // RUN: 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>
Context not available.

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

Context not available.
// FIXME: find a better solution. // FIXME: find a better solution.
// RUN: %clangxx_asan -O0 %s -lpthread -ldl -o %t -Wl,--export-dynamic || \ // RUN: %clangxx_asan -O0 %s -lpthread -ldl -o %t -Wl,--export-dynamic || \
// RUN: %clangxx_asan -O0 %s -lpthread -ldl -o %t // RUN: %clangxx_asan -O0 %s -lpthread -ldl -o %t
// RUN: ASAN_OPTIONS=strict_init_order=true %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=strict_init_order=true %run %t 2>&1 | FileCheck %s
#include <dlfcn.h> #include <dlfcn.h>
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
Context not available.

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

Context not available.
// called. // called.
// RUN: %clangxx_asan %s %p/Helpers/init-order-pthread-create-extra.cc -lpthread -o %t // RUN: %clangxx_asan %s %p/Helpers/init-order-pthread-create-extra.cc -lpthread -o %t
// RUN: ASAN_OPTIONS=strict_init_order=true %t // RUN: ASAN_OPTIONS=strict_init_order=true %run %t
#include <stdio.h> #include <stdio.h>
#include <pthread.h> #include <pthread.h>
Context not available.

test/asan/TestCases/initialization-blacklist.cc

Context not available.
// RUN: %p/Helpers/initialization-blacklist-extra2.cc \ // RUN: %p/Helpers/initialization-blacklist-extra2.cc \
// RUN: -fsanitize-blacklist=%p/Helpers/initialization-blacklist.txt \ // RUN: -fsanitize-blacklist=%p/Helpers/initialization-blacklist.txt \
// RUN: -fsanitize=init-order -o %t // RUN: -fsanitize=init-order -o %t
// RUN: ASAN_OPTIONS=check_initialization_order=true %t 2>&1 // RUN: 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 \ // RUN: -fsanitize-blacklist=%p/Helpers/initialization-blacklist.txt \
// RUN: -fsanitize=init-order -o %t // RUN: -fsanitize=init-order -o %t
// RUN: ASAN_OPTIONS=check_initialization_order=true %t 2>&1 // RUN: 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 \ // RUN: -fsanitize-blacklist=%p/Helpers/initialization-blacklist.txt \
// RUN: -fsanitize=init-order -o %t // RUN: -fsanitize=init-order -o %t
// RUN: ASAN_OPTIONS=check_initialization_order=true %t 2>&1 // RUN: 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();
Context not available.

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 // RUN: %clangxx_asan -O0 %s %p/Helpers/initialization-bug-extra2.cc -o %t
// RUN: ASAN_OPTIONS=check_initialization_order=true not %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=check_initialization_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.

test/asan/TestCases/initialization-constexpr.cc

Context not available.
// RUN: %clangxx_asan -O0 %s %p/Helpers/initialization-constexpr-extra.cc\ // RUN: %clangxx_asan -O0 %s %p/Helpers/initialization-constexpr-extra.cc\
// RUN: --std=c++11 -fsanitize=init-order -o %t // RUN: --std=c++11 -fsanitize=init-order -o %t
// RUN: ASAN_OPTIONS=check_initialization_order=true %t 2>&1 // RUN: ASAN_OPTIONS=check_initialization_order=true %run %t 2>&1
// RUN: %clangxx_asan -O1 %s %p/Helpers/initialization-constexpr-extra.cc\ // RUN: %clangxx_asan -O1 %s %p/Helpers/initialization-constexpr-extra.cc\
// RUN: --std=c++11 -fsanitize=init-order -o %t // RUN: --std=c++11 -fsanitize=init-order -o %t
// RUN: ASAN_OPTIONS=check_initialization_order=true %t 2>&1 // RUN: ASAN_OPTIONS=check_initialization_order=true %run %t 2>&1
// RUN: %clangxx_asan -O2 %s %p/Helpers/initialization-constexpr-extra.cc\ // RUN: %clangxx_asan -O2 %s %p/Helpers/initialization-constexpr-extra.cc\
// RUN: --std=c++11 -fsanitize=init-order -o %t // RUN: --std=c++11 -fsanitize=init-order -o %t
// RUN: ASAN_OPTIONS=check_initialization_order=true %t 2>&1 // RUN: ASAN_OPTIONS=check_initialization_order=true %run %t 2>&1
// RUN: %clangxx_asan -O3 %s %p/Helpers/initialization-constexpr-extra.cc\ // RUN: %clangxx_asan -O3 %s %p/Helpers/initialization-constexpr-extra.cc\
// RUN: --std=c++11 -fsanitize=init-order -o %t // RUN: --std=c++11 -fsanitize=init-order -o %t
// RUN: ASAN_OPTIONS=check_initialization_order=true %t 2>&1 // RUN: ASAN_OPTIONS=check_initialization_order=true %run %t 2>&1
class Integer { class Integer {
private: private:
Context not available.

test/asan/TestCases/initialization-nobug.cc

Context not available.
// 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 -fsanitize=init-order -o %t // RUN: %clangxx_asan -O0 %s %p/Helpers/initialization-nobug-extra.cc -fsanitize=init-order -o %t
// RUN: ASAN_OPTIONS=check_initialization_order=true %t 2>&1 // RUN: ASAN_OPTIONS=check_initialization_order=true %run %t 2>&1
// RUN: %clangxx_asan -O1 %s %p/Helpers/initialization-nobug-extra.cc -fsanitize=init-order -o %t // RUN: %clangxx_asan -O1 %s %p/Helpers/initialization-nobug-extra.cc -fsanitize=init-order -o %t
// RUN: ASAN_OPTIONS=check_initialization_order=true %t 2>&1 // RUN: ASAN_OPTIONS=check_initialization_order=true %run %t 2>&1
// RUN: %clangxx_asan -O2 %s %p/Helpers/initialization-nobug-extra.cc -fsanitize=init-order -o %t // RUN: %clangxx_asan -O2 %s %p/Helpers/initialization-nobug-extra.cc -fsanitize=init-order -o %t
// RUN: ASAN_OPTIONS=check_initialization_order=true %t 2>&1 // RUN: ASAN_OPTIONS=check_initialization_order=true %run %t 2>&1
// RUN: %clangxx_asan -O3 %s %p/Helpers/initialization-nobug-extra.cc -fsanitize=init-order -o %t // RUN: %clangxx_asan -O3 %s %p/Helpers/initialization-nobug-extra.cc -fsanitize=init-order -o %t
// RUN: ASAN_OPTIONS=check_initialization_order=true %t 2>&1 // RUN: 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
Context not available.

test/asan/TestCases/inline.cc

// RUN: %clangxx_asan -O3 %s -o %t && %t // RUN: %clangxx_asan -O3 %s -o %t && %run %t
// Test that no_sanitize_address attribute applies even when the function would // Test that no_sanitize_address attribute applies even when the function would
// be normally inlined. // be normally inlined.

test/asan/TestCases/interface_test.cc

// Check that user may include ASan interface header. // Check that user may include ASan interface header.
// RUN: %clang_asan %s -o %t && %t // RUN: %clang_asan %s -o %t && %run %t
// RUN: %clang_asan -x c %s -o %t && %t // RUN: %clang_asan -x c %s -o %t && %run %t
// RUN: %clang %s -o %t && %t // RUN: %clang %s -o %t && %run %t
// RUN: %clang -x c %s -o %t && %t // RUN: %clang -x c %s -o %t && %run %t
#include <sanitizer/asan_interface.h> #include <sanitizer/asan_interface.h>
int main() { int main() {

test/asan/TestCases/invalid-free.cc

// RUN: %clangxx_asan -O0 %s -o %t // RUN: %clangxx_asan -O0 %s -o %t
// RUN: not %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: ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=0 not %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=1 not %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>

test/asan/TestCases/ioctl.cc

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

test/asan/TestCases/large_allocator_unpoisons_on_free.cc

Context not available.
// 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=1 %t // RUN: ASAN_OPTIONS=quarantine_size=1 %run %t
#include <assert.h> #include <assert.h>
#include <string.h> #include <string.h>
Context not available.

test/asan/TestCases/large_func_test.cc

// RUN: %clangxx_asan -O0 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// RUN: %clangxx_asan -O1 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// RUN: %clangxx_asan -O2 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// RUN: %clangxx_asan -O3 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
#include <stdlib.h> #include <stdlib.h>
__attribute__((noinline)) __attribute__((noinline))

test/asan/TestCases/log-path_test.cc

// RUN: %clangxx_asan %s -o %t // RUN: %clangxx_asan %s -o %t
// Regular run. // Regular run.
// RUN: not %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: ASAN_OPTIONS=log_path=%t.log not %t 2> %t.out // RUN: 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: ASAN_OPTIONS=log_path=/INVALID not %t 2> %t.out // RUN: ASAN_OPTIONS=log_path=/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: ASAN_OPTIONS=log_path=`for((i=0;i<10000;i++)); do echo -n $i; done` \ // RUN: ASAN_OPTIONS=log_path=`for((i=0;i<10000;i++)); do echo -n $i; done` \
// RUN: not %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: ASAN_OPTIONS=log_path=%t.log %t ARG ARG ARG // RUN: ASAN_OPTIONS=log_path=%t.log %run %t ARG ARG ARG
// RUN: not cat %t.log.* // RUN: not cat %t.log.*

test/asan/TestCases/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: ASAN_OPTIONS="log_path=%t.log verbosity=1" not %t 2> %t.out // RUN: 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 ]

test/asan/TestCases/lsan_annotations.cc

// Check that LSan annotations work fine. // Check that LSan annotations work fine.
// RUN: %clangxx_asan -O0 %s -o %t && %t // RUN: %clangxx_asan -O0 %s -o %t && %run %t
// RUN: %clangxx_asan -O3 %s -o %t && %t // RUN: %clangxx_asan -O3 %s -o %t && %run %t
#include <sanitizer/lsan_interface.h> #include <sanitizer/lsan_interface.h>
#include <stdlib.h> #include <stdlib.h>

test/asan/TestCases/malloc_context_size.cc

// RUN: %clangxx_asan -O0 %s -o %t // RUN: %clangxx_asan -O0 %s -o %t
// RUN: ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=0 not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os // RUN: ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os
// RUN: ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=1 not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os // RUN: ASAN_OPTIONS=malloc_context_size=0:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os
// RUN: ASAN_OPTIONS=malloc_context_size=1:fast_unwind_on_malloc=0 not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os // RUN: ASAN_OPTIONS=malloc_context_size=1:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os
// RUN: ASAN_OPTIONS=malloc_context_size=1:fast_unwind_on_malloc=1 not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os // RUN: ASAN_OPTIONS=malloc_context_size=1:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os
// RUN: ASAN_OPTIONS=malloc_context_size=2 not %t 2>&1 | FileCheck %s --check-prefix=TWO // RUN: 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];

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: %t | FileCheck %s // RUN: %run %t | FileCheck %s
// RUN: ASAN_OPTIONS=max_malloc_fill_size=10:malloc_fill_byte=8 %t | FileCheck %s --check-prefix=CHECK-10-8 // RUN: ASAN_OPTIONS=max_malloc_fill_size=10:malloc_fill_byte=8 %run %t | FileCheck %s --check-prefix=CHECK-10-8
// RUN: ASAN_OPTIONS=max_malloc_fill_size=20:malloc_fill_byte=171 %t | FileCheck %s --check-prefix=CHECK-20-ab // RUN: 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) {

test/asan/TestCases/malloc_hook.cc

// RUN: %clangxx_asan -O2 %s -o %t // RUN: %clangxx_asan -O2 %s -o %t
// RUN: %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h> #include <unistd.h>

test/asan/TestCases/max_redzone.cc

// Test max_redzone runtime option. // Test max_redzone runtime option.
// RUN: %clangxx_asan -O0 %s -o %t && ASAN_OPTIONS=max_redzone=16 %t 0 2>&1 // RUN: %clangxx_asan -O0 %s -o %t && ASAN_OPTIONS=max_redzone=16 %run %t 0 2>&1
// RUN: %clangxx_asan -O0 %s -o %t && %t 1 2>&1 // RUN: %clangxx_asan -O0 %s -o %t && %run %t 1 2>&1
// RUN: %clangxx_asan -O3 %s -o %t && ASAN_OPTIONS=max_redzone=16 %t 0 2>&1 // RUN: %clangxx_asan -O3 %s -o %t && ASAN_OPTIONS=max_redzone=16 %run %t 0 2>&1
// RUN: %clangxx_asan -O3 %s -o %t && %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>

test/asan/TestCases/memcmp_strict_test.cc

// RUN: %clangxx_asan -O0 %s -o %t && ASAN_OPTIONS=strict_memcmp=0 %t // RUN: %clangxx_asan -O0 %s -o %t && ASAN_OPTIONS=strict_memcmp=0 %run %t
// RUN: %clangxx_asan -O0 %s -o %t && ASAN_OPTIONS=strict_memcmp=1 not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -o %t && 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 %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>

test/asan/TestCases/memcmp_test.cc

// RUN: %clangxx_asan -O0 %s -o %t && not %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 %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 %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 %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
// REQUIRES: compiler-rt-optimized // REQUIRES: compiler-rt-optimized

test/asan/TestCases/memset_test.cc

// Test that large memset/memcpy/memmove check the entire range. // Test that large memset/memcpy/memmove check the entire range.
// RUN: %clangxx_asan -O0 -DTEST_MEMSET %s -o %t && not %t 2>&1 | \ // RUN: %clangxx_asan -O0 -DTEST_MEMSET %s -o %t && not %run %t 2>&1 | \
// RUN: FileCheck %s --check-prefix=CHECK-MEMSET // RUN: FileCheck %s --check-prefix=CHECK-MEMSET
// RUN: %clangxx_asan -O1 -DTEST_MEMSET %s -o %t && not %t 2>&1 | \ // RUN: %clangxx_asan -O1 -DTEST_MEMSET %s -o %t && not %run %t 2>&1 | \
// RUN: FileCheck %s --check-prefix=CHECK-MEMSET // RUN: FileCheck %s --check-prefix=CHECK-MEMSET
// RUN: %clangxx_asan -O2 -DTEST_MEMSET %s -o %t && not %t 2>&1 | \ // RUN: %clangxx_asan -O2 -DTEST_MEMSET %s -o %t && not %run %t 2>&1 | \
// RUN: FileCheck %s --check-prefix=CHECK-MEMSET // RUN: FileCheck %s --check-prefix=CHECK-MEMSET
// RUN: %clangxx_asan -O3 -DTEST_MEMSET %s -o %t && not %t 2>&1 | \ // RUN: %clangxx_asan -O3 -DTEST_MEMSET %s -o %t && not %run %t 2>&1 | \
// RUN: FileCheck %s --check-prefix=CHECK-MEMSET // RUN: FileCheck %s --check-prefix=CHECK-MEMSET
// RUN: %clangxx_asan -O0 -DTEST_MEMCPY %s -o %t && not %t 2>&1 | \ // RUN: %clangxx_asan -O0 -DTEST_MEMCPY %s -o %t && not %run %t 2>&1 | \
// RUN: FileCheck %s --check-prefix=CHECK-MEMCPY // RUN: FileCheck %s --check-prefix=CHECK-MEMCPY
// RUN: %clangxx_asan -O1 -DTEST_MEMCPY %s -o %t && not %t 2>&1 | \ // RUN: %clangxx_asan -O1 -DTEST_MEMCPY %s -o %t && not %run %t 2>&1 | \
// RUN: FileCheck %s --check-prefix=CHECK-MEMCPY // RUN: FileCheck %s --check-prefix=CHECK-MEMCPY
// RUN: %clangxx_asan -O2 -DTEST_MEMCPY %s -o %t && not %t 2>&1 | \ // RUN: %clangxx_asan -O2 -DTEST_MEMCPY %s -o %t && not %run %t 2>&1 | \
// RUN: FileCheck %s --check-prefix=CHECK-MEMCPY // RUN: FileCheck %s --check-prefix=CHECK-MEMCPY
// RUN: %clangxx_asan -O3 -DTEST_MEMCPY %s -o %t && not %t 2>&1 | \ // RUN: %clangxx_asan -O3 -DTEST_MEMCPY %s -o %t && not %run %t 2>&1 | \
// RUN: FileCheck %s --check-prefix=CHECK-MEMCPY // RUN: FileCheck %s --check-prefix=CHECK-MEMCPY
// RUN: %clangxx_asan -O0 -DTEST_MEMMOVE %s -o %t && not %t 2>&1 | \ // RUN: %clangxx_asan -O0 -DTEST_MEMMOVE %s -o %t && not %run %t 2>&1 | \
// RUN: FileCheck %s --check-prefix=CHECK-MEMMOVE // RUN: FileCheck %s --check-prefix=CHECK-MEMMOVE
// RUN: %clangxx_asan -O1 -DTEST_MEMMOVE %s -o %t && not %t 2>&1 | \ // RUN: %clangxx_asan -O1 -DTEST_MEMMOVE %s -o %t && not %run %t 2>&1 | \
// RUN: FileCheck %s --check-prefix=CHECK-MEMMOVE // RUN: FileCheck %s --check-prefix=CHECK-MEMMOVE
// RUN: %clangxx_asan -O2 -DTEST_MEMMOVE %s -o %t && not %t 2>&1 | \ // RUN: %clangxx_asan -O2 -DTEST_MEMMOVE %s -o %t && not %run %t 2>&1 | \
// RUN: FileCheck %s --check-prefix=CHECK-MEMMOVE // RUN: FileCheck %s --check-prefix=CHECK-MEMMOVE
// RUN: %clangxx_asan -O3 -DTEST_MEMMOVE %s -o %t && not %t 2>&1 | \ // RUN: %clangxx_asan -O3 -DTEST_MEMMOVE %s -o %t && not %run %t 2>&1 | \
// RUN: FileCheck %s --check-prefix=CHECK-MEMMOVE // RUN: FileCheck %s --check-prefix=CHECK-MEMMOVE
// RUN: %clangxx_asan -O2 -DTEST_MEMCPY_SIZE_OVERFLOW %s -o %t && not %t 2>&1 | \ // RUN: %clangxx_asan -O2 -DTEST_MEMCPY_SIZE_OVERFLOW %s -o %t && not %run %t 2>&1 | \
// RUN: FileCheck %s --check-prefix=CHECK-MEMCPY_SIZE_OVERFLOW // RUN: FileCheck %s --check-prefix=CHECK-MEMCPY_SIZE_OVERFLOW
#include <assert.h> #include <assert.h>

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: %t 100 16 // RUN: %run %t 100 16
// RUN: %t 100 1000000 // RUN: %run %t 100 1000000
// RUN: ASAN_OPTIONS=mmap_limit_mb=500 %t 50 16 // RUN: ASAN_OPTIONS=mmap_limit_mb=500 %run %t 50 16
// RUN: ASAN_OPTIONS=mmap_limit_mb=500 %t 50 1000000 // RUN: ASAN_OPTIONS=mmap_limit_mb=500 %run %t 50 1000000
// RUN: ASAN_OPTIONS=mmap_limit_mb=500 not %t 500 16 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=mmap_limit_mb=500 not %run %t 500 16 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS=mmap_limit_mb=500 not %t 500 1000000 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=mmap_limit_mb=500 not %run %t 500 1000000 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>

test/asan/TestCases/null_deref.cc

// RUN: %clangxx_asan -O0 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// RUN: %clangxx_asan -O1 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// RUN: %clangxx_asan -O2 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// RUN: %clangxx_asan -O3 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
__attribute__((noinline)) __attribute__((noinline))
static void NullDeref(int *ptr) { static void NullDeref(int *ptr) {

test/asan/TestCases/on_error_callback.cc

// RUN: %clangxx_asan -O2 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/asan/TestCases/partial_right.cc

// RUN: %clangxx_asan -O0 %s -o %t && not %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 %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 %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 %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <stdlib.h> #include <stdlib.h>
int main(int argc, char **argv) { int main(int argc, char **argv) {

test/asan/TestCases/poison_partial.cc

// RUN: %clangxx_asan -O0 %s -o %t // RUN: %clangxx_asan -O0 %s -o %t
// RUN: not %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
// RUN: not %t heap 2>&1 | FileCheck %s // RUN: not %run %t heap 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS=poison_partial=0 %t // RUN: ASAN_OPTIONS=poison_partial=0 %run %t
// RUN: ASAN_OPTIONS=poison_partial=0 %t heap // RUN: ASAN_OPTIONS=poison_partial=0 %run %t heap
#include <string.h> #include <string.h>
char g[21]; char g[21];
char *x; char *x;

test/asan/TestCases/print-stack-trace.cc

// RUN: %clangxx_asan -O0 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <sanitizer/asan_interface.h> #include <sanitizer/asan_interface.h>

test/asan/TestCases/print_summary.cc

// RUN: %clangxx_asan -O0 %s -o %t // RUN: %clangxx_asan -O0 %s -o %t
// RUN: not %t 2>&1 | FileCheck %s --check-prefix=YES // RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=YES
// RUN: ASAN_OPTIONS=print_summary=false not %t 2>&1 | FileCheck %s --check-prefix=NO // RUN: ASAN_OPTIONS=print_summary=false not %run %t 2>&1 | FileCheck %s --check-prefix=NO
int main() { int main() {
char *x = new char[20]; char *x = new char[20];

test/asan/TestCases/printf-1.c

// RUN: %clang_asan -O2 %s -o %t // RUN: %clang_asan -O2 %s -o %t
// RUN: ASAN_OPTIONS=check_printf=1 %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=check_printf=1 %run %t 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS=check_printf=0 %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=check_printf=0 %run %t 2>&1 | FileCheck %s
// RUN: %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
int main() { int main() {

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: ASAN_OPTIONS=replace_str=0:replace_intrin=0:check_printf=1 not %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s // RUN: ASAN_OPTIONS=replace_str=0:replace_intrin=0:check_printf=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
// RUN: ASAN_OPTIONS=replace_str=0:replace_intrin=0:check_printf=0 %t 2>&1 | FileCheck --check-prefix=CHECK-OFF %s // RUN: ASAN_OPTIONS=replace_str=0:replace_intrin=0:check_printf=0 %run %t 2>&1 | FileCheck --check-prefix=CHECK-OFF %s
// RUN: ASAN_OPTIONS=replace_str=0:replace_intrin=0 not %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s // RUN: ASAN_OPTIONS=replace_str=0:replace_intrin=0 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/asan/TestCases/printf-3.c

// RUN: %clang_asan -O2 %s -o %t // RUN: %clang_asan -O2 %s -o %t
// RUN: ASAN_OPTIONS=check_printf=1 not %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s // RUN: ASAN_OPTIONS=check_printf=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
// RUN: ASAN_OPTIONS=check_printf=0 %t 2>&1 | FileCheck --check-prefix=CHECK-OFF %s // RUN: ASAN_OPTIONS=check_printf=0 %run %t 2>&1 | FileCheck --check-prefix=CHECK-OFF %s
// RUN: not %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s // RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
#include <stdio.h> #include <stdio.h>
int main() { int main() {

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: ASAN_OPTIONS=replace_str=0:replace_intrin=0:check_printf=1 not %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s // RUN: ASAN_OPTIONS=replace_str=0:replace_intrin=0:check_printf=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
// RUN: ASAN_OPTIONS=replace_str=0:replace_intrin=0:check_printf=0 %t 2>&1 | FileCheck --check-prefix=CHECK-OFF %s // RUN: ASAN_OPTIONS=replace_str=0:replace_intrin=0:check_printf=0 %run %t 2>&1 | FileCheck --check-prefix=CHECK-OFF %s
// RUN: ASAN_OPTIONS=replace_str=0:replace_intrin=0 not %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s // RUN: ASAN_OPTIONS=replace_str=0:replace_intrin=0 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
#include <stdio.h> #include <stdio.h>
int main() { int main() {

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: ASAN_OPTIONS=replace_intrin=0:check_printf=1 not %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s // RUN: ASAN_OPTIONS=replace_intrin=0:check_printf=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
// RUN: ASAN_OPTIONS=replace_intrin=0:check_printf=0 %t 2>&1 | FileCheck --check-prefix=CHECK-OFF %s // RUN: ASAN_OPTIONS=replace_intrin=0:check_printf=0 %run %t 2>&1 | FileCheck --check-prefix=CHECK-OFF %s
// RUN: ASAN_OPTIONS=replace_intrin=0 not %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s // RUN: ASAN_OPTIONS=replace_intrin=0 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>

test/asan/TestCases/readv.cc

// RUN: %clangxx_asan -O0 %s -o %t && %t // RUN: %clangxx_asan -O0 %s -o %t && %run %t
// RUN: %clangxx_asan -O0 %s -DPOSITIVE -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -DPOSITIVE -o %t && not %run %t 2>&1 | FileCheck %s
// Test the readv() interceptor. // Test the readv() interceptor.

test/asan/TestCases/sanity_check_pure_c.c

// Sanity checking a test in pure C. // Sanity checking a test in pure C.
// RUN: %clang_asan -O2 %s -o %t // RUN: %clang_asan -O2 %s -o %t
// RUN: not %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
// Sanity checking a test in pure C with -pie. // Sanity checking a test in pure C with -pie.
// RUN: %clang_asan -O2 %s -pie -fPIE -o %t // RUN: %clang_asan -O2 %s -pie -fPIE -o %t
// RUN: not %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <stdlib.h> #include <stdlib.h>
int main() { int main() {

test/asan/TestCases/shared-lib-test.cc

// RUN: %clangxx_asan -O0 %p/SharedLibs/shared-lib-test-so.cc -fPIC -shared -o %t-so.so // RUN: %clangxx_asan -O0 %p/SharedLibs/shared-lib-test-so.cc -fPIC -shared -o %t-so.so
// RUN: %clangxx_asan -O0 %s -ldl -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -ldl -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O1 %p/SharedLibs/shared-lib-test-so.cc -fPIC -shared -o %t-so.so // RUN: %clangxx_asan -O1 %p/SharedLibs/shared-lib-test-so.cc -fPIC -shared -o %t-so.so
// RUN: %clangxx_asan -O1 %s -ldl -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O1 %s -ldl -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O2 %p/SharedLibs/shared-lib-test-so.cc -fPIC -shared -o %t-so.so // RUN: %clangxx_asan -O2 %p/SharedLibs/shared-lib-test-so.cc -fPIC -shared -o %t-so.so
// RUN: %clangxx_asan -O2 %s -ldl -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O2 %s -ldl -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %p/SharedLibs/shared-lib-test-so.cc -fPIC -shared -o %t-so.so // RUN: %clangxx_asan -O3 %p/SharedLibs/shared-lib-test-so.cc -fPIC -shared -o %t-so.so
// RUN: %clangxx_asan -O3 %s -ldl -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -ldl -o %t && not %run %t 2>&1 | FileCheck %s
#include <dlfcn.h> #include <dlfcn.h>
#include <stdio.h> #include <stdio.h>

test/asan/TestCases/sleep_before_dying.c

// RUN: %clang_asan -O2 %s -o %t // RUN: %clang_asan -O2 %s -o %t
// RUN: ASAN_OPTIONS="sleep_before_dying=1" not %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS="sleep_before_dying=1" not %run %t 2>&1 | FileCheck %s
#include <stdlib.h> #include <stdlib.h>
int main() { int main() {

test/asan/TestCases/stack-buffer-overflow-with-position.cc

// RUN: %clangxx_asan -O2 %s -o %t // RUN: %clangxx_asan -O2 %s -o %t
// RUN: not %t -2 2>&1 | FileCheck --check-prefix=CHECK-m2 %s // RUN: not %run %t -2 2>&1 | FileCheck --check-prefix=CHECK-m2 %s
// RUN: not %t -1 2>&1 | FileCheck --check-prefix=CHECK-m1 %s // RUN: not %run %t -1 2>&1 | FileCheck --check-prefix=CHECK-m1 %s
// RUN: %t 0 // RUN: %run %t 0
// RUN: %t 8 // RUN: %run %t 8
// RUN: not %t 9 2>&1 | FileCheck --check-prefix=CHECK-9 %s // RUN: not %run %t 9 2>&1 | FileCheck --check-prefix=CHECK-9 %s
// RUN: not %t 10 2>&1 | FileCheck --check-prefix=CHECK-10 %s // RUN: not %run %t 10 2>&1 | FileCheck --check-prefix=CHECK-10 %s
// RUN: not %t 30 2>&1 | FileCheck --check-prefix=CHECK-30 %s // RUN: not %run %t 30 2>&1 | FileCheck --check-prefix=CHECK-30 %s
// RUN: not %t 31 2>&1 | FileCheck --check-prefix=CHECK-31 %s // RUN: not %run %t 31 2>&1 | FileCheck --check-prefix=CHECK-31 %s
// RUN: not %t 41 2>&1 | FileCheck --check-prefix=CHECK-41 %s // RUN: not %run %t 41 2>&1 | FileCheck --check-prefix=CHECK-41 %s
// RUN: not %t 42 2>&1 | FileCheck --check-prefix=CHECK-42 %s // RUN: not %run %t 42 2>&1 | FileCheck --check-prefix=CHECK-42 %s
// RUN: not %t 62 2>&1 | FileCheck --check-prefix=CHECK-62 %s // RUN: not %run %t 62 2>&1 | FileCheck --check-prefix=CHECK-62 %s
// RUN: not %t 63 2>&1 | FileCheck --check-prefix=CHECK-63 %s // RUN: not %run %t 63 2>&1 | FileCheck --check-prefix=CHECK-63 %s
// RUN: not %t 73 2>&1 | FileCheck --check-prefix=CHECK-73 %s // RUN: not %run %t 73 2>&1 | FileCheck --check-prefix=CHECK-73 %s
// RUN: not %t 74 2>&1 | FileCheck --check-prefix=CHECK-74 %s // RUN: not %run %t 74 2>&1 | FileCheck --check-prefix=CHECK-74 %s
#include <string.h> #include <string.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/asan/TestCases/stack-buffer-overflow.cc

// RUN: %clangxx_asan -O0 %s -o %t && not %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 %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 %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 %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <string.h> #include <string.h>
int main(int argc, char **argv) { int main(int argc, char **argv) {

test/asan/TestCases/stack-frame-demangle.cc

// RUN: %clangxx_asan -O0 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <string.h> #include <string.h>

test/asan/TestCases/stack-oob-frames.cc

// RUN: %clangxx_asan -O1 %s -o %t // RUN: %clangxx_asan -O1 %s -o %t
// RUN: not %t 0 2>&1 | FileCheck %s --check-prefix=CHECK0 // RUN: not %run %t 0 2>&1 | FileCheck %s --check-prefix=CHECK0
// RUN: not %t 1 2>&1 | FileCheck %s --check-prefix=CHECK1 // RUN: not %run %t 1 2>&1 | FileCheck %s --check-prefix=CHECK1
// RUN: not %t 2 2>&1 | FileCheck %s --check-prefix=CHECK2 // RUN: not %run %t 2 2>&1 | FileCheck %s --check-prefix=CHECK2
// RUN: not %t 3 2>&1 | FileCheck %s --check-prefix=CHECK3 // RUN: not %run %t 3 2>&1 | FileCheck %s --check-prefix=CHECK3
#define NOINLINE __attribute__((noinline)) #define NOINLINE __attribute__((noinline))
inline void break_optimization(void *arg) { inline void break_optimization(void *arg) {

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 -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -DSMALL_FRAME -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -DSMALL_FRAME -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -DSMALL_FRAME -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O0 %s -DSAVE_ALL_THE_REGISTERS -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -DSAVE_ALL_THE_REGISTERS -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -DSAVE_ALL_THE_REGISTERS -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -DSAVE_ALL_THE_REGISTERS -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O0 %s -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O0 %s -DTHREAD -DSMALL_FRAME -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -DTHREAD -DSMALL_FRAME -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -DTHREAD -DSMALL_FRAME -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -DTHREAD -DSMALL_FRAME -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O0 %s -DTHREAD -DSAVE_ALL_THE_REGISTERS -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -DTHREAD -DSAVE_ALL_THE_REGISTERS -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -DTHREAD -DSAVE_ALL_THE_REGISTERS -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -DTHREAD -DSAVE_ALL_THE_REGISTERS -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O0 %s -DTHREAD -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -DTHREAD -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -DTHREAD -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -DTHREAD -lpthread -o %t && ASAN_OPTIONS=use_sigaltstack=1 not %run %t 2>&1 | FileCheck %s
// RUN: not %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>

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

// RUN: export ASAN_OPTIONS=detect_stack_use_after_return=1 // RUN: export ASAN_OPTIONS=detect_stack_use_after_return=1
// RUN: %clangxx_asan -O0 %s -lpthread -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -lpthread -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O1 %s -lpthread -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O1 %s -lpthread -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O2 %s -lpthread -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O2 %s -lpthread -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -lpthread -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -lpthread -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS=detect_stack_use_after_return=0 %t // RUN: 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 -lpthread -o %t -DkSize=10000 -DUseThread -DkStackSize=65536 && not %t 2>&1 | FileCheck --check-prefix=THREAD %s // RUN: %clangxx_asan -O3 %s -lpthread -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 -lpthread -o %t && not %t 2>&1 | FileCheck --check-prefix=THREAD %s // RUN: %clangxx_asan -DUseThread -O2 %s -lpthread -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.
// //
// RUN: ASAN_OPTIONS=$ASAN_OPTIONS:max_uar_stack_size_log=20:verbosity=1 not %t 2>&1 | FileCheck --check-prefix=CHECK-20 %s // RUN: ASAN_OPTIONS=$ASAN_OPTIONS:max_uar_stack_size_log=20:verbosity=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-20 %s
// RUN: ASAN_OPTIONS=$ASAN_OPTIONS:min_uar_stack_size_log=24:max_uar_stack_size_log=24:verbosity=1 not %t 2>&1 | FileCheck --check-prefix=CHECK-24 %s // RUN: ASAN_OPTIONS=$ASAN_OPTIONS:min_uar_stack_size_log=24:max_uar_stack_size_log=24:verbosity=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-24 %s
#include <stdio.h> #include <stdio.h>
#include <pthread.h> #include <pthread.h>

test/asan/TestCases/start-deactivated.cc

Context not available.
// RUN: %clangxx_asan -O0 %p/SharedLibs/start-deactivated-so.cc -fPIC -shared -o %t-so.so // RUN: %clangxx_asan -O0 %p/SharedLibs/start-deactivated-so.cc -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 -ldl -o %t // RUN: %clangxx_asan -O0 %t.o -ldl -o %t
// RUN: ASAN_OPTIONS=start_deactivated=1 not %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=start_deactivated=1 not %run %t 2>&1 | FileCheck %s
#include <dlfcn.h> #include <dlfcn.h>
#include <stdio.h> #include <stdio.h>
Context not available.

test/asan/TestCases/strdup_oob_test.cc

// RUN: %clangxx_asan -O0 %s -o %t && not %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 %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 %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 %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <string.h> #include <string.h>

test/asan/TestCases/strerror_r_test.cc

// RUN: %clangxx_asan -O0 %s -o %t && %t // RUN: %clangxx_asan -O0 %s -o %t && %run %t
// Regression test for PR17138. // Regression test for PR17138.

test/asan/TestCases/strip_path_prefix.c

// RUN: %clang_asan -O2 %s -o %t // RUN: %clang_asan -O2 %s -o %t
// RUN: ASAN_OPTIONS="strip_path_prefix='/'" not %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS="strip_path_prefix='/'" not %run %t 2>&1 | FileCheck %s
#include <stdlib.h> #include <stdlib.h>
int main() { int main() {

test/asan/TestCases/strncpy-overflow.cc

// RUN: %clangxx_asan -O0 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// RUN: %clangxx_asan -O1 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// RUN: %clangxx_asan -O2 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// RUN: %clangxx_asan -O3 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// REQUIRES: compiler-rt-optimized // REQUIRES: compiler-rt-optimized

test/asan/TestCases/throw_call_test.cc

// RUN: %clangxx_asan %s -o %t && %t // RUN: %clangxx_asan %s -o %t && %run %t
// http://code.google.com/p/address-sanitizer/issues/detail?id=147 (not fixed). // http://code.google.com/p/address-sanitizer/issues/detail?id=147 (not fixed).
// BROKEN: %clangxx_asan %s -o %t -static-libstdc++ && %t // BROKEN: %clangxx_asan %s -o %t -static-libstdc++ && %run %t
// //
// Android builds with static libstdc++ by default. // Android builds with static libstdc++ by default.
// XFAIL: android // XFAIL: android

test/asan/TestCases/throw_catch.cc

// RUN: %clangxx_asan -O %s -o %t && %t // RUN: %clangxx_asan -O %s -o %t && %run %t
#include <assert.h> #include <assert.h>
#include <setjmp.h> #include <setjmp.h>

test/asan/TestCases/throw_invoke_test.cc

// RUN: %clangxx_asan %s -o %t && %t // RUN: %clangxx_asan %s -o %t && %run %t
// RUN: %clangxx_asan %s -o %t -static-libstdc++ && %t // RUN: %clangxx_asan %s -o %t -static-libstdc++ && %run %t
#include <stdio.h> #include <stdio.h>
static volatile int zero = 0; static volatile int zero = 0;
inline void pretend_to_do_something(void *x) { inline void pretend_to_do_something(void *x) {

test/asan/TestCases/time_interceptor.cc

// RUN: %clangxx_asan -O0 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
// Test the time() interceptor. // Test the time() interceptor.

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=detect_stack_use_after_return=1
// RUN: %clangxx_asan -O0 %s -o %t && %t // RUN: %clangxx_asan -O0 %s -o %t && %run %t
#include <stdio.h> #include <stdio.h>

test/asan/TestCases/unaligned_loads_and_stores.cc

// RUN: %clangxx_asan -O0 %s -o %t // RUN: %clangxx_asan -O0 %s -o %t
// RUN: not %t A 2>&1 | FileCheck --check-prefix=CHECK-A %s // RUN: not %run %t A 2>&1 | FileCheck --check-prefix=CHECK-A %s
// RUN: not %t B 2>&1 | FileCheck --check-prefix=CHECK-B %s // RUN: not %run %t B 2>&1 | FileCheck --check-prefix=CHECK-B %s
// RUN: not %t C 2>&1 | FileCheck --check-prefix=CHECK-C %s // RUN: not %run %t C 2>&1 | FileCheck --check-prefix=CHECK-C %s
// RUN: not %t D 2>&1 | FileCheck --check-prefix=CHECK-D %s // RUN: not %run %t D 2>&1 | FileCheck --check-prefix=CHECK-D %s
// RUN: not %t E 2>&1 | FileCheck --check-prefix=CHECK-E %s // RUN: not %run %t E 2>&1 | FileCheck --check-prefix=CHECK-E %s
// RUN: not %t K 2>&1 | FileCheck --check-prefix=CHECK-K %s // RUN: not %run %t K 2>&1 | FileCheck --check-prefix=CHECK-K %s
// RUN: not %t L 2>&1 | FileCheck --check-prefix=CHECK-L %s // RUN: not %run %t L 2>&1 | FileCheck --check-prefix=CHECK-L %s
// RUN: not %t M 2>&1 | FileCheck --check-prefix=CHECK-M %s // RUN: not %run %t M 2>&1 | FileCheck --check-prefix=CHECK-M %s
// RUN: not %t N 2>&1 | FileCheck --check-prefix=CHECK-N %s // RUN: not %run %t N 2>&1 | FileCheck --check-prefix=CHECK-N %s
// RUN: not %t O 2>&1 | FileCheck --check-prefix=CHECK-O %s // RUN: not %run %t O 2>&1 | FileCheck --check-prefix=CHECK-O %s
#include <sanitizer/asan_interface.h> #include <sanitizer/asan_interface.h>

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

// RUN: %clangxx_asan -O0 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// RUN: %clangxx_asan -O1 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// RUN: %clangxx_asan -O2 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// RUN: %clangxx_asan -O3 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
#include <stdlib.h> #include <stdlib.h>
int main() { int main() {

test/asan/TestCases/use-after-free-right.cc

// RUN: %clangxx_asan -O0 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// RUN: %clangxx_asan -O1 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// RUN: %clangxx_asan -O2 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// RUN: %clangxx_asan -O3 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// Test use-after-free report in the case when access is at the right border of // Test use-after-free report in the case when access is at the right border of
// the allocation. // the allocation.

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

// RUN: %clangxx_asan -O0 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// RUN: %clangxx_asan -O1 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// RUN: %clangxx_asan -O2 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
// RUN: %clangxx_asan -O3 %s -o %t && not %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%os --check-prefix=CHECK
#include <stdlib.h> #include <stdlib.h>
int main() { int main() {

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 %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: ASAN_OPTIONS=allow_user_poisoning=0 %t // RUN: ASAN_OPTIONS=allow_user_poisoning=0 %run %t
#include <stdlib.h> #include <stdlib.h>

test/asan/TestCases/use-after-scope-dtor-order.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 %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
struct IntHolder { struct IntHolder {

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

Context not available.
// happens. "always_inline" is not enough, as Clang doesn't emit // happens. "always_inline" is not enough, as Clang doesn't emit
// llvm.lifetime intrinsics at -O0. // llvm.lifetime intrinsics at -O0.
// //
// RUN: %clangxx_asan -O2 -fsanitize=use-after-scope %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O2 -fsanitize=use-after-scope %s -o %t && not %run %t 2>&1 | FileCheck %s
int *arr; int *arr;
Context not available.

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

// RUN: %clangxx_asan -O0 -fsanitize=use-after-scope %s -o %t && %t // RUN: %clangxx_asan -O0 -fsanitize=use-after-scope %s -o %t && %run %t
#include <stdio.h> #include <stdio.h>

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

// RUN: %clangxx_asan -O0 -fsanitize=use-after-scope %s -o %t && \ // RUN: %clangxx_asan -O0 -fsanitize=use-after-scope %s -o %t && \
// RUN: %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
// //
// Lifetime for temporaries is not emitted yet. // Lifetime for temporaries is not emitted yet.
// XFAIL: * // XFAIL: *

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 %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS="detect_stack_use_after_return=1" not %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS="detect_stack_use_after_return=1" not %run %t 2>&1 | FileCheck %s
int main() { int main() {
int *p = 0; int *p = 0;

test/asan/TestCases/wait.cc

// RUN: %clangxx_asan -DWAIT -O0 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -DWAIT -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -DWAIT -O3 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -DWAIT -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -DWAITPID -O0 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -DWAITPID -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -DWAITPID -O3 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -DWAITPID -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -DWAIT3 -O0 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -DWAIT3 -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -DWAIT3 -O3 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -DWAIT3 -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -DWAIT4 -O0 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -DWAIT4 -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -DWAIT4 -O3 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -DWAIT4 -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -DWAIT3_RUSAGE -O0 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -DWAIT3_RUSAGE -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -DWAIT3_RUSAGE -O3 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -DWAIT3_RUSAGE -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -DWAIT4_RUSAGE -O0 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -DWAIT4_RUSAGE -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -DWAIT4_RUSAGE -O3 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -DWAIT4_RUSAGE -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <sys/wait.h> #include <sys/wait.h>

test/asan/TestCases/waitid.cc

// RUN: %clangxx_asan -O0 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_asan -O3 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <sys/wait.h> #include <sys/wait.h>

test/dfsan/basic.c

// RUN: %clang_dfsan -m64 %s -o %t && %t // RUN: %clang_dfsan -m64 %s -o %t && %run %t
// RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 %s -o %t && %t // RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 %s -o %t && %run %t
// Tests that labels are propagated through loads and stores. // Tests that labels are propagated through loads and stores.

test/dfsan/custom.c

// RUN: %clang_dfsan -m64 %s -o %t && DFSAN_OPTIONS="strict_data_dependencies=0" %t // RUN: %clang_dfsan -m64 %s -o %t && DFSAN_OPTIONS="strict_data_dependencies=0" %run %t
// RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 %s -o %t && DFSAN_OPTIONS="strict_data_dependencies=0" %t // RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 %s -o %t && DFSAN_OPTIONS="strict_data_dependencies=0" %run %t
// RUN: %clang_dfsan -DSTRICT_DATA_DEPENDENCIES -m64 %s -o %t && %t // RUN: %clang_dfsan -DSTRICT_DATA_DEPENDENCIES -m64 %s -o %t && %run %t
// RUN: %clang_dfsan -DSTRICT_DATA_DEPENDENCIES -mllvm -dfsan-args-abi -m64 %s -o %t && %t // RUN: %clang_dfsan -DSTRICT_DATA_DEPENDENCIES -mllvm -dfsan-args-abi -m64 %s -o %t && %run %t
// Tests custom implementations of various glibc functions. // Tests custom implementations of various glibc functions.

test/dfsan/flags.c

// RUN: %clang_dfsan -m64 %s -fsanitize-blacklist=%S/Inputs/flags_abilist.txt -mllvm -dfsan-debug-nonzero-labels -o %t && %t 2>&1 | FileCheck %s // RUN: %clang_dfsan -m64 %s -fsanitize-blacklist=%S/Inputs/flags_abilist.txt -mllvm -dfsan-debug-nonzero-labels -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clang_dfsan -m64 %s -fsanitize-blacklist=%S/Inputs/flags_abilist.txt -mllvm -dfsan-debug-nonzero-labels -o %t && DFSAN_OPTIONS=warn_unimplemented=0 %t 2>&1 | count 0 // RUN: %clang_dfsan -m64 %s -fsanitize-blacklist=%S/Inputs/flags_abilist.txt -mllvm -dfsan-debug-nonzero-labels -o %t && DFSAN_OPTIONS=warn_unimplemented=0 %run %t 2>&1 | count 0
// RUN: %clang_dfsan -m64 %s -fsanitize-blacklist=%S/Inputs/flags_abilist.txt -mllvm -dfsan-debug-nonzero-labels -o %t && DFSAN_OPTIONS=warn_nonzero_labels=1 %t 2>&1 | FileCheck --check-prefix=CHECK-NONZERO %s // RUN: %clang_dfsan -m64 %s -fsanitize-blacklist=%S/Inputs/flags_abilist.txt -mllvm -dfsan-debug-nonzero-labels -o %t && DFSAN_OPTIONS=warn_nonzero_labels=1 %run %t 2>&1 | FileCheck --check-prefix=CHECK-NONZERO %s
// Tests that flags work correctly. // Tests that flags work correctly.

test/dfsan/fncall.c

// RUN: %clang_dfsan -m64 %s -o %t && %t // RUN: %clang_dfsan -m64 %s -o %t && %run %t
// RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 %s -o %t && %t // RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 %s -o %t && %run %t
// Tests that labels are propagated through function calls. // Tests that labels are propagated through function calls.

test/dfsan/label_count.c

// RUN: %clang_dfsan -DLIB -m64 -c %s -o %t.lib.o && \ // RUN: %clang_dfsan -DLIB -m64 -c %s -o %t.lib.o && \
// RUN: %clang_dfsan -m64 -c %s -o %t.o && \ // RUN: %clang_dfsan -m64 -c %s -o %t.o && \
// RUN: %clang_dfsan -m64 %t.lib.o %t.o -o %t.bin && \ // RUN: %clang_dfsan -m64 %t.lib.o %t.o -o %t.bin && \
// RUN: %t.bin // RUN: %run %t.bin
// RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 -DLIB -c %s -o %t.lib.o && \ // RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 -DLIB -c %s -o %t.lib.o && \
// RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 -c %s -o %t.o && \ // RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 -c %s -o %t.o && \
// RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 %t.o %t.lib.o -o %t.bin && \ // RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 %t.o %t.lib.o -o %t.bin && \
// RUN: %t.bin // RUN: %run %t.bin
#include <sanitizer/dfsan_interface.h> #include <sanitizer/dfsan_interface.h>
#include <assert.h> #include <assert.h>

test/dfsan/propagate.c

// RUN: %clang_dfsan -m64 %s -o %t && %t // RUN: %clang_dfsan -m64 %s -o %t && %run %t
// RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 %s -o %t && %t // RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 %s -o %t && %run %t
// Tests that labels are propagated through computation and that union labels // Tests that labels are propagated through computation and that union labels
// are properly created. // are properly created.

test/dfsan/write_callback.c

// RUN: %clang_dfsan -m64 %s -o %t && %t | FileCheck %s // RUN: %clang_dfsan -m64 %s -o %t && %run %t | FileCheck %s
// RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 %s -o %t && %t | FileCheck %s // RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 %s -o %t && %run %t | FileCheck %s
// Tests that the custom implementation of write() does writes with or without // Tests that the custom implementation of write() does writes with or without
// a callback set using dfsan_set_write_callback(). // a callback set using dfsan_set_write_callback().

test/lsan/TestCases/cleanup_in_tsd_destructor.cc

Context not available.
// makes its best effort. // makes its best effort.
// RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0" // RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:use_tls=1 %t // RUN: LSAN_OPTIONS=$LSAN_BASE:use_tls=1 %run %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:use_tls=0 not %t 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE:use_tls=0 not %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <pthread.h> #include <pthread.h>
Context not available.

test/lsan/TestCases/disabler.cc

// Test for ScopedDisabler. // Test for ScopedDisabler.
// RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0:use_tls=0" // RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0:use_tls=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE not %t 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/lsan/TestCases/disabler_in_tsd_destructor.cc

// Regression test. Disabler should not depend on TSD validity. // Regression test. Disabler should not depend on TSD validity.
// RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0:use_tls=1" // RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0:use_tls=1"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE %t // RUN: LSAN_OPTIONS=$LSAN_BASE %run %t
#include <assert.h> #include <assert.h>
#include <pthread.h> #include <pthread.h>

test/lsan/TestCases/do_leak_check_override.cc

Context not available.
// "normal" mode (LSan runs in "strict" mode by default). // "normal" mode (LSan runs in "strict" mode by default).
// RUN: LSAN_BASE="use_stacks=0:use_registers=0" // RUN: LSAN_BASE="use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE not %t 2>&1 | FileCheck --check-prefix=CHECK-strict %s // RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck --check-prefix=CHECK-strict %s
// RUN: LSAN_OPTIONS=$LSAN_BASE not %t foo 2>&1 | FileCheck --check-prefix=CHECK-normal %s // RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t foo 2>&1 | FileCheck --check-prefix=CHECK-normal %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
Context not available.

test/lsan/TestCases/fork.cc

// Test that thread local data is handled correctly after forking without exec(). // Test that thread local data is handled correctly after forking without exec().
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: %t 2>&1 // RUN: %run %t 2>&1
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>

test/lsan/TestCases/fork_threaded.cc

// Test that thread local data is handled correctly after forking without // Test that thread local data is handled correctly after forking without
// exec(). In this test leak checking is initiated from a non-main thread. // exec(). In this test leak checking is initiated from a non-main thread.
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: %t 2>&1 // RUN: %run %t 2>&1
#include <assert.h> #include <assert.h>
#include <pthread.h> #include <pthread.h>

test/lsan/TestCases/high_allocator_contention.cc

// A benchmark that executes malloc/free pairs in parallel. // A benchmark that executes malloc/free pairs in parallel.
// Usage: ./a.out number_of_threads total_number_of_allocations // Usage: ./a.out number_of_threads total_number_of_allocations
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: %t 5 1000000 2>&1 // RUN: %run %t 5 1000000 2>&1
#include <assert.h> #include <assert.h>
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>

test/lsan/TestCases/ignore_object.cc

// Test for __lsan_ignore_object(). // Test for __lsan_ignore_object().
// RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0:use_tls=0:verbosity=2" // RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0:use_tls=0:verbosity=2"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE ASAN_OPTIONS=$ASAN_OPTIONS:"verbosity=2" not %t 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE ASAN_OPTIONS=$ASAN_OPTIONS:"verbosity=2" not %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/lsan/TestCases/ignore_object_errors.cc

// Test for incorrect use of __lsan_ignore_object(). // Test for incorrect use of __lsan_ignore_object().
// RUN: LSAN_BASE="verbosity=2" // RUN: LSAN_BASE="verbosity=2"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE ASAN_OPTIONS=$ASAN_OPTIONS:verbosity=2 %t 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE ASAN_OPTIONS=$ASAN_OPTIONS:verbosity=2 %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/lsan/TestCases/large_allocation_leak.cc

// Test that LargeMmapAllocator's chunks aren't reachable via some internal data structure. // Test that LargeMmapAllocator's chunks aren't reachable via some internal data structure.
// RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0" // RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE not %t 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/lsan/TestCases/leak_check_at_exit.cc

// Test for the leak_check_at_exit flag. // Test for the leak_check_at_exit flag.
// RUN: LSAN_BASE="use_stacks=0:use_registers=0" // RUN: LSAN_BASE="use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE not %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-do // RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-do
// RUN: LSAN_OPTIONS=$LSAN_BASE not %t 2>&1 | FileCheck %s --check-prefix=CHECK-do // RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-do
// RUN: LSAN_OPTIONS=$LSAN_BASE:"leak_check_at_exit=0" ASAN_OPTIONS="$ASAN_OPTIONS:leak_check_at_exit=0" not %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-do // RUN: LSAN_OPTIONS=$LSAN_BASE:"leak_check_at_exit=0" ASAN_OPTIONS="$ASAN_OPTIONS:leak_check_at_exit=0" not %run %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-do
// RUN: LSAN_OPTIONS=%LSAN_BASE:"leak_check_at_exit=0" ASAN_OPTIONS="$ASAN_OPTIONS:leak_check_at_exit=0" %t 2>&1 | FileCheck %s --check-prefix=CHECK-dont // RUN: LSAN_OPTIONS=%LSAN_BASE:"leak_check_at_exit=0" ASAN_OPTIONS="$ASAN_OPTIONS:leak_check_at_exit=0" %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-dont
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/lsan/TestCases/link_turned_off.cc

// Test for disabling LSan at link-time. // Test for disabling LSan at link-time.
// RUN: LSAN_BASE="use_stacks=0:use_registers=0" // RUN: LSAN_BASE="use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE %t // RUN: LSAN_OPTIONS=$LSAN_BASE %run %t
// RUN: LSAN_OPTIONS=$LSAN_BASE not %t foo 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t foo 2>&1 | FileCheck %s
#include <sanitizer/lsan_interface.h> #include <sanitizer/lsan_interface.h>

test/lsan/TestCases/new_array_with_dtor_0.cc

// Regression test: // Regression test:
// https://code.google.com/p/address-sanitizer/issues/detail?id=257 // https://code.google.com/p/address-sanitizer/issues/detail?id=257
// RUN: %clangxx_lsan %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_lsan %s -o %t && %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>

test/lsan/TestCases/pointer_to_self.cc

Context not available.
// object is indirectly leaked. Only external pointers count. // object is indirectly leaked. Only external pointers count.
// RUN: LSAN_BASE="report_objects=1:use_registers=0" // RUN: LSAN_BASE="report_objects=1:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=0" not %t 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=0" not %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
Context not available.

test/lsan/TestCases/print_suppressions.cc

Context not available.
// matched. Default is print_suppressions=true. // matched. Default is print_suppressions=true.
// RUN: LSAN_BASE="use_registers=0:use_stacks=0" // RUN: LSAN_BASE="use_registers=0:use_stacks=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:print_suppressions=0 %t 2>&1 | FileCheck %s --check-prefix=CHECK-dont-print // RUN: LSAN_OPTIONS=$LSAN_BASE:print_suppressions=0 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-dont-print
// RUN: LSAN_OPTIONS=$LSAN_BASE %t 2>&1 | FileCheck %s --check-prefix=CHECK-dont-print // RUN: LSAN_OPTIONS=$LSAN_BASE %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-dont-print
// RUN: LSAN_OPTIONS=$LSAN_BASE:print_suppressions=0 %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-dont-print // RUN: LSAN_OPTIONS=$LSAN_BASE:print_suppressions=0 %run %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-dont-print
// RUN: LSAN_OPTIONS=$LSAN_BASE %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-print // RUN: LSAN_OPTIONS=$LSAN_BASE %run %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-print
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
Context not available.

test/lsan/TestCases/register_root_region.cc

// Test for __lsan_(un)register_root_region(). // Test for __lsan_(un)register_root_region().
// RUN: LSAN_BASE="use_stacks=0:use_registers=0" // RUN: LSAN_BASE="use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE %t // RUN: LSAN_OPTIONS=$LSAN_BASE %run %t
// RUN: LSAN_OPTIONS=$LSAN_BASE not %t foo 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t foo 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:use_root_regions=0 not %t 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE:use_root_regions=0 not %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>

test/lsan/TestCases/stale_stack_leak.cc

// Test that out-of-scope local variables are ignored by LSan. // Test that out-of-scope local variables are ignored by LSan.
// RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=1" // RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=1"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE not %t 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE":exitcode=0" %t 2>&1 | FileCheck --check-prefix=CHECK-sanity %s // RUN: LSAN_OPTIONS=$LSAN_BASE":exitcode=0" %run %t 2>&1 | FileCheck --check-prefix=CHECK-sanity %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/lsan/TestCases/suppressions_default.cc

// RUN: LSAN_BASE="use_registers=0:use_stacks=0" // RUN: LSAN_BASE="use_registers=0:use_stacks=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE not %t 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/lsan/TestCases/suppressions_file.cc

Context not available.
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: echo "leak:*LSanTestLeakingFunc*" > %t.supp1 // RUN: echo "leak:*LSanTestLeakingFunc*" > %t.supp1
// RUN: LSAN_OPTIONS=$LSAN_BASE:suppressions=%t.supp1 not %t 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE:suppressions=%t.supp1 not %run %t 2>&1 | FileCheck %s
// RUN: echo "leak:%t" > %t.supp2 // RUN: echo "leak:%t" > %t.supp2
// RUN: LSAN_OPTIONS=$LSAN_BASE:suppressions="%t.supp2":symbolize=false %t // RUN: LSAN_OPTIONS=$LSAN_BASE:suppressions="%t.supp2":symbolize=false %run %t
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
Context not available.

test/lsan/TestCases/swapcontext.cc

Context not available.
// memory. Make sure we don't report these leaks. // memory. Make sure we don't report these leaks.
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: %t 2>&1 // RUN: %run %t 2>&1
// RUN: not %t foo 2>&1 | FileCheck %s // RUN: not %run %t foo 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <ucontext.h> #include <ucontext.h>
Context not available.

test/lsan/TestCases/use_after_return.cc

Context not available.
// in the root set. // in the root set.
// RUN: LSAN_BASE="report_objects=1:use_registers=0" // RUN: LSAN_BASE="report_objects=1:use_registers=0"
// RUN: %clangxx_lsan %s -O2 -o %t // RUN: %clangxx_lsan %s -O2 -o %t
// RUN: ASAN_OPTIONS=$ASAN_OPTIONS:detect_stack_use_after_return=1 LSAN_OPTIONS=$LSAN_BASE:"use_stacks=0" not %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=$ASAN_OPTIONS:detect_stack_use_after_return=1 LSAN_OPTIONS=$LSAN_BASE:"use_stacks=0" not %run %t 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS=$ASAN_OPTIONS:detect_stack_use_after_return=1 LSAN_OPTIONS=$LSAN_BASE:"use_stacks=1" %t 2>&1 // RUN: ASAN_OPTIONS=$ASAN_OPTIONS:detect_stack_use_after_return=1 LSAN_OPTIONS=$LSAN_BASE:"use_stacks=1" %run %t 2>&1
// RUN: ASAN_OPTIONS=$ASAN_OPTIONS:detect_stack_use_after_return=1 LSAN_OPTIONS="" %t 2>&1 // RUN: ASAN_OPTIONS=$ASAN_OPTIONS:detect_stack_use_after_return=1 LSAN_OPTIONS="" %run %t 2>&1
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
Context not available.

test/lsan/TestCases/use_globals_initialized.cc

// Test that initialized globals are included in the root set. // Test that initialized globals are included in the root set.
// RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0" // RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_globals=0" not %t 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_globals=0" not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_globals=1" %t 2>&1 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_globals=1" %run %t 2>&1
// RUN: LSAN_OPTIONS="" %t 2>&1 // RUN: LSAN_OPTIONS="" %run %t 2>&1
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/lsan/TestCases/use_globals_uninitialized.cc

// Test that uninitialized globals are included in the root set. // Test that uninitialized globals are included in the root set.
// RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0" // RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_globals=0" not %t 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_globals=0" not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_globals=1" %t 2>&1 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_globals=1" %run %t 2>&1
// RUN: LSAN_OPTIONS="" %t 2>&1 // RUN: LSAN_OPTIONS="" %run %t 2>&1
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/lsan/TestCases/use_poisoned_asan.cc

Context not available.
// REQUIRES: asan // REQUIRES: asan
// RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0" // RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_poisoned=0" not %t 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_poisoned=0" not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_poisoned=1" %t 2>&1 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_poisoned=1" %run %t 2>&1
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
Context not available.

test/lsan/TestCases/use_registers.cc

// Test that registers of running threads are included in the root set. // Test that registers of running threads are included in the root set.
// RUN: LSAN_BASE="report_objects=1:use_stacks=0" // RUN: LSAN_BASE="report_objects=1:use_stacks=0"
// RUN: %clangxx_lsan -pthread %s -o %t // RUN: %clangxx_lsan -pthread %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_registers=0" not %t 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_registers=0" not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_registers=1" %t 2>&1 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_registers=1" %run %t 2>&1
// RUN: LSAN_OPTIONS="" %t 2>&1 // RUN: LSAN_OPTIONS="" %run %t 2>&1
#include <assert.h> #include <assert.h>
#include <pthread.h> #include <pthread.h>

test/lsan/TestCases/use_stacks.cc

// Test that stack of main thread is included in the root set. // Test that stack of main thread is included in the root set.
// RUN: LSAN_BASE="report_objects=1:use_registers=0" // RUN: LSAN_BASE="report_objects=1:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=0" not %t 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=0" not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=1" %t 2>&1 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=1" %run %t 2>&1
// RUN: LSAN_OPTIONS="" %t 2>&1 // RUN: LSAN_OPTIONS="" %run %t 2>&1
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/lsan/TestCases/use_stacks_threaded.cc

// Test that stacks of non-main threads are included in the root set. // Test that stacks of non-main threads are included in the root set.
// RUN: LSAN_BASE="report_objects=1:use_registers=0" // RUN: LSAN_BASE="report_objects=1:use_registers=0"
// RUN: %clangxx_lsan -pthread %s -o %t // RUN: %clangxx_lsan -pthread %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=0" not %t 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=0" not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=1" %t 2>&1 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=1" %run %t 2>&1
// RUN: LSAN_OPTIONS="" %t 2>&1 // RUN: LSAN_OPTIONS="" %run %t 2>&1
#include <assert.h> #include <assert.h>
#include <pthread.h> #include <pthread.h>

test/lsan/TestCases/use_tls_dynamic.cc

Context not available.
// RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0" // RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
// RUN: %clangxx %s -DBUILD_DSO -fPIC -shared -o %t-so.so // RUN: %clangxx %s -DBUILD_DSO -fPIC -shared -o %t-so.so
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=0" not %t 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=0" not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=1" %t 2>&1 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=1" %run %t 2>&1
// RUN: LSAN_OPTIONS="" %t 2>&1 // RUN: LSAN_OPTIONS="" %run %t 2>&1
#ifndef BUILD_DSO #ifndef BUILD_DSO
#include <assert.h> #include <assert.h>
Context not available.

test/lsan/TestCases/use_tls_pthread_specific_dynamic.cc

// Test that dynamically allocated thread-specific storage is included in the root set. // Test that dynamically allocated thread-specific storage is included in the root set.
// RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0" // RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=0" not %t 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=0" not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=1" %t 2>&1 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=1" %run %t 2>&1
// RUN: LSAN_OPTIONS="" %t 2>&1 // RUN: LSAN_OPTIONS="" %run %t 2>&1
#include <assert.h> #include <assert.h>
#include <pthread.h> #include <pthread.h>

test/lsan/TestCases/use_tls_pthread_specific_static.cc

// Test that statically allocated thread-specific storage is included in the root set. // Test that statically allocated thread-specific storage is included in the root set.
// RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0" // RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=0" not %t 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=0" not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=1" %t 2>&1 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=1" %run %t 2>&1
// RUN: LSAN_OPTIONS="" %t 2>&1 // RUN: LSAN_OPTIONS="" %run %t 2>&1
#include <assert.h> #include <assert.h>
#include <pthread.h> #include <pthread.h>

test/lsan/TestCases/use_tls_static.cc

// Test that statically allocated TLS space is included in the root set. // Test that statically allocated TLS space is included in the root set.
// RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0" // RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=0" not %t 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=0" not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=1" %t 2>&1 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=1" %run %t 2>&1
// RUN: LSAN_OPTIONS="" %t 2>&1 // RUN: LSAN_OPTIONS="" %run %t 2>&1
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/lsan/TestCases/use_unaligned.cc

// Test that unaligned pointers are detected correctly. // Test that unaligned pointers are detected correctly.
// RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0" // RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_unaligned=0" not %t 2>&1 | FileCheck %s // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_unaligned=0" not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_unaligned=1" %t 2>&1 // RUN: LSAN_OPTIONS=$LSAN_BASE:"use_unaligned=1" %run %t 2>&1
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/msan/Linux/getresid.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t %p 2>&1 // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t %p 2>&1
// RUN: %clangxx_msan -m64 -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %t %p 2>&1 // RUN: %clangxx_msan -m64 -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t %p 2>&1
// RUN: %clangxx_msan -m64 -O3 %s -o %t && %t %p 2>&1 // RUN: %clangxx_msan -m64 -O3 %s -o %t && %run %t %p 2>&1
#include <assert.h> #include <assert.h>
#include <unistd.h> #include <unistd.h>

test/msan/Linux/glob.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t %p 2>&1 | FileCheck %s // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t %p 2>&1 | FileCheck %s
// RUN: %clangxx_msan -m64 -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %t %p 2>&1 | FileCheck %s // RUN: %clangxx_msan -m64 -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t %p 2>&1 | FileCheck %s
// RUN: %clangxx_msan -m64 -O3 %s -o %t && %t %p 2>&1 | FileCheck %s // RUN: %clangxx_msan -m64 -O3 %s -o %t && %run %t %p 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <glob.h> #include <glob.h>

test/msan/Linux/glob_altdirfunc.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t %p 2>&1 | FileCheck %s // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t %p 2>&1 | FileCheck %s
// RUN: %clangxx_msan -m64 -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %t %p 2>&1 | FileCheck %s // RUN: %clangxx_msan -m64 -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t %p 2>&1 | FileCheck %s
// RUN: %clangxx_msan -m64 -O3 %s -o %t && %t %p 2>&1 | FileCheck %s // RUN: %clangxx_msan -m64 -O3 %s -o %t && %run %t %p 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <glob.h> #include <glob.h>

test/msan/Linux/glob_nomatch.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t %p // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t %p
// RUN: %clangxx_msan -m64 -O3 %s -o %t && %t %p // RUN: %clangxx_msan -m64 -O3 %s -o %t && %run %t %p
#include <assert.h> #include <assert.h>
#include <glob.h> #include <glob.h>

test/msan/Linux/sunrpc.cc

// RUN: %clangxx_msan -m64 -g -O0 -DTYPE=int -DFN=xdr_int %s -o %t && \ // RUN: %clangxx_msan -m64 -g -O0 -DTYPE=int -DFN=xdr_int %s -o %t && \
// RUN: %t 2>&1 // RUN: %run %t 2>&1
// RUN: %clangxx_msan -m64 -g -O0 -DTYPE=int -DFN=xdr_int -DUNINIT=1 %s -o %t && \ // RUN: %clangxx_msan -m64 -g -O0 -DTYPE=int -DFN=xdr_int -DUNINIT=1 %s -o %t && \
// RUN: not %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_msan -m64 -g -O0 -DTYPE=double -DFN=xdr_double %s -o %t && \ // RUN: %clangxx_msan -m64 -g -O0 -DTYPE=double -DFN=xdr_double %s -o %t && \
// RUN: %t 2>&1 // RUN: %run %t 2>&1
// RUN: %clangxx_msan -m64 -g -O0 -DTYPE=double -DFN=xdr_double -DUNINIT=1 %s -o %t && \ // RUN: %clangxx_msan -m64 -g -O0 -DTYPE=double -DFN=xdr_double -DUNINIT=1 %s -o %t && \
// RUN: not %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_msan -m64 -g -O0 -DTYPE=u_quad_t -DFN=xdr_u_longlong_t %s -o %t && \ // RUN: %clangxx_msan -m64 -g -O0 -DTYPE=u_quad_t -DFN=xdr_u_longlong_t %s -o %t && \
// RUN: %t 2>&1 // RUN: %run %t 2>&1
// RUN: %clangxx_msan -m64 -g -O0 -DTYPE=u_quad_t -DFN=xdr_u_longlong_t -DUNINIT=1 %s -o %t && \ // RUN: %clangxx_msan -m64 -g -O0 -DTYPE=u_quad_t -DFN=xdr_u_longlong_t -DUNINIT=1 %s -o %t && \
// RUN: not %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <rpc/xdr.h> #include <rpc/xdr.h>

test/msan/Linux/sunrpc_bytes.cc

// RUN: %clangxx_msan -m64 -g -O0 %s -o %t && \ // RUN: %clangxx_msan -m64 -g -O0 %s -o %t && \
// RUN: %t 2>&1 // RUN: %run %t 2>&1
// RUN: %clangxx_msan -m64 -g -O0 -DUNINIT=1 %s -o %t && \ // RUN: %clangxx_msan -m64 -g -O0 -DUNINIT=1 %s -o %t && \
// RUN: not %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <string.h> #include <string.h>

test/msan/Linux/sunrpc_string.cc

// RUN: %clangxx_msan -m64 -g -O0 %s -o %t && \ // RUN: %clangxx_msan -m64 -g -O0 %s -o %t && \
// RUN: %t 2>&1 // RUN: %run %t 2>&1
// RUN: %clangxx_msan -m64 -g -O0 -DUNINIT=1 %s -o %t && \ // RUN: %clangxx_msan -m64 -g -O0 -DUNINIT=1 %s -o %t && \
// RUN: not %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <string.h> #include <string.h>

test/msan/Linux/syscalls.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t 2>&1 // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t 2>&1
// RUN: %clangxx_msan -m64 -O3 %s -o %t && %t 2>&1 // RUN: %clangxx_msan -m64 -O3 %s -o %t && %run %t 2>&1
#include <assert.h> #include <assert.h>
#include <errno.h> #include <errno.h>

test/msan/Linux/tcgetattr.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t %p // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t %p
#include <assert.h> #include <assert.h>
#include <glob.h> #include <glob.h>

test/msan/Linux/xattr.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t %p 2>&1 // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t %p 2>&1
// RUN: %clangxx_msan -m64 -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %t %p 2>&1 // RUN: %clangxx_msan -m64 -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t %p 2>&1
// RUN: %clangxx_msan -m64 -O3 %s -o %t && %t %p 2>&1 // RUN: %clangxx_msan -m64 -O3 %s -o %t && %run %t %p 2>&1
#include <argz.h> #include <argz.h>
#include <assert.h> #include <assert.h>

test/msan/allocator_returns_null.cc

Context not available.
// With allocator_may_return_null=1 the allocator should return 0. // With allocator_may_return_null=1 the allocator should return 0.
// //
// RUN: %clangxx_msan -O0 %s -o %t // RUN: %clangxx_msan -O0 %s -o %t
// RUN: not %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mCRASH // RUN: not %run %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mCRASH
// RUN: MSAN_OPTIONS=allocator_may_return_null=0 not %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mCRASH // RUN: MSAN_OPTIONS=allocator_may_return_null=0 not %run %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mCRASH
// RUN: MSAN_OPTIONS=allocator_may_return_null=1 %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mNULL // RUN: MSAN_OPTIONS=allocator_may_return_null=1 %run %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mNULL
// RUN: MSAN_OPTIONS=allocator_may_return_null=0 not %t calloc 2>&1 | FileCheck %s --check-prefix=CHECK-cCRASH // RUN: MSAN_OPTIONS=allocator_may_return_null=0 not %run %t calloc 2>&1 | FileCheck %s --check-prefix=CHECK-cCRASH
// RUN: MSAN_OPTIONS=allocator_may_return_null=1 %t calloc 2>&1 | FileCheck %s --check-prefix=CHECK-cNULL // RUN: MSAN_OPTIONS=allocator_may_return_null=1 %run %t calloc 2>&1 | FileCheck %s --check-prefix=CHECK-cNULL
// RUN: MSAN_OPTIONS=allocator_may_return_null=0 not %t calloc-overflow 2>&1 | FileCheck %s --check-prefix=CHECK-coCRASH // RUN: MSAN_OPTIONS=allocator_may_return_null=0 not %run %t calloc-overflow 2>&1 | FileCheck %s --check-prefix=CHECK-coCRASH
// RUN: MSAN_OPTIONS=allocator_may_return_null=1 %t calloc-overflow 2>&1 | FileCheck %s --check-prefix=CHECK-coNULL // RUN: MSAN_OPTIONS=allocator_may_return_null=1 %run %t calloc-overflow 2>&1 | FileCheck %s --check-prefix=CHECK-coNULL
// RUN: MSAN_OPTIONS=allocator_may_return_null=0 not %t realloc 2>&1 | FileCheck %s --check-prefix=CHECK-rCRASH // RUN: MSAN_OPTIONS=allocator_may_return_null=0 not %run %t realloc 2>&1 | FileCheck %s --check-prefix=CHECK-rCRASH
// RUN: MSAN_OPTIONS=allocator_may_return_null=1 %t realloc 2>&1 | FileCheck %s --check-prefix=CHECK-rNULL // RUN: MSAN_OPTIONS=allocator_may_return_null=1 %run %t realloc 2>&1 | FileCheck %s --check-prefix=CHECK-rNULL
// RUN: MSAN_OPTIONS=allocator_may_return_null=0 not %t realloc-after-malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mrCRASH // RUN: MSAN_OPTIONS=allocator_may_return_null=0 not %run %t realloc-after-malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mrCRASH
// RUN: MSAN_OPTIONS=allocator_may_return_null=1 %t realloc-after-malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mrNULL // RUN: MSAN_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>
Context not available.

test/msan/backtrace.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t
#include <assert.h> #include <assert.h>
#include <execinfo.h> #include <execinfo.h>

test/msan/c-strdup.c

// RUN: %clang_msan -m64 -O0 %s -o %t && %t >%t.out 2>&1 // RUN: %clang_msan -m64 -O0 %s -o %t && %run %t >%t.out 2>&1
// RUN: %clang_msan -m64 -O1 %s -o %t && %t >%t.out 2>&1 // RUN: %clang_msan -m64 -O1 %s -o %t && %run %t >%t.out 2>&1
// RUN: %clang_msan -m64 -O2 %s -o %t && %t >%t.out 2>&1 // RUN: %clang_msan -m64 -O2 %s -o %t && %run %t >%t.out 2>&1
// RUN: %clang_msan -m64 -O3 %s -o %t && %t >%t.out 2>&1 // RUN: %clang_msan -m64 -O3 %s -o %t && %run %t >%t.out 2>&1
// Test that strdup in C programs is intercepted. // Test that strdup in C programs is intercepted.
// GLibC headers translate strdup to __strdup at -O1 and higher. // GLibC headers translate strdup to __strdup at -O1 and higher.

test/msan/chained_origin.cc

// RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -m64 -O3 %s -o %t && \ // RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -m64 -O3 %s -o %t && \
// RUN: not %t >%t.out 2>&1 // RUN: not %run %t >%t.out 2>&1
// RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-STACK < %t.out // RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-STACK < %t.out
// RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -DHEAP=1 -m64 -O3 %s -o %t && \ // RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -DHEAP=1 -m64 -O3 %s -o %t && \
// RUN: not %t >%t.out 2>&1 // RUN: not %run %t >%t.out 2>&1
// RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-HEAP < %t.out // RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-HEAP < %t.out
#include <stdio.h> #include <stdio.h>

test/msan/chained_origin_memcpy.cc

// RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -m64 -DOFFSET=0 -O3 %s -o %t && \ // RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -m64 -DOFFSET=0 -O3 %s -o %t && \
// RUN: not %t >%t.out 2>&1 // RUN: not %run %t >%t.out 2>&1
// RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-Z1 < %t.out // RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-Z1 < %t.out
// RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -DOFFSET=10 -m64 -O3 %s -o %t && \ // RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -DOFFSET=10 -m64 -O3 %s -o %t && \
// RUN: not %t >%t.out 2>&1 // RUN: not %run %t >%t.out 2>&1
// RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-Z2 < %t.out // RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-Z2 < %t.out
#include <stdio.h> #include <stdio.h>

test/msan/chained_origin_with_signals.cc

Context not available.
// implementation being not async-signal-safe. // implementation being not async-signal-safe.
// RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -m64 -O3 %s -o %t && \ // RUN: %clangxx_msan -fsanitize-memory-track-origins=2 -m64 -O3 %s -o %t && \
// RUN: not %t >%t.out 2>&1 // RUN: not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
#include <signal.h> #include <signal.h>
Context not available.

test/msan/check_mem_is_initialized.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O0 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// RUN: %clangxx_msan -m64 -O1 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O1 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// RUN: %clangxx_msan -m64 -O2 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O2 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// RUN: %clangxx_msan -m64 -O3 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O3 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O0 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O0 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out // RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O1 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O1 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out // RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O2 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O2 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out // RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O3 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O3 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out // RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
#include <sanitizer/msan_interface.h> #include <sanitizer/msan_interface.h>

test/msan/cxa_atexit.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t %p // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t %p
// PR17377: C++ module destructors get stale argument shadow. // PR17377: C++ module destructors get stale argument shadow.

test/msan/death-callback.cc

// RUN: %clangxx_msan -m64 -DERROR %s -o %t && not %t 2>&1 | \ // RUN: %clangxx_msan -m64 -DERROR %s -o %t && not %run %t 2>&1 | \
// RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NOCB // RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NOCB
// RUN: %clangxx_msan -m64 -DERROR -DMSANCB_SET %s -o %t && not %t 2>&1 | \ // RUN: %clangxx_msan -m64 -DERROR -DMSANCB_SET %s -o %t && not %run %t 2>&1 | \
// RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-CB // RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-CB
// RUN: %clangxx_msan -m64 -DERROR -DMSANCB_SET -DMSANCB_CLEAR %s -o %t && not %t 2>&1 | \ // RUN: %clangxx_msan -m64 -DERROR -DMSANCB_SET -DMSANCB_CLEAR %s -o %t && not %run %t 2>&1 | \
// RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NOCB // RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NOCB
// RUN: %clangxx_msan -m64 -DMSANCB_SET %s -o %t && %t 2>&1 | \ // RUN: %clangxx_msan -m64 -DMSANCB_SET %s -o %t && %run %t 2>&1 | \
// RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NOCB // RUN: FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NOCB
#include <sanitizer/msan_interface.h> #include <sanitizer/msan_interface.h>

test/msan/dlerror.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t
#include <assert.h> #include <assert.h>
#include <dlfcn.h> #include <dlfcn.h>

test/msan/dso-origin.cc

Context not available.
// Test that origin tracking is enabled at runtime. // Test that origin tracking is enabled at runtime.
// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O0 %p/SharedLibs/dso-origin-so.cc \ // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O0 %p/SharedLibs/dso-origin-so.cc \
// RUN: -fPIC -shared -o %t-so.so // RUN: -fPIC -shared -o %t-so.so
// RUN: %clangxx_msan -m64 -O0 %s %t-so.so -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_msan -m64 -O0 %s %t-so.so -o %t && not %run %t 2>&1 | FileCheck %s
#include <stdlib.h> #include <stdlib.h>
Context not available.

test/msan/dtls_test.c

/* RUN: %clang_msan -m64 %s -o %t /* RUN: %clang_msan -m64 %s -o %t
RUN: %clang_msan -m64 %s -DBUILD_SO -fPIC -o %t-so.so -shared RUN: %clang_msan -m64 %s -DBUILD_SO -fPIC -o %t-so.so -shared
RUN: not %t 2>&1 | FileCheck %s RUN: not %run %t 2>&1 | FileCheck %s
CHECK: MemorySanitizer: use-of-uninitialized-value CHECK: MemorySanitizer: use-of-uninitialized-value
This is an actual bug in msan/glibc integration, This is an actual bug in msan/glibc integration,

test/msan/errno.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t
#include <assert.h> #include <assert.h>
#include <errno.h> #include <errno.h>

test/msan/ftime.cc

// RUN: %clangxx_msan -m64 -O0 -g %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 -g %s -o %t && %run %t
#include <assert.h> #include <assert.h>
#include <sys/timeb.h> #include <sys/timeb.h>

test/msan/getaddrinfo-positive.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O0 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// RUN: %clangxx_msan -m64 -O3 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O3 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
#include <sys/types.h> #include <sys/types.h>

test/msan/getaddrinfo.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t
#include <sys/types.h> #include <sys/types.h>
#include <sys/socket.h> #include <sys/socket.h>

test/msan/getc_unlocked.c

// RUN: %clangxx_msan -DGETC -m64 -O0 -g -xc++ %s -o %t && %t // RUN: %clangxx_msan -DGETC -m64 -O0 -g -xc++ %s -o %t && %run %t
// RUN: %clangxx_msan -DGETC -m64 -O3 -g -xc++ %s -o %t && %t // RUN: %clangxx_msan -DGETC -m64 -O3 -g -xc++ %s -o %t && %run %t
// RUN: %clang_msan -DGETC -m64 -O0 -g %s -o %t && %t // RUN: %clang_msan -DGETC -m64 -O0 -g %s -o %t && %run %t
// RUN: %clang_msan -DGETC -m64 -O3 -g %s -o %t && %t // RUN: %clang_msan -DGETC -m64 -O3 -g %s -o %t && %run %t
// RUN: %clangxx_msan -DGETCHAR -m64 -O0 -g -xc++ %s -o %t && %t // RUN: %clangxx_msan -DGETCHAR -m64 -O0 -g -xc++ %s -o %t && %run %t
// RUN: %clangxx_msan -DGETCHAR -m64 -O3 -g -xc++ %s -o %t && %t // RUN: %clangxx_msan -DGETCHAR -m64 -O3 -g -xc++ %s -o %t && %run %t
// RUN: %clang_msan -DGETCHAR -m64 -O0 -g %s -o %t && %t // RUN: %clang_msan -DGETCHAR -m64 -O0 -g %s -o %t && %run %t
// RUN: %clang_msan -DGETCHAR -m64 -O3 -g %s -o %t && %t // RUN: %clang_msan -DGETCHAR -m64 -O3 -g %s -o %t && %run %t
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>

test/msan/getline.cc

// RUN: %clangxx_msan -O0 %s -o %t && %t %p // RUN: %clangxx_msan -O0 %s -o %t && %run %t %p
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>

test/msan/heap-origin.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O0 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// RUN: %clangxx_msan -m64 -O1 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O1 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// RUN: %clangxx_msan -m64 -O2 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O2 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// RUN: %clangxx_msan -m64 -O3 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O3 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O0 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O0 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out // RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O1 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O1 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out // RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O2 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O2 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out // RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O3 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O3 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out // RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
#include <stdlib.h> #include <stdlib.h>

test/msan/iconv.cc

// RUN: %clangxx_msan -m64 -O0 -g %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 -g %s -o %t && %run %t
// RUN: %clangxx_msan -m64 -O0 -g -DPOSITIVE %s -o %t && not %t |& FileCheck %s // RUN: %clangxx_msan -m64 -O0 -g -DPOSITIVE %s -o %t && not %run %t |& FileCheck %s
#include <assert.h> #include <assert.h>
#include <iconv.h> #include <iconv.h>

test/msan/if_indextoname.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t 2>&1 // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t 2>&1
// RUN: %clangxx_msan -m64 -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %t 2>&1 // RUN: %clangxx_msan -m64 -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t 2>&1
// RUN: %clangxx_msan -m64 -O3 %s -o %t && %t 2>&1 // RUN: %clangxx_msan -m64 -O3 %s -o %t && %run %t 2>&1
#include <assert.h> #include <assert.h>
#include <errno.h> #include <errno.h>

test/msan/ifaddrs.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t %p 2>&1 // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t %p 2>&1
// RUN: %clangxx_msan -m64 -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %t %p 2>&1 // RUN: %clangxx_msan -m64 -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t %p 2>&1
// RUN: %clangxx_msan -m64 -O3 %s -o %t && %t %p 2>&1 // RUN: %clangxx_msan -m64 -O3 %s -o %t && %run %t %p 2>&1
#include <assert.h> #include <assert.h>
#include <errno.h> #include <errno.h>

test/msan/initgroups.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t
#include <sys/types.h> #include <sys/types.h>
#include <grp.h> #include <grp.h>

test/msan/inline.cc

// RUN: %clangxx_msan -O3 %s -o %t && %t // RUN: %clangxx_msan -O3 %s -o %t && %run %t
// Test that no_sanitize_memory attribute applies even when the function would // Test that no_sanitize_memory attribute applies even when the function would
// be normally inlined. // be normally inlined.

test/msan/insertvalue_origin.cc

// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O0 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O0 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out && FileCheck %s < %t.out // RUN: FileCheck %s < %t.out && FileCheck %s < %t.out
// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O3 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O3 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out && FileCheck %s < %t.out // RUN: FileCheck %s < %t.out && FileCheck %s < %t.out
// Test origin propagation through insertvalue IR instruction. // Test origin propagation through insertvalue IR instruction.

test/msan/ioctl.cc

// RUN: %clangxx_msan -m64 -O0 -g %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 -g %s -o %t && %run %t
// RUN: %clangxx_msan -m64 -O3 -g %s -o %t && %t // RUN: %clangxx_msan -m64 -O3 -g %s -o %t && %run %t
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>

test/msan/ioctl_custom.cc

// RUN: %clangxx_msan -m64 -O0 -g %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 -g %s -o %t && %run %t
// RUN: %clangxx_msan -m64 -O3 -g %s -o %t && %t // RUN: %clangxx_msan -m64 -O3 -g %s -o %t && %run %t
// RUN: %clangxx_msan -DPOSITIVE -m64 -O0 -g %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_msan -DPOSITIVE -m64 -O0 -g %s -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_msan -DPOSITIVE -m64 -O3 -g %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_msan -DPOSITIVE -m64 -O3 -g %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>

test/msan/ioctl_sound.cc

// RUN: %clangxx_msan -m64 -O0 -g %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 -g %s -o %t && %run %t
// RUN: %clangxx_msan -m64 -O3 -g %s -o %t && %t // RUN: %clangxx_msan -m64 -O3 -g %s -o %t && %run %t
#include <assert.h> #include <assert.h>
#include <fcntl.h> #include <fcntl.h>

test/msan/keep-going-dso.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O0 %s -o %t && not %run %t >%t.out 2>&1
// FileCheck --check-prefix=CHECK-KEEP-GOING %s <%t.out // FileCheck --check-prefix=CHECK-KEEP-GOING %s <%t.out
// RUN: %clangxx_msan -m64 -O0 %s -o %t && MSAN_OPTIONS=keep_going=0 not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O0 %s -o %t && MSAN_OPTIONS=keep_going=0 not %run %t >%t.out 2>&1
// FileCheck %s <%t.out // FileCheck %s <%t.out
// RUN: %clangxx_msan -m64 -O0 %s -o %t && MSAN_OPTIONS=keep_going=1 not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O0 %s -o %t && MSAN_OPTIONS=keep_going=1 not %run %t >%t.out 2>&1
// FileCheck --check-prefix=CHECK-KEEP-GOING %s <%t.out // FileCheck --check-prefix=CHECK-KEEP-GOING %s <%t.out
// RUN: %clangxx_msan -m64 -mllvm -msan-keep-going=1 -O0 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -mllvm -msan-keep-going=1 -O0 %s -o %t && not %run %t >%t.out 2>&1
// FileCheck --check-prefix=CHECK-KEEP-GOING %s <%t.out // FileCheck --check-prefix=CHECK-KEEP-GOING %s <%t.out
// RUN: %clangxx_msan -m64 -mllvm -msan-keep-going=1 -O0 %s -o %t && MSAN_OPTIONS=keep_going=0 not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -mllvm -msan-keep-going=1 -O0 %s -o %t && MSAN_OPTIONS=keep_going=0 not %run %t >%t.out 2>&1
// FileCheck %s <%t.out // FileCheck %s <%t.out
// RUN: %clangxx_msan -m64 -mllvm -msan-keep-going=1 -O0 %s -o %t && MSAN_OPTIONS=keep_going=1 not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -mllvm -msan-keep-going=1 -O0 %s -o %t && MSAN_OPTIONS=keep_going=1 not %run %t >%t.out 2>&1
// FileCheck --check-prefix=CHECK-KEEP-GOING %s <%t.out // FileCheck --check-prefix=CHECK-KEEP-GOING %s <%t.out
// Test how -mllvm -msan-keep-going and MSAN_OPTIONS=keep_going affect reports // Test how -mllvm -msan-keep-going and MSAN_OPTIONS=keep_going affect reports

test/msan/keep-going.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O0 %s -o %t && not %run %t >%t.out 2>&1
// FileCheck %s <%t.out // FileCheck %s <%t.out
// RUN: %clangxx_msan -m64 -O0 %s -o %t && MSAN_OPTIONS=keep_going=0 not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O0 %s -o %t && MSAN_OPTIONS=keep_going=0 not %run %t >%t.out 2>&1
// FileCheck %s <%t.out // FileCheck %s <%t.out
// RUN: %clangxx_msan -m64 -O0 %s -o %t && MSAN_OPTIONS=keep_going=1 not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O0 %s -o %t && MSAN_OPTIONS=keep_going=1 not %run %t >%t.out 2>&1
// FileCheck %s <%t.out // FileCheck %s <%t.out
// RUN: %clangxx_msan -m64 -mllvm -msan-keep-going=1 -O0 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -mllvm -msan-keep-going=1 -O0 %s -o %t && not %run %t >%t.out 2>&1
// FileCheck --check-prefix=CHECK-KEEP-GOING %s <%t.out // FileCheck --check-prefix=CHECK-KEEP-GOING %s <%t.out
// RUN: %clangxx_msan -m64 -mllvm -msan-keep-going=1 -O0 %s -o %t && MSAN_OPTIONS=keep_going=0 not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -mllvm -msan-keep-going=1 -O0 %s -o %t && MSAN_OPTIONS=keep_going=0 not %run %t >%t.out 2>&1
// FileCheck %s <%t.out // FileCheck %s <%t.out
// RUN: %clangxx_msan -m64 -mllvm -msan-keep-going=1 -O0 %s -o %t && MSAN_OPTIONS=keep_going=1 not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -mllvm -msan-keep-going=1 -O0 %s -o %t && MSAN_OPTIONS=keep_going=1 not %run %t >%t.out 2>&1
// FileCheck --check-prefix=CHECK-KEEP-GOING %s <%t.out // FileCheck --check-prefix=CHECK-KEEP-GOING %s <%t.out
// RUN: %clangxx_msan -m64 -mllvm -msan-keep-going=1 -O0 %s -o %t && MSAN_OPTIONS=halt_on_error=1 not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -mllvm -msan-keep-going=1 -O0 %s -o %t && MSAN_OPTIONS=halt_on_error=1 not %run %t >%t.out 2>&1
// FileCheck %s <%t.out // FileCheck %s <%t.out
// RUN: %clangxx_msan -m64 -mllvm -msan-keep-going=1 -O0 %s -o %t && MSAN_OPTIONS=halt_on_error=0 not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -mllvm -msan-keep-going=1 -O0 %s -o %t && MSAN_OPTIONS=halt_on_error=0 not %run %t >%t.out 2>&1
// FileCheck --check-prefix=CHECK-KEEP-GOING %s <%t.out // FileCheck --check-prefix=CHECK-KEEP-GOING %s <%t.out
// Test behaviour of -mllvm -msan-keep-going and MSAN_OPTIONS=keep_going. // Test behaviour of -mllvm -msan-keep-going and MSAN_OPTIONS=keep_going.

test/msan/mallinfo.cc

// RUN: %clangxx_msan -m64 -O0 -g %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 -g %s -o %t && %run %t
#include <assert.h> #include <assert.h>
#include <malloc.h> #include <malloc.h>

test/msan/malloc_hook.cc

// RUN: %clangxx_msan -O2 %s -o %t // RUN: %clangxx_msan -O2 %s -o %t
// RUN: %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h> #include <unistd.h>

test/msan/mktime.cc

// RUN: %clangxx_msan -m64 -O0 -g %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 -g %s -o %t && %run %t
// RUN: %clangxx_msan -m64 -O0 -g -DUNINIT %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_msan -m64 -O0 -g -DUNINIT %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <time.h> #include <time.h>

test/msan/mmap_below_shadow.cc

Context not available.
// Without MAP_FIXED, we ignore the address hint and map somewhere in // Without MAP_FIXED, we ignore the address hint and map somewhere in
// application range. // application range.
// RUN: %clangxx_msan -m64 -O0 -DFIXED=0 %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 -DFIXED=0 %s -o %t && %run %t
// RUN: %clangxx_msan -m64 -O0 -DFIXED=1 %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 -DFIXED=1 %s -o %t && %run %t
// RUN: %clangxx_msan -m64 -O0 -DFIXED=0 -D_FILE_OFFSET_BITS=64 %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 -DFIXED=0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t
// RUN: %clangxx_msan -m64 -O0 -DFIXED=1 -D_FILE_OFFSET_BITS=64 %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 -DFIXED=1 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t
#include <assert.h> #include <assert.h>
#include <errno.h> #include <errno.h>
Context not available.

test/msan/no_sanitize_memory.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t >%t.out 2>&1
// RUN: %clangxx_msan -m64 -O1 %s -o %t && %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O1 %s -o %t && %run %t >%t.out 2>&1
// RUN: %clangxx_msan -m64 -O2 %s -o %t && %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O2 %s -o %t && %run %t >%t.out 2>&1
// RUN: %clangxx_msan -m64 -O3 %s -o %t && %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O3 %s -o %t && %run %t >%t.out 2>&1
// RUN: %clangxx_msan -m64 -O0 %s -o %t -DCHECK_IN_F && %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O0 %s -o %t -DCHECK_IN_F && %run %t >%t.out 2>&1
// RUN: %clangxx_msan -m64 -O1 %s -o %t -DCHECK_IN_F && %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O1 %s -o %t -DCHECK_IN_F && %run %t >%t.out 2>&1
// RUN: %clangxx_msan -m64 -O2 %s -o %t -DCHECK_IN_F && %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O2 %s -o %t -DCHECK_IN_F && %run %t >%t.out 2>&1
// RUN: %clangxx_msan -m64 -O3 %s -o %t -DCHECK_IN_F && %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O3 %s -o %t -DCHECK_IN_F && %run %t >%t.out 2>&1
// Test that (no_sanitize_memory) functions // Test that (no_sanitize_memory) functions
// * don't check shadow values (-DCHECK_IN_F) // * don't check shadow values (-DCHECK_IN_F)

test/msan/no_sanitize_memory_prop.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t >%t.out 2>&1
// RUN: %clangxx_msan -m64 -O1 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O1 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// RUN: %clangxx_msan -m64 -O2 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O2 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// RUN: %clangxx_msan -m64 -O3 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O3 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// Test that (no_sanitize_memory) functions propagate shadow. // Test that (no_sanitize_memory) functions propagate shadow.

test/msan/open_memstream.cc

// RUN: %clangxx_msan -m64 -O0 -g -xc++ %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 -g -xc++ %s -o %t && %run %t
// RUN: %clangxx_msan -m64 -O3 -g -xc++ %s -o %t && %t // RUN: %clangxx_msan -m64 -O3 -g -xc++ %s -o %t && %run %t
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/msan/poison_in_free.cc

// RUN: %clangxx_msan -O0 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -O0 %s -o %t && not %run %t >%t.out 2>&1
// FileCheck %s <%t.out // FileCheck %s <%t.out
// RUN: %clangxx_msan -O0 %s -o %t && MSAN_OPTIONS=poison_in_free=0 %t >%t.out 2>&1 // RUN: %clangxx_msan -O0 %s -o %t && MSAN_OPTIONS=poison_in_free=0 %run %t >%t.out 2>&1
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/msan/pthread_getattr_np_deadlock.cc

// RUN: %clangxx_msan -m64 -fsanitize-memory-track-origins -O0 %s -o %t && %t // RUN: %clangxx_msan -m64 -fsanitize-memory-track-origins -O0 %s -o %t && %run %t
// Regression test for a deadlock in pthread_getattr_np // Regression test for a deadlock in pthread_getattr_np

test/msan/ptrace.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>

test/msan/rand_r.cc

// RUN: %clangxx_msan -m64 -O0 -g %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 -g %s -o %t && %run %t
// RUN: %clangxx_msan -m64 -O0 -g -DUNINIT %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_msan -m64 -O0 -g -DUNINIT %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>

test/msan/readdir64.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t
// RUN: %clangxx_msan -m64 -O1 %s -o %t && %t // RUN: %clangxx_msan -m64 -O1 %s -o %t && %run %t
// RUN: %clangxx_msan -m64 -O2 %s -o %t && %t // RUN: %clangxx_msan -m64 -O2 %s -o %t && %run %t
// RUN: %clangxx_msan -m64 -O3 %s -o %t && %t // RUN: %clangxx_msan -m64 -O3 %s -o %t && %run %t
// RUN: %clangxx_msan -m64 -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t
// RUN: %clangxx_msan -m64 -O1 -D_FILE_OFFSET_BITS=64 %s -o %t && %t // RUN: %clangxx_msan -m64 -O1 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t
// RUN: %clangxx_msan -m64 -O2 -D_FILE_OFFSET_BITS=64 %s -o %t && %t // RUN: %clangxx_msan -m64 -O2 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t
// RUN: %clangxx_msan -m64 -O3 -D_FILE_OFFSET_BITS=64 %s -o %t && %t // RUN: %clangxx_msan -m64 -O3 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t
// Test that readdir64 is intercepted as well as readdir. // Test that readdir64 is intercepted as well as readdir.

test/msan/scandir.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t %p // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t %p
// RUN: %clangxx_msan -m64 -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %t %p // RUN: %clangxx_msan -m64 -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t %p
// RUN: %clangxx_msan -m64 -O3 %s -o %t && %t %p // RUN: %clangxx_msan -m64 -O3 %s -o %t && %run %t %p
#include <assert.h> #include <assert.h>
#include <glob.h> #include <glob.h>

test/msan/scandir_null.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t %p // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t %p
// RUN: %clangxx_msan -m64 -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %t %p // RUN: %clangxx_msan -m64 -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t %p
// RUN: %clangxx_msan -m64 -O3 %s -o %t && %t %p // RUN: %clangxx_msan -m64 -O3 %s -o %t && %run %t %p
#include <assert.h> #include <assert.h>
#include <glob.h> #include <glob.h>

test/msan/select.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O0 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// RUN: %clangxx_msan -m64 -O1 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O1 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// RUN: %clangxx_msan -m64 -O2 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O2 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// RUN: %clangxx_msan -m64 -O3 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O3 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
#include <stdlib.h> #include <stdlib.h>

test/msan/select_origin.cc

// RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_msan -fsanitize-memory-track-origins -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_msan -fsanitize-memory-track-origins -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_msan -fsanitize-memory-track-origins -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_msan -fsanitize-memory-track-origins -O2 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_msan -fsanitize-memory-track-origins -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
// Test condition origin propagation through "select" IR instruction. // Test condition origin propagation through "select" IR instruction.

test/msan/setlocale.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t
#include <assert.h> #include <assert.h>
#include <locale.h> #include <locale.h>

test/msan/signal_stress_test.cc

// RUN: %clangxx_msan -std=c++11 -O0 %s -o %t && %t // RUN: %clangxx_msan -std=c++11 -O0 %s -o %t && %run %t
// Test that va_arg shadow from a signal handler does not leak outside. // Test that va_arg shadow from a signal handler does not leak outside.

test/msan/sigwait.cc

// RUN: %clangxx_msan -std=c++11 -O0 -g %s -o %t && %t // RUN: %clangxx_msan -std=c++11 -O0 -g %s -o %t && %run %t
#include <assert.h> #include <assert.h>
#include <sanitizer/msan_interface.h> #include <sanitizer/msan_interface.h>

test/msan/sigwaitinfo.cc

// RUN: %clangxx_msan -std=c++11 -O0 -g %s -o %t && %t // RUN: %clangxx_msan -std=c++11 -O0 -g %s -o %t && %run %t
#include <assert.h> #include <assert.h>
#include <sanitizer/msan_interface.h> #include <sanitizer/msan_interface.h>

test/msan/stack-origin.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O0 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// RUN: %clangxx_msan -m64 -O1 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O1 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// RUN: %clangxx_msan -m64 -O2 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O2 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// RUN: %clangxx_msan -m64 -O3 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O3 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O0 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O0 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out // RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O1 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O1 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out // RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O2 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O2 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out // RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O3 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O3 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out // RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
#include <stdlib.h> #include <stdlib.h>

test/msan/strerror_r-non-gnu.c

// RUN: %clang_msan -std=c99 -O0 -g %s -o %t && %t // RUN: %clang_msan -std=c99 -O0 -g %s -o %t && %run %t
// strerror_r under a weird set of circumstances can be redirected to // strerror_r under a weird set of circumstances can be redirected to
// __xpg_strerror_r. Test that MSan handles this correctly. // __xpg_strerror_r. Test that MSan handles this correctly.

test/msan/strlen_of_shadow.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t
// Check that strlen() and similar intercepted functions can be called on shadow // Check that strlen() and similar intercepted functions can be called on shadow
// memory. // memory.

test/msan/sync_lock_set_and_test.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t
int main(void) { int main(void) {
int i; int i;

test/msan/textdomain.cc

// RUN: %clangxx_msan -m64 -O0 -g %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 -g %s -o %t && %run %t
#include <libintl.h> #include <libintl.h>
#include <stdio.h> #include <stdio.h>

test/msan/times.cc

// RUN: %clangxx_msan -m64 -O0 -g %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 -g %s -o %t && %run %t
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>

test/msan/tls_reuse.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t
// Check that when TLS block is reused between threads, its shadow is cleaned. // Check that when TLS block is reused between threads, its shadow is cleaned.

test/msan/tsearch.cc

// RUN: %clangxx_msan -O0 -g %s -o %t && %t // RUN: %clangxx_msan -O0 -g %s -o %t && %run %t
#include <assert.h> #include <assert.h>
#include <search.h> #include <search.h>

test/msan/tzset.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>

test/msan/unaligned_read_origin.cc

// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O0 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O0 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out && FileCheck %s < %t.out // RUN: FileCheck %s < %t.out && FileCheck %s < %t.out
// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O3 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O3 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out && FileCheck %s < %t.out // RUN: FileCheck %s < %t.out && FileCheck %s < %t.out
#include <sanitizer/msan_interface.h> #include <sanitizer/msan_interface.h>

test/msan/unpoison_string.cc

// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O0 %s -o %t // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O0 %s -o %t
// RUN: %t // RUN: %run %t
// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O3 %s -o %t // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O3 %s -o %t
// RUN: %t // RUN: %run %t
#include <assert.h> #include <assert.h>
#include <string.h> #include <string.h>

test/msan/use-after-free.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O0 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// RUN: %clangxx_msan -m64 -O1 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O1 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// RUN: %clangxx_msan -m64 -O2 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O2 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// RUN: %clangxx_msan -m64 -O3 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -m64 -O3 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out // RUN: FileCheck %s < %t.out
// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O0 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O0 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out // RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O1 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O1 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out // RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O2 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O2 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out // RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
// RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O3 %s -o %t && not %t >%t.out 2>&1 // RUN: %clangxx_msan -fsanitize-memory-track-origins -m64 -O3 %s -o %t && not %run %t >%t.out 2>&1
// RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out // RUN: FileCheck %s < %t.out && FileCheck %s --check-prefix=CHECK-ORIGINS < %t.out
#include <stdlib.h> #include <stdlib.h>

test/msan/vector_cvt.cc

// RUN: %clangxx_msan -m64 -O0 %s -o %t && %t // RUN: %clangxx_msan -m64 -O0 %s -o %t && %run %t
// RUN: %clangxx_msan -DPOSITIVE -m64 -O0 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_msan -DPOSITIVE -m64 -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <emmintrin.h> #include <emmintrin.h>

test/msan/wrap_indirect_calls.cc

Context not available.
// RUN: -mllvm -msan-wrap-indirect-calls-fast=0 \ // RUN: -mllvm -msan-wrap-indirect-calls-fast=0 \
// RUN: -DSLOW=1 \ // RUN: -DSLOW=1 \
// RUN: -Wl,--defsym=__executable_start=0 -o %t // RUN: -Wl,--defsym=__executable_start=0 -o %t
// RUN: %t // RUN: %run %t
// Enable fast path, call from executable, -O0. // Enable fast path, call from executable, -O0.
Context not available.
// RUN: -mllvm -msan-wrap-indirect-calls-fast=1 \ // RUN: -mllvm -msan-wrap-indirect-calls-fast=1 \
// RUN: -DSLOW=0 \ // RUN: -DSLOW=0 \
// RUN: -Wl,--defsym=__executable_start=0 -o %t // RUN: -Wl,--defsym=__executable_start=0 -o %t
// RUN: %t // RUN: %run %t
// Enable fast path, call from executable, -O3. // Enable fast path, call from executable, -O3.
Context not available.
// RUN: -mllvm -msan-wrap-indirect-calls-fast=1 \ // RUN: -mllvm -msan-wrap-indirect-calls-fast=1 \
// RUN: -DSLOW=0 \ // RUN: -DSLOW=0 \
// RUN: -Wl,--defsym=__executable_start=0 -o %t // RUN: -Wl,--defsym=__executable_start=0 -o %t
// RUN: %t // RUN: %run %t
// Enable fast path, call from DSO, -O0. // Enable fast path, call from DSO, -O0.
Context not available.
// RUN: -DSLOW=0 \ // RUN: -DSLOW=0 \
// RUN: -Wl,--defsym=__executable_start=0 -o %t-caller-so.so // RUN: -Wl,--defsym=__executable_start=0 -o %t-caller-so.so
// RUN: %clangxx_msan -O0 %s %t-caller-so.so %t-two-so.so %t-wrapper-so.so -o %t // RUN: %clangxx_msan -O0 %s %t-caller-so.so %t-two-so.so %t-wrapper-so.so -o %t
// RUN: %t // RUN: %run %t
// Enable fast path, call from DSO, -O3. // Enable fast path, call from DSO, -O3.
Context not available.
// RUN: -DSLOW=0 \ // RUN: -DSLOW=0 \
// RUN: -Wl,--defsym=__executable_start=0 -o %t-caller-so.so // RUN: -Wl,--defsym=__executable_start=0 -o %t-caller-so.so
// RUN: %clangxx_msan -O3 %s %t-caller-so.so %t-two-so.so %t-wrapper-so.so -o %t // RUN: %clangxx_msan -O3 %s %t-caller-so.so %t-two-so.so %t-wrapper-so.so -o %t
// RUN: %t // RUN: %run %t
// The actual test is in multiple files in wrap_indirect_calls/ directory. // The actual test is in multiple files in wrap_indirect_calls/ directory.
void run_test(); void run_test();
Context not available.

test/msan/wrap_indirect_calls2.cc

Context not available.
// RUN: %clangxx_msan -mllvm -msan-wrap-indirect-calls=__msan_wrap_indirect_call \ // RUN: %clangxx_msan -mllvm -msan-wrap-indirect-calls=__msan_wrap_indirect_call \
// RUN: -mllvm -msan-wrap-indirect-calls-fast=0 \ // RUN: -mllvm -msan-wrap-indirect-calls-fast=0 \
// RUN: -O0 -g -rdynamic -Wl,--defsym=__executable_start=0 %s -o %t && %t // RUN: -O0 -g -rdynamic -Wl,--defsym=__executable_start=0 %s -o %t && %run %t
// This test disables -msan-wrap-indirect-calls-fast, otherwise indirect calls // This test disables -msan-wrap-indirect-calls-fast, otherwise indirect calls
// inside the same module are short-circuited and are never seen by the wrapper. // inside the same module are short-circuited and are never seen by the wrapper.
Context not available.

test/msan/wrap_indirect_calls_in_rtl.cc

// Test indirect call wrapping in MemorySanitizer runtime. // Test indirect call wrapping in MemorySanitizer runtime.
// RUN: %clangxx_msan -O0 -g -rdynamic %s -o %t && %t // RUN: %clangxx_msan -O0 -g -rdynamic %s -o %t && %run %t
#include <assert.h> #include <assert.h>
#include <math.h> #include <math.h>

test/tsan/aligned_vs_unaligned_race.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
// Race between an aligned access and an unaligned access, which // Race between an aligned access and an unaligned access, which
// touches the same memory region. // touches the same memory region.
// This is a real race which is not detected by tsan. // This is a real race which is not detected by tsan.

test/tsan/allocator_returns_null.cc

Context not available.
// With allocator_may_return_null=1 the allocator should return 0. // With allocator_may_return_null=1 the allocator should return 0.
// //
// RUN: %clangxx_tsan -O0 %s -o %t // RUN: %clangxx_tsan -O0 %s -o %t
// RUN: not %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mCRASH // RUN: not %run %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mCRASH
// RUN: TSAN_OPTIONS=allocator_may_return_null=0 not %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mCRASH // RUN: TSAN_OPTIONS=allocator_may_return_null=0 not %run %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mCRASH
// RUN: TSAN_OPTIONS=allocator_may_return_null=0 not %t calloc 2>&1 | FileCheck %s --check-prefix=CHECK-cCRASH // RUN: TSAN_OPTIONS=allocator_may_return_null=0 not %run %t calloc 2>&1 | FileCheck %s --check-prefix=CHECK-cCRASH
// RUN: TSAN_OPTIONS=allocator_may_return_null=0 not %t calloc-overflow 2>&1 | FileCheck %s --check-prefix=CHECK-coCRASH // RUN: TSAN_OPTIONS=allocator_may_return_null=0 not %run %t calloc-overflow 2>&1 | FileCheck %s --check-prefix=CHECK-coCRASH
// RUN: TSAN_OPTIONS=allocator_may_return_null=0 not %t realloc 2>&1 | FileCheck %s --check-prefix=CHECK-rCRASH // RUN: TSAN_OPTIONS=allocator_may_return_null=0 not %run %t realloc 2>&1 | FileCheck %s --check-prefix=CHECK-rCRASH
// RUN: TSAN_OPTIONS=allocator_may_return_null=0 not %t realloc-after-malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mrCRASH // RUN: TSAN_OPTIONS=allocator_may_return_null=0 not %run %t realloc-after-malloc 2>&1 | FileCheck %s --check-prefix=CHECK-mrCRASH
#include <limits.h> #include <limits.h>
#include <stdlib.h> #include <stdlib.h>
Context not available.

test/tsan/atomic_free.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <unistd.h> #include <unistd.h>

test/tsan/atomic_free2.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <unistd.h> #include <unistd.h>

test/tsan/atomic_norace.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/atomic_race.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <unistd.h> #include <unistd.h>
#include <stdio.h> #include <stdio.h>

test/tsan/atomic_stack.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <unistd.h> #include <unistd.h>

test/tsan/barrier.cc

// RUN: %clang_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
// CHECK-NOT: ThreadSanitizer: data race // CHECK-NOT: ThreadSanitizer: data race
// CHECK: DONE // CHECK: DONE

test/tsan/bench_acquire_only.cc

// RUN: %clangxx_tsan %s -o %t // RUN: %clangxx_tsan %s -o %t
// RUN: %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
#include "bench.h" #include "bench.h"

test/tsan/bench_acquire_release.cc

// RUN: %clangxx_tsan %s -o %t // RUN: %clangxx_tsan %s -o %t
// RUN: %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
#include "bench.h" #include "bench.h"

test/tsan/bench_local_mutex.cc

// RUN: %clangxx_tsan %s -o %t // RUN: %clangxx_tsan %s -o %t
// RUN: %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
#include "bench.h" #include "bench.h"

test/tsan/bench_mutex.cc

// RUN: %clangxx_tsan %s -o %t // RUN: %clangxx_tsan %s -o %t
// RUN: %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
#include "bench.h" #include "bench.h"

test/tsan/bench_release_only.cc

// RUN: %clangxx_tsan %s -o %t // RUN: %clangxx_tsan %s -o %t
// RUN: %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
#include "bench.h" #include "bench.h"

test/tsan/bench_rwmutex.cc

// RUN: %clangxx_tsan %s -o %t // RUN: %clangxx_tsan %s -o %t
// RUN: %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
#include "bench.h" #include "bench.h"

test/tsan/bench_shadow_flush.cc

// RUN: %clangxx_tsan %s -o %t // RUN: %clangxx_tsan %s -o %t
// RUN: %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>

test/tsan/bench_single_writer.cc

// RUN: %clangxx_tsan %s -o %t // RUN: %clangxx_tsan %s -o %t
// RUN: %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
#include "bench.h" #include "bench.h"

test/tsan/bench_ten_mutexes.cc

// RUN: %clangxx_tsan %s -o %t // RUN: %clangxx_tsan %s -o %t
// RUN: %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
#include "bench.h" #include "bench.h"

test/tsan/benign_race.cc

// RUN: %clang_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/blacklist.cc

Context not available.
// RUN: %clangxx_tsan -O1 %s \ // RUN: %clangxx_tsan -O1 %s \
// RUN: -fsanitize-blacklist=%p/Helpers/blacklist.txt \ // RUN: -fsanitize-blacklist=%p/Helpers/blacklist.txt \
// RUN: -o %t && %t 2>&1 | FileCheck %s // RUN: -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
Context not available.

test/tsan/cond.c

// RUN: %clang_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
// CHECK-NOT: WARNING: ThreadSanitizer: data race // CHECK-NOT: WARNING: ThreadSanitizer: data race
// CHECK-NOT: ThreadSanitizer WARNING: double lock // CHECK-NOT: ThreadSanitizer WARNING: double lock
// CHECK-NOT: ThreadSanitizer WARNING: mutex unlock by another thread // CHECK-NOT: ThreadSanitizer WARNING: mutex unlock by another thread

test/tsan/cond_cancel.c

// RUN: %clang_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
// CHECK-NOT: WARNING // CHECK-NOT: WARNING
// CHECK: OK // CHECK: OK

test/tsan/cond_race.cc

// RUN: %clang_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
// CHECK-NOT: unlock of unlocked mutex // CHECK-NOT: unlock of unlocked mutex
// CHECK: ThreadSanitizer: data race // CHECK: ThreadSanitizer: data race
// CHECK: pthread_cond_signal // CHECK: pthread_cond_signal

test/tsan/cond_version.c

// RUN: %clang_tsan -O1 %s -o %t -lrt && %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t -lrt && %run %t 2>&1 | FileCheck %s
// Test that pthread_cond is properly intercepted, // Test that pthread_cond is properly intercepted,
// previously there were issues with versioned symbols. // previously there were issues with versioned symbols.
// CHECK: OK // CHECK: OK

test/tsan/deadlock_detector_stress_test.cc

// RUN: %clangxx_tsan %s -o %t -DLockType=PthreadMutex // RUN: %clangxx_tsan %s -o %t -DLockType=PthreadMutex
// RUN: TSAN_OPTIONS=detect_deadlocks=1 not %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NOT-SECOND // RUN: TSAN_OPTIONS=detect_deadlocks=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NOT-SECOND
// TSAN_OPTIONS="detect_deadlocks=1 second_deadlock_stack=1" not %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-SECOND // TSAN_OPTIONS="detect_deadlocks=1 second_deadlock_stack=1" not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-SECOND
// RUN: %clangxx_tsan %s -o %t -DLockType=PthreadSpinLock // RUN: %clangxx_tsan %s -o %t -DLockType=PthreadSpinLock
// RUN: TSAN_OPTIONS=detect_deadlocks=1 not %t 2>&1 | FileCheck %s // RUN: TSAN_OPTIONS=detect_deadlocks=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_tsan %s -o %t -DLockType=PthreadRWLock // RUN: %clangxx_tsan %s -o %t -DLockType=PthreadRWLock
// RUN: TSAN_OPTIONS=detect_deadlocks=1 not %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-RD // RUN: TSAN_OPTIONS=detect_deadlocks=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-RD
// RUN: %clangxx_tsan %s -o %t -DLockType=PthreadRecursiveMutex // RUN: %clangxx_tsan %s -o %t -DLockType=PthreadRecursiveMutex
// RUN: TSAN_OPTIONS=detect_deadlocks=1 not %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-REC // RUN: TSAN_OPTIONS=detect_deadlocks=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-REC
#include <pthread.h> #include <pthread.h>
#undef NDEBUG #undef NDEBUG
#include <assert.h> #include <assert.h>

test/tsan/deep_stack1.cc

// RUN: %clangxx_tsan -O1 %s -o %t -DORDER1 && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t -DORDER1 && not %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_tsan -O1 %s -o %t -DORDER2 && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t -DORDER2 && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/default_options.cc

// RUN: %clang_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>

test/tsan/fd_close_norace.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/fd_close_norace2.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/fd_dup_norace.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/fd_location.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/fd_pipe_norace.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/fd_pipe_race.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/fd_socket_connect_norace.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/tsan/fd_socket_norace.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/tsan/fd_socketpair_norace.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/fd_stdout_race.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/fork_atexit.cc

// RUN: %clangxx_tsan -O1 %s -o %t && TSAN_OPTIONS="atexit_sleep_ms=50" %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && TSAN_OPTIONS="atexit_sleep_ms=50" %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/tsan/fork_deadlock.cc

// RUN: %clangxx_tsan -O1 %s -o %t && TSAN_OPTIONS="atexit_sleep_ms=50" %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && TSAN_OPTIONS="atexit_sleep_ms=50" %run %t 2>&1 | FileCheck %s
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <errno.h> #include <errno.h>

test/tsan/fork_multithreaded.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s -check-prefix=CHECK-DIE // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s -check-prefix=CHECK-DIE
// RUN: %clangxx_tsan -O1 %s -o %t && TSAN_OPTIONS="die_after_fork=0" %t 2>&1 | FileCheck %s -check-prefix=CHECK-NODIE // RUN: %clangxx_tsan -O1 %s -o %t && TSAN_OPTIONS="die_after_fork=0" %run %t 2>&1 | FileCheck %s -check-prefix=CHECK-NODIE
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <errno.h> #include <errno.h>

test/tsan/fork_multithreaded3.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <errno.h> #include <errno.h>

test/tsan/free_race.c

// RUN: %clang_tsan -O1 %s -o %t // RUN: %clang_tsan -O1 %s -o %t
// RUN: not %t 2>&1 | FileCheck %s --check-prefix=CHECK-NOZUPP // RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-NOZUPP
// RUN: TSAN_OPTIONS="suppressions=%s.supp print_suppressions=1" %t 2>&1 | FileCheck %s --check-prefix=CHECK-SUPP // RUN: TSAN_OPTIONS="suppressions=%s.supp print_suppressions=1" %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-SUPP
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>

test/tsan/free_race2.c

// RUN: %clang_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <stdlib.h> #include <stdlib.h>
void __attribute__((noinline)) foo(int *mem) { void __attribute__((noinline)) foo(int *mem) {

test/tsan/getline_nohang.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t // RUN: %clangxx_tsan -O1 %s -o %t && %run %t
// Make sure TSan doesn't deadlock on a file stream lock at program shutdown. // Make sure TSan doesn't deadlock on a file stream lock at program shutdown.
// See https://code.google.com/p/thread-sanitizer/issues/detail?id=47 // See https://code.google.com/p/thread-sanitizer/issues/detail?id=47

test/tsan/global_race.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stddef.h> #include <stddef.h>

test/tsan/halt_on_error.cc

// RUN: %clang_tsan -O1 %s -o %t && TSAN_OPTIONS="$TSAN_OPTIONS halt_on_error=1" not %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && TSAN_OPTIONS="$TSAN_OPTIONS halt_on_error=1" not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/heap_race.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stddef.h> #include <stddef.h>

test/tsan/ignore_free.cc

// RUN: %clang_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>

test/tsan/ignore_lib0.cc

// RUN: %clangxx_tsan -O1 %s -DLIB -fPIC -fno-sanitize=thread -shared -o %T/libignore_lib0.so // RUN: %clangxx_tsan -O1 %s -DLIB -fPIC -fno-sanitize=thread -shared -o %T/libignore_lib0.so
// RUN: %clangxx_tsan -O1 %s -L%T -lignore_lib0 -o %t // RUN: %clangxx_tsan -O1 %s -L%T -lignore_lib0 -o %t
// RUN: echo running w/o suppressions: // RUN: echo running w/o suppressions:
// RUN: LD_LIBRARY_PATH=%T${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH} not %t 2>&1 | FileCheck %s --check-prefix=CHECK-NOSUPP // RUN: LD_LIBRARY_PATH=%T${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH} not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-NOSUPP
// RUN: echo running with suppressions: // RUN: echo running with suppressions:
// RUN: LD_LIBRARY_PATH=%T${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH} TSAN_OPTIONS="$TSAN_OPTIONS suppressions=%s.supp" %t 2>&1 | FileCheck %s --check-prefix=CHECK-WITHSUPP // RUN: LD_LIBRARY_PATH=%T${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH} TSAN_OPTIONS="$TSAN_OPTIONS suppressions=%s.supp" %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-WITHSUPP
// Tests that interceptors coming from a library specified in called_from_lib // Tests that interceptors coming from a library specified in called_from_lib
// suppression are ignored. // suppression are ignored.

test/tsan/ignore_lib1.cc

// RUN: %clangxx_tsan -O1 %s -DLIB -fPIC -fno-sanitize=thread -shared -o %T/libignore_lib1.so // RUN: %clangxx_tsan -O1 %s -DLIB -fPIC -fno-sanitize=thread -shared -o %T/libignore_lib1.so
// RUN: %clangxx_tsan -O1 %s -o %t // RUN: %clangxx_tsan -O1 %s -o %t
// RUN: echo running w/o suppressions: // RUN: echo running w/o suppressions:
// RUN: not %t 2>&1 | FileCheck %s --check-prefix=CHECK-NOSUPP // RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-NOSUPP
// RUN: echo running with suppressions: // RUN: echo running with suppressions:
// RUN: TSAN_OPTIONS="$TSAN_OPTIONS suppressions=%s.supp" %t 2>&1 | FileCheck %s --check-prefix=CHECK-WITHSUPP // RUN: TSAN_OPTIONS="$TSAN_OPTIONS suppressions=%s.supp" %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-WITHSUPP
// Tests that interceptors coming from a dynamically loaded library specified // Tests that interceptors coming from a dynamically loaded library specified
// in called_from_lib suppression are ignored. // in called_from_lib suppression are ignored.

test/tsan/ignore_lib2.cc

// RUN: %clangxx_tsan -O1 %s -DLIB -fPIC -fno-sanitize=thread -shared -o %T/libignore_lib2_0.so // RUN: %clangxx_tsan -O1 %s -DLIB -fPIC -fno-sanitize=thread -shared -o %T/libignore_lib2_0.so
// RUN: %clangxx_tsan -O1 %s -DLIB -fPIC -fno-sanitize=thread -shared -o %T/libignore_lib2_1.so // RUN: %clangxx_tsan -O1 %s -DLIB -fPIC -fno-sanitize=thread -shared -o %T/libignore_lib2_1.so
// RUN: %clangxx_tsan -O1 %s -o %t // RUN: %clangxx_tsan -O1 %s -o %t
// RUN: TSAN_OPTIONS="$TSAN_OPTIONS suppressions=%s.supp" not %t 2>&1 | FileCheck %s // RUN: TSAN_OPTIONS="$TSAN_OPTIONS suppressions=%s.supp" not %run %t 2>&1 | FileCheck %s
// Tests that called_from_lib suppression matched against 2 libraries // Tests that called_from_lib suppression matched against 2 libraries
// causes program crash (this is not supported). // causes program crash (this is not supported).

test/tsan/ignore_lib3.cc

// RUN: %clangxx_tsan -O1 %s -DLIB -fPIC -fno-sanitize=thread -shared -o %T/libignore_lib3.so // RUN: %clangxx_tsan -O1 %s -DLIB -fPIC -fno-sanitize=thread -shared -o %T/libignore_lib3.so
// RUN: %clangxx_tsan -O1 %s -o %t // RUN: %clangxx_tsan -O1 %s -o %t
// RUN: TSAN_OPTIONS="$TSAN_OPTIONS suppressions=%s.supp" not %t 2>&1 | FileCheck %s // RUN: TSAN_OPTIONS="$TSAN_OPTIONS suppressions=%s.supp" not %run %t 2>&1 | FileCheck %s
// Tests that unloading of a library matched against called_from_lib suppression // Tests that unloading of a library matched against called_from_lib suppression
// causes program crash (this is not supported). // causes program crash (this is not supported).

test/tsan/ignore_malloc.cc

// RUN: %clang_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>

test/tsan/ignore_race.cc

// RUN: %clang_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/ignore_sync.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>

test/tsan/inlined_memcpy_race.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stddef.h> #include <stddef.h>
#include <stdio.h> #include <stdio.h>

test/tsan/interface_atomic_test.c

// Test that we can include header with TSan atomic interface. // Test that we can include header with TSan atomic interface.
// RUN: %clang_tsan %s -o %t && %t | FileCheck %s // RUN: %clang_tsan %s -o %t && %run %t | FileCheck %s
#include <sanitizer/tsan_interface_atomic.h> #include <sanitizer/tsan_interface_atomic.h>
#include <stdio.h> #include <stdio.h>

test/tsan/java_alloc.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include "java.h" #include "java.h"
int const kHeapSize = 1024 * 1024; int const kHeapSize = 1024 * 1024;

test/tsan/java_lock.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include "java.h" #include "java.h"
#include <unistd.h> #include <unistd.h>

test/tsan/java_lock_move.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include "java.h" #include "java.h"
jptr varaddr; jptr varaddr;

test/tsan/java_lock_rec.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include "java.h" #include "java.h"
#include <unistd.h> #include <unistd.h>

test/tsan/java_lock_rec_race.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include "java.h" #include "java.h"
#include <unistd.h> #include <unistd.h>

test/tsan/java_race.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include "java.h" #include "java.h"
void *Thread(void *p) { void *Thread(void *p) {

test/tsan/java_race_move.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include "java.h" #include "java.h"
jptr varaddr; jptr varaddr;

test/tsan/java_rwlock.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include "java.h" #include "java.h"
#include <unistd.h> #include <unistd.h>

test/tsan/load_shared_lib.cc

Context not available.
// RUN: %clangxx_tsan -O1 %p/SharedLibs/load_shared_lib-so.cc \ // RUN: %clangxx_tsan -O1 %p/SharedLibs/load_shared_lib-so.cc \
// RUN: -fPIC -shared -o %t-so.so // RUN: -fPIC -shared -o %t-so.so
// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <dlfcn.h> #include <dlfcn.h>
#include <pthread.h> #include <pthread.h>
Context not available.

test/tsan/longjmp.cc

// RUN: %clang_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <setjmp.h> #include <setjmp.h>

test/tsan/longjmp2.cc

// RUN: %clang_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <setjmp.h> #include <setjmp.h>

test/tsan/longjmp3.cc

// RUN: %clang_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/tsan/longjmp4.cc

// RUN: %clang_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/tsan/malloc_hook.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <unistd.h> #include <unistd.h>
#include <stdio.h> #include <stdio.h>

test/tsan/malloc_overflow.cc

// RUN: %clangxx_tsan -O1 %s -o %t // RUN: %clangxx_tsan -O1 %s -o %t
// RUN: TSAN_OPTIONS=allocator_may_return_null=1 %t 2>&1 | FileCheck %s // RUN: TSAN_OPTIONS=allocator_may_return_null=1 %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/tsan/malloc_stack.cc

// RUN: %clang_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <unistd.h> #include <unistd.h>

test/tsan/memcpy_race.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stddef.h> #include <stddef.h>
#include <stdio.h> #include <stdio.h>

test/tsan/mmap_large.cc

// RUN: %clang_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <sys/mman.h> #include <sys/mman.h>

test/tsan/mop_with_offset.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stddef.h> #include <stddef.h>
#include <stdio.h> #include <stdio.h>

test/tsan/mop_with_offset2.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stddef.h> #include <stddef.h>
#include <stdio.h> #include <stdio.h>

test/tsan/mutex_bad_read_lock.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
extern "C" void AnnotateRWLockAcquired(const char *f, int l, void *m, long rw); extern "C" void AnnotateRWLockAcquired(const char *f, int l, void *m, long rw);
int main() { int main() {

test/tsan/mutex_bad_read_unlock.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
extern "C" void AnnotateRWLockAcquired(const char *f, int l, void *m, long rw); extern "C" void AnnotateRWLockAcquired(const char *f, int l, void *m, long rw);
extern "C" void AnnotateRWLockReleased(const char *f, int l, void *m, long rw); extern "C" void AnnotateRWLockReleased(const char *f, int l, void *m, long rw);

test/tsan/mutex_bad_unlock.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
extern "C" void AnnotateRWLockReleased(const char *f, int l, void *m, long rw); extern "C" void AnnotateRWLockReleased(const char *f, int l, void *m, long rw);
int main() { int main() {

test/tsan/mutex_cycle2.c

// RUN: %clangxx_tsan %s -o %t // RUN: %clangxx_tsan %s -o %t
// RUN: TSAN_OPTIONS=detect_deadlocks=1 not %t 2>&1 | FileCheck %s // RUN: TSAN_OPTIONS=detect_deadlocks=1 not %run %t 2>&1 | FileCheck %s
// RUN: echo "deadlock:main" > sup // RUN: echo "deadlock:main" > sup
// RUN: TSAN_OPTIONS="detect_deadlocks=1 suppressions=sup" %t // RUN: TSAN_OPTIONS="detect_deadlocks=1 suppressions=sup" %run %t
// RUN: echo "deadlock:zzzz" > sup // RUN: echo "deadlock:zzzz" > sup
// RUN: TSAN_OPTIONS="detect_deadlocks=1 suppressions=sup" not %t 2>&1 | FileCheck %s // RUN: TSAN_OPTIONS="detect_deadlocks=1 suppressions=sup" not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
int main() { int main() {

test/tsan/mutex_destroy_locked.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <unistd.h> #include <unistd.h>

test/tsan/mutex_double_lock.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <unistd.h> #include <unistd.h>

test/tsan/mutex_robust.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>

test/tsan/mutex_robust2.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>

test/tsan/mutexset1.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/mutexset2.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/mutexset3.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/mutexset4.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/mutexset5.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/mutexset6.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/mutexset7.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/mutexset8.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/oob_race.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/printf-1.c

// RUN: %clang_tsan -O2 %s -o %t // RUN: %clang_tsan -O2 %s -o %t
// RUN: ASAN_OPTIONS=check_printf=1 %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=check_printf=1 %run %t 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS=check_printf=0 %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=check_printf=0 %run %t 2>&1 | FileCheck %s
// RUN: %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
int main() { int main() {

test/tsan/race_on_barrier.c

// RUN: %clang_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stddef.h> #include <stddef.h>

test/tsan/race_on_barrier2.c

// RUN: %clang_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stddef.h> #include <stddef.h>

test/tsan/race_on_heap.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>

test/tsan/race_on_mutex.c

// RUN: %clang_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stddef.h> #include <stddef.h>

test/tsan/race_on_mutex2.c

// RUN: %clang_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stddef.h> #include <stddef.h>

test/tsan/race_on_read.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/race_on_speculative_load.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t | FileCheck %s
// Regtest for https://code.google.com/p/thread-sanitizer/issues/detail?id=40 // Regtest for https://code.google.com/p/thread-sanitizer/issues/detail?id=40
// This is a correct program and tsan should not report a race. // This is a correct program and tsan should not report a race.
#include <pthread.h> #include <pthread.h>

test/tsan/race_on_write.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/race_with_finished_thread.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stddef.h> #include <stddef.h>
#include <stdio.h> #include <stdio.h>

test/tsan/signal_errno.cc

// RUN: %clang_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/tsan/signal_malloc.cc

// RUN: %clang_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <signal.h> #include <signal.h>

test/tsan/sigsuspend.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
// Always enable asserts. // Always enable asserts.
#ifdef NDEBUG #ifdef NDEBUG

test/tsan/simple_race.c

// RUN: %clang_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/simple_race.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>

test/tsan/simple_stack.c

// RUN: %clang_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/simple_stack2.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/sleep_sync.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <unistd.h> #include <unistd.h>

test/tsan/sleep_sync2.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <unistd.h> #include <unistd.h>

test/tsan/stack_race.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stddef.h> #include <stddef.h>
#include <unistd.h> #include <unistd.h>

test/tsan/stack_race2.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stddef.h> #include <stddef.h>
#include <unistd.h> #include <unistd.h>

test/tsan/static_init1.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>

test/tsan/static_init2.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>

test/tsan/static_init3.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>

test/tsan/static_init4.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>

test/tsan/static_init5.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>

test/tsan/static_init6.cc

// RUN: %clangxx_tsan -static-libstdc++ -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -static-libstdc++ -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>

test/tsan/sunrpc.cc

// RUN: %clang_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <rpc/xdr.h> #include <rpc/xdr.h>

test/tsan/suppress_same_address.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <unistd.h> #include <unistd.h>

test/tsan/suppress_same_stacks.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
volatile int N; // Prevent loop unrolling. volatile int N; // Prevent loop unrolling.

test/tsan/suppressions_global.cc

// RUN: %clang_tsan -O1 %s -o %t && TSAN_OPTIONS="$TSAN_OPTIONS suppressions=%s.supp" %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && TSAN_OPTIONS="$TSAN_OPTIONS suppressions=%s.supp" %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>

test/tsan/suppressions_race.cc

// RUN: %clang_tsan -O1 %s -o %t && TSAN_OPTIONS="$TSAN_OPTIONS suppressions=%s.supp" %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && TSAN_OPTIONS="$TSAN_OPTIONS suppressions=%s.supp" %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/suppressions_race2.cc

// RUN: %clang_tsan -O1 %s -o %t && TSAN_OPTIONS="$TSAN_OPTIONS suppressions=%s.supp" %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && TSAN_OPTIONS="$TSAN_OPTIONS suppressions=%s.supp" %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/thread_end_with_ignore.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>

test/tsan/thread_end_with_ignore2.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
extern "C" void AnnotateIgnoreWritesBegin(const char *f, int l); extern "C" void AnnotateIgnoreWritesBegin(const char *f, int l);
int main() { int main() {

test/tsan/thread_end_with_ignore3.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
extern "C" void AnnotateIgnoreReadsBegin(const char *f, int l); extern "C" void AnnotateIgnoreReadsBegin(const char *f, int l);
extern "C" void AnnotateIgnoreReadsEnd(const char *f, int l); extern "C" void AnnotateIgnoreReadsEnd(const char *f, int l);

test/tsan/thread_leak.c

// RUN: %clang_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>

test/tsan/thread_leak2.c

// RUN: %clang_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>

test/tsan/thread_leak3.c

// RUN: %clang_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <unistd.h> #include <unistd.h>

test/tsan/thread_leak4.c

// RUN: %clang_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <unistd.h> #include <unistd.h>
#include <stdio.h> #include <stdio.h>

test/tsan/thread_leak5.c

// RUN: %clang_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <unistd.h> #include <unistd.h>

test/tsan/thread_name.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/thread_name2.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h> #include <unistd.h>

test/tsan/tiny_race.c

// RUN: %clang_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clang_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <unistd.h> #include <unistd.h>

test/tsan/tls_race.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stddef.h> #include <stddef.h>
#include <unistd.h> #include <unistd.h>

test/tsan/tls_race2.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stddef.h> #include <stddef.h>
#include <unistd.h> #include <unistd.h>

test/tsan/tsan-vs-gvn.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_tsan -O2 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O2 %s -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx_tsan -O3 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O3 %s -o %t && %run %t 2>&1 | FileCheck %s
// //
// Check that load widening is not tsan-hostile. // Check that load widening is not tsan-hostile.
#include <pthread.h> #include <pthread.h>

test/tsan/unaligned_norace.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/tsan/unaligned_race.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/tsan/user_fopen.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/tsan/user_malloc.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
// defined by tsan. // defined by tsan.

test/tsan/vfork.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

test/tsan/virtual_inheritance_compile_bug.cc

// Regression test for http://code.google.com/p/thread-sanitizer/issues/detail?id=3. // Regression test for http://code.google.com/p/thread-sanitizer/issues/detail?id=3.
// The C++ variant is much more compact that the LLVM IR equivalent. // The C++ variant is much more compact that the LLVM IR equivalent.
// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
struct AAA { virtual long aaa () { return 0; } }; // NOLINT struct AAA { virtual long aaa () { return 0; } }; // NOLINT
struct BBB: virtual AAA { unsigned long bbb; }; // NOLINT struct BBB: virtual AAA { unsigned long bbb; }; // NOLINT

test/tsan/vptr_benign_race.cc

// RUN: %clangxx_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <semaphore.h> #include <semaphore.h>
#include <stdio.h> #include <stdio.h>

test/tsan/vptr_harmful_race.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <semaphore.h> #include <semaphore.h>
#include <stdio.h> #include <stdio.h>

test/tsan/vptr_harmful_race2.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <semaphore.h> #include <semaphore.h>
#include <stdio.h> #include <stdio.h>

test/tsan/vptr_harmful_race3.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <semaphore.h> #include <semaphore.h>
#include <stdio.h> #include <stdio.h>

test/tsan/write_in_reader_lock.cc

// RUN: %clangxx_tsan -O1 %s -o %t && not %t 2>&1 | FileCheck %s // RUN: %clangxx_tsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
#include <pthread.h> #include <pthread.h>
#include <unistd.h> #include <unistd.h>

test/ubsan/TestCases/Float/cast-overflow.cpp

// RUN: %clangxx -fsanitize=float-cast-overflow %s -o %t // RUN: %clangxx -fsanitize=float-cast-overflow %s -o %t
// RUN: %t _ // RUN: %run %t _
// RUN: %t 0 2>&1 | FileCheck %s --check-prefix=CHECK-0 // RUN: %run %t 0 2>&1 | FileCheck %s --check-prefix=CHECK-0
// RUN: %t 1 2>&1 | FileCheck %s --check-prefix=CHECK-1 // RUN: %run %t 1 2>&1 | FileCheck %s --check-prefix=CHECK-1
// RUN: %t 2 2>&1 | FileCheck %s --check-prefix=CHECK-2 // RUN: %run %t 2 2>&1 | FileCheck %s --check-prefix=CHECK-2
// RUN: %t 3 2>&1 | FileCheck %s --check-prefix=CHECK-3 // RUN: %run %t 3 2>&1 | FileCheck %s --check-prefix=CHECK-3
// RUN: %t 4 2>&1 | FileCheck %s --check-prefix=CHECK-4 // RUN: %run %t 4 2>&1 | FileCheck %s --check-prefix=CHECK-4
// RUN: %t 5 2>&1 | FileCheck %s --check-prefix=CHECK-5 // RUN: %run %t 5 2>&1 | FileCheck %s --check-prefix=CHECK-5
// RUN: %t 6 2>&1 | FileCheck %s --check-prefix=CHECK-6 // RUN: %run %t 6 2>&1 | FileCheck %s --check-prefix=CHECK-6
// FIXME: %t 7 2>&1 | FileCheck %s --check-prefix=CHECK-7 // FIXME: %run %t 7 2>&1 | FileCheck %s --check-prefix=CHECK-7
// RUN: %t 8 2>&1 | FileCheck %s --check-prefix=CHECK-8 // RUN: %run %t 8 2>&1 | FileCheck %s --check-prefix=CHECK-8
// This test assumes float and double are IEEE-754 single- and double-precision. // This test assumes float and double are IEEE-754 single- and double-precision.

test/ubsan/TestCases/Integer/add-overflow.cpp

// RUN: %clangxx -DADD_I32 -fsanitize=signed-integer-overflow %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-ADD_I32 // RUN: %clangxx -DADD_I32 -fsanitize=signed-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-ADD_I32
// RUN: %clangxx -DADD_I64 -fsanitize=signed-integer-overflow %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-ADD_I64 // RUN: %clangxx -DADD_I64 -fsanitize=signed-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-ADD_I64
// RUN: %clangxx -DADD_I128 -fsanitize=signed-integer-overflow %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-ADD_I128 // RUN: %clangxx -DADD_I128 -fsanitize=signed-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-ADD_I128
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>

test/ubsan/TestCases/Integer/div-overflow.cpp

// RUN: %clangxx -fsanitize=signed-integer-overflow %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx -fsanitize=signed-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s
#include <stdint.h> #include <stdint.h>

test/ubsan/TestCases/Integer/div-zero.cpp

// RUN: %clangxx -fsanitize=integer-divide-by-zero -DDIVIDEND=0 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx -fsanitize=integer-divide-by-zero -DDIVIDEND=0 %s -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx -fsanitize=integer-divide-by-zero -DDIVIDEND=1U %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx -fsanitize=integer-divide-by-zero -DDIVIDEND=1U %s -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx -fsanitize=float-divide-by-zero -DDIVIDEND=1.5 %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx -fsanitize=float-divide-by-zero -DDIVIDEND=1.5 %s -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx -fsanitize=integer-divide-by-zero -DDIVIDEND='intmax(123)' %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx -fsanitize=integer-divide-by-zero -DDIVIDEND='intmax(123)' %s -o %t && %run %t 2>&1 | FileCheck %s
#ifdef __SIZEOF_INT128__ #ifdef __SIZEOF_INT128__
typedef __int128 intmax; typedef __int128 intmax;

test/ubsan/TestCases/Integer/incdec-overflow.cpp

// RUN: %clangxx -DOP=n++ -fsanitize=signed-integer-overflow %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx -DOP=n++ -fsanitize=signed-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx -DOP=++n -fsanitize=signed-integer-overflow %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx -DOP=++n -fsanitize=signed-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx -DOP=m-- -fsanitize=signed-integer-overflow %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx -DOP=m-- -fsanitize=signed-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s
// RUN: %clangxx -DOP=--m -fsanitize=signed-integer-overflow %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx -DOP=--m -fsanitize=signed-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s
#include <stdint.h> #include <stdint.h>

test/ubsan/TestCases/Integer/mul-overflow.cpp

// RUN: %clangxx -fsanitize=signed-integer-overflow %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx -fsanitize=signed-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s
#include <stdint.h> #include <stdint.h>

test/ubsan/TestCases/Integer/negate-overflow.cpp

// RUN: %clangxx -fsanitize=signed-integer-overflow %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECKS // RUN: %clangxx -fsanitize=signed-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECKS
// RUN: %clangxx -fsanitize=unsigned-integer-overflow %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECKU // RUN: %clangxx -fsanitize=unsigned-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECKU
int main() { int main() {
// CHECKS-NOT: runtime error // CHECKS-NOT: runtime error

test/ubsan/TestCases/Integer/no-recover.cpp

// RUN: %clangxx -fsanitize=unsigned-integer-overflow %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=RECOVER // RUN: %clangxx -fsanitize=unsigned-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=RECOVER
// RUN: %clangxx -fsanitize=unsigned-integer-overflow -fsanitize-recover %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=RECOVER // RUN: %clangxx -fsanitize=unsigned-integer-overflow -fsanitize-recover %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=RECOVER
// RUN: %clangxx -fsanitize=unsigned-integer-overflow -fno-sanitize-recover %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=ABORT // RUN: %clangxx -fsanitize=unsigned-integer-overflow -fno-sanitize-recover %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=ABORT
#include <stdint.h> #include <stdint.h>

test/ubsan/TestCases/Integer/shift.cpp

// RUN: %clangxx -DLSH_OVERFLOW -DOP='<<' -fsanitize=shift %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-LSH_OVERFLOW // RUN: %clangxx -DLSH_OVERFLOW -DOP='<<' -fsanitize=shift %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-LSH_OVERFLOW
// RUN: %clangxx -DLSH_OVERFLOW -DOP='<<=' -fsanitize=shift %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-LSH_OVERFLOW // RUN: %clangxx -DLSH_OVERFLOW -DOP='<<=' -fsanitize=shift %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-LSH_OVERFLOW
// RUN: %clangxx -DTOO_LOW -DOP='<<' -fsanitize=shift %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_LOW // RUN: %clangxx -DTOO_LOW -DOP='<<' -fsanitize=shift %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_LOW
// RUN: %clangxx -DTOO_LOW -DOP='>>' -fsanitize=shift %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_LOW // RUN: %clangxx -DTOO_LOW -DOP='>>' -fsanitize=shift %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_LOW
// RUN: %clangxx -DTOO_LOW -DOP='<<=' -fsanitize=shift %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_LOW // RUN: %clangxx -DTOO_LOW -DOP='<<=' -fsanitize=shift %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_LOW
// RUN: %clangxx -DTOO_LOW -DOP='>>=' -fsanitize=shift %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_LOW // RUN: %clangxx -DTOO_LOW -DOP='>>=' -fsanitize=shift %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_LOW
// RUN: %clangxx -DTOO_HIGH -DOP='<<' -fsanitize=shift %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_HIGH // RUN: %clangxx -DTOO_HIGH -DOP='<<' -fsanitize=shift %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_HIGH
// RUN: %clangxx -DTOO_HIGH -DOP='>>' -fsanitize=shift %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_HIGH // RUN: %clangxx -DTOO_HIGH -DOP='>>' -fsanitize=shift %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_HIGH
// RUN: %clangxx -DTOO_HIGH -DOP='<<=' -fsanitize=shift %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_HIGH // RUN: %clangxx -DTOO_HIGH -DOP='<<=' -fsanitize=shift %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_HIGH
// RUN: %clangxx -DTOO_HIGH -DOP='>>=' -fsanitize=shift %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_HIGH // RUN: %clangxx -DTOO_HIGH -DOP='>>=' -fsanitize=shift %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-TOO_HIGH
#include <stdint.h> #include <stdint.h>

test/ubsan/TestCases/Integer/sub-overflow.cpp

// RUN: %clangxx -DSUB_I32 -fsanitize=signed-integer-overflow %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-SUB_I32 // RUN: %clangxx -DSUB_I32 -fsanitize=signed-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-SUB_I32
// RUN: %clangxx -DSUB_I64 -fsanitize=signed-integer-overflow %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-SUB_I64 // RUN: %clangxx -DSUB_I64 -fsanitize=signed-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-SUB_I64
// RUN: %clangxx -DSUB_I128 -fsanitize=signed-integer-overflow %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-SUB_I128 // RUN: %clangxx -DSUB_I128 -fsanitize=signed-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-SUB_I128
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>

test/ubsan/TestCases/Integer/uadd-overflow.cpp

// RUN: %clangxx -DADD_I32 -fsanitize=unsigned-integer-overflow %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-ADD_I32 // RUN: %clangxx -DADD_I32 -fsanitize=unsigned-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-ADD_I32
// RUN: %clangxx -DADD_I64 -fsanitize=unsigned-integer-overflow %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-ADD_I64 // RUN: %clangxx -DADD_I64 -fsanitize=unsigned-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-ADD_I64
// RUN: %clangxx -DADD_I128 -fsanitize=unsigned-integer-overflow %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-ADD_I128 // RUN: %clangxx -DADD_I128 -fsanitize=unsigned-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-ADD_I128
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>

test/ubsan/TestCases/Integer/uincdec-overflow.cpp

// RUN: %clangxx -DOP=n++ -fsanitize=unsigned-integer-overflow %s -o %t && %t 2>&1 | FileCheck --check-prefix=CHECK-INC %s // RUN: %clangxx -DOP=n++ -fsanitize=unsigned-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck --check-prefix=CHECK-INC %s
// RUN: %clangxx -DOP=++n -fsanitize=unsigned-integer-overflow %s -o %t && %t 2>&1 | FileCheck --check-prefix=CHECK-INC %s // RUN: %clangxx -DOP=++n -fsanitize=unsigned-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck --check-prefix=CHECK-INC %s
// RUN: %clangxx -DOP=m-- -fsanitize=unsigned-integer-overflow %s -o %t && %t 2>&1 | FileCheck --check-prefix=CHECK-DEC %s // RUN: %clangxx -DOP=m-- -fsanitize=unsigned-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck --check-prefix=CHECK-DEC %s
// RUN: %clangxx -DOP=--m -fsanitize=unsigned-integer-overflow %s -o %t && %t 2>&1 | FileCheck --check-prefix=CHECK-DEC %s // RUN: %clangxx -DOP=--m -fsanitize=unsigned-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck --check-prefix=CHECK-DEC %s
#include <stdint.h> #include <stdint.h>

test/ubsan/TestCases/Integer/umul-overflow.cpp

// RUN: %clangxx -fsanitize=unsigned-integer-overflow %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx -fsanitize=unsigned-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s
#include <stdint.h> #include <stdint.h>

test/ubsan/TestCases/Integer/usub-overflow.cpp

// RUN: %clangxx -DSUB_I32 -fsanitize=unsigned-integer-overflow %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-SUB_I32 // RUN: %clangxx -DSUB_I32 -fsanitize=unsigned-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-SUB_I32
// RUN: %clangxx -DSUB_I64 -fsanitize=unsigned-integer-overflow %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-SUB_I64 // RUN: %clangxx -DSUB_I64 -fsanitize=unsigned-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-SUB_I64
// RUN: %clangxx -DSUB_I128 -fsanitize=unsigned-integer-overflow %s -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-SUB_I128 // RUN: %clangxx -DSUB_I128 -fsanitize=unsigned-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-SUB_I128
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>

test/ubsan/TestCases/Misc/deduplication.cpp

// RUN: %clangxx -fsanitize=undefined %s -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx -fsanitize=undefined %s -o %t && %run %t 2>&1 | FileCheck %s
// Verify deduplication works by ensuring only one diag is emitted. // Verify deduplication works by ensuring only one diag is emitted.
#include <limits.h> #include <limits.h>
#include <stdio.h> #include <stdio.h>

test/ubsan/TestCases/Misc/enum.cpp

// RUN: %clangxx -fsanitize=enum %s -O3 -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-PLAIN // RUN: %clangxx -fsanitize=enum %s -O3 -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-PLAIN
// RUN: %clangxx -fsanitize=enum -std=c++11 -DE="class E" %s -O3 -o %t && %t // RUN: %clangxx -fsanitize=enum -std=c++11 -DE="class E" %s -O3 -o %t && %run %t
// RUN: %clangxx -fsanitize=enum -std=c++11 -DE="class E : bool" %s -O3 -o %t && %t 2>&1 | FileCheck %s --check-prefix=CHECK-BOOL // RUN: %clangxx -fsanitize=enum -std=c++11 -DE="class E : bool" %s -O3 -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-BOOL
enum E { a = 1 } e; enum E { a = 1 } e;
#undef E #undef E

test/ubsan/TestCases/Misc/missing_return.cpp

// RUN: %clangxx -fsanitize=return %s -O3 -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx -fsanitize=return %s -O3 -o %t && %run %t 2>&1 | FileCheck %s
// CHECK: missing_return.cpp:4:5: runtime error: execution reached the end of a value-returning function without returning a value // CHECK: missing_return.cpp:4:5: runtime error: execution reached the end of a value-returning function without returning a value
int f() { int f() {

test/ubsan/TestCases/Misc/unreachable.cpp

// RUN: %clangxx -fsanitize=unreachable %s -O3 -o %t && %t 2>&1 | FileCheck %s // RUN: %clangxx -fsanitize=unreachable %s -O3 -o %t && %run %t 2>&1 | FileCheck %s
int main(int, char **argv) { int main(int, char **argv) {
// CHECK: unreachable.cpp:5:3: runtime error: execution reached a __builtin_unreachable() call // CHECK: unreachable.cpp:5:3: runtime error: execution reached a __builtin_unreachable() call

test/ubsan/TestCases/Misc/vla.c

// RUN: %clang -fsanitize=vla-bound %s -O3 -o %t // RUN: %clang -fsanitize=vla-bound %s -O3 -o %t
// RUN: %t 2>&1 | FileCheck %s --check-prefix=CHECK-MINUS-ONE // RUN: %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-MINUS-ONE
// RUN: %t a 2>&1 | FileCheck %s --check-prefix=CHECK-ZERO // RUN: %run %t a 2>&1 | FileCheck %s --check-prefix=CHECK-ZERO
// RUN: %t a b // RUN: %run %t a b
int main(int argc, char **argv) { int main(int argc, char **argv) {
// CHECK-MINUS-ONE: vla.c:9:11: runtime error: variable length array bound evaluates to non-positive value -1 // CHECK-MINUS-ONE: vla.c:9:11: runtime error: variable length array bound evaluates to non-positive value -1

test/ubsan/TestCases/TypeCheck/Function/function.cpp

// RUN: %clangxx -fsanitize=function %s -O3 -g -o %t // RUN: %clangxx -fsanitize=function %s -O3 -g -o %t
// RUN: %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
#include <stdint.h> #include <stdint.h>

test/ubsan/TestCases/TypeCheck/misaligned.cpp

// RUN: %clangxx -fsanitize=alignment %s -O3 -o %t // RUN: %clangxx -fsanitize=alignment %s -O3 -o %t
// RUN: %t l0 && %t s0 && %t r0 && %t m0 && %t f0 && %t n0 // RUN: %run %t l0 && %run %t s0 && %run %t r0 && %run %t m0 && %run %t f0 && %run %t n0
// RUN: %t l1 2>&1 | FileCheck %s --check-prefix=CHECK-LOAD --strict-whitespace // RUN: %run %t l1 2>&1 | FileCheck %s --check-prefix=CHECK-LOAD --strict-whitespace
// RUN: %t s1 2>&1 | FileCheck %s --check-prefix=CHECK-STORE // RUN: %run %t s1 2>&1 | FileCheck %s --check-prefix=CHECK-STORE
// RUN: %t r1 2>&1 | FileCheck %s --check-prefix=CHECK-REFERENCE // RUN: %run %t r1 2>&1 | FileCheck %s --check-prefix=CHECK-REFERENCE
// RUN: %t m1 2>&1 | FileCheck %s --check-prefix=CHECK-MEMBER // RUN: %run %t m1 2>&1 | FileCheck %s --check-prefix=CHECK-MEMBER
// RUN: %t f1 2>&1 | FileCheck %s --check-prefix=CHECK-MEMFUN // RUN: %run %t f1 2>&1 | FileCheck %s --check-prefix=CHECK-MEMFUN
// RUN: %t n1 2>&1 | FileCheck %s --check-prefix=CHECK-NEW // RUN: %run %t n1 2>&1 | FileCheck %s --check-prefix=CHECK-NEW
#include <new> #include <new>

test/ubsan/TestCases/TypeCheck/null.cpp

// RUN: %clangxx -fsanitize=null %s -O3 -o %t // RUN: %clangxx -fsanitize=null %s -O3 -o %t
// RUN: %t l 2>&1 | FileCheck %s --check-prefix=CHECK-LOAD // RUN: %run %t l 2>&1 | FileCheck %s --check-prefix=CHECK-LOAD
// RUN: %t s 2>&1 | FileCheck %s --check-prefix=CHECK-STORE // RUN: %run %t s 2>&1 | FileCheck %s --check-prefix=CHECK-STORE
// RUN: %t r 2>&1 | FileCheck %s --check-prefix=CHECK-REFERENCE // RUN: %run %t r 2>&1 | FileCheck %s --check-prefix=CHECK-REFERENCE
// RUN: %t m 2>&1 | FileCheck %s --check-prefix=CHECK-MEMBER // RUN: %run %t m 2>&1 | FileCheck %s --check-prefix=CHECK-MEMBER
// RUN: %t f 2>&1 | FileCheck %s --check-prefix=CHECK-MEMFUN // RUN: %run %t f 2>&1 | FileCheck %s --check-prefix=CHECK-MEMFUN
struct S { struct S {
int f() { return 0; } int f() { return 0; }

test/ubsan/TestCases/TypeCheck/vptr.cpp

// RUN: %clangxx -fsanitize=vptr %s -O3 -o %t // RUN: %clangxx -fsanitize=vptr %s -O3 -o %t
// RUN: %t rT && %t mT && %t fT && %t cT // RUN: %run %t rT && %run %t mT && %run %t fT && %run %t cT
// RUN: %t rU && %t mU && %t fU && %t cU // RUN: %run %t rU && %run %t mU && %run %t fU && %run %t cU
// RUN: %t rS && %t rV && %t oV // RUN: %run %t rS && %run %t rV && %run %t oV
// RUN: %t mS 2>&1 | FileCheck %s --check-prefix=CHECK-MEMBER --strict-whitespace // RUN: %run %t mS 2>&1 | FileCheck %s --check-prefix=CHECK-MEMBER --strict-whitespace
// RUN: %t fS 2>&1 | FileCheck %s --check-prefix=CHECK-MEMFUN --strict-whitespace // RUN: %run %t fS 2>&1 | FileCheck %s --check-prefix=CHECK-MEMFUN --strict-whitespace
// RUN: %t cS 2>&1 | FileCheck %s --check-prefix=CHECK-DOWNCAST --strict-whitespace // RUN: %run %t cS 2>&1 | FileCheck %s --check-prefix=CHECK-DOWNCAST --strict-whitespace
// RUN: %t mV 2>&1 | FileCheck %s --check-prefix=CHECK-MEMBER --strict-whitespace // RUN: %run %t mV 2>&1 | FileCheck %s --check-prefix=CHECK-MEMBER --strict-whitespace
// RUN: %t fV 2>&1 | FileCheck %s --check-prefix=CHECK-MEMFUN --strict-whitespace // RUN: %run %t fV 2>&1 | FileCheck %s --check-prefix=CHECK-MEMFUN --strict-whitespace
// RUN: %t cV 2>&1 | FileCheck %s --check-prefix=CHECK-DOWNCAST --strict-whitespace // RUN: %run %t cV 2>&1 | FileCheck %s --check-prefix=CHECK-DOWNCAST --strict-whitespace
// RUN: %t oU 2>&1 | FileCheck %s --check-prefix=CHECK-OFFSET --strict-whitespace // RUN: %run %t oU 2>&1 | FileCheck %s --check-prefix=CHECK-OFFSET --strict-whitespace
// RUN: %t m0 2>&1 | FileCheck %s --check-prefix=CHECK-NULL-MEMBER --strict-whitespace // RUN: %run %t m0 2>&1 | FileCheck %s --check-prefix=CHECK-NULL-MEMBER --strict-whitespace
// FIXME: This test produces linker errors on Darwin. // FIXME: This test produces linker errors on Darwin.
// XFAIL: darwin // XFAIL: darwin