This is an archive of the discontinued LLVM Phabricator instance.

Differential D147057

[compiler-rt][asan][test] Fix lit test config on MinGW
ClosedPublic

Authored by alvinhochun on Mar 28 2023, 9:18 AM.

Details

Reviewers
mstorsjo
vitalybuka
glider
kcc
Commits
rGbae2fbaebf25: [compiler-rt][asan][test] Fix lit test config on MinGW
Summary

MinGW is GCC-like and does not support clang-cl, so clean up the lit cfg
to reflect that. Also mark all Windows test cases using clang-cl as
UNSUPPORTED for now. We should probably adapt most of these test cases
to use the GCC-like clang driver, but that will be for later.

Diff Detail

Event Timeline

alvinhochun created this revision.Mar 28 2023, 9:18 AM
Herald added a project: Restricted Project. · View Herald TranscriptMar 28 2023, 9:18 AM
Herald added subscribers: Enna1, dberris. · View Herald Transcript
alvinhochun requested review of this revision.Mar 28 2023, 9:18 AM
Herald added a project: Restricted Project. · View Herald TranscriptMar 28 2023, 9:18 AM
Herald added a subscriber: Restricted Project. · View Herald Transcript
alvinhochun added a child revision: D147059: [asan][test] Fix tests or mark XFAIL for MinGW target.Mar 28 2023, 9:22 AM
Harbormaster completed remote builds in B222274: Diff 509043.Mar 28 2023, 9:42 AM
mstorsjo accepted this revision.Mar 28 2023, 1:14 PM
mstorsjo added a subscriber: llvm-commits.

Looks reasonable overall I think, nothing to object to from my point of view, just a few minor comments.. The patch is a bit unwieldy with the number of tests marked as unsupported, but I guess it's as good as it will be. If we're only touching tests that use specifically clang_cl_* to build/run, the mass editing probably is ok.

compiler-rt/test/asan/lit.cfg.py
109

Side note; since Clang 16.0.0 (fda44bedd64dbcde1b54432d99ad2f0fca0ad204) there's a new option in the GCC-style driver that does the same as /MD - -fms-runtime-lib=dll. So if/when we can assume Clang >= 16 here, we could simplify this line.

150

The RE match expression gets repeated quite a lot - is there any existing pattern for storing such things in a variable within asan (maybe for tests for other targets)?

This revision is now accepted and ready to land.Mar 28 2023, 1:14 PM
alvinhochun added inline comments.Mar 29 2023, 12:57 AM
compiler-rt/test/asan/lit.cfg.py
150

If you mean only in lit.cfg.py and lit.common.cfg.py, I guess it wouldn't hurt to use a local variable. By the way I am considering changing this check to detect msvc target instead of "not gnu".

If you mean for the UNSUPPORTED: tag in tests, I think the intended way to check for target is with the regex judging from 38e9660eaa3478b003cbc48cb4ed0adcf22e053a.

mstorsjo added inline comments.Mar 29 2023, 1:01 AM
compiler-rt/test/asan/lit.cfg.py
150

Yeah, I meant in the lit python scripts. Changing it to positively check for msvc instead of excluding gnu probably makes the logic clearer, so that sounds good!

alvinhochun updated this revision to Diff 509260.Mar 29 2023, 2:09 AM

Update msvc target check in lit python scripts

Harbormaster completed remote builds in B222446: Diff 509260.Mar 29 2023, 2:17 AM
Closed by commit rGbae2fbaebf25: [compiler-rt][asan][test] Fix lit test config on MinGW (authored by alvinhochun). · Explain WhyApr 1 2023, 10:06 AM
This revision was automatically updated to reflect the committed changes.
alvinhochun added a commit: rGbae2fbaebf25: [compiler-rt][asan][test] Fix lit test config on MinGW.

Revision Contents

PathSize
compiler-rt/
test/
asan/
TestCases/
Windows/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
1 line
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
10 lines
16 lines

Diff 510245

