This is an archive of the discontinued LLVM Phabricator instance.

Differential D32131

Allow for setting of global platform-specific lsan options in the test suite
ClosedPublic

Authored by fjricci on Apr 17 2017, 11:21 AM.

Details

Reviewers
kubamracek
alekseyshl
Commits
rGcae98fc8f058: Allow for setting of global platform-specific lsan options in the test suite
rCRT300592: Allow for setting of global platform-specific lsan options in the test suite
rL300592: Allow for setting of global platform-specific lsan options in the test suite

Diff Detail

Event Timeline

fjricci created this revision.Apr 17 2017, 11:21 AM
alekseyshl accepted this revision.Apr 18 2017, 1:53 PM
This revision is now accepted and ready to land.Apr 18 2017, 1:53 PM
Closed by commit rL300592: Allow for setting of global platform-specific lsan options in the test suite (authored by fjricci). · Explain WhyApr 18 2017, 2:09 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

Diff 95462

test/lsan/TestCases/Linux/cleanup_in_tsd_destructor.c

// Regression test for thread lifetime tracking. Thread data should be // Regression test for thread lifetime tracking. Thread data should be
// considered live during the thread's termination, at least until the // considered live during the thread's termination, at least until the
// user-installed TSD destructors have finished running (since they may contain // user-installed TSD destructors have finished running (since they may contain
// additional cleanup tasks). LSan doesn't actually meet that goal 100%, but it // additional cleanup tasks). LSan doesn't actually meet that goal 100%, but it
// makes its best effort. // makes its best effort.
// RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0" // RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0"
// RUN: %clang_lsan %s -o %t // RUN: %clang_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:use_tls=1 %run %t // RUN: %env_lsan_opts=$LSAN_BASE:use_tls=1 %run %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:use_tls=0 not %run %t 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE:use_tls=0 not %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "sanitizer/lsan_interface.h" #include "sanitizer/lsan_interface.h"
#include "sanitizer_common/print_address.h" #include "sanitizer_common/print_address.h"
Show All 29 Lines

test/lsan/TestCases/Linux/disabler_in_tsd_destructor.c

// Regression test. Disabler should not depend on TSD validity. // Regression test. Disabler should not depend on TSD validity.
// RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0:use_tls=1:use_ld_allocations=0" // RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0:use_tls=1:use_ld_allocations=0"
// RUN: %clang_lsan %s -o %t // RUN: %clang_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE %run %t // RUN: %env_lsan_opts=$LSAN_BASE %run %t
#include <assert.h> #include <assert.h>
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "sanitizer/lsan_interface.h" #include "sanitizer/lsan_interface.h"
Show All 27 Lines

test/lsan/TestCases/Linux/use_tls_dynamic.cc

// Test that dynamically allocated TLS space is included in the root set. // Test that dynamically allocated TLS space is included in the root set.
// RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_stacks=0:use_registers=0:use_ld_allocations=0" // RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_stacks=0:use_registers=0:use_ld_allocations=0"
// RUN: %clangxx %s -DBUILD_DSO -fPIC -shared -o %t-so.so // RUN: %clangxx %s -DBUILD_DSO -fPIC -shared -o %t-so.so
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=0" not %run %t 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE:"use_tls=0" not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=1" %run %t 2>&1 // RUN: %env_lsan_opts=$LSAN_BASE:"use_tls=1" %run %t 2>&1
// RUN: LSAN_OPTIONS="" %run %t 2>&1 // RUN: %env_lsan_opts="" %run %t 2>&1
// UNSUPPORTED: i386-linux,i686-linux,arm // UNSUPPORTED: i386-linux,i686-linux,arm
#ifndef BUILD_DSO #ifndef BUILD_DSO
#include <assert.h> #include <assert.h>
#include <dlfcn.h> #include <dlfcn.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string> #include <string>
Show All 37 Lines

test/lsan/TestCases/Linux/use_tls_pthread_specific_dynamic.cc

