This is an archive of the discontinued LLVM Phabricator instance.

Differential D3893

[ASan/Win] Use clang rather than clang-cl by default for lit tests. Make Windows-only tests explicitly use clang-cl.
ClosedPublic

Authored by timurrrr on May 23 2014, 5:53 AM.

Details

Reviewers
samsonov
Summary

This patch reverts minor parts of r208802, r208697, r208682.
See D3771 for the background on the change.

Enabling the non-Windows lit test is still a TODO, I have a local patch for that.

Diff Detail

Event Timeline

timurrrr updated this revision to Diff 9752.May 23 2014, 5:53 AM
timurrrr retitled this revision from to [ASan/Win] Use clang rather than clang-cl by default for lit tests. Make Windows-only tests explicitly use clang-cl..
timurrrr updated this object.
timurrrr edited the test plan for this revision. (Show Details)
timurrrr added a reviewer: samsonov.
timurrrr added a subscriber: Unknown Object (MLST).
samsonov added inline comments.May 23 2014, 3:07 PM
cmake/Modules/AddCompilerRT.cmake
151

Restore a space here.

cmake/Modules/CompilerRTCompile.cmake
24

what if the first element of global_flags starts with / ?

34

and here.

lib/asan/tests/CMakeLists.txt
29

Consider adding this (and, probably, -DGTEST_HAS_SEH=0 on Windows) to COMPILER_RT_GTEST_CFLAGS definition instead.

31

Any particular reason to switch to -gline-tables-only from -g here?

timurrrr added a comment.May 23 2014, 3:10 PM

Re: -g

  1. clang crashes on windows with -g [fixable]
  2. we had a chat with Kostya and decided it's the right thing to test ASan

with just glto to be sure it gives us enough DI
24 мая 2014 г. 2:07 пользователь "Alexey Samsonov" <vonosmas@gmail.com>
написал:

Comment at: cmake/Modules/AddCompilerRT.cmake:151
@@ -151,3 +150,3 @@

COMMAND ${COMPILER_RT_TEST_COMPILER} ${TEST_OBJECTS}
  • ${COMPILER_RT_TEST_COMPILER_EXE}"${output_bin}"

+ -o"${output_bin}"

${TEST_LINK_FLAGS}

Restore a space here.

Comment at: cmake/Modules/CompilerRTCompile.cmake:24
@@ +23,3 @@
+ if(MSVC)
+ string(REPLACE ";/" ";-" global_flags "${global_flags}")

+ endif()

what if the first element of global_flags starts with / ?

Comment at: cmake/Modules/CompilerRTCompile.cmake:33
@@ -27,3 +32,3 @@

COMMAND ${COMPILER_RT_TEST_COMPILER} ${compile_flags} -c
  • ${COMPILER_RT_TEST_COMPILER_OBJ}"${object_file}"

+ -o"${object_file}"

${source_rpath}

and here.

Comment at: lib/asan/tests/CMakeLists.txt:29
@@ -28,1 +28,3 @@

-I${COMPILER_RT_SOURCE_DIR}/lib/sanitizer_common/tests

+ -DGTEST_HAS_RTTI=0

+ -fno-rtti

Consider adding this (and, probably, -DGTEST_HAS_SEH=0 on Windows) to
COMPILER_RT_GTEST_CFLAGS definition instead.

Comment at: lib/asan/tests/CMakeLists.txt:31
@@ +30,3 @@
+ -fno-rtti
+ -gline-tables-only

+ -O2

Any particular reason to switch to -gline-tables-only from -g here?

http://reviews.llvm.org/D3893

samsonov edited edge metadata.May 23 2014, 3:11 PM

Okay, let's live with -gline-tables-info here then.

samsonov added a comment.May 23 2014, 3:12 PM

Oh, but please use COMPILER_RT_TEST_COMPILER_ID to enable it for Clang, and use plain -g otherwise.

timurrrr updated this revision to Diff 9810.May 26 2014, 9:00 AM
timurrrr edited edge metadata.

Addressed Alexey's comments.

timurrrr added a comment.May 26 2014, 9:00 AM

PTAL

cmake/Modules/CompilerRTCompile.cmake
24

Good catch, fixed.

samsonov accepted this revision.May 27 2014, 12:17 PM
samsonov edited edge metadata.

LGTM

lib/sanitizer_common/tests/CMakeLists.txt
60

GTEST_HAS_SEH=0 now comes from OMPILER_RT_GTEST_CFLAGS, doesn't it?

This revision is now accepted and ready to land.May 27 2014, 12:17 PM
timurrrr added a comment.May 28 2014, 1:49 AM

Landed as r209719, thanks for the review!

lib/sanitizer_common/tests/CMakeLists.txt
60

Oops, missed that -- thanks for catching!

I should probably move the stuff we conditionally append to SANITIZER_TEST_CFLAGS_COMMON to COMPILER_RT_GTEST_CFLAGS instead. Will do that in a separate commit.

timurrrr closed this revision.May 28 2014, 1:49 AM

Revision Contents

PathSize
10 lines
cmake/
Modules/
9 lines
10 lines
lib/
asan/
tests/
19 lines
sanitizer_common/
tests/
21 lines
test/
asan/
TestCases/
Windows/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
29 lines

