diff --git a/compiler-rt/lib/asan/CMakeLists.txt b/compiler-rt/lib/asan/CMakeLists.txt index b8bccbfcde3890..f993521d3ca88b 100644 --- a/compiler-rt/lib/asan/CMakeLists.txt +++ b/compiler-rt/lib/asan/CMakeLists.txt @@ -38,40 +38,9 @@ if (NOT WIN32 AND NOT APPLE) ) endif() -if (WIN32) - set(ASAN_CXX_SOURCES asan_win_new_delete.cpp) -else() - set(ASAN_CXX_SOURCES asan_new_delete.cpp) -endif() - -if (APPLE) - set(ASAN_SOURCES ASAN_CXX_SOURCES) -endif() - -if (WIN32) - set(ASAN_STATIC_IMPLIB_SOURCES - asan_win_delete_array_thunk.cpp - asan_win_delete_array_align_thunk.cpp - asan_win_delete_array_align_nothrow_thunk.cpp - asan_win_delete_array_nothrow_thunk.cpp - asan_win_delete_array_size_thunk.cpp - asan_win_delete_array_size_align_thunk.cpp - asan_win_delete_scalar_thunk.cpp - asan_win_delete_scalar_align_thunk.cpp - asan_win_delete_scalar_align_nothrow_thunk.cpp - asan_win_delete_scalar_nothrow_thunk.cpp - asan_win_delete_scalar_size_thunk.cpp - asan_win_delete_scalar_size_align_thunk.cpp - asan_win_new_array_thunk.cpp - asan_win_new_array_align_thunk.cpp - asan_win_new_array_align_nothrow_thunk.cpp - asan_win_new_array_nothrow_thunk.cpp - asan_win_new_scalar_thunk.cpp - asan_win_new_scalar_align_thunk.cpp - asan_win_new_scalar_align_nothrow_thunk.cpp - asan_win_new_scalar_nothrow_thunk.cpp - ) -endif() +set(ASAN_CXX_SOURCES + asan_new_delete.cpp + ) set(ASAN_STATIC_SOURCES asan_rtl_static.cpp @@ -114,20 +83,12 @@ SET(ASAN_HEADERS asan_thread.h ) -if (WIN32) - list(APPEND ASAN_HEADERS - asan_win_new_delete_thunk_common.h - asan_win_thunk_common.h - ) -endif() - include_directories(..) set(ASAN_CFLAGS ${SANITIZER_COMMON_CFLAGS}) set(ASAN_COMMON_DEFINITIONS ${COMPILER_RT_ASAN_SHADOW_SCALE_DEFINITION}) append_rtti_flag(OFF ASAN_CFLAGS) -append_list_if(MSVC /EHsc ASAN_CFLAGS) # Silence warnings in system headers with MSVC. if(NOT CLANG_CL) @@ -178,15 +139,6 @@ add_compiler_rt_object_libraries(RTAsan_dynamic CFLAGS ${ASAN_DYNAMIC_CFLAGS} DEFS ${ASAN_DYNAMIC_DEFINITIONS}) -if (WIN32) - add_compiler_rt_object_libraries(RTAsan_static_implib - ARCHS ${ASAN_SUPPORTED_ARCH} - SOURCES ${ASAN_STATIC_IMPLIB_SOURCES} - ADDITIONAL_HEADERS ${ASAN_HEADERS} - CFLAGS ${ASAN_CFLAGS} ${NO_DEFAULT_LIBS_OPTION} - DEFS ${ASAN_COMMON_DEFINITIONS}) -endif() - if(NOT APPLE) add_compiler_rt_object_libraries(RTAsan ARCHS ${ASAN_SUPPORTED_ARCH} @@ -287,24 +239,13 @@ else() DEFS ${ASAN_COMMON_DEFINITIONS} PARENT_TARGET asan) -if(WIN32) add_compiler_rt_runtime(clang_rt.asan_static STATIC ARCHS ${ASAN_SUPPORTED_ARCH} OBJECT_LIBS RTAsan_static - RTAsan_static_implib CFLAGS ${ASAN_CFLAGS} DEFS ${ASAN_COMMON_DEFINITIONS} PARENT_TARGET asan) -else() - add_compiler_rt_runtime(clang_rt.asan_static - STATIC - ARCHS ${ASAN_SUPPORTED_ARCH} - OBJECT_LIBS RTAsan_static - CFLAGS ${ASAN_CFLAGS} - DEFS ${ASAN_COMMON_DEFINITIONS} - PARENT_TARGET asan) -endif() add_compiler_rt_runtime(clang_rt.asan-preinit STATIC @@ -314,13 +255,6 @@ endif() DEFS ${ASAN_COMMON_DEFINITIONS} PARENT_TARGET asan) - - if (MSVC AND COMPILER_RT_DEBUG) - set(MSVC_DBG_SUFFIX _dbg) - else() - set(MSVC_DBG_SUFFIX ) - endif() - foreach(arch ${ASAN_SUPPORTED_ARCH}) if (COMPILER_RT_HAS_VERSION_SCRIPT) add_sanitizer_rt_version_list(clang_rt.asan-dynamic-${arch} @@ -377,27 +311,6 @@ endif() DEFS ${ASAN_DYNAMIC_DEFINITIONS} PARENT_TARGET asan) - if(WIN32) - set_target_properties(clang_rt.asan${MSVC_DBG_SUFFIX}-dynamic-${arch} - PROPERTIES ARCHIVE_OUTPUT_NAME clang_rt.asan_dynamic-${arch}_implib - ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}") - - add_library(clang_rt.asan-${arch}_implib STATIC) - target_link_libraries(clang_rt.asan-${arch}_implib RTAsan_static_implib.${arch}) - add_dependencies(asan clang_rt.asan-${arch}_implib) - add_dependencies(clang_rt.asan-${arch}_implib clang_rt.asan${MSVC_DBG_SUFFIX}-dynamic-${arch}) - get_compiler_rt_output_dir(${arch} IMPLIB_OUTPUT_DIR) - set_target_properties(clang_rt.asan-${arch}_implib - PROPERTIES ARCHIVE_OUTPUT_NAME clang_rt.asan${MSVC_DBG_SUFFIX}_dynamic-${arch} - ARCHIVE_OUTPUT_DIRECTORY ${IMPLIB_OUTPUT_DIR} - STATIC_LIBRARY_OPTIONS "$") - get_compiler_rt_install_dir(${arch} IMPLIB_INSTALL_DIR) - install(TARGETS clang_rt.asan-${arch}_implib - ARCHIVE DESTINATION ${IMPLIB_INSTALL_DIR} - LIBRARY DESTINATION ${IMPLIB_INSTALL_DIR} - RUNTIME DESTINATION ${IMPLIB_INSTALL_DIR}) - endif() - if (SANITIZER_USE_SYMBOLS AND NOT ${arch} STREQUAL "i386") add_sanitizer_rt_symbols(clang_rt.asan_cxx ARCHS ${arch}) diff --git a/compiler-rt/lib/asan/asan_interface.inc b/compiler-rt/lib/asan/asan_interface.inc index 83c0c1cffb8536..bfc44b46196232 100644 --- a/compiler-rt/lib/asan/asan_interface.inc +++ b/compiler-rt/lib/asan/asan_interface.inc @@ -187,22 +187,3 @@ INTERFACE_FUNCTION(__asan_update_allocation_context) INTERFACE_WEAK_FUNCTION(__asan_default_options) INTERFACE_WEAK_FUNCTION(__asan_default_suppressions) INTERFACE_WEAK_FUNCTION(__asan_on_error) - -#if SANITIZER_WINDOWS -INTERFACE_FUNCTION(__asan_delete) -INTERFACE_FUNCTION(__asan_delete_align) -INTERFACE_FUNCTION(__asan_delete_array) -INTERFACE_FUNCTION(__asan_delete_array_align) -INTERFACE_FUNCTION(__asan_delete_array_size) -INTERFACE_FUNCTION(__asan_delete_array_size_align) -INTERFACE_FUNCTION(__asan_delete_size) -INTERFACE_FUNCTION(__asan_delete_size_align) -INTERFACE_FUNCTION(__asan_new) -INTERFACE_FUNCTION(__asan_new_align) -INTERFACE_FUNCTION(__asan_new_align_nothrow) -INTERFACE_FUNCTION(__asan_new_array) -INTERFACE_FUNCTION(__asan_new_array_align) -INTERFACE_FUNCTION(__asan_new_array_align_nothrow) -INTERFACE_FUNCTION(__asan_new_array_nothrow) -INTERFACE_FUNCTION(__asan_new_nothrow) -#endif // SANITIZER_WINDOWS diff --git a/compiler-rt/lib/asan/asan_win_delete_array_align_nothrow_thunk.cpp b/compiler-rt/lib/asan/asan_win_delete_array_align_nothrow_thunk.cpp deleted file mode 100644 index 5740854b31d1f8..00000000000000 --- a/compiler-rt/lib/asan/asan_win_delete_array_align_nothrow_thunk.cpp +++ /dev/null @@ -1,24 +0,0 @@ -//===-- asan_win_delete_array_align_nothrow_thunk.cc ----------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file is a part of AddressSanitizer, an address sanity checker. -// -// Windows-specific user-provided new/delete operator detection and fallback. -//===----------------------------------------------------------------------===// -#include "asan_win_new_delete_thunk_common.h" - -// see diagram in asan_win_new_delete_thunk_common.h for the ordering of the -// new/delete fallbacks. - -// Avoid tailcall optimization to preserve stack frame. -#pragma optimize("", off) -void operator delete[](void* ptr, std::align_val_t align, - std::nothrow_t const&) noexcept { - // nothrow version is identical to throwing version - operator delete[](ptr, align); -} diff --git a/compiler-rt/lib/asan/asan_win_delete_array_align_thunk.cpp b/compiler-rt/lib/asan/asan_win_delete_array_align_thunk.cpp deleted file mode 100644 index 7e98380cb29519..00000000000000 --- a/compiler-rt/lib/asan/asan_win_delete_array_align_thunk.cpp +++ /dev/null @@ -1,28 +0,0 @@ -//===-- asan_win_delete_array_align_thunk.cc ------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file is a part of AddressSanitizer, an address sanity checker. -// -// Windows-specific user-provided new/delete operator detection and fallback. -//===----------------------------------------------------------------------===// -#include "asan_win_new_delete_thunk_common.h" - -// see diagram in asan_win_new_delete_thunk_common.h for the ordering of the -// new/delete fallbacks. - -__asan_InitDefine init_delete_array_align; - -// Avoid tailcall optimization to preserve stack frame. -#pragma optimize("", off) -void operator delete[](void* ptr, std::align_val_t align) noexcept { - if (__asan_InitDefine::defined) { - __asan_delete_array_align(ptr, align); - } else { - operator delete(ptr, align); - } -} diff --git a/compiler-rt/lib/asan/asan_win_delete_array_nothrow_thunk.cpp b/compiler-rt/lib/asan/asan_win_delete_array_nothrow_thunk.cpp deleted file mode 100644 index 2018adb498bbce..00000000000000 --- a/compiler-rt/lib/asan/asan_win_delete_array_nothrow_thunk.cpp +++ /dev/null @@ -1,23 +0,0 @@ -//===-- asan_win_delete_array_nothrow_thunk.cc ----------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file is a part of AddressSanitizer, an address sanity checker. -// -// Windows-specific user-provided new/delete operator detection and fallback. -//===----------------------------------------------------------------------===// -#include "asan_win_new_delete_thunk_common.h" - -// see diagram in asan_win_new_delete_thunk_common.h for the ordering of the -// new/delete fallbacks. - -// Avoid tailcall optimization to preserve stack frame. -#pragma optimize("", off) -void operator delete[](void* ptr, std::nothrow_t const&) noexcept { - // nothrow version is identical to throwing version - operator delete[](ptr); -} diff --git a/compiler-rt/lib/asan/asan_win_delete_array_size_align_thunk.cpp b/compiler-rt/lib/asan/asan_win_delete_array_size_align_thunk.cpp deleted file mode 100644 index ac576a1945bb92..00000000000000 --- a/compiler-rt/lib/asan/asan_win_delete_array_size_align_thunk.cpp +++ /dev/null @@ -1,28 +0,0 @@ -//===-- asan_win_delete_array_size_align_thunk.cc -------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file is a part of AddressSanitizer, an address sanity checker. -// -// Windows-specific user-provided new/delete operator detection and fallback. -//===----------------------------------------------------------------------===// -#include "asan_win_new_delete_thunk_common.h" - -// see diagram in asan_win_new_delete_thunk_common.h for the ordering of the -// new/delete fallbacks. - -// Avoid tailcall optimization to preserve stack frame. -#pragma optimize("", off) -void operator delete[](void* ptr, size_t size, - std::align_val_t align) noexcept { - if (__asan_InitDefine::defined && - __asan_InitDefine::defined) { - __asan_delete_array_size_align(ptr, size, align); - } else { - operator delete[](ptr, align); - } -} diff --git a/compiler-rt/lib/asan/asan_win_delete_array_size_thunk.cpp b/compiler-rt/lib/asan/asan_win_delete_array_size_thunk.cpp deleted file mode 100644 index 93c91e4651ab1d..00000000000000 --- a/compiler-rt/lib/asan/asan_win_delete_array_size_thunk.cpp +++ /dev/null @@ -1,27 +0,0 @@ -//===-- asan_win_delete_array_size_thunk.cc -------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file is a part of AddressSanitizer, an address sanity checker. -// -// Windows-specific user-provided new/delete operator detection and fallback. -//===----------------------------------------------------------------------===// -#include "asan_win_new_delete_thunk_common.h" - -// see diagram in asan_win_new_delete_thunk_common.h for the ordering of the -// new/delete fallbacks. - -// Avoid tailcall optimization to preserve stack frame. -#pragma optimize("", off) -void operator delete[](void* ptr, size_t size) noexcept { - if (__asan_InitDefine::defined && - __asan_InitDefine::defined) { - __asan_delete_array_size(ptr, size); - } else { - operator delete[](ptr); - } -} diff --git a/compiler-rt/lib/asan/asan_win_delete_array_thunk.cpp b/compiler-rt/lib/asan/asan_win_delete_array_thunk.cpp deleted file mode 100644 index 9cdab36c6125e9..00000000000000 --- a/compiler-rt/lib/asan/asan_win_delete_array_thunk.cpp +++ /dev/null @@ -1,28 +0,0 @@ -//===-- asan_win_delete_array_thunk.cc ------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file is a part of AddressSanitizer, an address sanity checker. -// -// Windows-specific user-provided new/delete operator detection and fallback. -//===----------------------------------------------------------------------===// -#include "asan_win_new_delete_thunk_common.h" - -// see diagram in asan_win_new_delete_thunk_common.h for the ordering of the -// new/delete fallbacks. - -__asan_InitDefine init_delete_array; - -// Avoid tailcall optimization to preserve stack frame. -#pragma optimize("", off) -void operator delete[](void* ptr) noexcept { - if (__asan_InitDefine::defined) { - __asan_delete_array(ptr); - } else { - operator delete(ptr); - } -} diff --git a/compiler-rt/lib/asan/asan_win_delete_scalar_align_nothrow_thunk.cpp b/compiler-rt/lib/asan/asan_win_delete_scalar_align_nothrow_thunk.cpp deleted file mode 100644 index 35db32976a4fab..00000000000000 --- a/compiler-rt/lib/asan/asan_win_delete_scalar_align_nothrow_thunk.cpp +++ /dev/null @@ -1,24 +0,0 @@ -//===-- asan_win_delete_scalar_align_nothrow_thunk.cc ---------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file is a part of AddressSanitizer, an address sanity checker. -// -// Windows-specific user-provided new/delete operator detection and fallback. -//===----------------------------------------------------------------------===// -#include "asan_win_new_delete_thunk_common.h" - -// see diagram in asan_win_new_delete_thunk_common.h for the ordering of the -// new/delete fallbacks. - -// Avoid tailcall optimization to preserve stack frame. -#pragma optimize("", off) -void operator delete(void* ptr, std::align_val_t align, - std::nothrow_t const&) noexcept { - // nothrow version is identical to throwing version - operator delete(ptr, align); -} diff --git a/compiler-rt/lib/asan/asan_win_delete_scalar_align_thunk.cpp b/compiler-rt/lib/asan/asan_win_delete_scalar_align_thunk.cpp deleted file mode 100644 index 4d2bd867284e0a..00000000000000 --- a/compiler-rt/lib/asan/asan_win_delete_scalar_align_thunk.cpp +++ /dev/null @@ -1,24 +0,0 @@ -//===-- asan_win_delete_scalar_align_thunk.cc -----------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file is a part of AddressSanitizer, an address sanity checker. -// -// Windows-specific user-provided new/delete operator detection and fallback. -//===----------------------------------------------------------------------===// -#include "asan_win_new_delete_thunk_common.h" - -// see diagram in asan_win_new_delete_thunk_common.h for the ordering of the -// new/delete fallbacks. - -__asan_InitDefine init_delete_scalar_align; - -// Avoid tailcall optimization to preserve stack frame. -#pragma optimize("", off) -void operator delete(void* ptr, std::align_val_t align) noexcept { - __asan_delete_align(ptr, align); -} diff --git a/compiler-rt/lib/asan/asan_win_delete_scalar_nothrow_thunk.cpp b/compiler-rt/lib/asan/asan_win_delete_scalar_nothrow_thunk.cpp deleted file mode 100644 index e2b34cca8232dd..00000000000000 --- a/compiler-rt/lib/asan/asan_win_delete_scalar_nothrow_thunk.cpp +++ /dev/null @@ -1,23 +0,0 @@ -//===-- asan_win_delete_scalar_nothrow_thunk.cc ---------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file is a part of AddressSanitizer, an address sanity checker. -// -// Windows-specific user-provided new/delete operator detection and fallback. -//===----------------------------------------------------------------------===// -#include "asan_win_new_delete_thunk_common.h" - -// see diagram in asan_win_new_delete_thunk_common.h for the ordering of the -// new/delete fallbacks. - -// Avoid tailcall optimization to preserve stack frame. -#pragma optimize("", off) -void operator delete(void* ptr, std::nothrow_t const&) noexcept { - // nothrow version is identical to throwing version - operator delete(ptr); -} diff --git a/compiler-rt/lib/asan/asan_win_delete_scalar_size_align_thunk.cpp b/compiler-rt/lib/asan/asan_win_delete_scalar_size_align_thunk.cpp deleted file mode 100644 index 54cc54009ec2a6..00000000000000 --- a/compiler-rt/lib/asan/asan_win_delete_scalar_size_align_thunk.cpp +++ /dev/null @@ -1,26 +0,0 @@ -//===-- asan_win_delete_scalar_size_align_thunk.cc ------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file is a part of AddressSanitizer, an address sanity checker. -// -// Windows-specific user-provided new/delete operator detection and fallback. -//===----------------------------------------------------------------------===// -#include "asan_win_new_delete_thunk_common.h" - -// see diagram in asan_win_new_delete_thunk_common.h for the ordering of the -// new/delete fallbacks. - -// Avoid tailcall optimization to preserve stack frame. -#pragma optimize("", off) -void operator delete(void* ptr, size_t size, std::align_val_t align) noexcept { - if (__asan_InitDefine::defined) { - __asan_delete_size_align(ptr, size, align); - } else { - operator delete(ptr, align); - } -} diff --git a/compiler-rt/lib/asan/asan_win_delete_scalar_size_thunk.cpp b/compiler-rt/lib/asan/asan_win_delete_scalar_size_thunk.cpp deleted file mode 100644 index ba988f39f12c49..00000000000000 --- a/compiler-rt/lib/asan/asan_win_delete_scalar_size_thunk.cpp +++ /dev/null @@ -1,26 +0,0 @@ -//===-- asan_win_delete_scalar_size_thunk.cc ------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file is a part of AddressSanitizer, an address sanity checker. -// -// Windows-specific user-provided new/delete operator detection and fallback. -//===----------------------------------------------------------------------===// -#include "asan_win_new_delete_thunk_common.h" - -// see diagram in asan_win_new_delete_thunk_common.h for the ordering of the -// new/delete fallbacks. - -// Avoid tailcall optimization to preserve stack frame. -#pragma optimize("", off) -void operator delete(void* ptr, size_t size) noexcept { - if (__asan_InitDefine::defined) { - __asan_delete_size(ptr, size); - } else { - operator delete(ptr); - } -} diff --git a/compiler-rt/lib/asan/asan_win_delete_scalar_thunk.cpp b/compiler-rt/lib/asan/asan_win_delete_scalar_thunk.cpp deleted file mode 100644 index 1104716fe476e5..00000000000000 --- a/compiler-rt/lib/asan/asan_win_delete_scalar_thunk.cpp +++ /dev/null @@ -1,22 +0,0 @@ -//===-- asan_win_delete_scalar_thunk.cc -----------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file is a part of AddressSanitizer, an address sanity checker. -// -// Windows-specific user-provided new/delete operator detection and fallback. -//===----------------------------------------------------------------------===// -#include "asan_win_new_delete_thunk_common.h" - -// see diagram in asan_win_new_delete_thunk_common.h for the ordering of the -// new/delete fallbacks. - -__asan_InitDefine init_delete_scalar; - -// Avoid tailcall optimization to preserve stack frame. -#pragma optimize("", off) -void operator delete(void* ptr) noexcept { __asan_delete(ptr); } diff --git a/compiler-rt/lib/asan/asan_win_new_array_align_nothrow_thunk.cpp b/compiler-rt/lib/asan/asan_win_new_array_align_nothrow_thunk.cpp deleted file mode 100644 index 04cc253f7e89b3..00000000000000 --- a/compiler-rt/lib/asan/asan_win_new_array_align_nothrow_thunk.cpp +++ /dev/null @@ -1,32 +0,0 @@ -//===-- asan_win_new_array_align_nothrow_thunk.cc -------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file is a part of AddressSanitizer, an address sanity checker. -// -// Windows-specific user-provided new/delete operator detection and fallback. -//===----------------------------------------------------------------------===// -#include "asan_win_new_delete_thunk_common.h" - -// see diagram in asan_win_new_delete_thunk_common.h for the ordering of the -// new/delete fallbacks. - -// Avoid tailcall optimization to preserve stack frame. -#pragma optimize("", off) -void* operator new[](size_t size, std::align_val_t align, - std::nothrow_t const&) noexcept { - if (__asan_InitDefine::defined && - __asan_InitDefine::defined) { - return __asan_new_array_align_nothrow(size, align); - } - - try { - return operator new[](size, align); - } catch (...) { - return nullptr; - } -} diff --git a/compiler-rt/lib/asan/asan_win_new_array_align_thunk.cpp b/compiler-rt/lib/asan/asan_win_new_array_align_thunk.cpp deleted file mode 100644 index 92f48756506715..00000000000000 --- a/compiler-rt/lib/asan/asan_win_new_array_align_thunk.cpp +++ /dev/null @@ -1,28 +0,0 @@ -//===-- asan_win_new_array_align_thunk.cc ---------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file is a part of AddressSanitizer, an address sanity checker. -// -// Windows-specific user-provided new/delete operator detection and fallback. -//===----------------------------------------------------------------------===// -#include "asan_win_new_delete_thunk_common.h" - -// see diagram in asan_win_new_delete_thunk_common.h for the ordering of the -// new/delete fallbacks. - -__asan_InitDefine init_new_array_align; - -// Avoid tailcall optimization to preserve stack frame. -#pragma optimize("", off) -void* operator new[](size_t size, std::align_val_t align) { - if (__asan_InitDefine::defined) { - return __asan_new_array_align(size, align); - } - - return operator new(size, align); -} diff --git a/compiler-rt/lib/asan/asan_win_new_array_nothrow_thunk.cpp b/compiler-rt/lib/asan/asan_win_new_array_nothrow_thunk.cpp deleted file mode 100644 index 33da812090725d..00000000000000 --- a/compiler-rt/lib/asan/asan_win_new_array_nothrow_thunk.cpp +++ /dev/null @@ -1,33 +0,0 @@ -//===-- asan_win_new_array_nothrow_thunk.cc -------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file is a part of AddressSanitizer, an address sanity checker. -// -// Windows-specific user-provided new/delete operator detection and fallback. -//===----------------------------------------------------------------------===// -#include "asan_win_new_delete_thunk_common.h" - -// see diagram in asan_win_new_delete_thunk_common.h for the ordering of the -// new/delete fallbacks. - -extern "C" void* __cdecl __asan_new_array_nothrow(size_t size); - -// Avoid tailcall optimization to preserve stack frame. -#pragma optimize("", off) -void* operator new[](size_t size, std::nothrow_t const&) noexcept { - if (__asan_InitDefine::defined && - __asan_InitDefine::defined) { - return __asan_new_array_nothrow(size); - } - - try { - return operator new[](size); - } catch (...) { - return nullptr; - } -} diff --git a/compiler-rt/lib/asan/asan_win_new_array_thunk.cpp b/compiler-rt/lib/asan/asan_win_new_array_thunk.cpp deleted file mode 100644 index 24d7ff14a4c5b4..00000000000000 --- a/compiler-rt/lib/asan/asan_win_new_array_thunk.cpp +++ /dev/null @@ -1,27 +0,0 @@ -//===-- asan_win_new_array_thunk.cc ---------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file is a part of AddressSanitizer, an address sanity checker. -// -// Windows-specific user-provided new/delete operator detection and fallback. -//===----------------------------------------------------------------------===// -#include "asan_win_new_delete_thunk_common.h" - -// see diagram in asan_win_new_delete_thunk_common.h for the ordering of the -// new/delete fallbacks. - -__asan_InitDefine init_new_array; - -// Avoid tailcall optimization to preserve stack frame. -#pragma optimize("", off) -void* operator new[](size_t size) { - if (__asan_InitDefine::defined) { - return __asan_new_array(size); - } - return operator new(size); -} diff --git a/compiler-rt/lib/asan/asan_win_new_delete.cpp b/compiler-rt/lib/asan/asan_win_new_delete.cpp deleted file mode 100644 index a3db56ffef7a96..00000000000000 --- a/compiler-rt/lib/asan/asan_win_new_delete.cpp +++ /dev/null @@ -1,132 +0,0 @@ -//===-- asan_win_new_delete.cc --------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file is a part of AddressSanitizer, an address sanity checker. -// -// Windows-specific user-provided new/delete operator detection and fallback. -//===----------------------------------------------------------------------===// -#include - -#include "asan_allocator.h" -#include "asan_internal.h" -#include "asan_report.h" -#include "asan_stack.h" - -// Fake std::align_val_t to avoid including . -namespace std { -enum class align_val_t : size_t {}; -} - -using namespace __asan; - -#define OPERATOR_NEW_BODY(type, nothrow) \ - GET_STACK_TRACE_MALLOC \ - void *res = asan_memalign(0, size, &stack, type); \ - if (!nothrow && UNLIKELY(!res)) \ - ReportOutOfMemory(size, &stack); \ - return res; - -#define OPERATOR_NEW_BODY_ALIGN(type, nothrow) \ - GET_STACK_TRACE_MALLOC \ - void *res = asan_memalign((uptr)align, size, &stack, type); \ - if (!nothrow && UNLIKELY(!res)) \ - ReportOutOfMemory(size, &stack); \ - return res; - -#define OPERATOR_DELETE_BODY(type) \ - GET_STACK_TRACE_FREE \ - asan_delete(ptr, 0, 0, &stack, type); - -#define OPERATOR_DELETE_BODY_SIZE(type) \ - GET_STACK_TRACE_FREE \ - asan_delete(ptr, size, 0, &stack, type); - -#define OPERATOR_DELETE_BODY_ALIGN(type) \ - GET_STACK_TRACE_FREE \ - asan_delete(ptr, 0, static_cast(align), &stack, type); - -#define OPERATOR_DELETE_BODY_SIZE_ALIGN(type) \ - GET_STACK_TRACE_FREE \ - asan_delete(ptr, size, static_cast(align), &stack, type); - -extern "C" { -__declspec(dllexport) void *__cdecl __asan_new(size_t const size) { - OPERATOR_NEW_BODY(FROM_NEW, false /*nothrow*/); -} - -__declspec(dllexport) void *__cdecl __asan_new_array(size_t const size) { - OPERATOR_NEW_BODY(FROM_NEW_BR, false /*nothrow*/); -} - -__declspec(dllexport) void *__cdecl __asan_new_nothrow(size_t const size) { - OPERATOR_NEW_BODY(FROM_NEW, true /*nothrow*/); -} - -__declspec(dllexport) void *__cdecl __asan_new_array_nothrow( - size_t const size) { - OPERATOR_NEW_BODY(FROM_NEW_BR, true /*nothrow*/); -} - -__declspec(dllexport) void *__cdecl __asan_new_align( - size_t const size, std::align_val_t const align) { - OPERATOR_NEW_BODY_ALIGN(FROM_NEW, false /*nothrow*/); -} - -__declspec(dllexport) void *__cdecl __asan_new_array_align( - size_t const size, std::align_val_t const align) { - OPERATOR_NEW_BODY_ALIGN(FROM_NEW_BR, false /*nothrow*/); -} - -__declspec(dllexport) void *__cdecl __asan_new_align_nothrow( - size_t const size, std::align_val_t const align) { - OPERATOR_NEW_BODY_ALIGN(FROM_NEW, true /*nothrow*/); -} - -__declspec(dllexport) void *__cdecl __asan_new_array_align_nothrow( - size_t const size, std::align_val_t const align) { - OPERATOR_NEW_BODY_ALIGN(FROM_NEW_BR, true /*nothrow*/); -} - -__declspec(dllexport) void __cdecl __asan_delete(void *ptr) { - OPERATOR_DELETE_BODY(FROM_NEW); -} - -__declspec(dllexport) void __cdecl __asan_delete_array(void *ptr) { - OPERATOR_DELETE_BODY(FROM_NEW_BR); -} - -__declspec(dllexport) void __cdecl __asan_delete_size(void *ptr, - size_t const size) { - OPERATOR_DELETE_BODY_SIZE(FROM_NEW); -} - -__declspec(dllexport) void __cdecl __asan_delete_array_size(void *ptr, - size_t const size) { - OPERATOR_DELETE_BODY_SIZE(FROM_NEW_BR); -} - -__declspec(dllexport) void __cdecl __asan_delete_align( - void *ptr, std::align_val_t const align) { - OPERATOR_DELETE_BODY_ALIGN(FROM_NEW); -} - -__declspec(dllexport) void __cdecl __asan_delete_array_align( - void *ptr, std::align_val_t const align) { - OPERATOR_DELETE_BODY_ALIGN(FROM_NEW_BR); -} - -__declspec(dllexport) void __cdecl __asan_delete_size_align( - void *ptr, size_t const size, std::align_val_t const align) { - OPERATOR_DELETE_BODY_SIZE_ALIGN(FROM_NEW); -} - -__declspec(dllexport) void __cdecl __asan_delete_array_size_align( - void *ptr, size_t const size, std::align_val_t const align) { - OPERATOR_DELETE_BODY_SIZE_ALIGN(FROM_NEW_BR); -} -} // extern "C" diff --git a/compiler-rt/lib/asan/asan_win_new_delete_thunk_common.h b/compiler-rt/lib/asan/asan_win_new_delete_thunk_common.h deleted file mode 100644 index c89b05c6fb1387..00000000000000 --- a/compiler-rt/lib/asan/asan_win_new_delete_thunk_common.h +++ /dev/null @@ -1,141 +0,0 @@ -//===-- asan_win_new_delete_thunk_common.h ----------------------*- C++ -*-===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file is a part of AddressSanitizer, an address sanity checker. -// -// Windows-specific user-provided new/delete operator detection and fallback. -// -// In order to provide correct fallback behavior for operator new and delete, we -// need to honor partially hooked new and delete operators. For example, if -// plain operator new is provided by the user, then array operator new should -// fallback to use that operator new. This is slighly complicated in that ASAN -// must know which operator new/delete was used to correctly track allocations. -// The solution here is to only pass the allocation/deallocation request -// directly to ASAN with full metadata when we know all fallbacks for the given -// overload are provided by ASAN. This requires us to detect which overloads are -// provided by ASAN. We can accomplish this by seperating the definitions into -// multiple TUs so each can be selected individually, and adding a dynamic -// initializer to those TUs to mark whether that overload is included. -//===----------------------------------------------------------------------===// -#ifndef ASAN_WIN_NEW_DELETE_THUNK_COMMON_H -#define ASAN_WIN_NEW_DELETE_THUNK_COMMON_H - -#include "sanitizer_common/sanitizer_internal_defs.h" -// Fake std::nothrow_t and std::align_val_t to avoid including . -namespace std { -struct nothrow_t {}; -enum class align_val_t : size_t {}; -} // namespace std - -void* operator new(size_t, std::align_val_t); -void* operator new[](size_t, std::align_val_t); -void operator delete(void* ptr, std::align_val_t align) noexcept; -void operator delete[](void* ptr, std::align_val_t align) noexcept; - -//////////////////////////////////// -// clang-format off -// Fallback Ordering for new/delete -// change this if the code called by a given operator in the case where the -// "less specific" operators are not provided by asan changes. -// -// +----------+ +----------------+ -// |new_scalar<---------------+ |new_scalar_align<--------------+ -// +----^-----+ | +----^-----------+ | -// | | | | -// +----+-------------+ +----+----+ +----+-------------------+ +---+-----------+ -// |new_scalar_nothrow| |new_array| |new_scalar_align_nothrow| |new_array_align| -// +------------------+ +----^----+ +------------------------+ +---^-----------+ -// | | -// +------------+----+ +-----------+-----------+ -// |new_array_nothrow| |new_array_align_nothrow| -// +-----------------+ +-----------------------+ -// -// +-------------+ +-------------------+ -// |delete_scalar<----+-----------------------+ |delete_scalar_align<----+---------------------------+ -// +--^----------+ | | +--^----------------+ | | -// | | | | | | -// +--+---------+ +--+---------------+ +----+----------------+ +--+---------------+ +--+---------------------+ +--+------------------------+ -// |delete_array| |delete_scalar_size| |delete_scalar_nothrow| |delete_array_align| |delete_scalar_size_align| |delete_scalar_align_nothrow| -// +--^----^----+ +------------------+ +---------------------+ +--^-----^---------+ +------------------------+ +---------------------------+ -// | | | | -// | +-------------------+ | +------------------------+ -// | | | | -// +--+--------------+ +------+-------------+ +--+--------------------+ +------+-------------------+ -// |delete_array_size| |delete_array_nothrow| |delete_array_size_align| |delete_array_align_nothrow| -// +-----------------+ +--------------------+ +-----------------------+ +--------------------------+ -// clang-format on - -// Only need definition detection for overloads with children. -enum defined_ops { - op_new_scalar, - op_new_array, - - op_new_scalar_align, - op_new_array_align, - - op_delete_scalar, - op_delete_array, - - op_delete_scalar_align, - op_delete_array_align -}; - -// Define a global of this type in each overload's translation unit -// so that the dynamic initializer will set defined to 1 when -// that TU is included. -// We can then use __asan_InitDefine::defined to check whether that TU is -// included. -template -struct __asan_InitDefine { - __asan_InitDefine() { defined = 1; } - - static int defined; -}; - -template -int __asan_InitDefine::defined = 0; - -extern "C" void __cdecl __asan_delete_array_align(void* ptr, - std::align_val_t align); - -extern "C" void __cdecl __asan_delete_array_size_align(void* ptr, size_t size, - std::align_val_t align); - -extern "C" void __cdecl __asan_delete_array_size(void* ptr, size_t size); - -extern "C" void __cdecl __asan_delete_array(void* ptr); - -extern "C" void __cdecl __asan_delete_align(void* ptr, std::align_val_t align); - -extern "C" void __cdecl __asan_delete_size_align( - void* ptr, size_t size, std::align_val_t align) noexcept; - -extern "C" void __cdecl __asan_delete_size(void* ptr, size_t size); - -extern "C" void __cdecl __asan_delete(void* ptr); - -extern "C" void* __cdecl __asan_new_array_align_nothrow(size_t size, - std::align_val_t align); - -extern "C" void* __cdecl __asan_new_array_align(size_t size, - std::align_val_t align); - -extern "C" void* __cdecl __asan_new_array_nothrow(size_t size); - -extern "C" void* __cdecl __asan_new_array(size_t size); - -extern "C" void* __cdecl __asan_new_align_nothrow(size_t size, - std::align_val_t align); - -extern "C" void* __cdecl __asan_new_align(size_t size, std::align_val_t align); - -extern "C" void* __cdecl __asan_new_nothrow(size_t size); - -extern "C" void* __cdecl __asan_new(size_t size); - -#endif // ASAN_WIN_NEW_DELETE_THUNK_COMMON_H diff --git a/compiler-rt/lib/asan/asan_win_new_scalar_align_nothrow_thunk.cpp b/compiler-rt/lib/asan/asan_win_new_scalar_align_nothrow_thunk.cpp deleted file mode 100644 index 44274e0db5db4c..00000000000000 --- a/compiler-rt/lib/asan/asan_win_new_scalar_align_nothrow_thunk.cpp +++ /dev/null @@ -1,31 +0,0 @@ -//===-- asan_win_new_scalar_align_nothrow_thunk.cc ------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file is a part of AddressSanitizer, an address sanity checker. -// -// Windows-specific user-provided new/delete operator detection and fallback. -//===----------------------------------------------------------------------===// -#include "asan_win_new_delete_thunk_common.h" - -// see diagram in asan_win_new_delete_thunk_common.h for the ordering of the -// new/delete fallbacks. - -// Avoid tailcall optimization to preserve stack frame. -#pragma optimize("", off) -void* operator new(size_t size, std::align_val_t align, - std::nothrow_t const&) noexcept { - if (__asan_InitDefine::defined) { - return __asan_new_align_nothrow(size, align); - } - - try { - return operator new(size, align); - } catch (...) { - return nullptr; - } -} diff --git a/compiler-rt/lib/asan/asan_win_new_scalar_align_thunk.cpp b/compiler-rt/lib/asan/asan_win_new_scalar_align_thunk.cpp deleted file mode 100644 index b654b1528701b9..00000000000000 --- a/compiler-rt/lib/asan/asan_win_new_scalar_align_thunk.cpp +++ /dev/null @@ -1,24 +0,0 @@ -//===-- asan_win_new_scalar_align_thunk.cc --------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file is a part of AddressSanitizer, an address sanity checker. -// -// Windows-specific user-provided new/delete operator detection and fallback. -//===----------------------------------------------------------------------===// -#include "asan_win_new_delete_thunk_common.h" - -// see diagram in asan_win_new_delete_thunk_common.h for the ordering of the -// new/delete fallbacks. - -__asan_InitDefine init_new_scalar_align; - -// Avoid tailcall optimization to preserve stack frame. -#pragma optimize("", off) -void* operator new(size_t size, std::align_val_t align) { - return __asan_new_align(size, align); -} diff --git a/compiler-rt/lib/asan/asan_win_new_scalar_nothrow_thunk.cpp b/compiler-rt/lib/asan/asan_win_new_scalar_nothrow_thunk.cpp deleted file mode 100644 index a2987c62bdf45d..00000000000000 --- a/compiler-rt/lib/asan/asan_win_new_scalar_nothrow_thunk.cpp +++ /dev/null @@ -1,30 +0,0 @@ -//===-- asan_win_new_scalar_nothrow_thunk.cc ------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file is a part of AddressSanitizer, an address sanity checker. -// -// Windows-specific user-provided new/delete operator detection and fallback. -//===----------------------------------------------------------------------===// -#include "asan_win_new_delete_thunk_common.h" - -// see diagram in asan_win_new_delete_thunk_common.h for the ordering of the -// new/delete fallbacks. - -// Avoid tailcall optimization to preserve stack frame. -#pragma optimize("", off) -void* operator new(size_t size, std::nothrow_t const&) noexcept { - if (__asan_InitDefine::defined) { - return __asan_new_nothrow(size); - } - - try { - return operator new(size); - } catch (...) { - return nullptr; - } -} diff --git a/compiler-rt/lib/asan/asan_win_new_scalar_thunk.cpp b/compiler-rt/lib/asan/asan_win_new_scalar_thunk.cpp deleted file mode 100644 index a85647aed42bef..00000000000000 --- a/compiler-rt/lib/asan/asan_win_new_scalar_thunk.cpp +++ /dev/null @@ -1,22 +0,0 @@ -//===-- asan_win_new_scalar_thunk.cc --------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file is a part of AddressSanitizer, an address sanity checker. -// -// Windows-specific user-provided new/delete operator detection and fallback. -//===----------------------------------------------------------------------===// -#include "asan_win_new_delete_thunk_common.h" - -// see diagram in asan_win_new_delete_thunk_common.h for the ordering of the -// new/delete fallbacks. - -__asan_InitDefine init_new_scalar; - -// Avoid tailcall optimization to preserve stack frame. -#pragma optimize("", off) -void* operator new(size_t size) { return __asan_new(size); } diff --git a/compiler-rt/test/asan/TestCases/Windows/double_operator_delete.cpp b/compiler-rt/test/asan/TestCases/Windows/double_operator_delete.cpp index 3966b36738f925..3668a40ce01d89 100644 --- a/compiler-rt/test/asan/TestCases/Windows/double_operator_delete.cpp +++ b/compiler-rt/test/asan/TestCases/Windows/double_operator_delete.cpp @@ -8,15 +8,15 @@ int main() { delete [] x; delete [] x; // CHECK: AddressSanitizer: attempting double-free on [[ADDR:0x[0-9a-f]+]] - // CHECK: {{#1 .* operator delete}}[] - // CHECK-NEXT: {{#2 .* main .*double_operator_delete.cpp}}:[[@LINE-3]] + // CHECK-NEXT: {{#0 .* operator delete}}[] + // CHECK-NEXT: {{#1 .* main .*double_operator_delete.cpp}}:[[@LINE-3]] // CHECK: [[ADDR]] is located 0 bytes inside of 168-byte region // CHECK-LABEL: freed by thread T0 here: - // CHECK: {{#1 .* operator delete}}[] - // CHECK-NEXT: {{#2 .* main .*double_operator_delete.cpp}}:[[@LINE-8]] + // CHECK-NEXT: {{#0 .* operator delete}}[] + // CHECK-NEXT: {{#1 .* main .*double_operator_delete.cpp}}:[[@LINE-8]] // CHECK-LABEL: previously allocated by thread T0 here: - // CHECK: {{#1 .* operator new}}[] - // CHECK-NEXT: {{#2 .* main .*double_operator_delete.cpp}}:[[@LINE-12]] + // CHECK-NEXT: {{#0 .* operator new}}[] + // CHECK-NEXT: {{#1 .* main .*double_operator_delete.cpp}}:[[@LINE-12]] return 0; } diff --git a/compiler-rt/test/asan/TestCases/Windows/new_delete_mfc_already_defined.cpp b/compiler-rt/test/asan/TestCases/Windows/new_delete_mfc_already_defined.cpp deleted file mode 100644 index 851d2463eb6778..00000000000000 --- a/compiler-rt/test/asan/TestCases/Windows/new_delete_mfc_already_defined.cpp +++ /dev/null @@ -1,25 +0,0 @@ -// RUN: %clang_cl_asan -Od %s -Fe%t -// RUN: %run %t - -// test fixing new/delete already defined -// as long as it finishes linking, it should be good - -// before fix: -// nafxcw.lib(afxmem.obj) : warning LNK4006: "void * __cdecl operator new(unsigned int)" (??2@YAPAXI@Z) already defined in clang_rt.asan_cxx-i386.lib(asan_win_new_scalar_thunk.cpp.obj); second definition ignored -// nafxcw.lib(afxmem.obj) : warning LNK4006: "void __cdecl operator delete(void *)" (??3@YAXPAX@Z) already defined in clang_rt.asan_cxx-i386.lib(asan_win_delete_scalar_thunk.cpp.obj); second definition ignored - -#ifdef _DLL -# define _AFXDLL -#endif - -#include "afxglobals.h" - -int AFX_CDECL AfxCriticalNewHandler(size_t nSize); - -int main(int argc, char **argv) { - AFX_MODULE_THREAD_STATE *pState = AfxGetModuleThreadState(); - _PNH pnhOldHandler = AfxSetNewHandler(&AfxCriticalNewHandler); - AfxSetNewHandler(pnhOldHandler); - puts("Pass"); - return 0; -} diff --git a/compiler-rt/test/asan/TestCases/Windows/new_delete_mfc_already_defined_dbg.cpp b/compiler-rt/test/asan/TestCases/Windows/new_delete_mfc_already_defined_dbg.cpp deleted file mode 100644 index bc53dd1f9f2562..00000000000000 --- a/compiler-rt/test/asan/TestCases/Windows/new_delete_mfc_already_defined_dbg.cpp +++ /dev/null @@ -1,25 +0,0 @@ -// RUN: %clang_cl_asan -Od %s -Fe%t /MT /link /WX -// RUN: %env_asan_opts=alloc_dealloc_mismatch=true %run %t - -// test fixing new already defined and mismatch between allocation and deallocation APis - -// before fix: -// nafxcwd.lib(afx_new_scalar.obj) : error LNK2005: "void * __cdecl operator new(unsigned int)" (??2@YAPAXI@Z) already defined in clang_rt.asan_cxx_dbg-i386.lib(asan_win_new_scalar_thunk.cpp.obj) -// Address Sanitizer error: mismatch between allocation and deallocation APis - -#ifdef _DLL -# define _AFXDLL -#endif - -#include -#include - -int main() { - int *normal = new int; - int *debug = DEBUG_NEW int; - - delete normal; - delete debug; - - return 0; -} diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_array_new_left_oob.cpp b/compiler-rt/test/asan/TestCases/Windows/operator_array_new_left_oob.cpp index 3ea71934dc6b10..96b9378cc51786 100644 --- a/compiler-rt/test/asan/TestCases/Windows/operator_array_new_left_oob.cpp +++ b/compiler-rt/test/asan/TestCases/Windows/operator_array_new_left_oob.cpp @@ -10,7 +10,7 @@ int main() { // // CHECK: [[ADDR]] is located 1 bytes before 42-byte region // CHECK-LABEL: allocated by thread T0 here: - // CHECK: #[[#NEW:]] {{.* operator new}}[] - // CHECK-NEXT: #[[#NEW+1]] {{.* main .*operator_array_new_left_oob.cpp}}:[[@LINE-9]] + // CHECK-NEXT: {{#0 .* operator new}}[] + // CHECK-NEXT: {{#1 .* main .*operator_array_new_left_oob.cpp}}:[[@LINE-9]] delete [] buffer; } diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_array_new_right_oob.cpp b/compiler-rt/test/asan/TestCases/Windows/operator_array_new_right_oob.cpp index 2b3e14f98d5762..1e29d752a783f9 100644 --- a/compiler-rt/test/asan/TestCases/Windows/operator_array_new_right_oob.cpp +++ b/compiler-rt/test/asan/TestCases/Windows/operator_array_new_right_oob.cpp @@ -11,7 +11,7 @@ int main() { // CHECK: {{#0 .* main .*operator_array_new_right_oob.cpp}}:[[@LINE-3]] // CHECK: [[ADDR]] is located 0 bytes after 42-byte region // CHECK: allocated by thread T0 here: - // CHECK: #[[#NEW:]] {{.* operator new}}[] - // CHECK: #[[#NEW+1]] {{.* main .*operator_array_new_right_oob.cpp}}:[[@LINE-8]] + // CHECK: {{#0 .* operator new}}[] + // CHECK: {{#1 .* main .*operator_array_new_right_oob.cpp}}:[[@LINE-8]] delete [] buffer; } diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_array_new_uaf.cpp b/compiler-rt/test/asan/TestCases/Windows/operator_array_new_uaf.cpp index cb1b510c4856bb..edeee99a76530b 100644 --- a/compiler-rt/test/asan/TestCases/Windows/operator_array_new_uaf.cpp +++ b/compiler-rt/test/asan/TestCases/Windows/operator_array_new_uaf.cpp @@ -12,11 +12,11 @@ int main() { // CHECK: {{#0 .* main .*operator_array_new_uaf.cpp}}:[[@LINE-3]] // CHECK: [[ADDR]] is located 0 bytes inside of 42-byte region // CHECK-LABEL: freed by thread T0 here: - // CHECK: #[[#DEL:]] {{.* operator delete}}[] - // CHECK: #[[#DEL+1]] {{.* main .*operator_array_new_uaf.cpp}}:[[@LINE-8]] + // CHECK: {{#0 .* operator delete}}[] + // CHECK: {{#1 .* main .*operator_array_new_uaf.cpp}}:[[@LINE-8]] // CHECK-LABEL: previously allocated by thread T0 here: - // CHECK: #[[#NEW:]] {{.* operator new}}[] - // CHECK: #[[#NEW+1]] {{.* main .*operator_array_new_uaf.cpp}}:[[@LINE-12]] + // CHECK: {{#0 .* operator new}}[] + // CHECK: {{#1 .* main .*operator_array_new_uaf.cpp}}:[[@LINE-12]] return 0; } diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_array_new_with_dtor_left_oob.cpp b/compiler-rt/test/asan/TestCases/Windows/operator_array_new_with_dtor_left_oob.cpp index 929fee44693c93..cad28ae8ace213 100644 --- a/compiler-rt/test/asan/TestCases/Windows/operator_array_new_with_dtor_left_oob.cpp +++ b/compiler-rt/test/asan/TestCases/Windows/operator_array_new_with_dtor_left_oob.cpp @@ -6,11 +6,7 @@ struct C { ~C() {} }; -#ifdef _MSC_VER -__declspec(noinline) int hide(int x) { return x; } -#else int __attribute__((noinline, optnone)) hide(int x) { return x; } -#endif int main() { C *buffer = new C[42]; @@ -24,7 +20,7 @@ int main() { // https://code.google.com/p/address-sanitizer/issues/detail?id=314 // CHECK: [[ADDR]] is located {{.*}} bytes before {{(172|176)}}-byte region // CHECK-LABEL: allocated by thread T0 here: - // CHECK: #[[#NEW:]] {{.* operator new}}[] - // CHECK-NEXT: #[[#NEW+1]] {{.* main .*operator_array_new_with_dtor_left_oob.cpp}}:[[@LINE-12]] + // CHECK-NEXT: {{#0 .* operator new}}[] + // CHECK-NEXT: {{#1 .* main .*operator_array_new_with_dtor_left_oob.cpp}}:[[@LINE-12]] delete [] buffer; } diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_delete_replacement_array.cpp b/compiler-rt/test/asan/TestCases/Windows/operator_delete_replacement_array.cpp deleted file mode 100644 index b65595cafc9f0a..00000000000000 --- a/compiler-rt/test/asan/TestCases/Windows/operator_delete_replacement_array.cpp +++ /dev/null @@ -1,43 +0,0 @@ -// RUN: %clang_cl_asan /EHsc /Od /std:c++17 %s -Fe%t -// RUN: %run %t 2>&1 | FileCheck %s -// RUN: %clang_cl_asan /EHsc /Od %p/dll_host.cpp -Fe%t -// RUN: %clang_cl_asan /EHsc /LD /Od /std:c++17 /DTEST_DLL %s -Fe%t.dll -// RUN: %run %t %t.dll 2>&1 | FileCheck %s - -#include "operator_new_delete_replacement_macros.h" -#define DEFINED_REPLACEMENTS \ - (ALL_NEW | ALL_ALIGNED_NEW | SCALAR_DELETE | ARRAY_DELETE | \ - SCALAR_ALIGNED_DELETE | ARRAY_ALIGNED_DELETE) -#include "operator_new_delete_replacement_common.h" - -// Covers: -// 12. sized array (asan) -> array (custom) -// 14. array nothrow (asan) -> array (custom) -// 19. aligned sized array (asan) -> aligned array (custom) -// 21. aligned array nothrow (asan) -> aligned array (custom) - -// CHECK: new_scalar -// CHECK: new_array -// CHECK: new_scalar_nothrow -// CHECK: new_array_nothrow -// CHECK: delete_scalar -// CHECK: delete_array -// CHECK: delete_scalar -// CHECK: delete_array -// CHECK: new_scalar -// CHECK: new_array -// CHECK: delete_scalar -// CHECK: delete_array - -// CHECK: new_scalar_align -// CHECK: new_array_align -// CHECK: new_scalar_align_nothrow -// CHECK: new_array_align_nothrow -// CHECK: delete_scalar_align -// CHECK: delete_array_align -// CHECK: delete_scalar_align -// CHECK: delete_array_align -// CHECK: new_scalar_align -// CHECK: new_array_align -// CHECK: delete_scalar_align -// CHECK: delete_array_align diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_delete_replacement_scalar.cpp b/compiler-rt/test/asan/TestCases/Windows/operator_delete_replacement_scalar.cpp deleted file mode 100644 index b796b41f0affd8..00000000000000 --- a/compiler-rt/test/asan/TestCases/Windows/operator_delete_replacement_scalar.cpp +++ /dev/null @@ -1,48 +0,0 @@ -// RUN: %clang_cl_asan /EHsc /Od /std:c++17 %s -Fe%t -// RUN: %run %t 2>&1 | FileCheck %s -// RUN: %clang_cl_asan /EHsc /Od %p/dll_host.cpp -Fe%t -// RUN: %clang_cl_asan /EHsc /LD /Od /std:c++17 /DTEST_DLL %s -Fe%t.dll -// RUN: %run %t %t.dll 2>&1 | FileCheck %s - -#include "operator_new_delete_replacement_macros.h" -#define DEFINED_REPLACEMENTS \ - (ALL_NEW | ALL_ALIGNED_NEW | SCALAR_DELETE | SCALAR_ALIGNED_DELETE) -#include "operator_new_delete_replacement_common.h" - -// Covers: -// 9. array (asan) -> scalar (custom) -// 10. nothrow (asan) -> scalar (custom) -// 11. sized (asan) -> scalar (custom) ** original bug report scenario ** -// 13. sized array (asan) -> array (asan) -> scalar (custom) -// 15. array nothrow (asan) -> array (asan) -> scalar (custom) -// 16. aligned array (asan) -> aligned scalar (custom) -// 17. aligned nothrow (asan) -> aligned scalar (custom) -// 18. aligned sized (asan) -> aligned scalar (custom) -// 20. aligned sized array (asan) -> aligned array (asan) -> aligned scalar (custom) -// 22. aligned array nothrow (asan) -> aligned array (asan) -> aligned scalar (custom) - -// CHECK: new_scalar -// CHECK: new_array -// CHECK: new_scalar_nothrow -// CHECK: new_array_nothrow -// CHECK: delete_scalar -// CHECK: delete_scalar -// CHECK: delete_scalar -// CHECK: delete_scalar -// CHECK: new_scalar -// CHECK: new_array -// CHECK: delete_scalar -// CHECK: delete_scalar - -// CHECK: new_scalar_align -// CHECK: new_array_align -// CHECK: new_scalar_align_nothrow -// CHECK: new_array_align_nothrow -// CHECK: delete_scalar_align -// CHECK: delete_scalar_align -// CHECK: delete_scalar_align -// CHECK: delete_scalar_align -// CHECK: new_scalar_align -// CHECK: new_array_align -// CHECK: delete_scalar_align -// CHECK: delete_scalar_align diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_delete_wrong_argument.cpp b/compiler-rt/test/asan/TestCases/Windows/operator_delete_wrong_argument.cpp index c5be40a810e7c3..f5be333a8db186 100644 --- a/compiler-rt/test/asan/TestCases/Windows/operator_delete_wrong_argument.cpp +++ b/compiler-rt/test/asan/TestCases/Windows/operator_delete_wrong_argument.cpp @@ -6,7 +6,7 @@ int main() { int *x = new int[42]; delete (x + 1); - // CHECK: AddressSanitizer: attempting free on address which was not malloc()-ed - // CHECK: #[[#DEL:]] {{0x.* operator delete}} - // CHECK: #[[#DEL+1]] {{.* main .*operator_delete_wrong_argument.cpp}}:[[@LINE-3]] +// CHECK: AddressSanitizer: attempting free on address which was not malloc()-ed +// CHECK: {{#0 0x.* operator delete}} +// CHECK: {{#1 .* main .*operator_delete_wrong_argument.cpp}}:[[@LINE-3]] } diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_new_delete_replacement_all.cpp b/compiler-rt/test/asan/TestCases/Windows/operator_new_delete_replacement_all.cpp deleted file mode 100644 index 9c343e55cdd186..00000000000000 --- a/compiler-rt/test/asan/TestCases/Windows/operator_new_delete_replacement_all.cpp +++ /dev/null @@ -1,35 +0,0 @@ -// RUN: %clang_cl_asan /EHsc /Od /std:c++17 %s -Fe%t -// RUN: %run %t 2>&1 | FileCheck %s -// RUN: %clang_cl_asan /EHsc /Od %p/dll_host.cpp -Fe%t -// RUN: %clang_cl_asan /EHsc /LD /Od /std:c++17 /DTEST_DLL %s -Fe%t.dll -// RUN: %run %t %t.dll 2>&1 | FileCheck %s - -#include "operator_new_delete_replacement_macros.h" -#define DEFINED_REPLACEMENTS ALL_OPERATORS -#include "operator_new_delete_replacement_common.h" - -// CHECK: new_scalar -// CHECK: new_array -// CHECK: new_scalar_nothrow -// CHECK: new_array_nothrow -// CHECK: delete_scalar -// CHECK: delete_array -// CHECK: delete_scalar_nothrow -// CHECK: delete_array_nothrow -// CHECK: new_scalar -// CHECK: new_array -// CHECK: delete_scalar_size -// CHECK: delete_array_size - -// CHECK: new_scalar_align -// CHECK: new_array_align -// CHECK: new_scalar_align_nothrow -// CHECK: new_array_align_nothrow -// CHECK: delete_scalar_align -// CHECK: delete_array_align -// CHECK: delete_scalar_align_nothrow -// CHECK: delete_array_align_nothrow -// CHECK: new_scalar_align -// CHECK: new_array_align -// CHECK: delete_scalar_size_align -// CHECK: delete_array_size_align diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_new_delete_replacement_common.h b/compiler-rt/test/asan/TestCases/Windows/operator_new_delete_replacement_common.h deleted file mode 100644 index 07e3d29f3264d8..00000000000000 --- a/compiler-rt/test/asan/TestCases/Windows/operator_new_delete_replacement_common.h +++ /dev/null @@ -1,413 +0,0 @@ -#include -#include - -// If users provide fallback, all parents must be replaced as well. -// That is, you can't sanely provide a non-forwarding array op new without also replacing scalar op new. - -// With that in mind, we need to cover the following scenarios for operator new: -// 1. array (asan) -> scalar (custom) -// 2. nothrow (asan) -> scalar (custom) -// 3. array nothrow (asan) -> array (custom) -// 4. array nothrow (asan) -> array (asan) -> scalar (custom) -// 5. aligned array (asan) -> aligned scalar (custom) -// 6. aligned nothrow (asan) -> aligned scalar (custom) -// 7. aligned array nothrow (asan) -> aligned array (custom) -// 8. aligned array nothrow (asan) -> aligned array (asan) -> aligned scalar (custom) - -// And the following for operator delete: -// 9. array (asan) -> scalar (custom) -// 10. nothrow (asan) -> scalar (custom) -// 11. sized (asan) -> scalar (custom) ** original bug report scenario ** -// 12. sized array (asan) -> array (custom) -// 13. sized array (asan) -> array (asan) -> scalar (custom) -// 14. array nothrow (asan) -> array (custom) -// 15. array nothrow (asan) -> array (asan) -> scalar (custom) -// 16. aligned array (asan) -> aligned scalar (custom) -// 17. aligned nothrow (asan) -> aligned scalar (custom) -// 18. aligned sized (asan) -> aligned scalar (custom) -// 19. aligned sized array (asan) -> aligned array (custom) -// 20. aligned sized array (asan) -> aligned array (asan) -> aligned scalar (custom) -// 21. aligned array nothrow (asan) -> aligned array (custom) -// 22. aligned array nothrow (asan) -> aligned array (asan) -> aligned scalar (custom) - -#ifdef VERBOSE -# define PRINTF(...) printf(__VA_ARGS__) -#else -# define PRINTF(...) -#endif - -template class arena { -public: - void *alloc(const size_t size, const std::align_val_t al) { - return alloc(size, static_cast(al)); - } - - void * - alloc(const size_t size, - const size_t requested_alignment = __STDCPP_DEFAULT_NEW_ALIGNMENT__) { - if (requested_alignment == 0 || - (requested_alignment & (requested_alignment - 1))) { - // Alignment must be non-zero and power of two. - PRINTF("Allocation of size '%zu' alignment '%zu' failed due to bad " - "arguments.\n", - size, requested_alignment); - throw std::bad_alloc{}; - } - - const size_t alignment = - (requested_alignment <= __STDCPP_DEFAULT_NEW_ALIGNMENT__) - ? __STDCPP_DEFAULT_NEW_ALIGNMENT__ - : requested_alignment; - - // Adjust for alignment - const size_t alignment_mask = alignment - 1; - m_cur = reinterpret_cast( - reinterpret_cast(m_cur + alignment_mask) & - ~alignment_mask); - const size_t memory_block_size = (size + alignment_mask) & ~alignment_mask; - - if (m_cur + memory_block_size > m_buffer + N) { - PRINTF("Allocation of size '%zu' alignment '%zu' failed due to out of " - "memory.\n", - size, requested_alignment); - throw std::bad_alloc{}; - } - - char *const returned_memory_block = m_cur; - m_cur += memory_block_size; - - PRINTF("Allocated '0x%p' of size '%zu' (requested '%zu') with alignment " - "'%zu' (requested '%zu')\n", - returned_memory_block, memory_block_size, size, alignment, - requested_alignment); - - return returned_memory_block; - } - - void free(const void *ptr) { PRINTF("Deallocated '0x%p'\n", ptr); } - -private: - char m_buffer[N]; - char *m_cur = m_buffer; -}; - -arena<100000> mem; - -//////////////////////////////////// -// clang-format off -// new() Fallback Ordering -// -// +----------+ -// |new_scalar<---------------+ -// +----^-----+ | -// | | -// +----+-------------+ +----+----+ -// |new_scalar_nothrow| |new_array| -// +------------------+ +----^----+ -// | -// +------------+----+ -// |new_array_nothrow| -// +-----------------+ -// clang-format on - -#if (DEFINED_REPLACEMENTS & SCALAR_NEW) -void *operator new(const size_t sz) { - puts("new_scalar"); - return mem.alloc(sz); -} -#endif // MISSING_SCALAR_NEW - -#if (DEFINED_REPLACEMENTS & SCALAR_NEW_NOTHROW) -void *operator new(const size_t sz, const std::nothrow_t &) noexcept { - puts("new_scalar_nothrow"); - try { - return mem.alloc(sz); - } catch (...) { - return nullptr; - } -} -#endif // MISSING_SCALAR_NEW_NOTHROW - -#if (DEFINED_REPLACEMENTS & ARRAY_NEW) -void *operator new[](const size_t sz) { - puts("new_array"); - return mem.alloc(sz); -} -#endif // MISSING_ARRAY_NEW - -#if (DEFINED_REPLACEMENTS & ARRAY_NEW_NOTHROW) -void *operator new[](const size_t sz, const std::nothrow_t &) noexcept { - puts("new_array_nothrow"); - try { - return mem.alloc(sz); - } catch (...) { - return nullptr; - } -} -#endif // MISSING_ARRAY_NEW_NOTHROW - -//////////////////////////////////////////////// -// clang-format off -// Aligned new() Fallback Ordering -// -// +----------------+ -// |new_scalar_align<--------------+ -// +----^-----------+ | -// | | -// +----+-------------------+ +---+-----------+ -// |new_scalar_align_nothrow| |new_array_align| -// +------------------------+ +---^-----------+ -// | -// +-----------+-----------+ -// |new_array_align_nothrow| -// +-----------------------+ -// clang-format on - -#if (DEFINED_REPLACEMENTS & SCALAR_ALIGNED_NEW) -void *operator new(const size_t sz, const std::align_val_t al) { - puts("new_scalar_align"); - return mem.alloc(sz, al); -} -#endif // MISSING_SCALAR_ALIGNED_NEW - -#if (DEFINED_REPLACEMENTS & SCALAR_ALIGNED_NEW_NOTHROW) -void *operator new(const size_t sz, const std::align_val_t al, - const std::nothrow_t &) noexcept { - puts("new_scalar_align_nothrow"); - try { - return mem.alloc(sz, al); - } catch (...) { - return nullptr; - } -} -#endif // MISSING_SCALAR_NEW_ALIGNED_NOTHROW - -#if (DEFINED_REPLACEMENTS & ARRAY_ALIGNED_NEW) -void *operator new[](const size_t sz, const std::align_val_t al) { - puts("new_array_align"); - return mem.alloc(sz, al); -} -#endif // MISSING_ARRAY_ALIGNED_NEW - -#if (DEFINED_REPLACEMENTS & ARRAY_ALIGNED_NEW_NOTHROW) -void *operator new[](const size_t sz, const std::align_val_t al, - const std::nothrow_t &) noexcept { - puts("new_array_align_nothrow"); - try { - return mem.alloc(sz, al); - } catch (...) { - return nullptr; - } -} -#endif // MISSING_ARRAY_ALIGNED_NEW_NOTHROW - -//////////////////////////////////////////////////////////////// -// clang-format off -// delete() Fallback Ordering -// -// +-------------+ -// |delete_scalar<----+-----------------------+ -// +--^----------+ | | -// | | | -// +--+---------+ +--+---------------+ +----+----------------+ -// |delete_array| |delete_scalar_size| |delete_scalar_nothrow| -// +--^----^----+ +------------------+ +---------------------+ -// | | -// | +-------------------+ -// | | -// +--+--------------+ +------+-------------+ -// |delete_array_size| |delete_array_nothrow| -// +-----------------+ +--------------------+ -// clang-format on - -#if (DEFINED_REPLACEMENTS & SCALAR_DELETE) -void operator delete(void *const ptr) noexcept { - puts("delete_scalar"); - mem.free(ptr); -} -#endif // MISSING_SCALAR_DELETE - -#if (DEFINED_REPLACEMENTS & ARRAY_DELETE) -void operator delete[](void *const ptr) noexcept { - puts("delete_array"); - mem.free(ptr); -} -#endif // MISSING_ARRAY_DELETE - -#if (DEFINED_REPLACEMENTS & ARRAY_SIZED_DELETE) -void operator delete[](void *const ptr, const size_t sz) noexcept { - puts("delete_array_size"); - mem.free(ptr); -} -#endif // MISSING_ARRAY_SIZED_DELETE - -#if (DEFINED_REPLACEMENTS & ARRAY_DELETE_NOTHROW) -void operator delete[](void *const ptr, const std::nothrow_t &) noexcept { - puts("delete_array_nothrow"); - mem.free(ptr); -} -#endif // MISSING_ARRAY_DELETE_NOTHROW - -#if (DEFINED_REPLACEMENTS & SCALAR_SIZED_DELETE) -void operator delete(void *const ptr, const size_t sz) noexcept { - puts("delete_scalar_size"); - mem.free(ptr); -} -#endif // MISSING_SCALAR_SIZED_DELETE - -#if (DEFINED_REPLACEMENTS & SCALAR_DELETE_NOTHROW) -void operator delete(void *const ptr, const std::nothrow_t &) noexcept { - puts("delete_scalar_nothrow"); - mem.free(ptr); -} -#endif // MISSING_SCALAR_DELETE_NOTHROW - -////////////////////////////////////////////////////////////////////////////////// -// clang-format off -// Aligned delete() Fallback Ordering -// -// +-------------------+ -// |delete_scalar_align<----+---------------------------+ -// +--^----------------+ | | -// | | | -// +--+---------------+ +--+---------------------+ +--+------------------------+ -// |delete_array_align| |delete_scalar_size_align| |delete_scalar_align_nothrow| -// +--^-----^---------+ +------------------------+ +---------------------------+ -// | | -// | +------------------------+ -// | | -// +--+--------------------+ +------+-------------------+ -// |delete_array_size_align| |delete_array_align_nothrow| -// +-----------------------+ +--------------------------+ -// clang-format on - -#if (DEFINED_REPLACEMENTS & SCALAR_ALIGNED_DELETE) -void operator delete(void *const ptr, const std::align_val_t) noexcept { - puts("delete_scalar_align"); - mem.free(ptr); -} -#endif // MISSING_SCALAR_DELETE - -#if (DEFINED_REPLACEMENTS & ARRAY_ALIGNED_DELETE) -void operator delete[](void *const ptr, const std::align_val_t) noexcept { - puts("delete_array_align"); - mem.free(ptr); -} -#endif // MISSING_ARRAY_DELETE - -#if (DEFINED_REPLACEMENTS & ARRAY_SIZED_ALIGNED_DELETE) -void operator delete[](void *const ptr, const size_t sz, - const std::align_val_t) noexcept { - puts("delete_array_size_align"); - mem.free(ptr); -} -#endif // MISSING_ARRAY_SIZED_DELETE - -#if (DEFINED_REPLACEMENTS & ARRAY_ALIGNED_DELETE_NOTHROW) -void operator delete[](void *const ptr, const std::align_val_t, - const std::nothrow_t &) noexcept { - puts("delete_array_align_nothrow"); - mem.free(ptr); -} -#endif // MISSING_ARRAY_DELETE_NOTHROW - -#if (DEFINED_REPLACEMENTS & SCALAR_SIZED_ALIGNED_DELETE) -void operator delete(void *const ptr, const size_t sz, - const std::align_val_t) noexcept { - puts("delete_scalar_size_align"); - mem.free(ptr); -} -#endif // MISSING_SCALAR_SIZED_DELETE - -#if (DEFINED_REPLACEMENTS & SCALAR_ALIGNED_DELETE_NOTHROW) -void operator delete(void *const ptr, const std::align_val_t, - const std::nothrow_t &) noexcept { - puts("delete_scalar_align_nothrow"); - mem.free(ptr); -} -#endif // MISSING_SCALAR_DELETE_NOTHROW - -// Explicitly call delete so we can explicitly choose sized vs non-sized versions of each. -// Also provide explicit nothrow version, since that can't be implicitly invoked. -template void op_delete_scalar(T *ptr) { - if (alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__) { - operator delete(ptr, std::align_val_t{alignof(T)}); - } else { - operator delete(ptr); - } -} - -template void op_delete_array(T *ptr) { - if (alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__) { - operator delete[](ptr, std::align_val_t{alignof(T)}); - } else { - operator delete[](ptr); - } -} - -template void op_delete_scalar_nothrow(T *ptr) { - if (alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__) { - operator delete(ptr, std::align_val_t{alignof(T)}, std::nothrow_t{}); - } else { - operator delete(ptr, std::nothrow_t{}); - } -} - -template void op_delete_array_nothrow(T *ptr) { - if (alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__) { - operator delete[](ptr, std::align_val_t{alignof(T)}, std::nothrow_t{}); - } else { - operator delete[](ptr, std::nothrow_t{}); - } -} - -template void op_delete_scalar_size(T *ptr) { - if (alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__) { - operator delete(ptr, sizeof(T), std::align_val_t{alignof(T)}); - } else { - operator delete(ptr, sizeof(T)); - } -} - -template void op_delete_array_size(T *ptr) { - if (alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__) { - operator delete[](ptr, sizeof(T) * N, std::align_val_t{alignof(T)}); - } else { - operator delete[](ptr, sizeof(T) * N); - } -} - -template void test_allocations() { - T *scalar = new T(); - T *array = new T[5]; - - T *scalar_nothrow = new (std::nothrow) T(); - T *array_nothrow = new (std::nothrow) T[5]; - - op_delete_scalar(scalar); - op_delete_array(array); - - op_delete_scalar_nothrow(scalar_nothrow); - op_delete_array_nothrow(array_nothrow); - - T *scalar_size = new T(); - T *array_size = new T[5]; - - op_delete_scalar_size(scalar_size); - op_delete_array_size<5>(array_size); -} - -struct alignas(32) overaligned { - double a; -}; - -#ifdef TEST_DLL -extern "C" __declspec(dllexport) int test_function() -#else -int main() -#endif -{ - test_allocations(); - test_allocations(); - return 0; -} diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_new_delete_replacement_macros.h b/compiler-rt/test/asan/TestCases/Windows/operator_new_delete_replacement_macros.h deleted file mode 100644 index 7ea1744bf9bd37..00000000000000 --- a/compiler-rt/test/asan/TestCases/Windows/operator_new_delete_replacement_macros.h +++ /dev/null @@ -1,30 +0,0 @@ -#define SCALAR_NEW 0x000001 -#define SCALAR_NEW_NOTHROW 0x000002 -#define ARRAY_NEW 0x000004 -#define ARRAY_NEW_NOTHROW 0x000008 -#define ALL_NEW 0x00000f - -#define SCALAR_ALIGNED_NEW 0x000010 -#define SCALAR_ALIGNED_NEW_NOTHROW 0x000020 -#define ARRAY_ALIGNED_NEW 0x000040 -#define ARRAY_ALIGNED_NEW_NOTHROW 0x000080 -#define ALL_ALIGNED_NEW 0x0000f0 - -#define SCALAR_DELETE 0x000100 -#define ARRAY_DELETE 0x000200 -#define ARRAY_SIZED_DELETE 0x000400 -#define ARRAY_DELETE_NOTHROW 0x000800 -#define SCALAR_SIZED_DELETE 0x001000 -#define SCALAR_DELETE_NOTHROW 0x002000 -#define ALL_DELETE 0x003f00 - -#define SCALAR_ALIGNED_DELETE 0x010000 -#define ARRAY_ALIGNED_DELETE 0x020000 -#define ARRAY_SIZED_ALIGNED_DELETE 0x040000 -#define ARRAY_ALIGNED_DELETE_NOTHROW 0x080000 -#define SCALAR_SIZED_ALIGNED_DELETE 0x100000 -#define SCALAR_ALIGNED_DELETE_NOTHROW 0x200000 -#define ALL_ALIGNED_DELETE 0x3f0000 - -#define ALL_OPERATORS \ - (ALL_NEW | ALL_ALIGNED_NEW | ALL_DELETE | ALL_ALIGNED_DELETE) diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_new_left_oob.cpp b/compiler-rt/test/asan/TestCases/Windows/operator_new_left_oob.cpp index 81303704da11e7..ab104ba1a4cdde 100644 --- a/compiler-rt/test/asan/TestCases/Windows/operator_new_left_oob.cpp +++ b/compiler-rt/test/asan/TestCases/Windows/operator_new_left_oob.cpp @@ -6,12 +6,12 @@ int main() { char *buffer = new char; buffer[-1] = 42; - // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]] - // CHECK: WRITE of size 1 at [[ADDR]] thread T0 - // CHECK: {{#0 .* main .*operator_new_left_oob.cpp}}:[[@LINE-3]] - // CHECK: [[ADDR]] is located 1 bytes before 1-byte region - // CHECK: allocated by thread T0 here: - // CHECK: #[[#NEW:]] {{.* operator new}} - // CHECK: #[[#NEW+1]] {{.* main .*operator_new_left_oob.cpp}}:[[@LINE-8]] +// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]] +// CHECK: WRITE of size 1 at [[ADDR]] thread T0 +// CHECK: {{#0 .* main .*operator_new_left_oob.cpp}}:[[@LINE-3]] +// CHECK: [[ADDR]] is located 1 bytes before 1-byte region +// CHECK: allocated by thread T0 here: +// CHECK: {{#0 .* operator new}} +// CHECK: {{#1 .* main .*operator_new_left_oob.cpp}}:[[@LINE-8]] delete buffer; } diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_new_replacement_array.cpp b/compiler-rt/test/asan/TestCases/Windows/operator_new_replacement_array.cpp deleted file mode 100644 index d36e235cb137dd..00000000000000 --- a/compiler-rt/test/asan/TestCases/Windows/operator_new_replacement_array.cpp +++ /dev/null @@ -1,41 +0,0 @@ -// RUN: %clang_cl_asan /EHsc /Od /std:c++17 %s -Fe%t -// RUN: %run %t 2>&1 | FileCheck %s -// RUN: %clang_cl_asan /EHsc /Od %p/dll_host.cpp -Fe%t -// RUN: %clang_cl_asan /EHsc /LD /Od /std:c++17 /DTEST_DLL %s -Fe%t.dll -// RUN: %run %t %t.dll 2>&1 | FileCheck %s - -#include "operator_new_delete_replacement_macros.h" -#define DEFINED_REPLACEMENTS \ - (SCALAR_NEW | ARRAY_NEW | SCALAR_ALIGNED_NEW | ARRAY_ALIGNED_NEW | \ - ALL_DELETE | ALL_ALIGNED_DELETE) -#include "operator_new_delete_replacement_common.h" - -// Covers: -// 3. array nothrow (asan) -> array (custom) -// 7. aligned array nothrow (asan) -> aligned array (custom) - -// CHECK: new_scalar -// CHECK: new_array -// CHECK: new_scalar -// CHECK: new_array -// CHECK: delete_scalar -// CHECK: delete_array -// CHECK: delete_scalar_nothrow -// CHECK: delete_array_nothrow -// CHECK: new_scalar -// CHECK: new_array -// CHECK: delete_scalar_size -// CHECK: delete_array_size - -// CHECK: new_scalar_align -// CHECK: new_array_align -// CHECK: new_scalar_align -// CHECK: new_array_align -// CHECK: delete_scalar_align -// CHECK: delete_array_align -// CHECK: delete_scalar_align_nothrow -// CHECK: delete_array_align_nothrow -// CHECK: new_scalar_align -// CHECK: new_array_align -// CHECK: delete_scalar_size_align -// CHECK: delete_array_size_align diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_new_replacement_scalar.cpp b/compiler-rt/test/asan/TestCases/Windows/operator_new_replacement_scalar.cpp deleted file mode 100644 index 032904e1243025..00000000000000 --- a/compiler-rt/test/asan/TestCases/Windows/operator_new_replacement_scalar.cpp +++ /dev/null @@ -1,44 +0,0 @@ -// RUN: %clang_cl_asan /EHsc /Od /std:c++17 %s -Fe%t -// RUN: %run %t 2>&1 | FileCheck %s -// RUN: %clang_cl_asan /EHsc /Od %p/dll_host.cpp -Fe%t -// RUN: %clang_cl_asan /EHsc /LD /Od /std:c++17 /DTEST_DLL %s -Fe%t.dll -// RUN: %run %t %t.dll 2>&1 | FileCheck %s - -#include "operator_new_delete_replacement_macros.h" -#define DEFINED_REPLACEMENTS \ - (SCALAR_NEW | SCALAR_ALIGNED_NEW | ALL_DELETE | ALL_ALIGNED_DELETE) -#include "operator_new_delete_replacement_common.h" - -// Covers: -// 1. array (asan) -> scalar (custom) -// 2. nothrow (asan) -> scalar (custom) -// 4. array nothrow (asan) -> array (asan) -> scalar (custom) -// 5. aligned array (asan) -> aligned scalar (custom) -// 6. aligned nothrow (asan) -> aligned scalar (custom) -// 8. aligned array nothrow (asan) -> aligned array (asan) -> aligned scalar (custom) - -// CHECK: new_scalar -// CHECK: new_scalar -// CHECK: new_scalar -// CHECK: new_scalar -// CHECK: delete_scalar -// CHECK: delete_array -// CHECK: delete_scalar_nothrow -// CHECK: delete_array_nothrow -// CHECK: new_scalar -// CHECK: new_scalar -// CHECK: delete_scalar_size -// CHECK: delete_array_size - -// CHECK: new_scalar_align -// CHECK: new_scalar_align -// CHECK: new_scalar_align -// CHECK: new_scalar_align -// CHECK: delete_scalar_align -// CHECK: delete_array_align -// CHECK: delete_scalar_align_nothrow -// CHECK: delete_array_align_nothrow -// CHECK: new_scalar_align -// CHECK: new_scalar_align -// CHECK: delete_scalar_size_align -// CHECK: delete_array_size_align diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_new_right_oob.cpp b/compiler-rt/test/asan/TestCases/Windows/operator_new_right_oob.cpp index 0950e6f0802b72..75db1498bb1a5a 100644 --- a/compiler-rt/test/asan/TestCases/Windows/operator_new_right_oob.cpp +++ b/compiler-rt/test/asan/TestCases/Windows/operator_new_right_oob.cpp @@ -6,12 +6,12 @@ int main() { char *buffer = new char; buffer[1] = 42; - // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]] - // CHECK: WRITE of size 1 at [[ADDR]] thread T0 - // CHECK: {{#0 .* main .*operator_new_right_oob.cpp}}:[[@LINE-3]] - // CHECK: [[ADDR]] is located 0 bytes after 1-byte region - // CHECK: allocated by thread T0 here: - // CHECK: #[[#NEW:]] {{.* operator new}} - // CHECK: #[[#NEW+1]] {{.* main .*operator_new_right_oob.cpp}}:[[@LINE-8]] +// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]] +// CHECK: WRITE of size 1 at [[ADDR]] thread T0 +// CHECK: {{#0 .* main .*operator_new_right_oob.cpp}}:[[@LINE-3]] +// CHECK: [[ADDR]] is located 0 bytes after 1-byte region +// CHECK: allocated by thread T0 here: +// CHECK: {{#0 .* operator new}} +// CHECK: {{#1 .* main .*operator_new_right_oob.cpp}}:[[@LINE-8]] delete buffer; } diff --git a/compiler-rt/test/asan/TestCases/Windows/operator_new_uaf.cpp b/compiler-rt/test/asan/TestCases/Windows/operator_new_uaf.cpp index 762d84f8c95502..f9c3753f7f8bfa 100644 --- a/compiler-rt/test/asan/TestCases/Windows/operator_new_uaf.cpp +++ b/compiler-rt/test/asan/TestCases/Windows/operator_new_uaf.cpp @@ -1,7 +1,5 @@ // RUN: %clang_cl_asan %Od %s %Fe%t // RUN: not %run %t 2>&1 | FileCheck %s -// RUN: %clang_cl_asan -Od %s -Fe%t_dbg /link /INFERASANLIBS:DEBUG -// RUN: not %run %t_dbg 2>&1 | FileCheck %s #include @@ -9,16 +7,16 @@ int main() { char *buffer = new char; delete buffer; *buffer = 42; - // CHECK: AddressSanitizer: heap-use-after-free on address [[ADDR:0x[0-9a-f]+]] - // CHECK: WRITE of size 1 at [[ADDR]] thread T0 - // CHECK: {{#0 .* main .*operator_new_uaf.cpp}}:[[@LINE-3]] - // CHECK: [[ADDR]] is located 0 bytes inside of 1-byte region - // CHECK-LABEL: freed by thread T0 here: - // CHECK: #[[#DEL:]] {{.* operator delete}} - // CHECK: #[[#DEL+1]] {{.* main .*operator_new_uaf.cpp}}:[[@LINE-8]] - // CHECK-LABEL: previously allocated by thread T0 here: - // CHECK: #[[#NEW:]] {{.* operator new}} - // CHECK: #[[#NEW+1]] {{.* main .*operator_new_uaf.cpp}}:[[@LINE-12]] +// CHECK: AddressSanitizer: heap-use-after-free on address [[ADDR:0x[0-9a-f]+]] +// CHECK: WRITE of size 1 at [[ADDR]] thread T0 +// CHECK: {{#0 .* main .*operator_new_uaf.cpp}}:[[@LINE-3]] +// CHECK: [[ADDR]] is located 0 bytes inside of 1-byte region +// CHECK-LABEL: freed by thread T0 here: +// CHECK: {{#0 .* operator delete}} +// CHECK: {{#1 .* main .*operator_new_uaf.cpp}}:[[@LINE-8]] +// CHECK-LABEL: previously allocated by thread T0 here: +// CHECK: {{#0 .* operator new}} +// CHECK: {{#1 .* main .*operator_new_uaf.cpp}}:[[@LINE-12]] return 0; } diff --git a/compiler-rt/test/asan/TestCases/Windows/wrong_downcast_on_heap.cpp b/compiler-rt/test/asan/TestCases/Windows/wrong_downcast_on_heap.cpp index 6b5d54d87cdeeb..a70a86eafec6fa 100644 --- a/compiler-rt/test/asan/TestCases/Windows/wrong_downcast_on_heap.cpp +++ b/compiler-rt/test/asan/TestCases/Windows/wrong_downcast_on_heap.cpp @@ -15,12 +15,12 @@ int main(void) { Parent *p = new Parent; Child *c = (Child*)p; // Intentional error here! c->extra_field = 42; - // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]] - // CHECK: WRITE of size 4 at [[ADDR]] thread T0 - // CHECK: {{#0 0x[0-9a-f]* in main .*wrong_downcast_on_heap.cpp}}:[[@LINE-3]] - // CHECK: [[ADDR]] is located 0 bytes after 4-byte region - // CHECK: allocated by thread T0 here: - // CHECK: {{.*}} operator new +// CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]] +// CHECK: WRITE of size 4 at [[ADDR]] thread T0 +// CHECK: {{#0 0x[0-9a-f]* in main .*wrong_downcast_on_heap.cpp}}:[[@LINE-3]] +// CHECK: [[ADDR]] is located 0 bytes after 4-byte region +// CHECK: allocated by thread T0 here: +// CHECK: #0 {{.*}} operator new return 0; } diff --git a/compiler-rt/test/asan/TestCases/large_func_test.cpp b/compiler-rt/test/asan/TestCases/large_func_test.cpp index 4d289586ac0416..37fec8bef6ce81 100644 --- a/compiler-rt/test/asan/TestCases/large_func_test.cpp +++ b/compiler-rt/test/asan/TestCases/large_func_test.cpp @@ -50,10 +50,10 @@ int main(int argc, char **argv) { // CHECK: {{allocated by thread T0 here:}} // CHECK-Linux: {{ #0 0x.* in operator new}} // CHECK-SunOS: {{ #0 0x.* in operator new}} - // CHECK-Windows:{{ #0 0x.* in __asan_new_array}} + // CHECK-Windows:{{ #0 0x.* in operator new}} // CHECK-FreeBSD:{{ #0 0x.* in operator new}} // CHECK-Darwin: {{ #0 0x.* in .*_Zna}} - // CHECK: {{ 0x.* in main .*large_func_test.cpp:}}[[@LINE-10]] + // CHECK-NEXT: {{ #1 0x.* in main .*large_func_test.cpp:}}[[@LINE-10]] int y = x[argc]; delete[] x; return y; diff --git a/compiler-rt/test/asan/TestCases/malloc_context_size.cpp b/compiler-rt/test/asan/TestCases/malloc_context_size.cpp index e90cd017682a0c..e75bc48793ad13 100644 --- a/compiler-rt/test/asan/TestCases/malloc_context_size.cpp +++ b/compiler-rt/test/asan/TestCases/malloc_context_size.cpp @@ -1,9 +1,9 @@ // RUN: %clangxx_asan -O0 %s -o %t -// RUN: %env_asan_opts=malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s --check-prefixes=CHECK,%if target={{.*-windows-.*}} %{CHECK-WIN%} %else %{CHECK-NOT-WIN%} -// RUN: %env_asan_opts=malloc_context_size=0:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s --check-prefixes=CHECK,%if target={{.*-windows-.*}} %{CHECK-WIN%} %else %{CHECK-NOT-WIN%} -// RUN: %env_asan_opts=malloc_context_size=1:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s --check-prefixes=CHECK,%if target={{.*-windows-.*}} %{CHECK-WIN%} %else %{CHECK-NOT-WIN%} -// RUN: %env_asan_opts=malloc_context_size=1:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s --check-prefixes=CHECK,%if target={{.*-windows-.*}} %{CHECK-WIN%} %else %{CHECK-NOT-WIN%} -// RUN: %env_asan_opts=malloc_context_size=2 not %run %t 2>&1 | FileCheck %s --check-prefixes=TWO,%if target={{.*-windows-.*}} %{TWO-WIN%} %else %{TWO-NOT-WIN%} +// RUN: %env_asan_opts=malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s +// RUN: %env_asan_opts=malloc_context_size=0:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s +// RUN: %env_asan_opts=malloc_context_size=1:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s +// RUN: %env_asan_opts=malloc_context_size=1:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s +// RUN: %env_asan_opts=malloc_context_size=2 not %run %t 2>&1 | FileCheck %s --check-prefix=TWO int main() { char *x = new char[20]; @@ -11,20 +11,17 @@ int main() { return x[0]; // CHECK: freed by thread T{{.*}} here: - // CHECK-NOT-WIN-NEXT: #0 0x{{.*}} in {{operator delete( )?\[\]|_ZdaPv}} - // CHECK-WIN-NEXT: #0 0x{{.*}} in {{__asan_delete_array}} + // CHECK-NEXT: #0 0x{{.*}} in {{operator delete( )?\[\]|_ZdaPv}} // CHECK-NOT: #1 0x{{.*}} // CHECK: previously allocated by thread T{{.*}} here: - // CHECK-NOT-WIN-NEXT: #0 0x{{.*}} in {{operator new( )?\[\]|_Znam}} - // CHECK-WIN-NEXT: #0 0x{{.*}} in {{__asan_new_array}} + // CHECK-NEXT: #0 0x{{.*}} in {{operator new( )?\[\]|_Znam}} // CHECK-NOT: #1 0x{{.*}} // CHECK: SUMMARY: AddressSanitizer: heap-use-after-free // TWO: previously allocated by thread T{{.*}} here: // TWO-NEXT: #0 0x{{.*}} - // TWO-NOT-WIN-NEXT: #1 0x{{.*}} in main {{.*}}malloc_context_size.cpp - // TWO-WIN-NEXT: #1 0x{{.*}} in {{operator new( )?\[\]|_Znam}} + // TWO-NEXT: #1 0x{{.*}} in main {{.*}}malloc_context_size.cpp // TWO: SUMMARY: AddressSanitizer: heap-use-after-free } diff --git a/compiler-rt/test/asan/TestCases/use-after-delete.cpp b/compiler-rt/test/asan/TestCases/use-after-delete.cpp index 273ebf72f132f6..4d0c055368bb0c 100644 --- a/compiler-rt/test/asan/TestCases/use-after-delete.cpp +++ b/compiler-rt/test/asan/TestCases/use-after-delete.cpp @@ -16,20 +16,21 @@ int main() { // CHECK: {{0x.* is located 5 bytes inside of 10-byte region .0x.*,0x.*}} // CHECK: {{freed by thread T0 here:}} - // CHECK-Linux: #[[#DEL:]] {{0x.* in operator delete\[\]}} - // CHECK-SunOS: #[[#DEL:]] {{0x.* in operator delete\[\]}} - // CHECK-Windows: #[[#DEL:]] {{0x.* in operator delete\[\]}} - // CHECK-FreeBSD: #[[#DEL:]] {{0x.* in operator delete\[\]}} - // CHECK-Darwin: #[[#DEL:]] {{0x.* in .*_Zda}} - // CHECK-NEXT: #[[#DEL+1]] {{0x.* in main .*use-after-delete.cpp:}}[[@LINE-14]] + // CHECK-Linux: {{ #0 0x.* in operator delete\[\]}} + // CHECK-SunOS: {{ #0 0x.* in operator delete\[\]}} + // CHECK-Windows:{{ #0 0x.* in operator delete\[\]}} + // CHECK-FreeBSD:{{ #0 0x.* in operator delete\[\]}} + // CHECK-Darwin: {{ #0 0x.* in .*_Zda}} + // CHECK-NEXT: {{ #1 0x.* in main .*use-after-delete.cpp:}}[[@LINE-14]] // CHECK: {{previously allocated by thread T0 here:}} - // CHECK-Linux: #[[#NEW:]] {{0x.* in operator new\[\]}} - // CHECK-SunOS: #[[#NEW:]] {{0x.* in operator new\[\]}} - // CHECK-Windows: #[[#NEW:]] {{0x.* in operator new\[\]}} - // CHECK-FreeBSD: #[[#NEW:]] {{0x.* in operator new\[\]}} - // CHECK-Darwin: #[[#NEW:]] {{0x.* in .*_Zna}} - // CHECK-NEXT: #[[#NEW+1]] {{0x.* in main .*use-after-delete.cpp:}}[[@LINE-23]] + // CHECK-Linux: {{ #0 0x.* in operator new\[\]}} + // CHECK-SunOS: {{ #0 0x.* in operator new\[\]}} + // CHECK-Windows:{{ #0 0x.* in operator new\[\]}} + // CHECK-FreeBSD:{{ #0 0x.* in operator new\[\]}} + // CHECK-Darwin: {{ #0 0x.* in .*_Zna}} + // CHECK-NEXT: {{ #1 0x.* in main .*use-after-delete.cpp:}}[[@LINE-23]] + // CHECK: Shadow byte legend (one shadow byte represents {{[0-9]+}} application bytes): // CHECK: Global redzone: