This is an archive of the discontinued LLVM Phabricator instance.

Differential D64506

clang-cl: Remove -O0 option
ClosedPublic

Authored by thakis on Jul 10 2019, 9:12 AM.

Details

Reviewers
rnk
Commits
rGda233838c9b0: clang-cl: Remove -O0 option
rC365724: clang-cl: Remove -O0 option
rCRT365724: clang-cl: Remove -O0 option
rL365724: clang-cl: Remove -O0 option
Summary

cl.exe doesn't understand it; there's /Od instead. See also the review
thread for r229575.

Update lots of compiler-rt tests to use -Od instead of -O0.
Ran rg -l 'clang_cl.*O0' compiler-rt/test/ | xargs sed -i -c 's/-O0/-Od/'

Diff Detail

Event Timeline

thakis created this revision.Jul 10 2019, 9:12 AM

I did check that we now warn, like you had requested:

$ out/gn/bin/clang-cl test.cc /O0 /c
clang: warning: argument unused during compilation: '/O0' [-Wunused-command-line-argument]

Adding a test for that felt weird though, so I didn't.

rnk added a comment.Jul 10 2019, 1:48 PM

Does clang-cl -O0 without a / still work, though? It's used:

$ git grep O0 ../compiler-rt/test/asan/TestCases/Windows/
../compiler-rt/test/asan/TestCases/Windows/aligned_mallocs.cc:// RUN: %clang_cl_asan -O0 %s -Fe%t
../compiler-rt/test/asan/TestCases/Windows/allocators_sanity.cc:// RUN: %clang_cl_asan -O0 %s -Fe%t
../compiler-rt/test/asan/TestCases/Windows/beginthreadex.cc:// RUN: %clang_cl_asan -O0 %s -Fe%t
../compiler-rt/test/asan/TestCases/Windows/bitfield.cc:// RUN: %clang_cl_asan -O0 %s -Fe%t
../compiler-rt/test/asan/TestCases/Windows/bitfield_uaf.cc:// RUN: %clang_cl_asan -O0 %s -Fe%t
../compiler-rt/test/asan/TestCases/Windows/calloc_left_oob.cc:// RUN: %clang_cl_asan -O0 %s -Fe%t
../compiler-rt/test/asan/TestCases/Windows/calloc_right_oob.cc:// RUN: %clang_cl_asan -O0 %s -Fe%t
...

thakis added a comment.Jul 10 2019, 4:15 PM
In D64506#1579251, @rnk wrote:

Does clang-cl -O0 without a / still work, though? It's used:

$ git grep O0 ../compiler-rt/test/asan/TestCases/Windows/
../compiler-rt/test/asan/TestCases/Windows/aligned_mallocs.cc:// RUN: %clang_cl_asan -O0 %s -Fe%t
../compiler-rt/test/asan/TestCases/Windows/allocators_sanity.cc:// RUN: %clang_cl_asan -O0 %s -Fe%t
../compiler-rt/test/asan/TestCases/Windows/beginthreadex.cc:// RUN: %clang_cl_asan -O0 %s -Fe%t
../compiler-rt/test/asan/TestCases/Windows/bitfield.cc:// RUN: %clang_cl_asan -O0 %s -Fe%t
../compiler-rt/test/asan/TestCases/Windows/bitfield_uaf.cc:// RUN: %clang_cl_asan -O0 %s -Fe%t
../compiler-rt/test/asan/TestCases/Windows/calloc_left_oob.cc:// RUN: %clang_cl_asan -O0 %s -Fe%t
../compiler-rt/test/asan/TestCases/Windows/calloc_right_oob.cc:// RUN: %clang_cl_asan -O0 %s -Fe%t
...

Oh thanks, I only ran clang tests, not compiler-rt tests.

It no longer works, O isn't a CoreOption:

$ out/gn/bin/clang-cl test.cc -O0 /c
clang: warning: argument unused during compilation: '-O0' [-Wunused-command-line-argument]

But these tests should just use /Od, right?

thakis updated this revision to Diff 209092.Jul 10 2019, 4:18 PM

update tests