compiler-rt/test/asan/TestCases/Windows/aligned_mallocs.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %run %t // RUN: %run %t
#include <windows.h> #include <windows.h>
#define CHECK_ALIGNED(ptr,alignment) \ #define CHECK_ALIGNED(ptr,alignment) \
do { \ do { \
if (((uintptr_t)(ptr) % (alignment)) != 0) \ if (((uintptr_t)(ptr) % (alignment)) != 0) \
Show All 21 Lines

compiler-rt/test/asan/TestCases/Windows/allocators_sanity.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %run %t | FileCheck %s // RUN: %run %t | FileCheck %s
#include <malloc.h> #include <malloc.h>
#include <stdio.h> #include <stdio.h>
int main() { int main() {
int *p = (int*)malloc(1024 * sizeof(int)); int *p = (int*)malloc(1024 * sizeof(int));
Show All 29 Lines

compiler-rt/test/asan/TestCases/Windows/beginthreadex.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %run %t // RUN: %run %t
#include <windows.h> #include <windows.h>
#include <process.h> #include <process.h>
unsigned WINAPI thread_proc(void *) { unsigned WINAPI thread_proc(void *) {
volatile char stack_buffer[42]; volatile char stack_buffer[42];
Show All 13 Lines

compiler-rt/test/asan/TestCases/Windows/bitfield.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %run %t // RUN: %run %t
#include <windows.h> #include <windows.h>
typedef struct _S { typedef struct _S {
unsigned int bf1:1; unsigned int bf1:1;
unsigned int bf2:2; unsigned int bf2:2;
Show All 13 Lines

compiler-rt/test/asan/TestCases/Windows/bitfield_uaf.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <windows.h> #include <windows.h>
typedef struct _S { typedef struct _S {
unsigned int bf1:1; unsigned int bf1:1;
unsigned int bf2:2; unsigned int bf2:2;
Show All 26 Lines

compiler-rt/test/asan/TestCases/Windows/breakpoint.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %env_asan_opts=handle_sigill=1 not %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=handle_sigill=1 not %run %t 2>&1 | FileCheck %s
// Test the error output from a breakpoint. Assertion-like macros often end in // Test the error output from a breakpoint. Assertion-like macros often end in
// int3 on Windows. // int3 on Windows.
#include <stdio.h> #include <stdio.h>
Show All 10 Lines

compiler-rt/test/asan/TestCases/Windows/calloc_left_oob.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <malloc.h> #include <malloc.h>
int main() { int main() {
int *buffer = (int*)calloc(42, sizeof(int)); int *buffer = (int*)calloc(42, sizeof(int));
buffer[-1] = 42; buffer[-1] = 42;
Show All 9 Lines

compiler-rt/test/asan/TestCases/Windows/calloc_right_oob.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <malloc.h> #include <malloc.h>
int main() { int main() {
int *buffer = (int*)calloc(42, sizeof(int)); int *buffer = (int*)calloc(42, sizeof(int));
buffer[42] = 42; buffer[42] = 42;
Show All 9 Lines

compiler-rt/test/asan/TestCases/Windows/calloc_uaf.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <malloc.h> #include <malloc.h>
int main() { int main() {
int *buffer = (int*)calloc(42, sizeof(int)); int *buffer = (int*)calloc(42, sizeof(int));
free(buffer); free(buffer);
Show All 12 Lines

compiler-rt/test/asan/TestCases/Windows/coverage-dll-stdio.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// Test that coverage and MSVC CRT stdio work from a DLL. This ensures that the // Test that coverage and MSVC CRT stdio work from a DLL. This ensures that the
// __local_stdio_printf_options function isn't instrumented for coverage. // __local_stdio_printf_options function isn't instrumented for coverage.
// RUN: rm -rf %t && mkdir %t && cd %t // RUN: rm -rf %t && mkdir %t && cd %t
// RUN: %clang_cl_asan -fsanitize-coverage=func,trace-pc-guard -Od %p/dll_host.cpp -Fet.exe // RUN: %clang_cl_asan -fsanitize-coverage=func,trace-pc-guard -Od %p/dll_host.cpp -Fet.exe
// RUN: %clang_cl_asan -fsanitize-coverage=func,trace-pc-guard -LD -Od %s -Fet.dll // RUN: %clang_cl_asan -fsanitize-coverage=func,trace-pc-guard -LD -Od %s -Fet.dll
// RUN: %run ./t.exe t.dll 2>&1 | FileCheck %s // RUN: %run ./t.exe t.dll 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
extern "C" __declspec(dllexport) extern "C" __declspec(dllexport)
int test_function() { int test_function() {
printf("hello world\n"); printf("hello world\n");
// CHECK: hello world // CHECK: hello world
return 0; return 0;
} }

compiler-rt/test/asan/TestCases/Windows/crt_initializers.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %run %t | FileCheck %s // RUN: %run %t | FileCheck %s
// This is a test for http://code.google.com/p/address-sanitizer/issues/detail?id=305 // This is a test for http://code.google.com/p/address-sanitizer/issues/detail?id=305
#include <stdio.h> #include <stdio.h>
typedef void (*FPTR)(); typedef void (*FPTR)();
Show All 23 Lines

compiler-rt/test/asan/TestCases/Windows/delay_dbghelp.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// Build an executable with ASan, then extract the DLLs that it depends on. // Build an executable with ASan, then extract the DLLs that it depends on.
// RUN: %clang_cl_asan %s -Fe%t.exe // RUN: %clang_cl_asan %s -Fe%t.exe
// RUN: llvm-readobj --coff-imports %t.exe | grep Name: | sed -e 's/ *Name: *//' > %t // RUN: llvm-readobj --coff-imports %t.exe | grep Name: | sed -e 's/ *Name: *//' > %t
// //
// Make sure the binary doesn't depend on dbghelp directly. // Make sure the binary doesn't depend on dbghelp directly.
// RUN: not grep dbghelp.dll %t // RUN: not grep dbghelp.dll %t
// //
// Make sure any clang_rt DLLs it depends on don't depend on dbghelp. In the // Make sure any clang_rt DLLs it depends on don't depend on dbghelp. In the
Show All 10 Lines

compiler-rt/test/asan/TestCases/Windows/demangled_names.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
// //
// This test makes sure ASan symbolizes stack traces the way they are typically // This test makes sure ASan symbolizes stack traces the way they are typically
// symbolized on Windows. // symbolized on Windows.
#include <malloc.h> #include <malloc.h>
namespace foo { namespace foo {
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

compiler-rt/test/asan/TestCases/Windows/dll_aligned_mallocs.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll // RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
// RUN: %run %t %t.dll | FileCheck %s // RUN: %run %t %t.dll | FileCheck %s
#include <malloc.h> #include <malloc.h>
#include <stdio.h> #include <stdio.h>
#define CHECK_ALIGNED(ptr,alignment) \ #define CHECK_ALIGNED(ptr,alignment) \
Show All 26 Lines

compiler-rt/test/asan/TestCases/Windows/dll_allocators_sanity.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll // RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
// RUN: %run %t %t.dll | FileCheck %s // RUN: %run %t %t.dll | FileCheck %s
#include <malloc.h> #include <malloc.h>
#include <stdio.h> #include <stdio.h>
extern "C" __declspec(dllexport) extern "C" __declspec(dllexport)
Show All 31 Lines

compiler-rt/test/asan/TestCases/Windows/dll_and_lib.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// Just make sure we can link an implib into another DLL // Just make sure we can link an implib into another DLL
// This used to fail between r212699 and r212814. // This used to fail between r212699 and r212814.
// RUN: %clang_cl_asan -DCONFIG=1 %s -c -Fo%t.1.obj // RUN: %clang_cl_asan -DCONFIG=1 %s -c -Fo%t.1.obj
// RUN: lld-link /nologo /DLL /OUT:%t.1.dll %t.1.obj %asan_dll_thunk // RUN: lld-link /nologo /DLL /OUT:%t.1.dll %t.1.obj %asan_dll_thunk
// RUN: %clang_cl_asan -DCONFIG=2 %s -c -Fo%t.2.obj // RUN: %clang_cl_asan -DCONFIG=2 %s -c -Fo%t.2.obj
// RUN: lld-link /nologo /DLL /OUT:%t.2.dll %t.2.obj %t.1.lib %asan_dll_thunk // RUN: lld-link /nologo /DLL /OUT:%t.2.dll %t.2.obj %t.1.lib %asan_dll_thunk
// REQUIRES: asan-static-runtime // REQUIRES: asan-static-runtime
// REQUIRES: lld-available // REQUIRES: lld-available
Show All 12 Lines

compiler-rt/test/asan/TestCases/Windows/dll_cerr.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll // RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
// RUN: %run %t %t.dll 2>&1 | FileCheck %s // RUN: %run %t %t.dll 2>&1 | FileCheck %s
// Test that it works correctly even with ICF enabled. // Test that it works correctly even with ICF enabled.
// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll -link /OPT:REF /OPT:ICF // RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll -link /OPT:REF /OPT:ICF
// RUN: %run %t %t.dll 2>&1 | FileCheck %s // RUN: %run %t %t.dll 2>&1 | FileCheck %s
Show All 15 Lines

compiler-rt/test/asan/TestCases/Windows/dll_control_c.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
// RUN: %clang_cl_asan -LD -O2 %s -Fe%t.dll // RUN: %clang_cl_asan -LD -O2 %s -Fe%t.dll
// RUNX: %run %t %t.dll 2>&1 | FileCheck %s // RUNX: %run %t %t.dll 2>&1 | FileCheck %s
// Check that ASan does not CHECK fail when SEH is used around a crash from a // Check that ASan does not CHECK fail when SEH is used around a crash from a
// thread injected by control C. // thread injected by control C.
#include <stdio.h> #include <stdio.h>
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

compiler-rt/test/asan/TestCases/Windows/dll_global_dead_strip.c

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
// //
// RUN: %clang_cl_asan /Gw -LD -Od %s -Fe%t.dll // RUN: %clang_cl_asan /Gw -LD -Od %s -Fe%t.dll
// RUN: %env_asan_opts=report_globals=2 %run %t %t.dll 2>&1 | FileCheck %s --check-prefix=NOSTRIP // RUN: %env_asan_opts=report_globals=2 %run %t %t.dll 2>&1 | FileCheck %s --check-prefix=NOSTRIP
// RUN: %clang_cl_asan /Gw -LD -O2 %s -Fe%t.dll -link -opt:ref // RUN: %clang_cl_asan /Gw -LD -O2 %s -Fe%t.dll -link -opt:ref
// RUN: %env_asan_opts=report_globals=2 %run %t %t.dll 2>&1 | FileCheck %s --check-prefix=STRIP // RUN: %env_asan_opts=report_globals=2 %run %t %t.dll 2>&1 | FileCheck %s --check-prefix=STRIP
#include <stdio.h> #include <stdio.h>
Show All 20 Lines

compiler-rt/test/asan/TestCases/Windows/dll_heap_allocation.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl -LD %s -Fe%t.dll -DHEAP_LIBRARY -MD // RUN: %clang_cl -LD %s -Fe%t.dll -DHEAP_LIBRARY -MD
// RUN: %clang_cl %s %t.lib -Fe%t -fsanitize=address -MT // RUN: %clang_cl %s %t.lib -Fe%t -fsanitize=address -MT
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
// Check that ASan does not fail when releasing allocations that occurred within // Check that ASan does not fail when releasing allocations that occurred within
// an uninstrumented DLL. // an uninstrumented DLL.
Show All 22 Lines

compiler-rt/test/asan/TestCases/Windows/dll_host.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// This is a host program for DLL tests. // This is a host program for DLL tests.
// //
// Just make sure we can compile this. // Just make sure we can compile this.
// The actual compile&run sequence is to be done by the DLL tests. // The actual compile&run sequence is to be done by the DLL tests.
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// //
// Get the list of ASan wrappers exported by the main module RTL: // Get the list of ASan wrappers exported by the main module RTL:
// note: The mangling decoration (i.e. @4 )is removed because calling convention // note: The mangling decoration (i.e. @4 )is removed because calling convention
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

compiler-rt/test/asan/TestCases/Windows/dll_intercept_memchr.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll // RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
// RUN: not %run %t %t.dll 2>&1 | FileCheck %s // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
// On windows 64-bit, the memchr function is written in assembly and is not // On windows 64-bit, the memchr function is written in assembly and is not
// hookable with the interception library. There is not enough padding before // hookable with the interception library. There is not enough padding before
// the function and there is a short jump on the second instruction which // the function and there is a short jump on the second instruction which
// doesn't not allow enough space to encode a 64-bit indirect jump. // doesn't not allow enough space to encode a 64-bit indirect jump.
Show All 19 Lines

compiler-rt/test/asan/TestCases/Windows/dll_intercept_memcpy.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
// RUN: %clang_cl_asan -Wno-fortify-source -LD -Od %s -Fe%t.dll // RUN: %clang_cl_asan -Wno-fortify-source -LD -Od %s -Fe%t.dll
// RUN: not %run %t %t.dll 2>&1 | FileCheck %s // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
// Test that it works correctly even with ICF enabled. // Test that it works correctly even with ICF enabled.
// RUN: %clang_cl_asan -Wno-fortify-source -LD -Od %s -Fe%t.dll -link /OPT:REF /OPT:ICF // RUN: %clang_cl_asan -Wno-fortify-source -LD -Od %s -Fe%t.dll -link /OPT:REF /OPT:ICF
// RUN: not %run %t %t.dll 2>&1 | FileCheck %s // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
Show All 24 Lines

compiler-rt/test/asan/TestCases/Windows/dll_intercept_memcpy_indirect.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll // RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
// RUN: not %run %t %t.dll 2>&1 | FileCheck %s // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
void call_memcpy(void* (*f)(void *, const void *, size_t), void call_memcpy(void* (*f)(void *, const void *, size_t),
Show All 26 Lines

compiler-rt/test/asan/TestCases/Windows/dll_intercept_memset.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
// RUN: %clang_cl_asan -Wno-fortify-source -LD -Od %s -Fe%t.dll // RUN: %clang_cl_asan -Wno-fortify-source -LD -Od %s -Fe%t.dll
// RUN: not %run %t %t.dll 2>&1 | FileCheck %s // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
// Test that it works correctly even with ICF enabled. // Test that it works correctly even with ICF enabled.
// RUN: %clang_cl_asan -Wno-fortify-source -LD -Od %s -Fe%t.dll -link /OPT:REF /OPT:ICF // RUN: %clang_cl_asan -Wno-fortify-source -LD -Od %s -Fe%t.dll -link /OPT:REF /OPT:ICF
// RUN: not %run %t %t.dll 2>&1 | FileCheck %s // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
Show All 24 Lines

compiler-rt/test/asan/TestCases/Windows/dll_intercept_strlen.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll // RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
// RUN: not %run %t %t.dll 2>&1 | FileCheck %s // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
extern "C" __declspec(dllexport) extern "C" __declspec(dllexport)
Show All 20 Lines

compiler-rt/test/asan/TestCases/Windows/dll_large_function.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// Make sure we can link a DLL with large functions which would mean // Make sure we can link a DLL with large functions which would mean
// functions such as __asan_loadN and __asan_storeN will be called // functions such as __asan_loadN and __asan_storeN will be called
// from the DLL. We simulate the large function with // from the DLL. We simulate the large function with
// -mllvm -asan-instrumentation-with-call-threshold=0. // -mllvm -asan-instrumentation-with-call-threshold=0.
// RUN: %clang_cl_asan %s -c -Fo%t.obj -mllvm -asan-instrumentation-with-call-threshold=0 // RUN: %clang_cl_asan %s -c -Fo%t.obj -mllvm -asan-instrumentation-with-call-threshold=0
// RUN: lld-link /nologo /DLL /OUT:%t.dll %t.obj %asan_dll_thunk // RUN: lld-link /nologo /DLL /OUT:%t.dll %t.obj %asan_dll_thunk
// REQUIRES: asan-static-runtime // REQUIRES: asan-static-runtime
// REQUIRES: lld-available // REQUIRES: lld-available
void f(long* foo, long* bar) { void f(long* foo, long* bar) {
// One load and one store // One load and one store
*foo = *bar; *foo = *bar;
} }

compiler-rt/test/asan/TestCases/Windows/dll_malloc_left_oob.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll // RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
// RUN: not %run %t %t.dll 2>&1 | FileCheck %s // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
#include <malloc.h> #include <malloc.h>
extern "C" __declspec(dllexport) extern "C" __declspec(dllexport)
int test_function() { int test_function() {
char *buffer = (char*)malloc(42); char *buffer = (char*)malloc(42);
Show All 15 Lines

compiler-rt/test/asan/TestCases/Windows/dll_malloc_uaf.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll // RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
// RUN: not %run %t %t.dll 2>&1 | FileCheck %s // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
#include <malloc.h> #include <malloc.h>
extern "C" __declspec(dllexport) extern "C" __declspec(dllexport)
int test_function() { int test_function() {
Show All 20 Lines

compiler-rt/test/asan/TestCases/Windows/dll_noreturn.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll // RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
// RUN: not %run %t %t.dll 2>&1 | FileCheck %s // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
#include <process.h> #include <process.h>
void noreturn_f() { void noreturn_f() {
int subscript = -1; int subscript = -1;
Show All 20 Lines

compiler-rt/test/asan/TestCases/Windows/dll_null_deref.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll // RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
// RUN: not %run %t %t.dll 2>&1 | FileCheck %s // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
__attribute__((noinline)) __attribute__((noinline))
static void NullDeref(int *ptr) { static void NullDeref(int *ptr) {
// CHECK: ERROR: AddressSanitizer: access-violation on unknown address // CHECK: ERROR: AddressSanitizer: access-violation on unknown address
// CHECK: {{0x0*000.. .*pc 0x.*}} // CHECK: {{0x0*000.. .*pc 0x.*}}
Show All 10 Lines

compiler-rt/test/asan/TestCases/Windows/dll_operator_array_new_left_oob.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll // RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
// RUN: not %run %t %t.dll 2>&1 | FileCheck %s // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
extern "C" __declspec(dllexport) extern "C" __declspec(dllexport)
int test_function() { int test_function() {
char *buffer = new char[42]; char *buffer = new char[42];
buffer[-1] = 42; buffer[-1] = 42;
Show All 17 Lines

compiler-rt/test/asan/TestCases/Windows/dll_operator_array_new_with_dtor_left_oob.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll // RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
// RUN: not %run %t %t.dll 2>&1 | FileCheck %s // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
struct C { struct C {
int x; int x;
~C() {} ~C() {}
}; };
Show All 27 Lines

compiler-rt/test/asan/TestCases/Windows/dll_poison_unpoison.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll // RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
// RUN: not %run %t %t.dll 2>&1 | FileCheck %s // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
#include <sanitizer/asan_interface.h> #include <sanitizer/asan_interface.h>
void should_not_crash(volatile char *c) { void should_not_crash(volatile char *c) {
*c = 42; *c = 42;
Show All 27 Lines

compiler-rt/test/asan/TestCases/Windows/dll_report_globals_symbolization_at_startup.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -LD -Od -DDLL %s -Fe%t.dll // RUN: %clang_cl_asan -LD -Od -DDLL %s -Fe%t.dll
// RUN: %clang_cl_asan -Od -DEXE %s %t.lib -Fe%te.exe // RUN: %clang_cl_asan -Od -DEXE %s %t.lib -Fe%te.exe
// RUN: %env_asan_opts=report_globals=2 %run %te.exe 2>&1 | FileCheck %s // RUN: %env_asan_opts=report_globals=2 %run %te.exe 2>&1 | FileCheck %s
// FIXME: Currently, the MT runtime build crashes on startup due to dbghelp.dll // FIXME: Currently, the MT runtime build crashes on startup due to dbghelp.dll
// initialization failure. // initialization failure.
// REQUIRES: asan-dynamic-runtime // REQUIRES: asan-dynamic-runtime
Show All 32 Lines

compiler-rt/test/asan/TestCases/Windows/dll_seh.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
// //
// Check both -GS and -GS- builds: // Check both -GS and -GS- builds:
// RUN: %clang_cl_asan -GS -LD -Od %s -Fe%t.dll // RUN: %clang_cl_asan -GS -LD -Od %s -Fe%t.dll
// RUN: %run %t %t.dll // RUN: %run %t %t.dll
// //
// RUN: %clang_cl_asan -GS- -LD -Od %s -Fe%t.dll // RUN: %clang_cl_asan -GS- -LD -Od %s -Fe%t.dll
// RUN: %run %t %t.dll // RUN: %run %t %t.dll
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

compiler-rt/test/asan/TestCases/Windows/dll_stack_use_after_return.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll // RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
// RUN: %env_asan_opts=detect_stack_use_after_return=1 not %run %t %t.dll 2>&1 | FileCheck %s // RUN: %env_asan_opts=detect_stack_use_after_return=1 not %run %t %t.dll 2>&1 | FileCheck %s
// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll -fsanitize-address-use-after-return=always // RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll -fsanitize-address-use-after-return=always
// RUN: not %run %t %t.dll 2>&1 | FileCheck %s // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
#include <malloc.h> #include <malloc.h>
Show All 22 Lines

compiler-rt/test/asan/TestCases/Windows/dll_thread_stack_array_left_oob.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll // RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
// RUN: not %run %t %t.dll 2>&1 | FileCheck %s // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
#include <windows.h> #include <windows.h>
#include <malloc.h> #include <malloc.h>
DWORD WINAPI thread_proc(void *context) { DWORD WINAPI thread_proc(void *context) {
Show All 28 Lines

compiler-rt/test/asan/TestCases/Windows/dll_unload.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
#include <stdio.h> #include <stdio.h>
#include <windows.h> #include <windows.h>
// RUN: %clang_cl_asan -LD /Od -DDLL %s -Fe%t.dll // RUN: %clang_cl_asan -LD /Od -DDLL %s -Fe%t.dll
// RUN: %clang_cl /Od -DEXE %s -Fe%te.exe // RUN: %clang_cl /Od -DEXE %s -Fe%te.exe
// RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %te.exe %t.dll 2>&1 | FileCheck %s // RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %te.exe %t.dll 2>&1 | FileCheck %s
// REQUIRES: asan-dynamic-runtime // REQUIRES: asan-dynamic-runtime
// REQUIRES: asan-32-bits // REQUIRES: asan-32-bits
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

compiler-rt/test/asan/TestCases/Windows/double_free.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <malloc.h> #include <malloc.h>
int main() { int main() {
int *x = (int*)malloc(42 * sizeof(int)); int *x = (int*)malloc(42 * sizeof(int));
free(x); free(x);
Show All 13 Lines

compiler-rt/test/asan/TestCases/Windows/double_operator_delete.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <malloc.h> #include <malloc.h>
int main() { int main() {
int *x = new int[42]; int *x = new int[42];
delete [] x; delete [] x;
Show All 17 Lines

compiler-rt/test/asan/TestCases/Windows/global_const_string.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %run %t | FileCheck %s // RUN: %run %t | FileCheck %s
#include <windows.h> #include <windows.h>
#include <stdio.h> #include <stdio.h>
int main(void) { int main(void) {
static const char *foo = "foobarspam"; static const char *foo = "foobarspam";
printf("Global string is `%s`\n", foo); printf("Global string is `%s`\n", foo);
// CHECK: Global string is `foobarspam` // CHECK: Global string is `foobarspam`
return 0; return 0;
} }

compiler-rt/test/asan/TestCases/Windows/global_const_string_oob.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <windows.h> #include <windows.h>
#include <stdio.h> #include <stdio.h>
extern "C" const char *foo = "foobarspam"; extern "C" const char *foo = "foobarspam";
Show All 12 Lines

compiler-rt/test/asan/TestCases/Windows/global_dead_strip.c

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan /Gw /Od %s /Fe%t.exe // RUN: %clang_cl_asan /Gw /Od %s /Fe%t.exe
// RUN: %env_asan_opts=report_globals=2 %t.exe 2>&1 | FileCheck %s --check-prefix=NOSTRIP // RUN: %env_asan_opts=report_globals=2 %t.exe 2>&1 | FileCheck %s --check-prefix=NOSTRIP
// RUN: %clang_cl_asan /Gw /O2 %s /Fe%t.exe -link -opt:ref // RUN: %clang_cl_asan /Gw /O2 %s /Fe%t.exe -link -opt:ref
// RUN: %env_asan_opts=report_globals=2 %t.exe 2>&1 | FileCheck %s --check-prefix=STRIP // RUN: %env_asan_opts=report_globals=2 %t.exe 2>&1 | FileCheck %s --check-prefix=STRIP
#include <stdio.h> #include <stdio.h>
int dead_global = 42; int dead_global = 42;
int live_global = 0; int live_global = 0;
Show All 15 Lines

compiler-rt/test/asan/TestCases/Windows/heapalloc.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// UNSUPPORTED: asan-64-bits // UNSUPPORTED: asan-64-bits
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s
#include <windows.h> #include <windows.h>
int main() { int main() {
char *buffer; char *buffer;
buffer = (char *)HeapAlloc(GetProcessHeap(), 0, 32), buffer = (char *)HeapAlloc(GetProcessHeap(), 0, 32),
buffer[33] = 'a'; buffer[33] = 'a';
// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]] // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
// CHECK: WRITE of size 1 at [[ADDR]] thread T0 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
} }

compiler-rt/test/asan/TestCases/Windows/heapalloc_dll_double_free.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
#include <stdio.h> #include <stdio.h>
#include <windows.h> #include <windows.h>
// RUN: %clang_cl_asan -LD /Od -DDLL %s -Fe%t.dll // RUN: %clang_cl_asan -LD /Od -DDLL %s -Fe%t.dll
// RUN: %clang_cl /Od -DEXE %s -Fe%te.exe // RUN: %clang_cl /Od -DEXE %s -Fe%te.exe
// RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %te.exe %t.dll 2>&1 | FileCheck %s // RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %te.exe %t.dll 2>&1 | FileCheck %s
// REQUIRES: asan-dynamic-runtime // REQUIRES: asan-dynamic-runtime
// REQUIRES: asan-32-bits // REQUIRES: asan-32-bits
Show All 32 Lines

compiler-rt/test/asan/TestCases/Windows/heapalloc_dll_unload_realloc_uaf.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
#include <stdio.h> #include <stdio.h>
#include <windows.h> #include <windows.h>
// RUN: %clang_cl_asan -LD /Od -DDLL %s -Fe%t.dll // RUN: %clang_cl_asan -LD /Od -DDLL %s -Fe%t.dll
// RUN: %clang_cl /Od -DEXE %s -Fe%te.exe // RUN: %clang_cl /Od -DEXE %s -Fe%te.exe
// RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %te.exe %t.dll 2>&1 | FileCheck %s // RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %te.exe %t.dll 2>&1 | FileCheck %s
// REQUIRES: asan-dynamic-runtime // REQUIRES: asan-dynamic-runtime
// REQUIRES: asan-32-bits // REQUIRES: asan-32-bits
Show All 32 Lines

compiler-rt/test/asan/TestCases/Windows/heapalloc_doublefree.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s
// UNSUPPORTED: asan-64-bits // UNSUPPORTED: asan-64-bits
#include <cassert> #include <cassert>
#include <windows.h> #include <windows.h>
int main() { int main() {
void *allocation = HeapAlloc(GetProcessHeap(), 0, 10); void *allocation = HeapAlloc(GetProcessHeap(), 0, 10);
assert(allocation != 0); assert(allocation != 0);
assert(HeapFree(GetProcessHeap(), 0, allocation)); assert(HeapFree(GetProcessHeap(), 0, allocation));
HeapFree(GetProcessHeap(), 0, allocation); //will dump HeapFree(GetProcessHeap(), 0, allocation); //will dump
assert(0 && "HeapFree double free should produce an ASAN dump\n"); assert(0 && "HeapFree double free should produce an ASAN dump\n");
return 0; return 0;
} }
// CHECK: AddressSanitizer: attempting double-free on [[addr:0x[0-9a-fA-F]+]] in thread T0: // CHECK: AddressSanitizer: attempting double-free on [[addr:0x[0-9a-fA-F]+]] in thread T0:

compiler-rt/test/asan/TestCases/Windows/heapalloc_flags_fallback.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
// RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
// UNSUPPORTED: asan-64-bits // UNSUPPORTED: asan-64-bits
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
#include <windows.h> #include <windows.h>
Show All 12 Lines

compiler-rt/test/asan/TestCases/Windows/heapalloc_huge.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %env_asan_opts=allocator_may_return_null=true %run %t // RUN: %env_asan_opts=allocator_may_return_null=true %run %t
// RUN: %env_asan_opts=allocator_may_return_null=true:windows_hook_rtl_allocators=true %run %t // RUN: %env_asan_opts=allocator_may_return_null=true:windows_hook_rtl_allocators=true %run %t
// UNSUPPORTED: asan-64-bits // UNSUPPORTED: asan-64-bits
#include <windows.h> #include <windows.h>
int main() { int main() {
void *nope = HeapAlloc(GetProcessHeap(), 0, ((size_t)0) - 1); void *nope = HeapAlloc(GetProcessHeap(), 0, ((size_t)0) - 1);
return (nope == nullptr) ? 0 : 1; return (nope == nullptr) ? 0 : 1;
} }

compiler-rt/test/asan/TestCases/Windows/heapalloc_rtl_transfer.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
#include "sanitizer\allocator_interface.h" #include "sanitizer\allocator_interface.h"
#include <cassert> #include <cassert>
#include <stdio.h> #include <stdio.h>
#include <windows.h> #include <windows.h>
// RUN: %clang_cl_asan %s -o%t // RUN: %clang_cl_asan %s -o%t
// RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
// UNSUPPORTED: asan-64-bits // UNSUPPORTED: asan-64-bits
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Linesint main() {
} }
printf("Success\n"); printf("Success\n");
} }
// CHECK-NOT: Assertion failed: // CHECK-NOT: Assertion failed:
// CHECK-NOT: AddressSanitizer // CHECK-NOT: AddressSanitizer
// CHECK: Success // CHECK: Success
No newline at end of file No newline at end of file

compiler-rt/test/asan/TestCases/Windows/heapalloc_sanity.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <windows.h> #include <windows.h>
int main() { int main() {
char *buffer; char *buffer;
buffer = (char *)HeapAlloc(GetProcessHeap(), 0, 32), buffer = (char *)HeapAlloc(GetProcessHeap(), 0, 32),
buffer[0] = 'a'; buffer[0] = 'a';
HeapFree(GetProcessHeap(), 0, buffer); HeapFree(GetProcessHeap(), 0, buffer);
puts("Okay"); puts("Okay");
// CHECK: Okay // CHECK: Okay
} }

compiler-rt/test/asan/TestCases/Windows/heapalloc_transfer.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
#include "sanitizer\allocator_interface.h" #include "sanitizer\allocator_interface.h"
#include <cassert> #include <cassert>
#include <stdio.h> #include <stdio.h>
#include <windows.h> #include <windows.h>
// RUN: %clang_cl_asan %s -o%t // RUN: %clang_cl_asan %s -o%t
// RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
// UNSUPPORTED: asan-64-bits // UNSUPPORTED: asan-64-bits
Show All 12 Linesint main() {
alloc = HeapReAlloc(GetProcessHeap(), HEAP_GENERATE_EXCEPTIONS, realloc, 100); alloc = HeapReAlloc(GetProcessHeap(), HEAP_GENERATE_EXCEPTIONS, realloc, 100);
assert(alloc && !__sanitizer_get_ownership(alloc) && HeapValidate(GetProcessHeap(), 0, alloc)); assert(alloc && !__sanitizer_get_ownership(alloc) && HeapValidate(GetProcessHeap(), 0, alloc));
printf("Success\n"); printf("Success\n");
} }
// CHECK-NOT: assert // CHECK-NOT: assert
// CHECK-NOT: AddressSanitizer // CHECK-NOT: AddressSanitizer
// CHECK: Success // CHECK: Success
No newline at end of file No newline at end of file

compiler-rt/test/asan/TestCases/Windows/heapalloc_uaf.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s
// UNSUPPORTED: asan-64-bits // UNSUPPORTED: asan-64-bits
#include <windows.h> #include <windows.h>
int main() { int main() {
char *buffer; char *buffer;
buffer = (char *)HeapAlloc(GetProcessHeap(), 0, 32), buffer = (char *)HeapAlloc(GetProcessHeap(), 0, 32),
HeapFree(GetProcessHeap(), 0, buffer); HeapFree(GetProcessHeap(), 0, buffer);
buffer[0] = 'a'; buffer[0] = 'a';
// CHECK: AddressSanitizer: heap-use-after-free on address [[ADDR:0x[0-9a-f]+]] // CHECK: AddressSanitizer: heap-use-after-free on address [[ADDR:0x[0-9a-f]+]]
// CHECK: WRITE of size 1 at [[ADDR]] thread T0 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
} }

compiler-rt/test/asan/TestCases/Windows/heapalloc_zero_size.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan /Od -o %t %s // RUN: %clang_cl_asan /Od -o %t %s
// RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
// RUN: %env_asan_opts=windows_hook_rtl_allocators=false %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=windows_hook_rtl_allocators=false %run %t 2>&1 | FileCheck %s
// RUN: %clang_cl /Od -o %t %s // RUN: %clang_cl /Od -o %t %s
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
// UNSUPPORTED: asan-64-bits // UNSUPPORTED: asan-64-bits
#include <cassert> #include <cassert>
#include <stdio.h> #include <stdio.h>
Show All 15 Lines

compiler-rt/test/asan/TestCases/Windows/heaprealloc.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s
// UNSUPPORTED: asan-64-bits // UNSUPPORTED: asan-64-bits
#include <stdio.h> #include <stdio.h>
#include <windows.h> #include <windows.h>
int main() { int main() {
char *oldbuf; char *oldbuf;
Show All 15 Lines

compiler-rt/test/asan/TestCases/Windows/heaprealloc_alloc_zero.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan /Od /MT -o %t %s // RUN: %clang_cl_asan /Od /MT -o %t %s
// RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
// UNSUPPORTED: asan-64-bits // UNSUPPORTED: asan-64-bits
#include <cassert> #include <cassert>
#include <iostream> #include <iostream>
#include <windows.h> #include <windows.h>
int main() { int main() {
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Linesint main() {
HeapFree(GetProcessHeap(), 0, ptr3); HeapFree(GetProcessHeap(), 0, ptr3);
return 0; return 0;
} }
// CHECK: allocated! // CHECK: allocated!
// CHECK-NOT: heap-buffer-overflow // CHECK-NOT: heap-buffer-overflow
// CHECK-NOT: AddressSanitizer // CHECK-NOT: AddressSanitizer
// CHECK-NOT: HeapAlloc size failure! // CHECK-NOT: HeapAlloc size failure!
No newline at end of file No newline at end of file

compiler-rt/test/asan/TestCases/Windows/heaprealloc_zero_size.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan /Od -o %t %s // RUN: %clang_cl_asan /Od -o %t %s
// RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
// RUN: %env_asan_opts=windows_hook_rtl_allocators=false %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=windows_hook_rtl_allocators=false %run %t 2>&1 | FileCheck %s
// RUN: %clang_cl /Od -o %t %s // RUN: %clang_cl /Od -o %t %s
// RUN: %run %t 2>&1 | FileCheck %s // RUN: %run %t 2>&1 | FileCheck %s
// UNSUPPORTED: asan-64-bits // UNSUPPORTED: asan-64-bits
#include <cassert> #include <cassert>
#include <stdio.h> #include <stdio.h>
#include<windows.h> #include<windows.h>
int main() { int main() {
HANDLE heap = HeapCreate(0, 0, 0); HANDLE heap = HeapCreate(0, 0, 0);
void *ptr = HeapAlloc(heap, 0, 4); void *ptr = HeapAlloc(heap, 0, 4);
assert(ptr); assert(ptr);
void *ptr2 = HeapReAlloc(heap, 0, ptr, 0); void *ptr2 = HeapReAlloc(heap, 0, ptr, 0);
assert(ptr2); assert(ptr2);
HeapFree(heap, 0, ptr2); HeapFree(heap, 0, ptr2);
fprintf(stderr, "passed!\n"); fprintf(stderr, "passed!\n");
} }
// CHECK-NOT: double-free // CHECK-NOT: double-free
// CHECK-NOT: AddressSanitizer // CHECK-NOT: AddressSanitizer
// CHECK: passed! // CHECK: passed!
No newline at end of file No newline at end of file

compiler-rt/test/asan/TestCases/Windows/hello_world.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %run %t | FileCheck %s // RUN: %run %t | FileCheck %s
#include <stdio.h> #include <stdio.h>
int main() { int main() {
printf("Hello, world!\n"); printf("Hello, world!\n");
// CHECK: Hello, world! // CHECK: Hello, world!
} }

compiler-rt/test/asan/TestCases/Windows/illegal_instruction.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %env_asan_opts=handle_sigill=1 not %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=handle_sigill=1 not %run %t 2>&1 | FileCheck %s
// Test the error output from an illegal instruction. // Test the error output from an illegal instruction.
#include <stdio.h> #include <stdio.h>
int main() { int main() {
Show All 9 Lines

compiler-rt/test/asan/TestCases/Windows/integer_divide_by_zero.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %env_asan_opts=handle_sigfpe=1 not %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=handle_sigfpe=1 not %run %t 2>&1 | FileCheck %s
// Test the error output from dividing by zero. // Test the error output from dividing by zero.
#include <stdio.h> #include <stdio.h>
int main() { int main() {
Show All 10 Lines

compiler-rt/test/asan/TestCases/Windows/intercept_memcpy.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
void call_memcpy(void* (*f)(void *, const void *, size_t), void call_memcpy(void* (*f)(void *, const void *, size_t),
void *a, const void *b, size_t c) { void *a, const void *b, size_t c) {
Show All 23 Lines

compiler-rt/test/asan/TestCases/Windows/intercept_strdup.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <malloc.h> #include <malloc.h>
int main() { int main() {
Show All 24 Lines

compiler-rt/test/asan/TestCases/Windows/intercept_strlen.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
int main() { int main() {
char str[] = "Hello"; char str[] = "Hello";
Show All 19 Lines

compiler-rt/test/asan/TestCases/Windows/interface_symbols_windows.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// Check that the interface exported by asan static lib matches the list of // Check that the interface exported by asan static lib matches the list of
// functions mentioned in sanitizer_interface.inc. // functions mentioned in sanitizer_interface.inc.
// //
// Just make sure we can compile this. // Just make sure we can compile this.
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// //
// note: The mangling decoration (i.e. @4 )is removed because calling convention // note: The mangling decoration (i.e. @4 )is removed because calling convention
// differ from 32-bit and 64-bit. // differ from 32-bit and 64-bit.
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

compiler-rt/test/asan/TestCases/Windows/iostream_sbo.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// First, check this works with the default ignorelist: // First, check this works with the default ignorelist:
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: echo "42" | %run %t 2>&1 | FileCheck %s // RUN: echo "42" | %run %t 2>&1 | FileCheck %s
// //
// Then, make sure it still works when a user uses their own ignorelist file: // Then, make sure it still works when a user uses their own ignorelist file:
// RUN: %clang_cl_asan -Od %s -fsanitize-ignorelist=%p/../Helpers/initialization-ignorelist.txt -Fe%t2 // RUN: %clang_cl_asan -Od %s -fsanitize-ignorelist=%p/../Helpers/initialization-ignorelist.txt -Fe%t2
// RUN: echo "42" | %run %t2 2>&1 | FileCheck %s // RUN: echo "42" | %run %t2 2>&1 | FileCheck %s
Show All 10 Lines

compiler-rt/test/asan/TestCases/Windows/malloc_left_oob.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <malloc.h> #include <malloc.h>
int main() { int main() {
char *buffer = (char*)malloc(42); char *buffer = (char*)malloc(42);
buffer[-1] = 42; buffer[-1] = 42;
Show All 9 Lines

compiler-rt/test/asan/TestCases/Windows/malloc_right_oob.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <malloc.h> #include <malloc.h>
int main() { int main() {
char *buffer = (char*)malloc(42); char *buffer = (char*)malloc(42);
buffer[42] = 42; buffer[42] = 42;
Show All 9 Lines

compiler-rt/test/asan/TestCases/Windows/malloc_uaf.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <malloc.h> #include <malloc.h>
int main() { int main() {
char *buffer = (char*)malloc(42); char *buffer = (char*)malloc(42);
free(buffer); free(buffer);
Show All 12 Lines

compiler-rt/test/asan/TestCases/Windows/null_deref_multiple_dlls.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// Make sure everything works even if the main module doesn't have any stack // Make sure everything works even if the main module doesn't have any stack
// variables, thus doesn't explicitly reference any symbol exported by the // variables, thus doesn't explicitly reference any symbol exported by the
// runtime thunk. // runtime thunk.
// //
// RUN: %clang_cl_asan -LD -Od -DDLL1 %s -Fe%t1.dll // RUN: %clang_cl_asan -LD -Od -DDLL1 %s -Fe%t1.dll
// RUN: %clang_cl_asan -LD -Od -DDLL2 %s -Fe%t2.dll // RUN: %clang_cl_asan -LD -Od -DDLL2 %s -Fe%t2.dll
// RUN: %clang_cl_asan -Od -DEXE %s %t1.lib %t2.lib -Fe%t // RUN: %clang_cl_asan -Od -DEXE %s %t1.lib %t2.lib -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
Show All 32 Lines

compiler-rt/test/asan/TestCases/Windows/oom.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
// REQUIRES: asan-32-bits // REQUIRES: asan-32-bits
#include <malloc.h> #include <malloc.h>
int main() { int main() {
while (true) { while (true) {
void *ptr = malloc(200 * 1024 * 1024); // 200MB void *ptr = malloc(200 * 1024 * 1024); // 200MB
} }
// CHECK: SUMMARY: AddressSanitizer: out-of-memory // CHECK: SUMMARY: AddressSanitizer: out-of-memory
} }

compiler-rt/test/asan/TestCases/Windows/operator_array_new_left_oob.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
int main() { int main() {
char *buffer = new char[42]; char *buffer = new char[42];
buffer[-1] = 42; buffer[-1] = 42;
// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]] // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
// CHECK: WRITE of size 1 at [[ADDR]] thread T0 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
Show All 9 Lines

compiler-rt/test/asan/TestCases/Windows/operator_array_new_right_oob.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <windows.h> #include <windows.h>
int main() { int main() {
char *buffer = new char[42]; char *buffer = new char[42];
buffer[42] = 42; buffer[42] = 42;
Show All 10 Lines

compiler-rt/test/asan/TestCases/Windows/operator_array_new_uaf.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <windows.h> #include <windows.h>
int main() { int main() {
char *buffer = new char[42]; char *buffer = new char[42];
delete [] buffer; delete [] buffer;
Show All 16 Lines

compiler-rt/test/asan/TestCases/Windows/operator_array_new_with_dtor_left_oob.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
struct C { struct C {
int x; int x;
~C() {} ~C() {}
}; };
Show All 19 Lines

compiler-rt/test/asan/TestCases/Windows/operator_delete_wrong_argument.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <windows.h> #include <windows.h>
int main() { int main() {
int *x = new int[42]; int *x = new int[42];
delete (x + 1); delete (x + 1);
// CHECK: AddressSanitizer: attempting free on address which was not malloc()-ed // CHECK: AddressSanitizer: attempting free on address which was not malloc()-ed
// CHECK: {{#0 0x.* operator delete}} // CHECK: {{#0 0x.* operator delete}}
// CHECK: {{#1 .* main .*operator_delete_wrong_argument.cpp}}:[[@LINE-3]] // CHECK: {{#1 .* main .*operator_delete_wrong_argument.cpp}}:[[@LINE-3]]
} }

compiler-rt/test/asan/TestCases/Windows/operator_new_left_oob.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <windows.h> #include <windows.h>
int main() { int main() {
char *buffer = new char; char *buffer = new char;
buffer[-1] = 42; buffer[-1] = 42;
Show All 9 Lines

compiler-rt/test/asan/TestCases/Windows/operator_new_right_oob.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <windows.h> #include <windows.h>
int main() { int main() {
char *buffer = new char; char *buffer = new char;
buffer[1] = 42; buffer[1] = 42;
Show All 9 Lines

compiler-rt/test/asan/TestCases/Windows/operator_new_uaf.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <windows.h> #include <windows.h>
int main() { int main() {
char *buffer = new char; char *buffer = new char;
delete buffer; delete buffer;
Show All 14 Lines

compiler-rt/test/asan/TestCases/Windows/queue_user_work_item_report.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <windows.h> #include <windows.h>
HANDLE done; HANDLE done;
DWORD CALLBACK work_item(LPVOID) { DWORD CALLBACK work_item(LPVOID) {
Show All 19 Lines

compiler-rt/test/asan/TestCases/Windows/realloc_left_oob.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <malloc.h> #include <malloc.h>
int main() { int main() {
char *buffer = (char*)realloc(0, 42); char *buffer = (char*)realloc(0, 42);
buffer[-1] = 42; buffer[-1] = 42;
Show All 9 Lines

compiler-rt/test/asan/TestCases/Windows/realloc_right_oob.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <malloc.h> #include <malloc.h>
int main() { int main() {
char *buffer = (char*)realloc(0, 42); char *buffer = (char*)realloc(0, 42);
buffer[42] = 42; buffer[42] = 42;
Show All 9 Lines

compiler-rt/test/asan/TestCases/Windows/realloc_uaf.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <malloc.h> #include <malloc.h>
int main() { int main() {
char *buffer = (char*)realloc(0, 42); char *buffer = (char*)realloc(0, 42);
free(buffer); free(buffer);
Show All 12 Lines

compiler-rt/test/asan/TestCases/Windows/recalloc_sanity.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// Workaround for "LINK : fatal error LNK1318: Unexpected PDB error" // Workaround for "LINK : fatal error LNK1318: Unexpected PDB error"
// RUN: rm -f %t.pdb // RUN: rm -f %t.pdb
// RUN: %clang_cl_asan %s -o %t.exe // RUN: %clang_cl_asan %s -o %t.exe
// RUN: %run %t.exe 2>&1 | FileCheck %s // RUN: %run %t.exe 2>&1 | FileCheck %s
// RUN: %clang_cl %s -o %t.exe // RUN: %clang_cl %s -o %t.exe
// RUN: %run %t.exe 2>&1 | FileCheck %s // RUN: %run %t.exe 2>&1 | FileCheck %s
Show All 24 Lines for (int i = 100; i < 200; i++) {
assert(((BYTE *)nnnp)[i] == 0); assert(((BYTE *)nnnp)[i] == 0);
} }
fprintf(stderr, "passed\n"); fprintf(stderr, "passed\n");
return 0; return 0;
} }
// CHECK-NOT: Assertion // CHECK-NOT: Assertion
// CHECK: passed // CHECK: passed
No newline at end of file No newline at end of file

compiler-rt/test/asan/TestCases/Windows/report_globals_reload_dll.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// Make sure we can handle reloading the same DLL multiple times. // Make sure we can handle reloading the same DLL multiple times.
// RUN: %clang_cl_asan -LD -Od -DDLL %s -Fe%t.dll // RUN: %clang_cl_asan -LD -Od -DDLL %s -Fe%t.dll
// RUN: %clang_cl_asan -Od -DEXE %s -Fe%te.exe // RUN: %clang_cl_asan -Od -DEXE %s -Fe%te.exe
// RUN: %env_asan_opts=report_globals=1 %run %te.exe %t.dll 2>&1 | FileCheck %s // RUN: %env_asan_opts=report_globals=1 %run %te.exe %t.dll 2>&1 | FileCheck %s
#include <windows.h> #include <windows.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

compiler-rt/test/asan/TestCases/Windows/report_globals_vs_freelibrary.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -LD -Od -DDLL %s -Fe%t.dll // RUN: %clang_cl_asan -LD -Od -DDLL %s -Fe%t.dll
// RUN: %clang_cl_asan -Od -DEXE %s -Fe%te.exe // RUN: %clang_cl_asan -Od -DEXE %s -Fe%te.exe
// RUN: %env_asan_opts=report_globals=2 %run %te.exe %t.dll 2>&1 | FileCheck %s // RUN: %env_asan_opts=report_globals=2 %run %te.exe %t.dll 2>&1 | FileCheck %s
#include <windows.h> #include <windows.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
Show All 39 Lines

compiler-rt/test/asan/TestCases/Windows/rtlallocateheap.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t /MD // RUN: %clang_cl_asan -Od %s -Fe%t /MD
// RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s
// UNSUPPORTED: asan-64-bits // UNSUPPORTED: asan-64-bits
// REQUIRES: asan-rtl-heap-interception // REQUIRES: asan-rtl-heap-interception
#include <stdio.h> #include <stdio.h>
#include <windows.h> #include <windows.h>
Show All 22 Lines

compiler-rt/test/asan/TestCases/Windows/rtlallocateheap_dll_unload_double_free.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -LD /Od -DDLL %s -Fe%t.dll // RUN: %clang_cl_asan -LD /Od -DDLL %s -Fe%t.dll
// RUN: %clang_cl /Od -DEXE %s -Fe%te.exe // RUN: %clang_cl /Od -DEXE %s -Fe%te.exe
// RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %te.exe %t.dll 2>&1 | FileCheck %s // RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %te.exe %t.dll 2>&1 | FileCheck %s
// REQUIRES: asan-dynamic-runtime // REQUIRES: asan-dynamic-runtime
// REQUIRES: asan-32-bits // REQUIRES: asan-32-bits
// REQUIRES: asan-rtl-heap-interception // REQUIRES: asan-rtl-heap-interception
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

compiler-rt/test/asan/TestCases/Windows/rtlallocateheap_dll_unload_realloc.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -LD /Od -DDLL %s -Fe%t.dll // RUN: %clang_cl_asan -LD /Od -DDLL %s -Fe%t.dll
// RUN: %clang_cl /Od -DEXE %s -Fe%te.exe // RUN: %clang_cl /Od -DEXE %s -Fe%te.exe
// RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %te.exe %t.dll 2>&1 | FileCheck %s // RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %te.exe %t.dll 2>&1 | FileCheck %s
// REQUIRES: asan-dynamic-runtime // REQUIRES: asan-dynamic-runtime
// REQUIRES: asan-32-bits // REQUIRES: asan-32-bits
// REQUIRES: asan-rtl-heap-interception // REQUIRES: asan-rtl-heap-interception
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

compiler-rt/test/asan/TestCases/Windows/rtlallocateheap_flags_fallback.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t /MD // RUN: %clang_cl_asan -Od %s -Fe%t /MD
// RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
// UNSUPPORTED: asan-64-bits // UNSUPPORTED: asan-64-bits
// REQUIRES: asan-rtl-heap-interception // REQUIRES: asan-rtl-heap-interception
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
#include <windows.h> #include <windows.h>
Show All 37 Lines

compiler-rt/test/asan/TestCases/Windows/rtlallocateheap_zero.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t /MD // RUN: %clang_cl_asan -Od %s -Fe%t /MD
// RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s
// UNSUPPORTED: asan-64-bits // UNSUPPORTED: asan-64-bits
// REQUIRES: asan-rtl-heap-interception // REQUIRES: asan-rtl-heap-interception
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
#include <windows.h> #include <windows.h>
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

compiler-rt/test/asan/TestCases/Windows/sanitizer_purge.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
#include <Windows.h> #include <Windows.h>
#include <stdio.h> #include <stdio.h>
#include <sanitizer/allocator_interface.h> #include <sanitizer/allocator_interface.h>
#include <psapi.h> #include <psapi.h>
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %t // RUN: %t
// REQUIRES: asan-64-bits // REQUIRES: asan-64-bits
Show All 15 Linesint main(){
size_t rss_post = GetRSS(); size_t rss_post = GetRSS();
if (rss_pre <= rss_post){ if (rss_pre <= rss_post){
return -1; return -1;
} }
return 0; return 0;
} }
No newline at end of file No newline at end of file

compiler-rt/test/asan/TestCases/Windows/seh.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// Make sure that ASan works with SEH in both Clang and MSVC. MSVC uses a // Make sure that ASan works with SEH in both Clang and MSVC. MSVC uses a
// different EH personality depending on the -GS setting, so test both -GS+ and // different EH personality depending on the -GS setting, so test both -GS+ and
// -GS-. // -GS-.
// //
// RUN: cl -c %s -Fo%t.obj -DCOMPILE_SEH // RUN: cl -c %s -Fo%t.obj -DCOMPILE_SEH
// RUN: %clangxx_asan -o %t.exe %s %t.obj // RUN: %clangxx_asan -o %t.exe %s %t.obj
// RUN: %run %t.exe // RUN: %run %t.exe
// //
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

compiler-rt/test/asan/TestCases/Windows/shadow_conflict_32.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// Load this DLL at the default 32-bit ASan shadow base, and test how we dump // Load this DLL at the default 32-bit ASan shadow base, and test how we dump
// the process memory layout. // the process memory layout.
// REQUIRES: asan-32-bits // REQUIRES: asan-32-bits
// //
// RUN: %clang_cl_asan -DBUILD_DLL -LD %s -Fe%t_dll.dll -link -base:0x30000000 -fixed -dynamicbase:no // RUN: %clang_cl_asan -DBUILD_DLL -LD %s -Fe%t_dll.dll -link -base:0x30000000 -fixed -dynamicbase:no
// RUN: %clang_cl_asan %s -Fe%t.exe -link %t_dll.lib // RUN: %clang_cl_asan %s -Fe%t.exe -link %t_dll.lib
// RUN: not %run %t.exe 2>&1 | FileCheck %s // RUN: not %run %t.exe 2>&1 | FileCheck %s
Show All 21 Lines

compiler-rt/test/asan/TestCases/Windows/shadow_mapping_failure.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
// REQUIRES: asan-32-bits // REQUIRES: asan-32-bits
#include <stdio.h> #include <stdio.h>
char bigchunk[1 << 30]; char bigchunk[1 << 30];
Show All 10 Lines

compiler-rt/test/asan/TestCases/Windows/sse_misalignment.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %env_asan_opts=handle_sigfpe=1 not %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=handle_sigfpe=1 not %run %t 2>&1 | FileCheck %s
// Test the error output from misaligned SSE2 memory access. This is a READ // Test the error output from misaligned SSE2 memory access. This is a READ
// memory access. Windows appears to always provide an address of -1 for these // memory access. Windows appears to always provide an address of -1 for these
// types of faults, and there doesn't seem to be a way to distinguish them from // types of faults, and there doesn't seem to be a way to distinguish them from
// other types of access violations without disassembling. // other types of access violations without disassembling.
Show All 20 Lines

compiler-rt/test/asan/TestCases/Windows/stack_array_left_oob.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
int main() { int main() {
int subscript = -1; int subscript = -1;
char buffer[42]; char buffer[42];
buffer[subscript] = 42; buffer[subscript] = 42;
// CHECK: AddressSanitizer: stack-buffer-underflow on address [[ADDR:0x[0-9a-f]+]] // CHECK: AddressSanitizer: stack-buffer-underflow on address [[ADDR:0x[0-9a-f]+]]
// CHECK: WRITE of size 1 at [[ADDR]] thread T0 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
// CHECK-NEXT: {{#0 .* main .*stack_array_left_oob.cpp}}:[[@LINE-3]] // CHECK-NEXT: {{#0 .* main .*stack_array_left_oob.cpp}}:[[@LINE-3]]
// CHECK: Address [[ADDR]] is located in stack of thread T0 at offset [[OFFSET:.*]] in frame // CHECK: Address [[ADDR]] is located in stack of thread T0 at offset [[OFFSET:.*]] in frame
// CHECK-NEXT: {{#0 .* main .*stack_array_left_oob.cpp}} // CHECK-NEXT: {{#0 .* main .*stack_array_left_oob.cpp}}
// CHECK: 'buffer'{{.*}} <== Memory access at offset [[OFFSET]] underflows this variable // CHECK: 'buffer'{{.*}} <== Memory access at offset [[OFFSET]] underflows this variable
} }

compiler-rt/test/asan/TestCases/Windows/stack_array_right_oob.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <stdio.h> #include <stdio.h>
int main() { int main() {
int subscript = 42; int subscript = 42;
char buffer[42]; char buffer[42];
buffer[subscript] = 42; buffer[subscript] = 42;
// CHECK: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]] // CHECK: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
// CHECK: WRITE of size 1 at [[ADDR]] thread T0 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
// CHECK-NEXT: {{#0 .* main .*stack_array_right_oob.cpp}}:[[@LINE-3]] // CHECK-NEXT: {{#0 .* main .*stack_array_right_oob.cpp}}:[[@LINE-3]]
// CHECK: Address [[ADDR]] is located in stack of thread T0 at offset [[OFFSET:.*]] in frame // CHECK: Address [[ADDR]] is located in stack of thread T0 at offset [[OFFSET:.*]] in frame
// CHECK-NEXT: {{#0 .* main .*stack_array_right_oob.cpp}} // CHECK-NEXT: {{#0 .* main .*stack_array_right_oob.cpp}}
// CHECK: 'buffer'{{.*}} <== Memory access at offset [[OFFSET]] overflows this variable // CHECK: 'buffer'{{.*}} <== Memory access at offset [[OFFSET]] overflows this variable
} }

compiler-rt/test/asan/TestCases/Windows/stack_array_sanity.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %run %t | FileCheck %s // RUN: %run %t | FileCheck %s
#include <stdio.h> #include <stdio.h>
int main() { int main() {
int subscript = 1; int subscript = 1;
char buffer[42]; char buffer[42];
buffer[subscript] = 42; buffer[subscript] = 42;
printf("OK\n"); printf("OK\n");
// CHECK: OK // CHECK: OK
} }

compiler-rt/test/asan/TestCases/Windows/stack_use_after_return.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %env_asan_opts=detect_stack_use_after_return=1 not %run %t 2>&1 | FileCheck %s // RUN: %env_asan_opts=detect_stack_use_after_return=1 not %run %t 2>&1 | FileCheck %s
// RUN: %clang_cl_asan -Od %s -Fe%t -fsanitize-address-use-after-return=always // RUN: %clang_cl_asan -Od %s -Fe%t -fsanitize-address-use-after-return=always
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
char *x; char *x;
void foo() { void foo() {
Show All 16 Lines

compiler-rt/test/asan/TestCases/Windows/symbols_path.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// Make sure symbolization works even if the path to the .exe file changes. // Make sure symbolization works even if the path to the .exe file changes.
// RUN: mkdir %t || true // RUN: mkdir %t || true
// RUN: %clang_cl_asan -Od %s -Fe%t/symbols_path.exe // RUN: %clang_cl_asan -Od %s -Fe%t/symbols_path.exe
// RUN: not %run %t/symbols_path.exe 2>&1 | FileCheck %s // RUN: not %run %t/symbols_path.exe 2>&1 | FileCheck %s
// RUN: mkdir %t2 || true // RUN: mkdir %t2 || true
// RUN: mv %t/* %t2 // RUN: mv %t/* %t2
// RUN: not %run %t2/symbols_path.exe 2>&1 | FileCheck %s // RUN: not %run %t2/symbols_path.exe 2>&1 | FileCheck %s
Show All 14 Lines

compiler-rt/test/asan/TestCases/Windows/thread_simple.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %run %t // RUN: %run %t
#include <windows.h> #include <windows.h>
DWORD WINAPI thread_proc(void *) { DWORD WINAPI thread_proc(void *) {
volatile char stack_buffer[42]; volatile char stack_buffer[42];
for (int i = 0; i < sizeof(stack_buffer); ++i) for (int i = 0; i < sizeof(stack_buffer); ++i)
Show All 18 Lines

compiler-rt/test/asan/TestCases/Windows/thread_stack_array_left_oob.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <windows.h> #include <windows.h>
DWORD WINAPI thread_proc(void *) { DWORD WINAPI thread_proc(void *) {
int subscript = -1; int subscript = -1;
volatile char stack_buffer[42]; volatile char stack_buffer[42];
Show All 19 Lines

compiler-rt/test/asan/TestCases/Windows/thread_stack_array_right_oob.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <windows.h> #include <windows.h>
DWORD WINAPI thread_proc(void *) { DWORD WINAPI thread_proc(void *) {
int subscript = 42; int subscript = 42;
volatile char stack_buffer[42]; volatile char stack_buffer[42];
Show All 19 Lines

compiler-rt/test/asan/TestCases/Windows/thread_stack_reuse.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %run %t // RUN: %run %t
#include <windows.h> #include <windows.h>
DWORD WINAPI thread_proc_1(void *) { DWORD WINAPI thread_proc_1(void *) {
volatile int x, y, z; volatile int x, y, z;
x = 1; x = 1;
Show All 29 Lines

compiler-rt/test/asan/TestCases/Windows/thread_stress.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %run %t // RUN: %run %t
#include <windows.h> #include <windows.h>
DWORD WINAPI thread_proc(void *) { DWORD WINAPI thread_proc(void *) {
volatile char stack_buffer[42]; volatile char stack_buffer[42];
for (int i = 0; i < sizeof(stack_buffer); ++i) for (int i = 0; i < sizeof(stack_buffer); ++i)
Show All 22 Lines

compiler-rt/test/asan/TestCases/Windows/thread_suspended.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %run %t // RUN: %run %t
#include <windows.h> #include <windows.h>
DWORD WINAPI thread_proc(void *) { DWORD WINAPI thread_proc(void *) {
volatile char stack_buffer[42]; volatile char stack_buffer[42];
for (int i = 0; i < sizeof(stack_buffer); ++i) for (int i = 0; i < sizeof(stack_buffer); ++i)
Show All 19 Lines

compiler-rt/test/asan/TestCases/Windows/tls_init.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan %s -Fe%t.exe /MD // RUN: %clang_cl_asan %s -Fe%t.exe /MD
// RUN: %run %t.exe | FileCheck %s // RUN: %run %t.exe | FileCheck %s
// CHECK: my_thread_callback // CHECK: my_thread_callback
// CHECK: ran_before_main: 1 // CHECK: ran_before_main: 1
#include <windows.h> #include <windows.h>
#include <stdio.h> #include <stdio.h>
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

compiler-rt/test/asan/TestCases/Windows/use_after_realloc.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
#include <malloc.h> #include <malloc.h>
int main() { int main() {
char *buffer = (char*)realloc(0, 32), char *buffer = (char*)realloc(0, 32),
*stale = buffer; *stale = buffer;
Show All 15 Lines

compiler-rt/test/asan/TestCases/Windows/use_after_return_linkage.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// Make sure LIBCMT doesn't accidentally get added to the list of DEFAULTLIB // Make sure LIBCMT doesn't accidentally get added to the list of DEFAULTLIB
// directives. // directives.
// REQUIRES: asan-dynamic-runtime // REQUIRES: asan-dynamic-runtime
// RUN: %clang_cl_asan -LD %s | FileCheck %s // RUN: %clang_cl_asan -LD %s | FileCheck %s
// CHECK: Creating library // CHECK: Creating library
// CHECK-NOT: LIBCMT // CHECK-NOT: LIBCMT
void foo(int *p) { *p = 42; } void foo(int *p) { *p = 42; }
__declspec(dllexport) void bar() { __declspec(dllexport) void bar() {
int x; int x;
foo(&x); foo(&x);
} }

compiler-rt/test/asan/TestCases/Windows/user-exception.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: env ASAN_OPTIONS=handle_segv=0 %run %t 2>&1 | FileCheck %s --check-prefix=USER // RUN: env ASAN_OPTIONS=handle_segv=0 %run %t 2>&1 | FileCheck %s --check-prefix=USER
// RUN: env ASAN_OPTIONS=handle_segv=1 not %run %t 2>&1 | FileCheck %s --check-prefix=ASAN // RUN: env ASAN_OPTIONS=handle_segv=1 not %run %t 2>&1 | FileCheck %s --check-prefix=ASAN
// Test the default. // Test the default.
// RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=ASAN // RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=ASAN
// This test exits zero when its unhandled exception filter is set. ASan should // This test exits zero when its unhandled exception filter is set. ASan should
// not disturb it when handle_segv=0. // not disturb it when handle_segv=0.
Show All 28 Lines

compiler-rt/test/asan/TestCases/Windows/windows_h.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: %run %t // RUN: %run %t
// Just make sure we can parse <windows.h> // Just make sure we can parse <windows.h>
#include <windows.h> #include <windows.h>
int main() {} int main() {}

compiler-rt/test/asan/TestCases/Windows/wrong_downcast_on_heap.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
class Parent { class Parent {
public: public:
int field; int field;
}; };
Show All 18 Lines

compiler-rt/test/asan/TestCases/Windows/wrong_downcast_on_stack.cpp

// UNSUPPORTED: target={{.*-windows-gnu}}
// RUN: %clang_cl_asan -Od %s -Fe%t // RUN: %clang_cl_asan -Od %s -Fe%t
// RUN: not %run %t 2>&1 | FileCheck %s // RUN: not %run %t 2>&1 | FileCheck %s
class Parent { class Parent {
public: public:
int field; int field;
}; };
Show All 18 Lines

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

Show First 20 Lines • Show All 93 Lines • ▼ Show 20 Linesclang_asan_static_cflags = (["-fsanitize=address",
"-mno-omit-leaf-frame-pointer", "-mno-omit-leaf-frame-pointer",
"-fno-omit-frame-pointer", "-fno-omit-frame-pointer",
"-fno-optimize-sibling-calls"] + "-fno-optimize-sibling-calls"] +
config.debug_info_flags + target_cflags) config.debug_info_flags + target_cflags)
if config.target_arch == 's390x': if config.target_arch == 's390x':
clang_asan_static_cflags.append("-mbackchain") clang_asan_static_cflags.append("-mbackchain")
clang_asan_static_cxxflags = config.cxx_mode_flags + clang_asan_static_cflags clang_asan_static_cxxflags = config.cxx_mode_flags + clang_asan_static_cflags
target_is_msvc = bool(re.match(r'.*-windows-msvc$', config.target_triple))
asan_dynamic_flags = [] asan_dynamic_flags = []
if config.asan_dynamic: if config.asan_dynamic:
asan_dynamic_flags = ["-shared-libasan"] asan_dynamic_flags = ["-shared-libasan"]
if platform.system() == 'Windows': if platform.system() == 'Windows' and target_is_msvc:
# On Windows, we need to simulate "clang-cl /MD" on the clang driver side. # On MSVC target, we need to simulate "clang-cl /MD" on the clang driver side.
asan_dynamic_flags += ["-D_MT", "-D_DLL", "-Wl,-nodefaultlib:libcmt,-defaultlib:msvcrt,-defaultlib:oldnames"] asan_dynamic_flags += ["-D_MT", "-D_DLL", "-Wl,-nodefaultlib:libcmt,-defaultlib:msvcrt,-defaultlib:oldnames"]
mstorsjoUnsubmitted
Not Done
ReplyInline Actions

Side note; since Clang 16.0.0 (fda44bedd64dbcde1b54432d99ad2f0fca0ad204) there's a new option in the GCC-style driver that does the same as /MD - -fms-runtime-lib=dll. So if/when we can assume Clang >= 16 here, we could simplify this line.

mstorsjo: Side note; since Clang 16.0.0 (fda44bedd64dbcde1b54432d99ad2f0fca0ad204) there's a new option…
elif platform.system() == 'FreeBSD': elif platform.system() == 'FreeBSD':
# On FreeBSD, we need to add -pthread to ensure pthread functions are available. # On FreeBSD, we need to add -pthread to ensure pthread functions are available.
asan_dynamic_flags += ['-pthread'] asan_dynamic_flags += ['-pthread']
config.available_features.add("asan-dynamic-runtime") config.available_features.add("asan-dynamic-runtime")
else: else:
config.available_features.add("asan-static-runtime") config.available_features.add("asan-static-runtime")
clang_asan_cflags = clang_asan_static_cflags + asan_dynamic_flags clang_asan_cflags = clang_asan_static_cflags + asan_dynamic_flags
clang_asan_cxxflags = clang_asan_static_cxxflags + asan_dynamic_flags clang_asan_cxxflags = clang_asan_static_cxxflags + asan_dynamic_flags
Show All 23 Lines else:
lit_config.warning('%shared_libasan substitution not set but dynamic ASan is available.') lit_config.warning('%shared_libasan substitution not set but dynamic ASan is available.')
shared_libasan_path = None shared_libasan_path = None
if shared_libasan_path is not None: if shared_libasan_path is not None:
config.substitutions.append( ("%shared_libasan", shared_libasan_path) ) config.substitutions.append( ("%shared_libasan", shared_libasan_path) )
config.substitutions.append( ("%clang_asan_static ", build_invocation(clang_asan_static_cflags)) ) config.substitutions.append( ("%clang_asan_static ", build_invocation(clang_asan_static_cflags)) )
config.substitutions.append( ("%clangxx_asan_static ", build_invocation(clang_asan_static_cxxflags)) ) config.substitutions.append( ("%clangxx_asan_static ", build_invocation(clang_asan_static_cxxflags)) )
# Windows-specific tests might also use the clang-cl.exe driver. # MSVC-specific tests might also use the clang-cl.exe driver.
if platform.system() == 'Windows': if platform.system() == 'Windows' and target_is_msvc:
mstorsjoUnsubmitted
Not Done
ReplyInline Actions

The RE match expression gets repeated quite a lot - is there any existing pattern for storing such things in a variable within asan (maybe for tests for other targets)?

mstorsjo: The RE match expression gets repeated quite a lot - is there any existing pattern for storing…
alvinhochunAuthorUnsubmitted
Done
ReplyInline Actions

If you mean only in lit.cfg.py and lit.common.cfg.py, I guess it wouldn't hurt to use a local variable. By the way I am considering changing this check to detect msvc target instead of "not gnu".

If you mean for the UNSUPPORTED: tag in tests, I think the intended way to check for target is with the regex judging from 38e9660eaa3478b003cbc48cb4ed0adcf22e053a.

alvinhochun: If you mean only in `lit.cfg.py` and `lit.common.cfg.py`, I guess it wouldn't hurt to use a…
mstorsjoUnsubmitted
Not Done
ReplyInline Actions

Yeah, I meant in the lit python scripts. Changing it to positively check for msvc instead of excluding gnu probably makes the logic clearer, so that sounds good!

mstorsjo: Yeah, I meant in the lit python scripts. Changing it to positively check for msvc instead of…
clang_cl_cxxflags = ["-Wno-deprecated-declarations", clang_cl_cxxflags = ["-Wno-deprecated-declarations",
"-WX", "-WX",
"-D_HAS_EXCEPTIONS=0", "-D_HAS_EXCEPTIONS=0",
"-Zi"] + target_cflags "-Zi"] + target_cflags
clang_cl_asan_cxxflags = ["-fsanitize=address"] + clang_cl_cxxflags clang_cl_asan_cxxflags = ["-fsanitize=address"] + clang_cl_cxxflags
if config.asan_dynamic: if config.asan_dynamic:
clang_cl_asan_cxxflags.append("-MD") clang_cl_asan_cxxflags.append("-MD")
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

compiler-rt/test/lit.common.cfg.py

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 Lines
# Allow expanding substitutions that are based on other substitutions # Allow expanding substitutions that are based on other substitutions
config.recursiveExpansionLimit = 10 config.recursiveExpansionLimit = 10
# Setup test format. # Setup test format.
config.test_format = lit.formats.ShTest(execute_external) config.test_format = lit.formats.ShTest(execute_external)
if execute_external: if execute_external:
config.available_features.add('shell') config.available_features.add('shell')
target_is_msvc = bool(re.match(r'.*-windows-msvc$', config.target_triple))
compiler_id = getattr(config, 'compiler_id', None) compiler_id = getattr(config, 'compiler_id', None)
if compiler_id == "Clang": if compiler_id == "Clang":
if platform.system() != 'Windows': if not (platform.system() == 'Windows' and target_is_msvc):
config.cxx_mode_flags = ["--driver-mode=g++"] config.cxx_mode_flags = ["--driver-mode=g++"]
else: else:
config.cxx_mode_flags = [] config.cxx_mode_flags = []
# We assume that sanitizers should provide good enough error # We assume that sanitizers should provide good enough error
# reports and stack traces even with minimal debug info. # reports and stack traces even with minimal debug info.
config.debug_info_flags = ["-gline-tables-only"] config.debug_info_flags = ["-gline-tables-only"]
if platform.system() == 'Windows': if platform.system() == 'Windows' and target_is_msvc:
# On Windows, use CodeView with column info instead of DWARF. Both VS and # On MSVC, use CodeView with column info instead of DWARF. Both VS and
# windbg do not behave well when column info is enabled, but users have # windbg do not behave well when column info is enabled, but users have
# requested it because it makes ASan reports more precise. # requested it because it makes ASan reports more precise.
config.debug_info_flags.append("-gcodeview") config.debug_info_flags.append("-gcodeview")
config.debug_info_flags.append("-gcolumn-info") config.debug_info_flags.append("-gcolumn-info")
elif compiler_id == 'GNU': elif compiler_id == 'GNU':
config.cxx_mode_flags = ["-x c++"] config.cxx_mode_flags = ["-x c++"]
config.debug_info_flags = ["-g"] config.debug_info_flags = ["-g"]
else: else:
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Linespossibly_dangerous_env_vars = ['ASAN_OPTIONS', 'DFSAN_OPTIONS', 'HWASAN_OPTIONS',
'CPATH', 'C_INCLUDE_PATH', 'CPLUS_INCLUDE_PATH', 'CPATH', 'C_INCLUDE_PATH', 'CPLUS_INCLUDE_PATH',
'OBJC_INCLUDE_PATH', 'OBJCPLUS_INCLUDE_PATH', 'OBJC_INCLUDE_PATH', 'OBJCPLUS_INCLUDE_PATH',
'LIBCLANG_TIMING', 'LIBCLANG_OBJTRACKING', 'LIBCLANG_TIMING', 'LIBCLANG_OBJTRACKING',
'LIBCLANG_LOGGING', 'LIBCLANG_BGPRIO_INDEX', 'LIBCLANG_LOGGING', 'LIBCLANG_BGPRIO_INDEX',
'LIBCLANG_BGPRIO_EDIT', 'LIBCLANG_NOTHREADS', 'LIBCLANG_BGPRIO_EDIT', 'LIBCLANG_NOTHREADS',
'LIBCLANG_RESOURCE_USAGE', 'LIBCLANG_RESOURCE_USAGE',
'LIBCLANG_CODE_COMPLETION_LOGGING', 'LIBCLANG_CODE_COMPLETION_LOGGING',
'XRAY_OPTIONS'] 'XRAY_OPTIONS']
# Clang/Win32 may refer to %INCLUDE%. vsvarsall.bat sets it. # Clang/MSVC may refer to %INCLUDE%. vsvarsall.bat sets it.
if platform.system() != 'Windows': if not (platform.system() == 'Windows' and target_is_msvc):
possibly_dangerous_env_vars.append('INCLUDE') possibly_dangerous_env_vars.append('INCLUDE')
for name in possibly_dangerous_env_vars: for name in possibly_dangerous_env_vars:
if name in config.environment: if name in config.environment:
del config.environment[name] del config.environment[name]
# Tweak PATH to include llvm tools dir. # Tweak PATH to include llvm tools dir.
if (not config.llvm_tools_dir) or (not os.path.exists(config.llvm_tools_dir)): if (not config.llvm_tools_dir) or (not os.path.exists(config.llvm_tools_dir)):
lit_config.fatal("Invalid llvm_tools_dir config attribute: %r" % config.llvm_tools_dir) lit_config.fatal("Invalid llvm_tools_dir config attribute: %r" % config.llvm_tools_dir)
path = os.path.pathsep.join((config.llvm_tools_dir, config.environment['PATH'])) path = os.path.pathsep.join((config.llvm_tools_dir, config.environment['PATH']))
config.environment['PATH'] = path config.environment['PATH'] = path
# Help MSVS link.exe find the standard libraries. # Help MSVS link.exe find the standard libraries.
# Make sure we only try to use it when targetting Windows. # Make sure we only try to use it when targetting Windows.
if platform.system() == 'Windows' and '-win' in config.target_triple: if platform.system() == 'Windows' and target_is_msvc:
config.environment['LIB'] = os.environ['LIB'] config.environment['LIB'] = os.environ['LIB']
config.available_features.add(config.host_os.lower()) config.available_features.add(config.host_os.lower())
if config.target_triple.startswith("ppc") or config.target_triple.startswith("powerpc"): if config.target_triple.startswith("ppc") or config.target_triple.startswith("powerpc"):
config.available_features.add("ppc") config.available_features.add("ppc")
if re.match(r'^x86_64.*-linux', config.target_triple): if re.match(r'^x86_64.*-linux', config.target_triple):
▲ Show 20 Lines • Show All 333 Lines • ▼ Show 20 Lines for exe in (config.gnu_ld_executable, config.gold_executable):
except OSError: except OSError:
return False return False
if not '-plugin' in ld_out: if not '-plugin' in ld_out:
return False return False
return True return True
def is_windows_lto_supported(): def is_windows_lto_supported():
if not target_is_msvc:
return True
return os.path.exists(os.path.join(config.llvm_tools_dir, 'lld-link.exe')) return os.path.exists(os.path.join(config.llvm_tools_dir, 'lld-link.exe'))
if config.host_os == 'Darwin' and is_darwin_lto_supported(): if config.host_os == 'Darwin' and is_darwin_lto_supported():
config.lto_supported = True config.lto_supported = True
config.lto_flags = [ '-Wl,-lto_library,' + liblto_path() ] config.lto_flags = [ '-Wl,-lto_library,' + liblto_path() ]
elif config.host_os in ['Linux', 'FreeBSD', 'NetBSD']: elif config.host_os in ['Linux', 'FreeBSD', 'NetBSD']:
config.lto_supported = False config.lto_supported = False
if config.use_lld: if config.use_lld:
▲ Show 20 Lines • Show All 182 Lines • Show Last 20 Lines