// Test that dynamically allocated thread-specific storage is included in the root set. // Test that dynamically allocated thread-specific storage is included in the root set.
// RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_stacks=0:use_registers=0" // RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=0" not %run %t 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE:"use_tls=0" not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=1" %run %t 2>&1 // RUN: %env_lsan_opts=$LSAN_BASE:"use_tls=1" %run %t 2>&1
// RUN: LSAN_OPTIONS="" %run %t 2>&1 // RUN: %env_lsan_opts="" %run %t 2>&1
#include <assert.h> #include <assert.h>
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "sanitizer_common/print_address.h" #include "sanitizer_common/print_address.h"
// From glibc: this many keys are stored in the thread descriptor directly. // From glibc: this many keys are stored in the thread descriptor directly.
Show All 24 Lines

test/lsan/TestCases/Linux/use_tls_pthread_specific_static.cc

// Test that statically allocated thread-specific storage is included in the root set. // Test that statically allocated thread-specific storage is included in the root set.
// RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_stacks=0:use_registers=0" // RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=0" not %run %t 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE:"use_tls=0" not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=1" %run %t 2>&1 // RUN: %env_lsan_opts=$LSAN_BASE:"use_tls=1" %run %t 2>&1
// RUN: LSAN_OPTIONS="" %run %t 2>&1 // RUN: %env_lsan_opts="" %run %t 2>&1
#include <assert.h> #include <assert.h>
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "sanitizer_common/print_address.h" #include "sanitizer_common/print_address.h"
// From glibc: this many keys are stored in the thread descriptor directly. // From glibc: this many keys are stored in the thread descriptor directly.
Show All 18 Lines

test/lsan/TestCases/Linux/use_tls_static.cc

// Test that statically allocated TLS space is included in the root set. // Test that statically allocated TLS space is included in the root set.
// RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_stacks=0:use_registers=0" // RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=0" not %run %t 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE:"use_tls=0" not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_tls=1" %run %t 2>&1 // RUN: %env_lsan_opts=$LSAN_BASE:"use_tls=1" %run %t 2>&1
// RUN: LSAN_OPTIONS="" %run %t 2>&1 // RUN: %env_lsan_opts="" %run %t 2>&1
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "sanitizer_common/print_address.h" #include "sanitizer_common/print_address.h"
__thread void *tls_var; __thread void *tls_var;
int main() { int main() {
tls_var = malloc(1337); tls_var = malloc(1337);
print_address("Test alloc: ", 1, tls_var); print_address("Test alloc: ", 1, tls_var);
return 0; return 0;
} }
// CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]] // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
// CHECK: LeakSanitizer: detected memory leaks // CHECK: LeakSanitizer: detected memory leaks
// CHECK: [[ADDR]] (1337 bytes) // CHECK: [[ADDR]] (1337 bytes)
// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer: // CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:

test/lsan/TestCases/disabler.c