Diff 9810

CMakeLists.txt

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Linesif (NOT COMPILER_RT_STANDALONE_BUILD)
option(COMPILER_RT_INCLUDE_TESTS "Generate and build compiler-rt unit tests." option(COMPILER_RT_INCLUDE_TESTS "Generate and build compiler-rt unit tests."
${LLVM_INCLUDE_TESTS}) ${LLVM_INCLUDE_TESTS})
option(COMPILER_RT_ENABLE_WERROR "Fail and stop if warning is triggered" option(COMPILER_RT_ENABLE_WERROR "Fail and stop if warning is triggered"
${LLVM_ENABLE_WERROR}) ${LLVM_ENABLE_WERROR})
# Use just-built Clang to compile/link tests on all platforms, except for # Use just-built Clang to compile/link tests on all platforms, except for
# Windows where we need to use clang-cl instead. # Windows where we need to use clang-cl instead.
if(NOT MSVC) if(NOT MSVC)
set(COMPILER_RT_TEST_COMPILER ${LLVM_RUNTIME_OUTPUT_INTDIR}/clang) set(COMPILER_RT_TEST_COMPILER ${LLVM_RUNTIME_OUTPUT_INTDIR}/clang)
set(COMPILER_RT_TEST_COMPILER_EXE "-o")
set(COMPILER_RT_TEST_COMPILER_OBJ "-o")
else() else()
set(COMPILER_RT_TEST_COMPILER ${LLVM_RUNTIME_OUTPUT_INTDIR}/clang-cl.exe) set(COMPILER_RT_TEST_COMPILER ${LLVM_RUNTIME_OUTPUT_INTDIR}/clang.exe)
set(COMPILER_RT_TEST_COMPILER_EXE "-Fe")
set(COMPILER_RT_TEST_COMPILER_OBJ "-Fo")
endif() endif()
else() else()
# Take output dir and install path from the user. # Take output dir and install path from the user.
set(COMPILER_RT_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR} CACHE PATH set(COMPILER_RT_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR} CACHE PATH
"Path where built compiler-rt libraries should be stored.") "Path where built compiler-rt libraries should be stored.")
set(COMPILER_RT_EXEC_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR}/bin CACHE PATH set(COMPILER_RT_EXEC_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR}/bin CACHE PATH
"Path where built compiler-rt executables should be stored.") "Path where built compiler-rt executables should be stored.")
set(COMPILER_RT_INSTALL_PATH ${CMAKE_INSTALL_PREFIX} CACHE PATH set(COMPILER_RT_INSTALL_PATH ${CMAKE_INSTALL_PREFIX} CACHE PATH
"Path where built compiler-rt libraries should be installed.") "Path where built compiler-rt libraries should be installed.")
option(COMPILER_RT_INCLUDE_TESTS "Generate and build compiler-rt unit tests." OFF) option(COMPILER_RT_INCLUDE_TESTS "Generate and build compiler-rt unit tests." OFF)
option(COMPILER_RT_ENABLE_WERROR "Fail and stop if warning is triggered" OFF) option(COMPILER_RT_ENABLE_WERROR "Fail and stop if warning is triggered" OFF)
# Use a host compiler to compile/link tests. # Use a host compiler to compile/link tests.
set(COMPILER_RT_TEST_COMPILER ${CMAKE_C_COMPILER} CACHE PATH "Compiler to use for testing") set(COMPILER_RT_TEST_COMPILER ${CMAKE_C_COMPILER} CACHE PATH "Compiler to use for testing")
set(COMPILER_RT_TEST_COMPILER_EXE "-o")
set(COMPILER_RT_TEST_COMPILER_OBJ "-o")
if (NOT LLVM_CONFIG_PATH) if (NOT LLVM_CONFIG_PATH)
find_program(LLVM_CONFIG_PATH "llvm-config" find_program(LLVM_CONFIG_PATH "llvm-config"
DOC "Path to llvm-config binary") DOC "Path to llvm-config binary")
if (NOT LLVM_CONFIG_PATH) if (NOT LLVM_CONFIG_PATH)
message(FATAL_ERROR "llvm-config not found: specify LLVM_CONFIG_PATH") message(FATAL_ERROR "llvm-config not found: specify LLVM_CONFIG_PATH")
endif() endif()
endif() endif()
Show All 33 Lineselse()
if (MSVC OR XCODE) if (MSVC OR XCODE)
set(LIT_ARGS_DEFAULT "${LIT_ARGS_DEFAULT} --no-progress-bar") set(LIT_ARGS_DEFAULT "${LIT_ARGS_DEFAULT} --no-progress-bar")
endif() endif()
set(LLVM_LIT_ARGS "${LIT_ARGS_DEFAULT}" CACHE STRING "Default options for lit") set(LLVM_LIT_ARGS "${LIT_ARGS_DEFAULT}" CACHE STRING "Default options for lit")
endif() endif()
if("${COMPILER_RT_TEST_COMPILER}" MATCHES "clang[+]*$") if("${COMPILER_RT_TEST_COMPILER}" MATCHES "clang[+]*$")
set(COMPILER_RT_TEST_COMPILER_ID Clang) set(COMPILER_RT_TEST_COMPILER_ID Clang)
elseif("${COMPILER_RT_TEST_COMPILER}" MATCHES "clang-cl.exe$") elseif("${COMPILER_RT_TEST_COMPILER}" MATCHES "clang.*.exe$")
set(COMPILER_RT_TEST_COMPILER_ID Clang) set(COMPILER_RT_TEST_COMPILER_ID Clang)
else() else()
set(COMPILER_RT_TEST_COMPILER_ID GNU) set(COMPILER_RT_TEST_COMPILER_ID GNU)
endif() endif()
# Tests using XFAIL use the first value in COMPILER_RT_TEST_TARGET_TRIPLE # Tests using XFAIL use the first value in COMPILER_RT_TEST_TARGET_TRIPLE
set(COMPILER_RT_TEST_TARGET_TRIPLE ${TARGET_TRIPLE} CACHE STRING set(COMPILER_RT_TEST_TARGET_TRIPLE ${TARGET_TRIPLE} CACHE STRING
"Default triple for cross-compiled executables") "Default triple for cross-compiled executables")
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