(not yet executed, don't have a win machine today)

Herald added a project: Restricted Project. · View Herald TranscriptJul 10 2019, 4:18 PM
Herald added subscribers: llvm-commits, kubamracek. · View Herald Transcript
thakis edited the summary of this revision. (Show Details)Jul 10 2019, 4:18 PM
thakis edited the summary of this revision. (Show Details)
rnk accepted this revision.Jul 10 2019, 5:19 PM

lgtm

This revision is now accepted and ready to land.Jul 10 2019, 5:19 PM
Closed by commit rL365724: clang-cl: Remove -O0 option (authored by nico). · Explain WhyJul 10 2019, 6:19 PM
This revision was automatically updated to reflect the committed changes.
Herald added a subscriber: delcypher. · View Herald TranscriptJul 10 2019, 6:19 PM
alvinhochun mentioned this in D147432: [asan][test][win] Port trivial tests to not use clang-cl on MinGW.Apr 15 2023, 6:15 AM

Revision Contents

PathSize
clang/
include/
clang/
Driver/
2 lines
compiler-rt/
test/
asan/
TestCases/
Windows/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
4 lines
4 lines
6 lines
2 lines
4 lines
2 lines
4 lines
6 lines
4 lines
6 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
6 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines

Diff 209092

clang/include/clang/Driver/CLCompatOptions.td

Show First 20 Lines • Show All 112 Lines • ▼ Show 20 Lines
def _SLASH_J : CLFlag<"J">, HelpText<"Make char type unsigned">, def _SLASH_J : CLFlag<"J">, HelpText<"Make char type unsigned">,
Alias<funsigned_char>; Alias<funsigned_char>;
// The _SLASH_O option handles all the /O flags, but we also provide separate // The _SLASH_O option handles all the /O flags, but we also provide separate
// aliased options to provide separate help messages. // aliased options to provide separate help messages.
def _SLASH_O : CLJoined<"O">, def _SLASH_O : CLJoined<"O">,
HelpText<"Set multiple /O flags at once; e.g. '/O2y-' for '/O2 /Oy-'">, HelpText<"Set multiple /O flags at once; e.g. '/O2y-' for '/O2 /Oy-'">,
MetaVarName<"<flags>">; MetaVarName<"<flags>">;
// FIXME: Not sure why we have -O0 here; MSVC doesn't support that.
def : CLFlag<"O0">, Alias<O0>, HelpText<"Disable optimization">;
def : CLFlag<"O1">, Alias<_SLASH_O>, AliasArgs<["1"]>, def : CLFlag<"O1">, Alias<_SLASH_O>, AliasArgs<["1"]>,
HelpText<"Optimize for size (same as /Og /Os /Oy /Ob2 /GF /Gy)">; HelpText<"Optimize for size (same as /Og /Os /Oy /Ob2 /GF /Gy)">;
def : CLFlag<"O2">, Alias<_SLASH_O>, AliasArgs<["2"]>, def : CLFlag<"O2">, Alias<_SLASH_O>, AliasArgs<["2"]>,
HelpText<"Optimize for speed (same as /Og /Oi /Ot /Oy /Ob2 /GF /Gy)">; HelpText<"Optimize for speed (same as /Og /Oi /Ot /Oy /Ob2 /GF /Gy)">;
def : CLFlag<"Ob0">, Alias<_SLASH_O>, AliasArgs<["b0"]>, def : CLFlag<"Ob0">, Alias<_SLASH_O>, AliasArgs<["b0"]>,
HelpText<"Disable function inlining">; HelpText<"Disable function inlining">;
def : CLFlag<"Ob1">, Alias<_SLASH_O>, AliasArgs<["b1"]>, def : CLFlag<"Ob1">, Alias<_SLASH_O>, AliasArgs<["b1"]>,
HelpText<"Only inline functions which are (explicitly or implicitly) marked inline">; HelpText<"Only inline functions which are (explicitly or implicitly) marked inline">;
▲ Show 20 Lines • Show All 328 Lines • Show Last 20 Lines

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

// RUN: %clang_cl_asan -O0 %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) \
return __LINE__; \ return __LINE__; \
Show All 20 Lines

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

// RUN: %clang_cl_asan -O0 %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));
p[512] = 0; p[512] = 0;
Show All 28 Lines

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

// RUN: %clang_cl_asan -O0 %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];
for (int i = 0; i < sizeof(stack_buffer); ++i) for (int i = 0; i < sizeof(stack_buffer); ++i)
Show All 12 Lines

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

// RUN: %clang_cl_asan -O0 %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;
unsigned int bf3:3; unsigned int bf3:3;
Show All 12 Lines

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

// RUN: %clang_cl_asan -O0 %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;
unsigned int bf3:3; unsigned int bf3:3;
Show All 25 Lines

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

// RUN: %clang_cl_asan -O0 %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;
// 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 4 at [[ADDR]] thread T0 // CHECK: WRITE of size 4 at [[ADDR]] thread T0
// CHECK-NEXT: {{#0 .* main .*calloc_left_oob.cc}}:[[@LINE-3]] // CHECK-NEXT: {{#0 .* main .*calloc_left_oob.cc}}:[[@LINE-3]]
// CHECK: [[ADDR]] is located 4 bytes to the left of 168-byte region // CHECK: [[ADDR]] is located 4 bytes to the left of 168-byte region
// CHECK: allocated by thread T0 here: // CHECK: allocated by thread T0 here:
// CHECK-NEXT: {{#0 .* calloc }} // CHECK-NEXT: {{#0 .* calloc }}
// CHECK-NEXT: {{#1 .* main .*calloc_left_oob.cc}}:[[@LINE-8]] // CHECK-NEXT: {{#1 .* main .*calloc_left_oob.cc}}:[[@LINE-8]]
free(buffer); free(buffer);
} }

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

