This is an archive of the discontinued LLVM Phabricator instance.

Differential D11982

Use %env_asan_opts= substitution instead of 'env ASAN_OPTIONS=$ASAN_OPTIONS'
ClosedPublic

Authored by rnk on Aug 12 2015, 10:03 AM.

Details

Reviewers
filcab
samsonov
Commits
rG85220d021878: Use %env_asan_opts= substitution instead of 'env ASAN_OPTIONS=$ASAN_OPTIONS'
rCRT244839: Use %env_asan_opts= substitution instead of 'env ASAN_OPTIONS=$ASAN_OPTIONS'
rL244839: Use %env_asan_opts= substitution instead of 'env ASAN_OPTIONS=$ASAN_OPTIONS'
Summary

The lit internal shell is used by default on Windows, and it does not support
bash variable expansion. Because bash variable expansion interacts with
tokenization, it is prohibitively difficult to make the existing lit shell do
general shell variable expansion.

The most common use of shell variables in the asan tests is to add options to
the default set of options set by lit.cfg. We can avoid the need for variable
expansion with a substitution that expands to 'env ASAN_OPTIONS=<defaults:>'.

This has the side benefit of shortening the RUN lines, so it seemed better than
implementing limited variable expansion in lit.

Diff Detail

Repository
rL LLVM

Event Timeline

rnk updated this revision to Diff 31954.Aug 12 2015, 10:03 AM
rnk updated this revision to Diff 31955.
rnk retitled this revision from to Use %env_asan_opts= substitution instead of 'env ASAN_OPTIONS=$ASAN_OPTIONS'.
rnk updated this object.
rnk added reviewers: samsonov, filcab.
rnk added a subscriber: llvm-commits.
  • Revert lsan change
samsonov accepted this revision.Aug 12 2015, 4:21 PM
samsonov edited edge metadata.

LGTM with an important note.