cmake/Modules/AddCompilerRT.cmake

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Lines
LIBRARY DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR}) LIBRARY DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR})
endmacro() endmacro()
# Unittests support. # Unittests support.
set(COMPILER_RT_GTEST_PATH ${LLVM_MAIN_SRC_DIR}/utils/unittest/googletest) set(COMPILER_RT_GTEST_PATH ${LLVM_MAIN_SRC_DIR}/utils/unittest/googletest)
set(COMPILER_RT_GTEST_SOURCE ${COMPILER_RT_GTEST_PATH}/src/gtest-all.cc) set(COMPILER_RT_GTEST_SOURCE ${COMPILER_RT_GTEST_PATH}/src/gtest-all.cc)
set(COMPILER_RT_GTEST_CFLAGS set(COMPILER_RT_GTEST_CFLAGS
-DGTEST_NO_LLVM_RAW_OSTREAM=1 -DGTEST_NO_LLVM_RAW_OSTREAM=1
-DGTEST_HAS_RTTI=0
-I${COMPILER_RT_GTEST_PATH}/include -I${COMPILER_RT_GTEST_PATH}/include
-I${COMPILER_RT_GTEST_PATH} -I${COMPILER_RT_GTEST_PATH}
) )
if(MSVC)
# Clang doesn't support SEH on Windows yet.
list(APPEND COMPILER_RT_GTEST_CFLAGS -DGTEST_HAS_SEH=0)
endif()
# Link objects into a single executable with COMPILER_RT_TEST_COMPILER, # Link objects into a single executable with COMPILER_RT_TEST_COMPILER,
# using specified link flags. Make executable a part of provided # using specified link flags. Make executable a part of provided
# test_suite. # test_suite.
# add_compiler_rt_test(<test_suite> <test_name> # add_compiler_rt_test(<test_suite> <test_name>
# OBJECTS <object files> # OBJECTS <object files>
# DEPS <deps (e.g. runtime libs)> # DEPS <deps (e.g. runtime libs)>
# LINK_FLAGS <link flags>) # LINK_FLAGS <link flags>)
macro(add_compiler_rt_test test_suite test_name) macro(add_compiler_rt_test test_suite test_name)
parse_arguments(TEST "OBJECTS;DEPS;LINK_FLAGS" "" ${ARGN}) parse_arguments(TEST "OBJECTS;DEPS;LINK_FLAGS" "" ${ARGN})
set(output_bin "${CMAKE_CURRENT_BINARY_DIR}/${test_name}") set(output_bin "${CMAKE_CURRENT_BINARY_DIR}/${test_name}")
# Use host compiler in a standalone build, and just-built Clang otherwise. # Use host compiler in a standalone build, and just-built Clang otherwise.
if(NOT COMPILER_RT_STANDALONE_BUILD) if(NOT COMPILER_RT_STANDALONE_BUILD)
list(APPEND TEST_DEPS clang) list(APPEND TEST_DEPS clang)
endif() endif()
# If we're not on MSVC, include the linker flags from CMAKE but override them # If we're not on MSVC, include the linker flags from CMAKE but override them
# with the provided link flags. This ensures that flags which are required to # with the provided link flags. This ensures that flags which are required to
# link programs at all are included, but the changes needed for the test # link programs at all are included, but the changes needed for the test
# trump. With MSVC we can't do that because CMake is set up to run link.exe # trump. With MSVC we can't do that because CMake is set up to run link.exe
# when linking, not the compiler. Here, we hack it to use the compiler # when linking, not the compiler. Here, we hack it to use the compiler
# because we want to use -fsanitize flags. # because we want to use -fsanitize flags.
if(NOT MSVC) if(NOT MSVC)
samsonovUnsubmitted
Not Done
ReplyInline Actions

Restore a space here.