// RUN: %clang_cl_asan -O0 %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;
// 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 4 at [[ADDR]] thread T0 // CHECK: WRITE of size 4 at [[ADDR]] thread T0
// CHECK-NEXT: {{#0 .* main .*calloc_right_oob.cc}}:[[@LINE-3]] // CHECK-NEXT: {{#0 .* main .*calloc_right_oob.cc}}:[[@LINE-3]]
// CHECK: [[ADDR]] is located 0 bytes to the right of 168-byte region // CHECK: [[ADDR]] is located 0 bytes to the right of 168-byte region
// CHECK: allocated by thread T0 here: // CHECK: allocated by thread T0 here:
// CHECK-NEXT: {{#0 .* calloc }} // CHECK-NEXT: {{#0 .* calloc }}
// CHECK-NEXT: {{#1 .* main .*calloc_right_oob.cc}}:[[@LINE-8]] // CHECK-NEXT: {{#1 .* main .*calloc_right_oob.cc}}:[[@LINE-8]]
free(buffer); free(buffer);
} }

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

// RUN: %clang_cl_asan -O0 %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);
buffer[0] = 42; buffer[0] = 42;
Show All 11 Lines

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

// 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 -O0 %p/dll_host.cc -Fet.exe // RUN: %clang_cl_asan -fsanitize-coverage=func,trace-pc-guard -Od %p/dll_host.cc -Fet.exe
// RUN: %clang_cl_asan -fsanitize-coverage=func,trace-pc-guard -LD -O0 %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.cc

// RUN: %clang_cl_asan -O0 %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 22 Lines

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

// RUN: %clang_cl_asan -O0 %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 {
// A template function in a namespace. // A template function in a namespace.
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

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

// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cc -Fe%t
// RUN: %clang_cl_asan -LD -O0 %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) \
do { \ do { \
if (((uintptr_t)(ptr) % (alignment)) != 0) \ if (((uintptr_t)(ptr) % (alignment)) != 0) \
Show All 24 Lines

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

// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cc -Fe%t
// RUN: %clang_cl_asan -LD -O0 %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)
int test_function() { int test_function() {
int *p = (int*)malloc(1024 * sizeof(int)); int *p = (int*)malloc(1024 * sizeof(int));
Show All 29 Lines

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

// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cc -Fe%t
// RUN: %clang_cl_asan -LD -O0 %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 -O0 %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
#include <iostream> #include <iostream>
extern "C" __declspec(dllexport) extern "C" __declspec(dllexport)
int test_function() { int test_function() {
// Just make sure we can use cout. // Just make sure we can use cout.
std::cout << "All ok\n"; std::cout << "All ok\n";
Show All 9 Lines

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

// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cc -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>
#include <stdlib.h> #include <stdlib.h>
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

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

// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cc -Fe%t
// //
// RUN: %clang_cl_asan /Gw -LD -O0 %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>
int dead_global = 42; int dead_global = 42;
int live_global = 0; int live_global = 0;
Show All 17 Lines

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

// 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 -O0 %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
// differ from 32-bit and 64-bit. // differ from 32-bit and 64-bit.
// RUN: dumpbin /EXPORTS %t | grep -o "__asan_wrap[^ ]*" | sed -e s/@.*// > %t.exports1 // RUN: dumpbin /EXPORTS %t | grep -o "__asan_wrap[^ ]*" | sed -e s/@.*// > %t.exports1
// //
// The exception handlers differ in 32-bit and 64-bit, so we ignore them: // The exception handlers differ in 32-bit and 64-bit, so we ignore them:
// RUN: grep '[E]XPORT:' %s | sed -e 's/.*[E]XPORT: //' > %t.exports2 // RUN: grep '[E]XPORT:' %s | sed -e 's/.*[E]XPORT: //' > %t.exports2
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

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

// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cc -Fe%t
// RUN: %clang_cl_asan -LD -O0 %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.
// UNSUPPORTED: x86_64-windows // UNSUPPORTED: x86_64-windows
Show All 17 Lines

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

// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cc -Fe%t
// RUN: %clang_cl_asan -Wno-fortify-source -LD -O0 %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 -O0 %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
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
extern "C" __declspec(dllexport) extern "C" __declspec(dllexport)
int test_function() { int test_function() {
char buff1[6] = "Hello", buff2[5]; char buff1[6] = "Hello", buff2[5];
Show All 18 Lines

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

// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cc -Fe%t
// RUN: %clang_cl_asan -LD -O0 %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),
void *a, const void *b, size_t c) { void *a, const void *b, size_t c) {
f(a, b, c); f(a, b, c);
Show All 24 Lines

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

// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cc -Fe%t
// RUN: %clang_cl_asan -Wno-fortify-source -LD -O0 %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 -O0 %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
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
extern "C" __declspec(dllexport) extern "C" __declspec(dllexport)
int test_function() { int test_function() {
char buff[5] = "aaaa"; char buff[5] = "aaaa";
Show All 18 Lines

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

// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cc -Fe%t
// RUN: %clang_cl_asan -LD -O0 %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)
int test_function() { int test_function() {
char str[] = "Hello!"; char str[] = "Hello!";
Show All 18 Lines

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

// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cc -Fe%t
// RUN: %clang_cl_asan -LD -O0 %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);
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]+]]
Show All 13 Lines

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

// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cc -Fe%t
// RUN: %clang_cl_asan -LD -O0 %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() {
int *buffer = (int*)malloc(42); int *buffer = (int*)malloc(42);
free(buffer); free(buffer);
Show All 18 Lines

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

// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cc -Fe%t
// RUN: %clang_cl_asan -LD -O0 %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;
char buffer[42]; char buffer[42];
buffer[subscript] = 42; buffer[subscript] = 42;
Show All 18 Lines

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

// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cc -Fe%t
// RUN: %clang_cl_asan -LD -O0 %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.*}}
ptr[10]++; // BOOM ptr[10]++; // BOOM
} }
extern "C" __declspec(dllexport) extern "C" __declspec(dllexport)
int test_function() { int test_function() {
NullDeref((int*)0); NullDeref((int*)0);
// CHECK: {{ #1 0x.* in test_function .*\dll_null_deref.cc:}}[[@LINE-1]] // CHECK: {{ #1 0x.* in test_function .*\dll_null_deref.cc:}}[[@LINE-1]]
// CHECK: AddressSanitizer can not provide additional info. // CHECK: AddressSanitizer can not provide additional info.
return 0; return 0;
} }

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

// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cc -Fe%t
// RUN: %clang_cl_asan -LD -O0 %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;
// 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 15 Lines

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

// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cc -Fe%t
// RUN: %clang_cl_asan -LD -O0 %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() {}
}; };
extern "C" __declspec(dllexport) extern "C" __declspec(dllexport)
Show All 23 Lines

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

// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cc -Fe%t
// RUN: %clang_cl_asan -LD -O0 %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 25 Lines

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

// RUN: %clang_cl_asan -LD -O0 -DDLL %s -Fe%t.dll // RUN: %clang_cl_asan -LD -Od -DDLL %s -Fe%t.dll
// RUN: %clang_cl_asan -O0 -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
#include <windows.h> #include <windows.h>
#include <stdio.h> #include <stdio.h>
Show All 30 Lines

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

// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cc -Fe%t
// //
// Check both -GS and -GS- builds: // Check both -GS and -GS- builds:
// RUN: %clang_cl_asan -GS -LD -O0 %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 -O0 %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
#include <windows.h> #include <windows.h>
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
// Should just "#include <sanitizer/asan_interface.h>" when C++ exceptions are // Should just "#include <sanitizer/asan_interface.h>" when C++ exceptions are
// supported and we don't need to use CL. // supported and we don't need to use CL.
Show All 35 Lines

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

// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cc -Fe%t
// RUN: %clang_cl_asan -LD -O0 %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
#include <malloc.h> #include <malloc.h>
char *x; char *x;
void foo() { void foo() {
char stack_buffer[42]; char stack_buffer[42];
Show All 18 Lines

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

// RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -Od %p/dll_host.cc -Fe%t
// RUN: %clang_cl_asan -LD -O0 %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) {
int subscript = -1; int subscript = -1;
char stack_buffer[42]; char stack_buffer[42];
Show All 26 Lines

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

// RUN: %clang_cl_asan -O0 %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);
free(x); free(x);
Show All 12 Lines

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

// RUN: %clang_cl_asan -O0 %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;
delete [] x; delete [] x;
Show All 16 Lines

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

// RUN: %clang_cl_asan -O0 %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.cc

// RUN: %clang_cl_asan -O0 %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";
int main(void) { int main(void) {
Show All 11 Lines

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

// UNSUPPORTED: asan-64-bits // UNSUPPORTED: asan-64-bits
// RUN: %clang_cl_asan -O0 %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_doublefree.cc

// RUN: %clang_cl_asan -O0 %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:
No newline at end of file

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

// RUN: %clang_cl_asan -O0 %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>
extern "C" int extern "C" int
Show All 11 Lines

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

// RUN: %clang_cl_asan -O0 %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;
} }
No newline at end of file

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

// RUN: %clang_cl_asan -O0 %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_uaf.cc

// RUN: %clang_cl_asan -O0 %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/heaprealloc.cc

// RUN: %clang_cl_asan -O0 %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;
size_t sz = 8; size_t sz = 8;
Show All 14 Lines

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

// RUN: %clang_cl_asan -O0 %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/intercept_memcpy.cc

// RUN: %clang_cl_asan -O0 %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) {
f(a, b, c); f(a, b, c);
Show All 22 Lines

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

// RUN: %clang_cl_asan -O0 %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() {
char *ptr = _strdup("Hello"); char *ptr = _strdup("Hello");
Show All 23 Lines

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

// RUN: %clang_cl_asan -O0 %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";
if (5 != strlen(str)) if (5 != strlen(str))
Show All 18 Lines

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

// 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 -O0 %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.
// //
// RUN: dumpbin /EXPORTS %t | sed "s/=.*//" \ // RUN: dumpbin /EXPORTS %t | sed "s/=.*//" \
// RUN: | grep -o "\(__asan_\|__ubsan_\|__sanitizer_\|__sancov_\)[^ ]*" \ // RUN: | grep -o "\(__asan_\|__ubsan_\|__sanitizer_\|__sancov_\)[^ ]*" \
// RUN: | grep -v "__asan_wrap" \ // RUN: | grep -v "__asan_wrap" \
// RUN: | sed -e s/@.*// > %t.exports // RUN: | sed -e s/@.*// > %t.exports
Show All 40 Lines

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

// First, check this works with the default blacklist: // First, check this works with the default blacklist:
// RUN: %clang_cl_asan -O0 %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 his own blacklist file: // Then, make sure it still works when a user uses his own blacklist file:
// RUN: %clang_cl_asan -O0 %s -fsanitize-blacklist=%p/../Helpers/initialization-blacklist.txt -Fe%t2 // RUN: %clang_cl_asan -Od %s -fsanitize-blacklist=%p/../Helpers/initialization-blacklist.txt -Fe%t2
// RUN: echo "42" | %run %t2 2>&1 | FileCheck %s // RUN: echo "42" | %run %t2 2>&1 | FileCheck %s
#include <iostream> #include <iostream>
int main() { int main() {
int i; int i;
std::cout << "Type i: "; std::cout << "Type i: ";
std::cin >> i; std::cin >> i;
return 0; return 0;
// CHECK: Type i: // CHECK: Type i:
// CHECK-NOT: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]] // CHECK-NOT: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
} }

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

// RUN: %clang_cl_asan -O0 %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;
// 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
// CHECK-NEXT: {{#0 .* main .*malloc_left_oob.cc}}:[[@LINE-3]] // CHECK-NEXT: {{#0 .* main .*malloc_left_oob.cc}}:[[@LINE-3]]
// CHECK: [[ADDR]] is located 1 bytes to the left of 42-byte region // CHECK: [[ADDR]] is located 1 bytes to the left of 42-byte region
// CHECK: allocated by thread T0 here: // CHECK: allocated by thread T0 here:
// CHECK-NEXT: {{#0 .* malloc }} // CHECK-NEXT: {{#0 .* malloc }}
// CHECK-NEXT: {{#1 .* main .*malloc_left_oob.cc}}:[[@LINE-8]] // CHECK-NEXT: {{#1 .* main .*malloc_left_oob.cc}}:[[@LINE-8]]
free(buffer); free(buffer);
} }

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

// RUN: %clang_cl_asan -O0 %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;
// 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
// CHECK-NEXT: {{#0 .* main .*malloc_right_oob.cc}}:[[@LINE-3]] // CHECK-NEXT: {{#0 .* main .*malloc_right_oob.cc}}:[[@LINE-3]]
// CHECK: [[ADDR]] is located 0 bytes to the right of 42-byte region // CHECK: [[ADDR]] is located 0 bytes to the right of 42-byte region
// CHECK: allocated by thread T0 here: // CHECK: allocated by thread T0 here:
// CHECK-NEXT: {{#0 .* malloc }} // CHECK-NEXT: {{#0 .* malloc }}
// CHECK-NEXT: {{#1 .* main .*malloc_right_oob.cc}}:[[@LINE-8]] // CHECK-NEXT: {{#1 .* main .*malloc_right_oob.cc}}:[[@LINE-8]]
free(buffer); free(buffer);
} }

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

// RUN: %clang_cl_asan -O0 %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);
buffer[0] = 42; buffer[0] = 42;
Show All 11 Lines

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

// 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 -O0 -DDLL1 %s -Fe%t1.dll // RUN: %clang_cl_asan -LD -Od -DDLL1 %s -Fe%t1.dll
// RUN: %clang_cl_asan -LD -O0 -DDLL2 %s -Fe%t2.dll // RUN: %clang_cl_asan -LD -Od -DDLL2 %s -Fe%t2.dll
// RUN: %clang_cl_asan -O0 -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
#include <malloc.h> #include <malloc.h>
#include <string.h> #include <string.h>
extern "C" { extern "C" {
#if defined(EXE) #if defined(EXE)
__declspec(dllimport) void foo1(); __declspec(dllimport) void foo1();
Show All 25 Lines

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

// RUN: %clang_cl_asan -O0 %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.cc

// RUN: %clang_cl_asan -O0 %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
// CHECK-NEXT: {{#0 .* main .*operator_array_new_left_oob.cc}}:[[@LINE-3]] // CHECK-NEXT: {{#0 .* main .*operator_array_new_left_oob.cc}}:[[@LINE-3]]
// //
// CHECK: [[ADDR]] is located 1 bytes to the left of 42-byte region // CHECK: [[ADDR]] is located 1 bytes to the left of 42-byte region
// CHECK-LABEL: allocated by thread T0 here: // CHECK-LABEL: allocated by thread T0 here:
// FIXME: The 'operator new' frame should have []. // FIXME: The 'operator new' frame should have [].
// CHECK-NEXT: {{#0 .* operator new}} // CHECK-NEXT: {{#0 .* operator new}}
// CHECK-NEXT: {{#1 .* main .*operator_array_new_left_oob.cc}}:[[@LINE-10]] // CHECK-NEXT: {{#1 .* main .*operator_array_new_left_oob.cc}}:[[@LINE-10]]
delete [] buffer; delete [] buffer;
} }

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

// RUN: %clang_cl_asan -O0 %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;
// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]] // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
Show All 9 Lines

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

// RUN: %clang_cl_asan -O0 %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;
buffer[0] = 42; buffer[0] = 42;
Show All 15 Lines

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

// RUN: %clang_cl_asan -O0 %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() {}
}; };
int main() { int main() {
Show All 16 Lines

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

// RUN: %clang_cl_asan -O0 %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.cc}}:[[@LINE-3]] // CHECK: {{#1 .* main .*operator_delete_wrong_argument.cc}}:[[@LINE-3]]
} }

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

// RUN: %clang_cl_asan -O0 %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;
// 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
// CHECK: {{#0 .* main .*operator_new_left_oob.cc}}:[[@LINE-3]] // CHECK: {{#0 .* main .*operator_new_left_oob.cc}}:[[@LINE-3]]
// CHECK: [[ADDR]] is located 1 bytes to the left of 1-byte region // CHECK: [[ADDR]] is located 1 bytes to the left of 1-byte region
// CHECK: allocated by thread T0 here: // CHECK: allocated by thread T0 here:
// CHECK: {{#0 .* operator new}} // CHECK: {{#0 .* operator new}}
// CHECK: {{#1 .* main .*operator_new_left_oob.cc}}:[[@LINE-8]] // CHECK: {{#1 .* main .*operator_new_left_oob.cc}}:[[@LINE-8]]
delete buffer; delete buffer;
} }

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