test/asan/lit.cfg
38 ↗(On Diff #31955)

Please make sure ASAN_OPTIONS environment variable is only set on Darwin. On Linux we still want to test the "default configuration", i.e. when there are no extra env variables set at all.

This revision is now accepted and ready to land.Aug 12 2015, 4:21 PM
filcab accepted this revision.Aug 12 2015, 4:31 PM
filcab edited edge metadata.

Thanks! Are you planning on doing this for the other sanitizers?

rnk added a comment.Aug 12 2015, 4:35 PM
In D11982#223341, @filcab wrote:

Thanks! Are you planning on doing this for the other sanitizers?

For every sanitizer that we port to Windows, yes, eventually. It's going to take a while to port tsan and msan, though, so I don't see any reason to make this change now.

Closed by commit rL244839: Use %env_asan_opts= substitution instead of 'env ASAN_OPTIONS=$ASAN_OPTIONS' (authored by rnk). · Explain WhyAug 12 2015, 4:51 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
compiler-rt/
trunk/
test/
asan/
TestCases/
Posix/
2 lines
12 lines
4 lines
8 lines
2 lines
26 lines
6 lines
20 lines
2 lines
2 lines
2 lines
12 lines
12 lines
12 lines
2 lines
2 lines
2 lines
4 lines
16 lines
8 lines
2 lines
16 lines
2 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
6 lines
2 lines
8 lines
8 lines
4 lines
8 lines
10 lines
4 lines
4 lines
4 lines
8 lines
4 lines
4 lines
4 lines
6 lines
4 lines
4 lines
6 lines
4 lines
4 lines
4 lines
8 lines
4 lines
4 lines
4 lines
4 lines
4 lines
8 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
28 lines
28 lines
4 lines
2 lines
2 lines
8 lines

Diff 32004

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

// Check that when the program closed its std(in|out|err), running the external // Check that when the program closed its std(in|out|err), running the external
// symbolizer still works. // symbolizer still works.
// RUN: rm -f %t.log.* // RUN: rm -f %t.log.*
// RUN: %clangxx_asan -O0 %s -o %t 2>&1 && ASAN_OPTIONS=$ASAN_OPTIONS:log_path=%t.log:verbosity=2 not %run %t 2>&1 // RUN: %clangxx_asan -O0 %s -o %t 2>&1 && %env_asan_opts=log_path=%t.log:verbosity=2 not %run %t 2>&1
// RUN: FileCheck %s --check-prefix=CHECK-FILE < %t.log.* // RUN: FileCheck %s --check-prefix=CHECK-FILE < %t.log.*
// FIXME: copy %t.log back from the device and re-enable on Android. // FIXME: copy %t.log back from the device and re-enable on Android.
// UNSUPPORTED: android // UNSUPPORTED: android
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
Show All 20 Lines

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

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

compiler-rt/trunk/test/asan/TestCases/Posix/coverage-maybe-open-file.cc

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

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

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

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

// Check that init-order checking is properly disabled if pthread_create is // Check that init-order checking is properly disabled if pthread_create is
// called. // called.
// RUN: %clangxx_asan -c -DCONFIG1 %s -o %t1.o // RUN: %clangxx_asan -c -DCONFIG1 %s -o %t1.o
// RUN: %clangxx_asan -c %s -o %t2.o // RUN: %clangxx_asan -c %s -o %t2.o
// RUN: %clangxx_asan -pthread %t1.o %t2.o -o %t // RUN: %clangxx_asan -pthread %t1.o %t2.o -o %t
// RUN: env ASAN_OPTIONS=$ASAN_OPTIONS:strict_init_order=true %run %t // RUN: %env_asan_opts=strict_init_order=true %run %t
#ifdef CONFIG1 #ifdef CONFIG1
#include <stdio.h> #include <stdio.h>
#include <pthread.h> #include <pthread.h>
#include <unistd.h> #include <unistd.h>
void *bar(void *input, bool sleep_before_init) { void *bar(void *input, bool sleep_before_init) {
Show All 39 Lines

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Show All 24 Linesdef push_dynamic_library_lookup_path(config, new_path):
new_ld_library_path = os.path.pathsep.join( new_ld_library_path = os.path.pathsep.join(
(new_path, config.environment.get(dynamic_library_lookup_var, ''))) (new_path, config.environment.get(dynamic_library_lookup_var, '')))
config.environment[dynamic_library_lookup_var] = new_ld_library_path config.environment[dynamic_library_lookup_var] = new_ld_library_path
# Setup config name. # Setup config name.
config.name = 'AddressSanitizer' + config.name_suffix config.name = 'AddressSanitizer' + config.name_suffix
# Platform-specific default ASAN_OPTIONS for lit tests. # Platform-specific default ASAN_OPTIONS for lit tests.
default_asan_opts = ''
if config.host_os == 'Darwin': if config.host_os == 'Darwin':
# On Darwin, we default to `abort_on_error=1`, which would make tests run # On Darwin, we default to `abort_on_error=1`, which would make tests run
# much slower. Let's override this and run lit tests with 'abort_on_error=0'. # much slower. Let's override this and run lit tests with 'abort_on_error=0'.
config.environment['ASAN_OPTIONS'] = 'abort_on_error=0' default_asan_opts = 'abort_on_error=0'
if default_asan_opts:
config.environment['ASAN_OPTIONS'] = default_asan_opts
default_asan_opts += ':'
config.substitutions.append(('%env_asan_opts=',
'env ASAN_OPTIONS=' + default_asan_opts))
# Setup source root. # Setup source root.
config.test_source_root = os.path.dirname(__file__) config.test_source_root = os.path.dirname(__file__)
# There is no libdl on FreeBSD. # There is no libdl on FreeBSD.
if config.host_os != 'FreeBSD': if config.host_os != 'FreeBSD':
libdl_flag = "-ldl" libdl_flag = "-ldl"
else: else:
▲ Show 20 Lines • Show All 144 Lines • Show Last 20 Lines