samsonov: Restore a space here.
set(TEST_LINK_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${TEST_LINK_FLAGS}") set(TEST_LINK_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${TEST_LINK_FLAGS}")
separate_arguments(TEST_LINK_FLAGS) separate_arguments(TEST_LINK_FLAGS)
endif() endif()
add_custom_target(${test_name} add_custom_target(${test_name}
# MSVS CL doesn't allow a space between -Fe and the output file name.
COMMAND ${COMPILER_RT_TEST_COMPILER} ${TEST_OBJECTS} COMMAND ${COMPILER_RT_TEST_COMPILER} ${TEST_OBJECTS}
${COMPILER_RT_TEST_COMPILER_EXE}"${output_bin}" -o "${output_bin}"
${TEST_LINK_FLAGS} ${TEST_LINK_FLAGS}
DEPENDS ${TEST_DEPS}) DEPENDS ${TEST_DEPS})
# Make the test suite depend on the binary. # Make the test suite depend on the binary.
add_dependencies(${test_suite} ${test_name}) add_dependencies(${test_suite} ${test_name})
endmacro() endmacro()
macro(add_compiler_rt_resource_file target_name file_name) macro(add_compiler_rt_resource_file target_name file_name)
set(src_file "${CMAKE_CURRENT_SOURCE_DIR}/${file_name}") set(src_file "${CMAKE_CURRENT_SOURCE_DIR}/${file_name}")
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

cmake/Modules/CompilerRTCompile.cmake

Show All 11 Lines if(NOT COMPILER_RT_STANDALONE_BUILD)
list(APPEND SOURCE_DEPS clang) list(APPEND SOURCE_DEPS clang)
endif() endif()
string(REGEX MATCH "[.](cc|cpp)$" is_cxx ${source_rpath}) string(REGEX MATCH "[.](cc|cpp)$" is_cxx ${source_rpath})
if(is_cxx) if(is_cxx)
string(REPLACE " " ";" global_flags "${CMAKE_CXX_FLAGS}") string(REPLACE " " ";" global_flags "${CMAKE_CXX_FLAGS}")
else() else()
string(REPLACE " " ";" global_flags "${CMAKE_C_FLAGS}") string(REPLACE " " ";" global_flags "${CMAKE_C_FLAGS}")
endif() endif()
# On Windows, CMAKE_*_FLAGS are built for MSVC but we use the GCC clang.exe
# which doesn't support flags starting with "/smth". Replace those with
# "-smth" equivalents.
if(MSVC)
string(REGEX REPLACE "^/" "-" global_flags "${global_flags}")
samsonovUnsubmitted
Not Done
ReplyInline Actions

what if the first element of global_flags starts with / ?

samsonov: what if the first element of global_flags starts with / ?
timurrrrAuthorUnsubmitted
Not Done
ReplyInline Actions

Good catch, fixed.

timurrrr: Good catch, fixed.
string(REPLACE ";/" ";-" global_flags "${global_flags}")
endif()
# Ignore unknown warnings. CMAKE_CXX_FLAGS may contain GCC-specific options # Ignore unknown warnings. CMAKE_CXX_FLAGS may contain GCC-specific options
# which are not supported by Clang. # which are not supported by Clang.
list(APPEND global_flags -Wno-unknown-warning-option) list(APPEND global_flags -Wno-unknown-warning-option)
set(compile_flags ${global_flags} ${SOURCE_CFLAGS}) set(compile_flags ${global_flags} ${SOURCE_CFLAGS})
add_custom_command( add_custom_command(
OUTPUT ${object_file} OUTPUT ${object_file}
# MSVS CL doesn't allow a space between -Fo and the object file name.
COMMAND ${COMPILER_RT_TEST_COMPILER} ${compile_flags} -c COMMAND ${COMPILER_RT_TEST_COMPILER} ${compile_flags} -c
${COMPILER_RT_TEST_COMPILER_OBJ}"${object_file}" -o "${object_file}"
samsonovUnsubmitted
Not Done
ReplyInline Actions

and here.

samsonov: and here.
${source_rpath} ${source_rpath}
MAIN_DEPENDENCY ${source} MAIN_DEPENDENCY ${source}
DEPENDS ${SOURCE_DEPS}) DEPENDS ${SOURCE_DEPS})
endmacro() endmacro()

lib/asan/tests/CMakeLists.txt