// RUN: %clang_cl_asan -O0 %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;
// 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
// CHECK: {{#0 .* main .*operator_new_right_oob.cc}}:[[@LINE-3]] // CHECK: {{#0 .* main .*operator_new_right_oob.cc}}:[[@LINE-3]]
// CHECK: [[ADDR]] is located 0 bytes to the right of 1-byte region // CHECK: [[ADDR]] is located 0 bytes to the right of 1-byte region
// CHECK: allocated by thread T0 here: // CHECK: allocated by thread T0 here:
// CHECK: {{#0 .* operator new}} // CHECK: {{#0 .* operator new}}
// CHECK: {{#1 .* main .*operator_new_right_oob.cc}}:[[@LINE-8]] // CHECK: {{#1 .* main .*operator_new_right_oob.cc}}:[[@LINE-8]]
delete buffer; delete buffer;
} }

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

// RUN: %clang_cl_asan -O0 %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;
*buffer = 42; *buffer = 42;
Show All 13 Lines

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

// RUN: %clang_cl_asan -O0 %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) {
int subscript = -1; int subscript = -1;
Show All 18 Lines

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

// RUN: %clang_cl_asan -O0 %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;
// 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
// CHECK-NEXT: {{#0 .* main .*realloc_left_oob.cc}}:[[@LINE-3]] // CHECK-NEXT: {{#0 .* main .*realloc_left_oob.cc}}:[[@LINE-3]]
// CHECK: [[ADDR]] is located 1 bytes to the left of 42-byte region // CHECK: [[ADDR]] is located 1 bytes to the left of 42-byte region
// CHECK: allocated by thread T0 here: // CHECK: allocated by thread T0 here:
// CHECK-NEXT: {{#0 .* realloc }} // CHECK-NEXT: {{#0 .* realloc }}
// CHECK-NEXT: {{#1 .* main .*realloc_left_oob.cc}}:[[@LINE-8]] // CHECK-NEXT: {{#1 .* main .*realloc_left_oob.cc}}:[[@LINE-8]]
free(buffer); free(buffer);
} }

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