// Test for __lsan_disable() / __lsan_enable(). // Test for __lsan_disable() / __lsan_enable().
// RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0:use_tls=0" // RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0:use_tls=0"
// RUN: %clang_lsan %s -o %t // RUN: %clang_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE not %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "sanitizer/lsan_interface.h" #include "sanitizer/lsan_interface.h"
int main() { int main() {
void **p; void **p;
Show All 12 Lines

test/lsan/TestCases/disabler.cc

// Test for ScopedDisabler. // Test for ScopedDisabler.
// RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_registers=0:use_stacks=0:use_globals=0:use_tls=0" // RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_registers=0:use_stacks=0:use_globals=0:use_tls=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE not %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "sanitizer/lsan_interface.h" #include "sanitizer/lsan_interface.h"
int main() { int main() {
void **p; void **p;
Show All 13 Lines

test/lsan/TestCases/do_leak_check_override.cc

// Test for __lsan_do_leak_check(). We test it by making the leak check run // Test for __lsan_do_leak_check(). We test it by making the leak check run
// before global destructors, which also tests compatibility with HeapChecker's // before global destructors, which also tests compatibility with HeapChecker's
// "normal" mode (LSan runs in "strict" mode by default). // "normal" mode (LSan runs in "strict" mode by default).
// RUN: LSAN_BASE="detect_leaks=1:use_stacks=0:use_registers=0" // RUN: LSAN_BASE="detect_leaks=1:use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck --check-prefix=CHECK-strict %s // RUN: %env_lsan_opts=$LSAN_BASE not %run %t 2>&1 | FileCheck --check-prefix=CHECK-strict %s
// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t foo 2>&1 | FileCheck --check-prefix=CHECK-normal %s // RUN: %env_lsan_opts=$LSAN_BASE not %run %t foo 2>&1 | FileCheck --check-prefix=CHECK-normal %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <sanitizer/lsan_interface.h> #include <sanitizer/lsan_interface.h>
struct LeakyGlobal { struct LeakyGlobal {
LeakyGlobal() { LeakyGlobal() {
p = malloc(1337); p = malloc(1337);
Show All 21 Lines

test/lsan/TestCases/high_allocator_contention.cc

// A benchmark that executes malloc/free pairs in parallel. // A benchmark that executes malloc/free pairs in parallel.
// Usage: ./a.out number_of_threads total_number_of_allocations // Usage: ./a.out number_of_threads total_number_of_allocations
// RUN: LSAN_BASE="detect_leaks=1:use_ld_allocations=0" // RUN: LSAN_BASE="detect_leaks=1:use_ld_allocations=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE %run %t 5 1000000 2>&1 // RUN: %env_lsan_opts=$LSAN_BASE %run %t 5 1000000 2>&1
#include <assert.h> #include <assert.h>
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
int num_threads; int num_threads;
int total_num_alloc; int total_num_alloc;
const int kMaxNumThreads = 5000; const int kMaxNumThreads = 5000;
Show All 36 Lines

test/lsan/TestCases/ignore_object.c

// Test for __lsan_ignore_object(). // Test for __lsan_ignore_object().
// RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0:use_tls=0" // RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0:use_tls=0"
// RUN: %clang_lsan %s -o %t // RUN: %clang_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE not %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "sanitizer/lsan_interface.h" #include "sanitizer/lsan_interface.h"
int main() { int main() {
// Explicitly ignored object. // Explicitly ignored object.
Show All 11 Lines

test/lsan/TestCases/ignore_object_errors.cc

// Test for incorrect use of __lsan_ignore_object(). // Test for incorrect use of __lsan_ignore_object().
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE %run %t 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "sanitizer/lsan_interface.h" #include "sanitizer/lsan_interface.h"
int main() { int main() {
void *p = malloc(1337); void *p = malloc(1337);
Show All 9 Lines

test/lsan/TestCases/large_allocation_leak.cc

// Test that LargeMmapAllocator's chunks aren't reachable via some internal data structure. // Test that LargeMmapAllocator's chunks aren't reachable via some internal data structure.
// RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_stacks=0:use_registers=0" // RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE not %run %t 2>&1 | FileCheck %s
// For 32 bit LSan it's pretty likely that large chunks are "reachable" from some // For 32 bit LSan it's pretty likely that large chunks are "reachable" from some
// internal data structures (e.g. Glibc global data). // internal data structures (e.g. Glibc global data).
// UNSUPPORTED: x86, arm // UNSUPPORTED: x86, arm
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "sanitizer_common/print_address.h" #include "sanitizer_common/print_address.h"
Show All 11 Lines

test/lsan/TestCases/leak_check_at_exit.cc

// Test for the leak_check_at_exit flag. // Test for the leak_check_at_exit flag.
// RUN: LSAN_BASE="detect_leaks=1:use_stacks=0:use_registers=0" // RUN: LSAN_BASE="detect_leaks=1:use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-do // RUN: %env_lsan_opts=$LSAN_BASE not %run %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-do
// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-do // RUN: %env_lsan_opts=$LSAN_BASE not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-do
// RUN: LSAN_OPTIONS=$LSAN_BASE:"leak_check_at_exit=0" not %run %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-do // RUN: %env_lsan_opts=$LSAN_BASE:"leak_check_at_exit=0" not %run %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-do
// RUN: LSAN_OPTIONS=$LSAN_BASE:"leak_check_at_exit=0" %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-dont // RUN: %env_lsan_opts=$LSAN_BASE:"leak_check_at_exit=0" %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-dont
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <sanitizer/lsan_interface.h> #include <sanitizer/lsan_interface.h>
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
fprintf(stderr, "Test alloc: %p.\n", malloc(1337)); fprintf(stderr, "Test alloc: %p.\n", malloc(1337));
if (argc > 1) if (argc > 1)
__lsan_do_leak_check(); __lsan_do_leak_check();
return 0; return 0;
} }
// CHECK-do: SUMMARY: {{(Leak|Address)}}Sanitizer: // CHECK-do: SUMMARY: {{(Leak|Address)}}Sanitizer:
// CHECK-dont-NOT: SUMMARY: {{(Leak|Address)}}Sanitizer: // CHECK-dont-NOT: SUMMARY: {{(Leak|Address)}}Sanitizer:

test/lsan/TestCases/leak_check_before_thread_started.cc

// Regression test for http://llvm.org/bugs/show_bug.cgi?id=21621 // Regression test for http://llvm.org/bugs/show_bug.cgi?id=21621
// This test relies on timing between threads, so any failures will be flaky. // This test relies on timing between threads, so any failures will be flaky.
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS="log_pointers=1:log_threads=1" %run %t // RUN: %env_lsan_opts="log_pointers=1:log_threads=1" %run %t
#include <assert.h> #include <assert.h>
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
pthread_cond_t cond = PTHREAD_COND_INITIALIZER; pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
bool flag = false; bool flag = false;
Show All 28 Lines

test/lsan/TestCases/link_turned_off.cc

// Test for disabling LSan at link-time. // Test for disabling LSan at link-time.
// RUN: LSAN_BASE="detect_leaks=1:use_stacks=0:use_registers=0" // RUN: LSAN_BASE="detect_leaks=1:use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE %run %t // RUN: %env_lsan_opts=$LSAN_BASE %run %t
// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t foo 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE not %run %t foo 2>&1 | FileCheck %s
#include <sanitizer/lsan_interface.h> #include <sanitizer/lsan_interface.h>
int argc_copy; int argc_copy;
extern "C" { extern "C" {
int __lsan_is_turned_off() { int __lsan_is_turned_off() {
return (argc_copy == 1); return (argc_copy == 1);
Show All 11 Lines

test/lsan/TestCases/pointer_to_self.cc

// Regression test: pointers to self should not confuse LSan into thinking the // Regression test: pointers to self should not confuse LSan into thinking the
// object is indirectly leaked. Only external pointers count. // object is indirectly leaked. Only external pointers count.
// RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_registers=0" // RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=0" not %run %t 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE:"use_stacks=0" not %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "sanitizer_common/print_address.h" #include "sanitizer_common/print_address.h"
int main() { int main() {
void *p = malloc(1337); void *p = malloc(1337);
*reinterpret_cast<void **>(p) = p; *reinterpret_cast<void **>(p) = p;
print_address("Test alloc: ", 1, p); print_address("Test alloc: ", 1, p);
} }
// CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]] // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
// CHECK: LeakSanitizer: detected memory leaks // CHECK: LeakSanitizer: detected memory leaks
// CHECK: [[ADDR]] (1337 bytes) // CHECK: [[ADDR]] (1337 bytes)
// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer: // CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:

test/lsan/TestCases/print_suppressions.cc

// Print matched suppressions only if print_suppressions=1 AND at least one is // Print matched suppressions only if print_suppressions=1 AND at least one is
// matched. Default is print_suppressions=true. // matched. Default is print_suppressions=true.
// RUN: LSAN_BASE="detect_leaks=1:use_registers=0:use_stacks=0" // RUN: LSAN_BASE="detect_leaks=1:use_registers=0:use_stacks=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:print_suppressions=0 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-dont-print // RUN: %env_lsan_opts=$LSAN_BASE:print_suppressions=0 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-dont-print
// RUN: LSAN_OPTIONS=$LSAN_BASE %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-dont-print // RUN: %env_lsan_opts=$LSAN_BASE %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-dont-print
// RUN: LSAN_OPTIONS=$LSAN_BASE:print_suppressions=0 %run %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-dont-print // RUN: %env_lsan_opts=$LSAN_BASE:print_suppressions=0 %run %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-dont-print
// RUN: LSAN_OPTIONS=$LSAN_BASE %run %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-print // RUN: %env_lsan_opts=$LSAN_BASE %run %t foo 2>&1 | FileCheck %s --check-prefix=CHECK-print
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "sanitizer/lsan_interface.h" #include "sanitizer/lsan_interface.h"
extern "C" extern "C"
const char *__lsan_default_suppressions() { const char *__lsan_default_suppressions() {
Show All 17 Lines

test/lsan/TestCases/recoverable_leak_check.cc

// Test for on-demand leak checking. // Test for on-demand leak checking.
// RUN: LSAN_BASE="detect_leaks=1:use_stacks=0:use_registers=0" // RUN: LSAN_BASE="detect_leaks=1:use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE %run %t foo 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE %run %t foo 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE %run %t 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h> #include <unistd.h>
#include <sanitizer/lsan_interface.h> #include <sanitizer/lsan_interface.h>
void *p; void *p;
Show All 19 Lines

test/lsan/TestCases/register_root_region.cc

// Test for __lsan_(un)register_root_region(). // Test for __lsan_(un)register_root_region().
// RUN: LSAN_BASE="detect_leaks=1:use_stacks=0:use_registers=0" // RUN: LSAN_BASE="detect_leaks=1:use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE %run %t // RUN: %env_lsan_opts=$LSAN_BASE %run %t
// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t foo 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE not %run %t foo 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:use_root_regions=0 not %run %t 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE:use_root_regions=0 not %run %t 2>&1 | FileCheck %s
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <sys/mman.h> #include <sys/mman.h>
#include <unistd.h> #include <unistd.h>
#include <sanitizer/lsan_interface.h> #include <sanitizer/lsan_interface.h>
Show All 18 Lines

test/lsan/TestCases/stale_stack_leak.cc

// Test that out-of-scope local variables are ignored by LSan. // Test that out-of-scope local variables are ignored by LSan.
// RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_registers=0:use_stacks=1" // RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_registers=0:use_stacks=1"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE":exitcode=0" %run %t 2>&1 | FileCheck --check-prefix=CHECK-sanity %s // RUN: %env_lsan_opts=$LSAN_BASE":exitcode=0" %run %t 2>&1 | FileCheck --check-prefix=CHECK-sanity %s
// //
// x86 passes parameters through stack that may lead to false negatives // x86 passes parameters through stack that may lead to false negatives
// UNSUPPORTED: x86 // UNSUPPORTED: x86
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "sanitizer_common/print_address.h" #include "sanitizer_common/print_address.h"
Show All 34 Lines

test/lsan/TestCases/suppressions_default.cc

// RUN: LSAN_BASE="detect_leaks=1:use_registers=0:use_stacks=0" // RUN: LSAN_BASE="detect_leaks=1:use_registers=0:use_stacks=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE not %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "sanitizer/lsan_interface.h" #include "sanitizer/lsan_interface.h"
extern "C" extern "C"
const char *__lsan_default_suppressions() { const char *__lsan_default_suppressions() {
Show All 17 Lines

test/lsan/TestCases/suppressions_file.cc

// RUN: LSAN_BASE="detect_leaks=1:use_registers=0:use_stacks=0" // RUN: LSAN_BASE="detect_leaks=1:use_registers=0:use_stacks=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: rm -f %t.supp // RUN: rm -f %t.supp
// RUN: touch %t.supp // RUN: touch %t.supp
// RUN: LSAN_OPTIONS="$LSAN_BASE:suppressions='%t.supp'" not %run %t 2>&1 | FileCheck %s --check-prefix=NOSUPP // RUN: %env_lsan_opts="$LSAN_BASE:suppressions='%t.supp'" not %run %t 2>&1 | FileCheck %s --check-prefix=NOSUPP
// RUN: echo "leak:*LSanTestLeakingFunc*" > %t.supp // RUN: echo "leak:*LSanTestLeakingFunc*" > %t.supp
// RUN: LSAN_OPTIONS="$LSAN_BASE:suppressions='%t.supp'" not %run %t 2>&1 | FileCheck %s // RUN: %env_lsan_opts="$LSAN_BASE:suppressions='%t.supp'" not %run %t 2>&1 | FileCheck %s
// RUN: echo "leak:%t" > %t.supp // RUN: echo "leak:%t" > %t.supp
// RUN: LSAN_OPTIONS="$LSAN_BASE:suppressions='%t.supp':symbolize=false" %run %t // RUN: %env_lsan_opts="$LSAN_BASE:suppressions='%t.supp':symbolize=false" %run %t
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
void LSanTestLeakingFunc() { void LSanTestLeakingFunc() {
void *p = malloc(666); void *p = malloc(666);
fprintf(stderr, "Test alloc: %p.\n", p); fprintf(stderr, "Test alloc: %p.\n", p);
} }
Show All 12 Lines

test/lsan/TestCases/swapcontext.cc

// We can't unwind stack if we're running coroutines on heap-allocated // We can't unwind stack if we're running coroutines on heap-allocated
// memory. Make sure we don't report these leaks. // memory. Make sure we don't report these leaks.
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_BASE="detect_leaks=1" // RUN: LSAN_BASE="detect_leaks=1"
// RUN: LSAN_OPTIONS=$LSAN_BASE %run %t 2>&1 // RUN: %env_lsan_opts=$LSAN_BASE %run %t 2>&1
// RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t foo 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE not %run %t foo 2>&1 | FileCheck %s
// UNSUPPORTED: arm // UNSUPPORTED: arm
#include <stdio.h> #include <stdio.h>
#if defined(__APPLE__) #if defined(__APPLE__)
// Note: ucontext.h is deprecated on OSX, so this test may stop working // Note: ucontext.h is deprecated on OSX, so this test may stop working
// someday. We define _XOPEN_SOURCE to keep using ucontext.h for now. // someday. We define _XOPEN_SOURCE to keep using ucontext.h for now.
#define _XOPEN_SOURCE 1 #define _XOPEN_SOURCE 1
#endif #endif
Show All 34 Lines

test/lsan/TestCases/use_after_return.cc

// Test that fake stack (introduced by ASan's use-after-return mode) is included // Test that fake stack (introduced by ASan's use-after-return mode) is included
// in the root set. // in the root set.
// RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_registers=0" // RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_registers=0"
// RUN: %clangxx_lsan %s -O2 -o %t // RUN: %clangxx_lsan %s -O2 -o %t
// RUN: ASAN_OPTIONS=$ASAN_OPTIONS:detect_stack_use_after_return=1 LSAN_OPTIONS=$LSAN_BASE:"use_stacks=0" not %run %t 2>&1 | FileCheck %s // RUN: ASAN_OPTIONS=$ASAN_OPTIONS:detect_stack_use_after_return=1 %env_lsan_opts=$LSAN_BASE:"use_stacks=0" not %run %t 2>&1 | FileCheck %s
// RUN: ASAN_OPTIONS=$ASAN_OPTIONS:detect_stack_use_after_return=1 LSAN_OPTIONS=$LSAN_BASE:"use_stacks=1" %run %t 2>&1 // RUN: ASAN_OPTIONS=$ASAN_OPTIONS:detect_stack_use_after_return=1 %env_lsan_opts=$LSAN_BASE:"use_stacks=1" %run %t 2>&1
// RUN: ASAN_OPTIONS=$ASAN_OPTIONS:detect_stack_use_after_return=1 LSAN_OPTIONS="" %run %t 2>&1 // RUN: ASAN_OPTIONS=$ASAN_OPTIONS:detect_stack_use_after_return=1 %env_lsan_opts="" %run %t 2>&1
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "sanitizer_common/print_address.h" #include "sanitizer_common/print_address.h"
int main() { int main() {
void *stack_var = malloc(1337); void *stack_var = malloc(1337);
print_address("Test alloc: ", 1, stack_var); print_address("Test alloc: ", 1, stack_var);
Show All 9 Lines

test/lsan/TestCases/use_globals_initialized.cc

// Test that initialized globals are included in the root set. // Test that initialized globals are included in the root set.
// RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_stacks=0:use_registers=0" // RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_globals=0" not %run %t 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE:"use_globals=0" not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_globals=1" %run %t 2>&1 // RUN: %env_lsan_opts=$LSAN_BASE:"use_globals=1" %run %t 2>&1
// RUN: LSAN_OPTIONS="" %run %t 2>&1 // RUN: %env_lsan_opts="" %run %t 2>&1
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "sanitizer_common/print_address.h" #include "sanitizer_common/print_address.h"
void *data_var = (void *)1; void *data_var = (void *)1;
int main() { int main() {
data_var = malloc(1337); data_var = malloc(1337);
print_address("Test alloc: ", 1, data_var); print_address("Test alloc: ", 1, data_var);
return 0; return 0;
} }
// CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]] // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
// CHECK: LeakSanitizer: detected memory leaks // CHECK: LeakSanitizer: detected memory leaks
// CHECK: [[ADDR]] (1337 bytes) // CHECK: [[ADDR]] (1337 bytes)
// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer: // CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:

test/lsan/TestCases/use_globals_uninitialized.cc

// Test that uninitialized globals are included in the root set. // Test that uninitialized globals are included in the root set.
// RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_stacks=0:use_registers=0" // RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_globals=0" not %run %t 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE:"use_globals=0" not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_globals=1" %run %t 2>&1 // RUN: %env_lsan_opts=$LSAN_BASE:"use_globals=1" %run %t 2>&1
// RUN: LSAN_OPTIONS="" %run %t 2>&1 // RUN: %env_lsan_opts="" %run %t 2>&1
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "sanitizer_common/print_address.h" #include "sanitizer_common/print_address.h"
void *bss_var; void *bss_var;
int main() { int main() {
bss_var = malloc(1337); bss_var = malloc(1337);
print_address("Test alloc: ", 1, bss_var); print_address("Test alloc: ", 1, bss_var);
return 0; return 0;
} }
// CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]] // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
// CHECK: LeakSanitizer: detected memory leaks // CHECK: LeakSanitizer: detected memory leaks
// CHECK: [[ADDR]] (1337 bytes) // CHECK: [[ADDR]] (1337 bytes)
// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer: // CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:

test/lsan/TestCases/use_poisoned_asan.cc

// ASan-poisoned memory should be ignored if use_poisoned is false. // ASan-poisoned memory should be ignored if use_poisoned is false.
// REQUIRES: asan // REQUIRES: asan
// RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_stacks=0:use_registers=0" // RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_poisoned=0" not %run %t 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE:"use_poisoned=0" not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_poisoned=1" %run %t 2>&1 // RUN: %env_lsan_opts=$LSAN_BASE:"use_poisoned=1" %run %t 2>&1
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <sanitizer/asan_interface.h> #include <sanitizer/asan_interface.h>
#include <assert.h> #include <assert.h>
#include "sanitizer_common/print_address.h" #include "sanitizer_common/print_address.h"
void **p; void **p;
Show All 12 Lines

test/lsan/TestCases/use_registers.cc

// Test that registers of running threads are included in the root set. // Test that registers of running threads are included in the root set.
// RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_stacks=0" // RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_stacks=0"
// RUN: %clangxx_lsan -pthread %s -o %t // RUN: %clangxx_lsan -pthread %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_registers=0" not %run %t 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE:"use_registers=0" not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_registers=1" %run %t 2>&1 // RUN: %env_lsan_opts=$LSAN_BASE:"use_registers=1" %run %t 2>&1
// RUN: LSAN_OPTIONS="" %run %t 2>&1 // RUN: %env_lsan_opts="" %run %t 2>&1
#include <assert.h> #include <assert.h>
#include <pthread.h> #include <pthread.h>
#include <sched.h> #include <sched.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "sanitizer_common/print_address.h" #include "sanitizer_common/print_address.h"
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

test/lsan/TestCases/use_stacks.cc

// Test that stack of main thread is included in the root set. // Test that stack of main thread is included in the root set.
// RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_registers=0" // RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=0" not %run %t 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE:"use_stacks=0" not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_stacks=1" %run %t 2>&1 // RUN: %env_lsan_opts=$LSAN_BASE:"use_stacks=1" %run %t 2>&1
// RUN: LSAN_OPTIONS="" %run %t 2>&1 // RUN: %env_lsan_opts="" %run %t 2>&1
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "sanitizer_common/print_address.h" #include "sanitizer_common/print_address.h"
int main() { int main() {
void *stack_var = malloc(1337); void *stack_var = malloc(1337);
print_address("Test alloc: ", 1, stack_var); print_address("Test alloc: ", 1, stack_var);
// Do not return from main to prevent the pointer from going out of scope. // Do not return from main to prevent the pointer from going out of scope.
exit(0); exit(0);
} }
// CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]] // CHECK: Test alloc: [[ADDR:0x[0-9,a-f]+]]
// CHECK: LeakSanitizer: detected memory leaks // CHECK: LeakSanitizer: detected memory leaks
// CHECK: [[ADDR]] (1337 bytes) // CHECK: [[ADDR]] (1337 bytes)
// CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer: // CHECK: SUMMARY: {{(Leak|Address)}}Sanitizer:

test/lsan/TestCases/use_stacks_threaded.cc

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

test/lsan/TestCases/use_unaligned.cc

// Test that unaligned pointers are detected correctly. // Test that unaligned pointers are detected correctly.
// RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_stacks=0:use_registers=0" // RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_stacks=0:use_registers=0"
// RUN: %clangxx_lsan %s -o %t // RUN: %clangxx_lsan %s -o %t
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_unaligned=0" not %run %t 2>&1 | FileCheck %s // RUN: %env_lsan_opts=$LSAN_BASE:"use_unaligned=0" not %run %t 2>&1 | FileCheck %s
// RUN: LSAN_OPTIONS=$LSAN_BASE:"use_unaligned=1" %run %t 2>&1 // RUN: %env_lsan_opts=$LSAN_BASE:"use_unaligned=1" %run %t 2>&1
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include "sanitizer_common/print_address.h" #include "sanitizer_common/print_address.h"
void *arr[2]; void *arr[2];
Show All 11 Lines

test/lsan/lit.common.cfg

Show All 26 Lines
elif lsan_lit_test_mode == "AddressSanitizer": elif lsan_lit_test_mode == "AddressSanitizer":
config.name = "LeakSanitizer-AddressSanitizer" config.name = "LeakSanitizer-AddressSanitizer"
lsan_cflags = ["-fsanitize=address"] lsan_cflags = ["-fsanitize=address"]
config.available_features.add('asan') config.available_features.add('asan')
else: else:
lit_config.fatal("Unknown LSan test mode: %r" % lsan_lit_test_mode) lit_config.fatal("Unknown LSan test mode: %r" % lsan_lit_test_mode)
config.name += config.name_suffix config.name += config.name_suffix
# Platform-specific default LSAN_OPTIONS for lit tests.
default_lsan_opts = ''
if default_lsan_opts:
config.environment['LSAN_OPTIONS'] = default_lsan_opts
default_lsan_opts += ':'
config.substitutions.append(('%env_lsan_opts=',
'env LSAN_OPTIONS=' + default_lsan_opts))
if lit.util.which('strace'): if lit.util.which('strace'):
config.available_features.add('strace') config.available_features.add('strace')
clang_cflags = ["-O0", config.target_cflags] + config.debug_info_flags clang_cflags = ["-O0", config.target_cflags] + config.debug_info_flags
clang_cxxflags = config.cxx_mode_flags + clang_cflags clang_cxxflags = config.cxx_mode_flags + clang_cflags
lsan_incdir = config.test_source_root + "/../" lsan_incdir = config.test_source_root + "/../"
clang_lsan_cflags = clang_cflags + lsan_cflags + ["-I%s" % lsan_incdir] clang_lsan_cflags = clang_cflags + lsan_cflags + ["-I%s" % lsan_incdir]
clang_lsan_cxxflags = clang_cxxflags + lsan_cflags + ["-I%s" % lsan_incdir] clang_lsan_cxxflags = clang_cxxflags + lsan_cflags + ["-I%s" % lsan_incdir]
Show All 21 Lines