Show All 20 Linesset(ASAN_UNITTEST_HEADERS
asan_test_utils.h) asan_test_utils.h)
set(ASAN_UNITTEST_COMMON_CFLAGS set(ASAN_UNITTEST_COMMON_CFLAGS
${COMPILER_RT_GTEST_CFLAGS} ${COMPILER_RT_GTEST_CFLAGS}
-I${COMPILER_RT_SOURCE_DIR}/include -I${COMPILER_RT_SOURCE_DIR}/include
-I${COMPILER_RT_SOURCE_DIR}/lib -I${COMPILER_RT_SOURCE_DIR}/lib
-I${COMPILER_RT_SOURCE_DIR}/lib/asan -I${COMPILER_RT_SOURCE_DIR}/lib/asan
-I${COMPILER_RT_SOURCE_DIR}/lib/sanitizer_common/tests -I${COMPILER_RT_SOURCE_DIR}/lib/sanitizer_common/tests
-fno-rtti
samsonovUnsubmitted
Not Done
ReplyInline Actions

Consider adding this (and, probably, -DGTEST_HAS_SEH=0 on Windows) to COMPILER_RT_GTEST_CFLAGS definition instead.

samsonov: Consider adding this (and, probably, -DGTEST_HAS_SEH=0 on Windows) to COMPILER_RT_GTEST_CFLAGS…
-O2
-Wno-format -Wno-format
samsonovUnsubmitted
Not Done
ReplyInline Actions

Any particular reason to switch to -gline-tables-only from -g here?

samsonov: Any particular reason to switch to -gline-tables-only from -g here?
-Werror=sign-compare -Werror=sign-compare)
-O2)
append_if(COMPILER_RT_HAS_G_FLAG -g ASAN_UNITTEST_COMMON_CFLAGS)
append_if(COMPILER_RT_HAS_Zi_FLAG -Zi ASAN_UNITTEST_COMMON_CFLAGS)
append_if(COMPILER_RT_HAS_WNO_VARIADIC_MACROS_FLAG -Wno-variadic-macros ASAN_UNITTEST_COMMON_CFLAGS) append_if(COMPILER_RT_HAS_WNO_VARIADIC_MACROS_FLAG -Wno-variadic-macros ASAN_UNITTEST_COMMON_CFLAGS)
# -gline-tables-only must be enough for ASan, so use it if possible.
if(COMPILER_RT_TEST_COMPILER_ID MATCHES "Clang")
list(APPEND ASAN_UNITTEST_COMMON_CFLAGS -gline-tables-only)
else()
list(APPEND ASAN_UNITTEST_COMMON_CFLAGS -g)
endif()
if(MSVC) if(MSVC)
# MSVC system headers and gtest use a lot of deprecated stuff. # MSVC system headers and gtest use a lot of deprecated stuff.
list(APPEND ASAN_UNITTEST_COMMON_CFLAGS list(APPEND ASAN_UNITTEST_COMMON_CFLAGS
-Wno-deprecated-declarations) -Wno-deprecated-declarations)
# clang-cl doesn't support exceptions yet. # clang doesn't support exceptions on Windows yet.
list(APPEND ASAN_UNITTEST_COMMON_CFLAGS list(APPEND ASAN_UNITTEST_COMMON_CFLAGS
/fallback
-D_HAS_EXCEPTIONS=0) -D_HAS_EXCEPTIONS=0)
# We should teach clang-cl to understand more pragmas. # We should teach clang to understand more pragmas.
list(APPEND ASAN_UNITTEST_COMMON_CFLAGS list(APPEND ASAN_UNITTEST_COMMON_CFLAGS
-Wno-unknown-pragmas -Wno-unknown-pragmas
-Wno-undefined-inline) -Wno-undefined-inline)
endif() endif()
# Use -D instead of definitions to please custom compile command. # Use -D instead of definitions to please custom compile command.
list(APPEND ASAN_UNITTEST_COMMON_CFLAGS list(APPEND ASAN_UNITTEST_COMMON_CFLAGS
-DASAN_HAS_BLACKLIST=1 -DASAN_HAS_BLACKLIST=1
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

lib/sanitizer_common/tests/CMakeLists.txt

Show All 32 Linesforeach(header ${SANITIZER_HEADERS})
list(APPEND SANITIZER_TEST_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/../${header}) list(APPEND SANITIZER_TEST_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/../${header})
endforeach() endforeach()
set(SANITIZER_TEST_CFLAGS_COMMON set(SANITIZER_TEST_CFLAGS_COMMON
${COMPILER_RT_GTEST_CFLAGS} ${COMPILER_RT_GTEST_CFLAGS}
-I${COMPILER_RT_SOURCE_DIR}/include -I${COMPILER_RT_SOURCE_DIR}/include
-I${COMPILER_RT_SOURCE_DIR}/lib -I${COMPILER_RT_SOURCE_DIR}/lib
-I${COMPILER_RT_SOURCE_DIR}/lib/sanitizer_common -I${COMPILER_RT_SOURCE_DIR}/lib/sanitizer_common
-DGTEST_HAS_RTTI=0 -fno-rtti
-O2 -O2
-Werror=sign-compare -Werror=sign-compare
-Wno-non-virtual-dtor) -Wno-non-virtual-dtor)
append_if(COMPILER_RT_HAS_G_FLAG -g SANITIZER_TEST_CFLAGS_COMMON) # -gline-tables-only must be enough for these tests, so use it if possible.
append_if(COMPILER_RT_HAS_Zi_FLAG -Zi SANITIZER_TEST_CFLAGS_COMMON) if(COMPILER_RT_TEST_COMPILER_ID MATCHES "Clang")
list(APPEND ASAN_UNITTEST_COMMON_CFLAGS -gline-tables-only)
append_if(COMPILER_RT_HAS_FNO_RTTI_FLAG -fno-rtti SANITIZER_TEST_CFLAGS_COMMON) else()
append_if(COMPILER_RT_HAS_GR_FLAG -GR- SANITIZER_TEST_CFLAGS_COMMON) list(APPEND ASAN_UNITTEST_COMMON_CFLAGS -g)
endif()
if(MSVC) if(MSVC)
# System headers and gtest use a lot of deprecated stuff. # MSVC system headers and gtest use a lot of deprecated stuff.
list(APPEND SANITIZER_TEST_CFLAGS_COMMON list(APPEND SANITIZER_TEST_CFLAGS_COMMON
-Wno-deprecated-declarations) -Wno-deprecated-declarations)
# clang-cl doesn't support exceptions yet. # clang doesn't support exceptions on Windows yet.
list(APPEND SANITIZER_TEST_CFLAGS_COMMON list(APPEND SANITIZER_TEST_CFLAGS_COMMON
/fallback -DGTEST_HAS_SEH=0
samsonovUnsubmitted
Not Done
ReplyInline Actions

GTEST_HAS_SEH=0 now comes from OMPILER_RT_GTEST_CFLAGS, doesn't it?

samsonov: GTEST_HAS_SEH=0 now comes from OMPILER_RT_GTEST_CFLAGS, doesn't it?
timurrrrAuthorUnsubmitted
Not Done
ReplyInline Actions

Oops, missed that -- thanks for catching!

I should probably move the stuff we conditionally append to SANITIZER_TEST_CFLAGS_COMMON to COMPILER_RT_GTEST_CFLAGS instead. Will do that in a separate commit.

timurrrr: Oops, missed that -- thanks for catching! I should probably move the stuff we conditionally…
-D_HAS_EXCEPTIONS=0) -D_HAS_EXCEPTIONS=0)
# We should teach clang-cl to understand more pragmas. # We should teach clang to understand more pragmas.
list(APPEND SANITIZER_TEST_CFLAGS_COMMON list(APPEND SANITIZER_TEST_CFLAGS_COMMON
-Wno-unknown-pragmas -Wno-unknown-pragmas
-Wno-undefined-inline) -Wno-undefined-inline)
endif() endif()
if(NOT MSVC) if(NOT MSVC)
list(APPEND SANITIZER_TEST_LINK_FLAGS_COMMON --driver-mode=g++) list(APPEND SANITIZER_TEST_LINK_FLAGS_COMMON --driver-mode=g++)
endif() endif()
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

test/asan/TestCases/Windows/aligned_mallocs.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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

test/asan/TestCases/Windows/allocators_sanity.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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

test/asan/TestCases/Windows/beginthreadex.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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

test/asan/TestCases/Windows/bitfield.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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

test/asan/TestCases/Windows/bitfield_uaf.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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

test/asan/TestCases/Windows/calloc_left_oob.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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);
} }