// RUN: %clang_cl_asan -O0 %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;
// 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
// CHECK-NEXT: {{#0 .* main .*realloc_right_oob.cc}}:[[@LINE-3]] // CHECK-NEXT: {{#0 .* main .*realloc_right_oob.cc}}:[[@LINE-3]]
// CHECK: [[ADDR]] is located 0 bytes to the right of 42-byte region // CHECK: [[ADDR]] is located 0 bytes to the right of 42-byte region
// CHECK: allocated by thread T0 here: // CHECK: allocated by thread T0 here:
// CHECK-NEXT: {{#0 .* realloc }} // CHECK-NEXT: {{#0 .* realloc }}
// CHECK-NEXT: {{#1 .* main .*realloc_right_oob.cc}}:[[@LINE-8]] // CHECK-NEXT: {{#1 .* main .*realloc_right_oob.cc}}:[[@LINE-8]]
free(buffer); free(buffer);
} }

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

// RUN: %clang_cl_asan -O0 %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);
buffer[0] = 42; buffer[0] = 42;
Show All 11 Lines

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

// Make sure we can handle reloading the same DLL multiple times. // Make sure we can handle reloading the same DLL multiple times.
// RUN: %clang_cl_asan -LD -O0 -DDLL %s -Fe%t.dll // RUN: %clang_cl_asan -LD -Od -DDLL %s -Fe%t.dll
// RUN: %clang_cl_asan -O0 -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>
extern "C" { extern "C" {
#if defined(EXE) #if defined(EXE)
Show All 40 Lines

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

// RUN: %clang_cl_asan -LD -O0 -DDLL %s -Fe%t.dll // RUN: %clang_cl_asan -LD -Od -DDLL %s -Fe%t.dll
// RUN: %clang_cl_asan -O0 -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>
extern "C" { extern "C" {
#if defined(EXE) #if defined(EXE)
Show All 37 Lines

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

// RUN: %clang_cl_asan -O0 %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>
using AllocateFunctionPtr = PVOID(__stdcall *)(PVOID, ULONG, SIZE_T); using AllocateFunctionPtr = PVOID(__stdcall *)(PVOID, ULONG, SIZE_T);
Show All 21 Lines

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

// RUN: %clang_cl_asan -O0 %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 36 Lines

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

// RUN: %clang_cl_asan -O0 %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 59 Lines • Show Last 20 Lines

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

// RUN: %clang_cl_asan -O0 %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];
int main() { int main() {
Show All 9 Lines

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

// RUN: %clang_cl_asan -O0 %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.cc}}:[[@LINE-3]] // CHECK-NEXT: {{#0 .* main .*stack_array_left_oob.cc}}:[[@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.cc}} // CHECK-NEXT: {{#0 .* main .*stack_array_left_oob.cc}}
// 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.cc

// RUN: %clang_cl_asan -O0 %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.cc}}:[[@LINE-3]] // CHECK-NEXT: {{#0 .* main .*stack_array_right_oob.cc}}:[[@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.cc}} // CHECK-NEXT: {{#0 .* main .*stack_array_right_oob.cc}}
// 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.cc

// RUN: %clang_cl_asan -O0 %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.cc

// RUN: %clang_cl_asan -O0 %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
char *x; char *x;
void foo() { void foo() {
char stack_buffer[42]; char stack_buffer[42];
x = &stack_buffer[13]; x = &stack_buffer[13];
} }
Show All 13 Lines

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

// 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 -O0 %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
#include <malloc.h> #include <malloc.h>
int main() { int main() {
Show All 11 Lines

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

// RUN: %clang_cl_asan -O0 %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)
stack_buffer[i] = 42; stack_buffer[i] = 42;
Show All 17 Lines

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

// RUN: %clang_cl_asan -O0 %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];
stack_buffer[subscript] = 42; stack_buffer[subscript] = 42;
Show All 18 Lines

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

// RUN: %clang_cl_asan -O0 %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];
stack_buffer[subscript] = 42; stack_buffer[subscript] = 42;
Show All 18 Lines

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

// RUN: %clang_cl_asan -O0 %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;
y = 2; y = 2;
Show All 28 Lines

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

// RUN: %clang_cl_asan -O0 %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)
stack_buffer[i] = 42; stack_buffer[i] = 42;
Show All 21 Lines

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

// RUN: %clang_cl_asan -O0 %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)
stack_buffer[i] = 42; stack_buffer[i] = 42;
Show All 18 Lines

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

// RUN: %clang_cl_asan -O0 %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;
buffer = (char*)realloc(buffer, 64); buffer = (char*)realloc(buffer, 64);
Show All 14 Lines

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

// RUN: %clang_cl_asan -O0 %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 27 Lines

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

// RUN: %clang_cl_asan -O0 %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.cc

// RUN: %clang_cl_asan -O0 %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;
}; };
class Child : public Parent { class Child : public Parent {
Show All 17 Lines

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

// RUN: %clang_cl_asan -O0 %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;
}; };
class Child : public Parent { class Child : public Parent {
Show All 17 Lines