test/asan/TestCases/Windows/calloc_right_oob.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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);
} }

test/asan/TestCases/Windows/calloc_uaf.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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

test/asan/TestCases/Windows/crt_initializers.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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

test/asan/TestCases/Windows/dll_aligned_mallocs.cc

// RUN: %clangxx_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
// RUN: %clangxx_asan -LD -O0 %s -Fe%t.dll // RUN: %clang_cl_asan -LD -O0 %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

test/asan/TestCases/Windows/dll_allocators_sanity.cc

// RUN: %clangxx_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
// RUN: %clangxx_asan -LD -O0 %s -Fe%t.dll // RUN: %clang_cl_asan -LD -O0 %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

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: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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:
// RUN: dumpbin /EXPORTS %t | grep -o "__asan_wrap[^ ]*" | grep -v @ | sort | uniq > %t.exported_wrappers // RUN: dumpbin /EXPORTS %t | grep -o "__asan_wrap[^ ]*" | grep -v @ | sort | uniq > %t.exported_wrappers
// //
// Get the list of ASan wrappers imported by the DLL RTL: // Get the list of ASan wrappers imported by the DLL RTL:
// RUN: grep INTERCEPT_LIBRARY_FUNCTION %p/../../../../lib/asan/asan_dll_thunk.cc | grep -v define | sed "s/.*(\(.*\)).*/__asan_wrap_\1/" | sort | uniq > %t.dll_imports // RUN: grep INTERCEPT_LIBRARY_FUNCTION %p/../../../../lib/asan/asan_dll_thunk.cc | grep -v define | sed "s/.*(\(.*\)).*/__asan_wrap_\1/" | sort | uniq > %t.dll_imports
// //
// Now make sure the DLL thunk imports everything: // Now make sure the DLL thunk imports everything:
Show All 35 Lines

test/asan/TestCases/Windows/dll_intercept_memcpy.cc

// RUN: %clangxx_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
// RUN: %clangxx_asan -LD -O0 %s -Fe%t.dll // RUN: %clang_cl_asan -LD -O0 %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 23 Lines

test/asan/TestCases/Windows/dll_intercept_strlen.cc

// RUN: %clangxx_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
// RUN: %clangxx_asan -LD -O0 %s -Fe%t.dll // RUN: %clang_cl_asan -LD -O0 %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

test/asan/TestCases/Windows/dll_malloc_left_oob.cc

// RUN: %clangxx_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
// RUN: %clangxx_asan -LD -O0 %s -Fe%t.dll // RUN: %clang_cl_asan -LD -O0 %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

test/asan/TestCases/Windows/dll_malloc_uaf.cc

// RUN: %clangxx_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
// RUN: %clangxx_asan -LD -O0 %s -Fe%t.dll // RUN: %clang_cl_asan -LD -O0 %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

test/asan/TestCases/Windows/dll_noreturn.cc

// RUN: %clangxx_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
// RUN: %clangxx_asan -LD -O0 %s -Fe%t.dll // RUN: %clang_cl_asan -LD -O0 %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

test/asan/TestCases/Windows/dll_operator_array_new_left_oob.cc

// RUN: %clangxx_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
// RUN: %clangxx_asan -LD -O0 %s -Fe%t.dll // RUN: %clang_cl_asan -LD -O0 %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

test/asan/TestCases/Windows/dll_operator_array_new_with_dtor_left_oob.cc

// RUN: %clangxx_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
// RUN: %clangxx_asan -LD -O0 %s -Fe%t.dll // RUN: %clang_cl_asan -LD -O0 %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

test/asan/TestCases/Windows/dll_poison_unpoison.cc

// RUN: %clangxx_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
// RUN: %clangxx_asan -LD -O0 %s -Fe%t.dll // RUN: %clang_cl_asan -LD -O0 %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

test/asan/TestCases/Windows/dll_stack_use_after_return.cc

// RUN: %clangxx_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
// RUN: %clangxx_asan -LD -O0 %s -Fe%t.dll // RUN: %clang_cl_asan -LD -O0 %s -Fe%t.dll
// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=1 not %run %t %t.dll 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=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

test/asan/TestCases/Windows/dll_thread_stack_array_left_oob.cc

// RUN: %clangxx_asan -O0 %p/dll_host.cc -Fe%t // RUN: %clang_cl_asan -O0 %p/dll_host.cc -Fe%t
// RUN: %clangxx_asan -LD -O0 %s -Fe%t.dll // RUN: %clang_cl_asan -LD -O0 %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

test/asan/TestCases/Windows/double_free.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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

test/asan/TestCases/Windows/double_operator_delete.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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 13 Lines

test/asan/TestCases/Windows/global_const_string.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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;
} }

test/asan/TestCases/Windows/global_const_string_oob.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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

test/asan/TestCases/Windows/hello_world.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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!
} }

test/asan/TestCases/Windows/intercept_memcpy.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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

test/asan/TestCases/Windows/intercept_strdup.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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 18 Lines

test/asan/TestCases/Windows/intercept_strlen.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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

test/asan/TestCases/Windows/malloc_left_oob.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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);
} }

test/asan/TestCases/Windows/malloc_right_oob.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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);
} }

test/asan/TestCases/Windows/malloc_uaf.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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

test/asan/TestCases/Windows/operator_array_new_left_oob.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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:
// CHECK-NEXT: {{#0 .* operator new}}[] // CHECK-NEXT: {{#0 .* operator new}}[]
// CHECK-NEXT: {{#1 .* main .*operator_array_new_left_oob.cc}}:[[@LINE-9]] // CHECK-NEXT: {{#1 .* main .*operator_array_new_left_oob.cc}}:[[@LINE-9]]
delete [] buffer; delete [] buffer;
} }

test/asan/TestCases/Windows/operator_array_new_right_oob.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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]+]]
// CHECK: WRITE of size 1 at [[ADDR]] thread T0 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
// CHECK: {{#0 .* main .*operator_array_new_right_oob.cc}}:[[@LINE-3]] // CHECK: {{#0 .* main .*operator_array_new_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: {{#0 .* operator new}}[] // CHECK: {{#0 .* operator new}}[]
// CHECK: {{#1 .* main .*operator_array_new_right_oob.cc}}:[[@LINE-8]] // CHECK: {{#1 .* main .*operator_array_new_right_oob.cc}}:[[@LINE-8]]
delete [] buffer; delete [] buffer;
} }

test/asan/TestCases/Windows/operator_array_new_uaf.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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 13 Lines

test/asan/TestCases/Windows/operator_array_new_with_dtor_left_oob.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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 15 Lines

test/asan/TestCases/Windows/operator_delete_wrong_argument.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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]]
} }

test/asan/TestCases/Windows/operator_new_left_oob.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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;
} }

test/asan/TestCases/Windows/operator_new_right_oob.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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;
} }

test/asan/TestCases/Windows/operator_new_uaf.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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

test/asan/TestCases/Windows/realloc_left_oob.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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);
} }

test/asan/TestCases/Windows/realloc_right_oob.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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);
} }

test/asan/TestCases/Windows/realloc_uaf.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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

test/asan/TestCases/Windows/stack_array_left_oob.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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-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_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
} }

test/asan/TestCases/Windows/stack_array_right_oob.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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
} }

test/asan/TestCases/Windows/stack_array_sanity.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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
} }

test/asan/TestCases/Windows/stack_use_after_return.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %s -Fe%t
// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=1 not %run %t 2>&1 | FileCheck %s // RUN: env ASAN_OPTIONS=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

test/asan/TestCases/Windows/thread_simple.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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

test/asan/TestCases/Windows/thread_stack_array_left_oob.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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

test/asan/TestCases/Windows/thread_stack_array_right_oob.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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

test/asan/TestCases/Windows/thread_stack_reuse.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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

test/asan/TestCases/Windows/thread_stress.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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

test/asan/TestCases/Windows/use_after_realloc.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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

test/asan/TestCases/Windows/windows_h.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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() {}

test/asan/TestCases/Windows/wrong_downcast_on_heap.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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

test/asan/TestCases/Windows/wrong_downcast_on_stack.cc

// RUN: %clangxx_asan -O0 %s -Fe%t // RUN: %clang_cl_asan -O0 %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

test/asan/lit.cfg

# -*- Python -*- # -*- Python -*-
import os import os
import platform
def get_required_attr(config, attr_name): def get_required_attr(config, attr_name):
attr_value = getattr(config, attr_name, None) attr_value = getattr(config, attr_name, None)
if attr_value == None: if attr_value == None:
lit_config.fatal( lit_config.fatal(
"No attribute %r in test configuration! You may need to run " "No attribute %r in test configuration! You may need to run "
"tests from your build directory or add this attribute " "tests from your build directory or add this attribute "
"to lit.site.cfg " % attr_name) "to lit.site.cfg " % attr_name)
Show All 15 Lines
if config.compiler_id == 'GNU': if config.compiler_id == 'GNU':
extra_linkflags = ["-lpthread", "-lstdc++", "-ldl"] extra_linkflags = ["-lpthread", "-lstdc++", "-ldl"]
else: else:
extra_linkflags = [] extra_linkflags = []
# Setup default compiler flags used with -fsanitize=address option. # Setup default compiler flags used with -fsanitize=address option.
# FIXME: Review the set of required flags and check if it can be reduced. # FIXME: Review the set of required flags and check if it can be reduced.
target_cflags = [get_required_attr(config, "target_cflags")] + extra_linkflags target_cflags = [get_required_attr(config, "target_cflags")] + extra_linkflags
target_cxxflags = config.cxx_mode_flags + target_cflags target_cxxflags = config.cxx_mode_flags + target_cflags
clang_asan_static_cflags = ["-fsanitize=address"] + target_cflags clang_asan_static_cflags = ["-fsanitize=address",
clang_path = getattr(config, 'clang', None)
if clang_path.find("clang-cl") == -1:
clang_asan_static_cflags += ["-g",
"-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",
else: "-g"] + target_cflags
clang_asan_static_cflags += ["-Zi",
"-Wno-deprecated-declarations",
"-D_HAS_EXCEPTIONS=0"]
clang_asan_static_cxxflags = config.cxx_mode_flags + clang_asan_static_cflags clang_asan_static_cxxflags = config.cxx_mode_flags + clang_asan_static_cflags
if config.asan_dynamic: if config.asan_dynamic:
clang_asan_cflags = clang_asan_static_cflags + ['-shared-libasan'] clang_asan_cflags = clang_asan_static_cflags + ['-shared-libasan']
clang_asan_cxxflags = clang_asan_static_cxxflags + ['-shared-libasan'] clang_asan_cxxflags = clang_asan_static_cxxflags + ['-shared-libasan']
config.available_features.add("asan-dynamic-runtime") config.available_features.add("asan-dynamic-runtime")
else: else:
clang_asan_cflags = clang_asan_static_cflags clang_asan_cflags = clang_asan_static_cflags
Show All 15 Lines
config.substitutions.append( ("%clangxx ", build_invocation(target_cxxflags)) ) config.substitutions.append( ("%clangxx ", build_invocation(target_cxxflags)) )
config.substitutions.append( ("%clang_asan ", build_invocation(clang_asan_cflags)) ) config.substitutions.append( ("%clang_asan ", build_invocation(clang_asan_cflags)) )
config.substitutions.append( ("%clangxx_asan ", build_invocation(clang_asan_cxxflags)) ) config.substitutions.append( ("%clangxx_asan ", build_invocation(clang_asan_cxxflags)) )
config.substitutions.append( ("%shared_libasan", "libclang_rt.asan-%s.so" % config.target_arch)) config.substitutions.append( ("%shared_libasan", "libclang_rt.asan-%s.so" % config.target_arch))
if config.asan_dynamic: if config.asan_dynamic:
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.
if platform.system() == 'Windows':
clang_cl_asan_cxxflags = ["-fsanitize=address",
"-Wno-deprecated-declarations",
"-D_HAS_EXCEPTIONS=0",
"-Zi"] + target_cflags
clang_invocation = build_invocation(clang_cl_asan_cxxflags)
clang_cl_invocation = clang_invocation.replace("clang.exe","clang-cl.exe")
config.substitutions.append( ("%clang_cl_asan ", clang_cl_invocation) )
# FIXME: De-hardcode this path. # FIXME: De-hardcode this path.
asan_source_dir = os.path.join( asan_source_dir = os.path.join(
get_required_attr(config, "compiler_rt_src_root"), "lib", "asan") get_required_attr(config, "compiler_rt_src_root"), "lib", "asan")
# Setup path to asan_symbolize.py script. # Setup path to asan_symbolize.py script.
asan_symbolize = os.path.join(asan_source_dir, "scripts", "asan_symbolize.py") asan_symbolize = os.path.join(asan_source_dir, "scripts", "asan_symbolize.py")
if not os.path.exists(asan_symbolize): if not os.path.exists(asan_symbolize):
lit_config.fatal("Can't find script on path %r" % asan_symbolize) lit_config.fatal("Can't find script on path %r" % asan_symbolize)
python_exec = get_required_attr(config, "python_executable") python_exec = get_required_attr(config, "python_executable")
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines