head 1.4; access; symbols netbsd-11-0-RELEASE:1.3 netbsd-11-0-RC7:1.3 netbsd-11-0-RC6:1.3 netbsd-11-0-RC5:1.3 netbsd-11-0-RC4:1.3 netbsd-11-0-RC3:1.3 netbsd-11-0-RC2:1.3 netbsd-11-0-RC1:1.3 gcc-14-3-0:1.1.1.3 perseant-exfatfs-base-20250801:1.3 netbsd-11:1.3.0.4 netbsd-11-base:1.3 gcc-12-5-0:1.1.1.2 perseant-exfatfs-base-20240630:1.3 gcc-12-4-0:1.1.1.2 perseant-exfatfs:1.3.0.2 perseant-exfatfs-base:1.3 gcc-12-3-0:1.1.1.2 gcc-10-5-0:1.1.1.1 gcc-10-4-0:1.1.1.1 cjep_sun2x:1.2.0.4 cjep_sun2x-base:1.2 cjep_staticlib_x-base1:1.2 cjep_staticlib_x:1.2.0.2 cjep_staticlib_x-base:1.2 gcc-10-3-0:1.1.1.1 FSF:1.1.1; locks; strict; comment @// @; 1.4 date 2025.09.14.00.08.54; author mrg; state Exp; branches; next 1.3; commitid x9D5QEnvbeMI4CaG; 1.3 date 2023.07.31.01.44.54; author mrg; state Exp; branches; next 1.2; commitid q79F5Opf0FLsyTyE; 1.2 date 2021.04.11.23.54.25; author mrg; state dead; branches; next 1.1; commitid wJn7ggfUTEMOWVOC; 1.1 date 2021.04.10.22.09.22; author mrg; state Exp; branches 1.1.1.1; next ; commitid eC4g0MRpqTvEkNOC; 1.1.1.1 date 2021.04.10.22.09.22; author mrg; state Exp; branches; next 1.1.1.2; commitid eC4g0MRpqTvEkNOC; 1.1.1.2 date 2023.07.30.05.20.41; author mrg; state Exp; branches; next 1.1.1.3; commitid tk6nV4mbc9nVEMyE; 1.1.1.3 date 2025.09.13.23.45.04; author mrg; state Exp; branches; next ; commitid KwhwN4krNWa6XBaG; desc @@ 1.4 log @merge GCC 14.3.0. @ text @//===-- asan_linux.cpp ----------------------------------------------------===// // // 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. // // Linux-specific details. //===----------------------------------------------------------------------===// #include "sanitizer_common/sanitizer_platform.h" #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \ SANITIZER_SOLARIS # include # include # include # include # include # include # include # include # include # include # include # include # include "asan_interceptors.h" # include "asan_internal.h" # include "asan_premap_shadow.h" # include "asan_thread.h" # include "sanitizer_common/sanitizer_flags.h" # include "sanitizer_common/sanitizer_freebsd.h" # include "sanitizer_common/sanitizer_hash.h" # include "sanitizer_common/sanitizer_libc.h" # include "sanitizer_common/sanitizer_procmaps.h" # if SANITIZER_FREEBSD # include # endif # if SANITIZER_SOLARIS # include # endif # if SANITIZER_ANDROID || SANITIZER_FREEBSD || SANITIZER_SOLARIS # include extern "C" void *_DYNAMIC; # elif SANITIZER_NETBSD # include # include extern Elf_Dyn _DYNAMIC; # else # include # include extern ElfW(Dyn) _DYNAMIC[]; # endif // x86-64 FreeBSD 9.2 and older define 'ucontext_t' incorrectly in // 32-bit mode. # if SANITIZER_FREEBSD && (SANITIZER_WORDSIZE == 32) && \ __FreeBSD_version <= 902001 // v9.2 # define ucontext_t xucontext_t # endif typedef enum { ASAN_RT_VERSION_UNDEFINED = 0, ASAN_RT_VERSION_DYNAMIC, ASAN_RT_VERSION_STATIC, } asan_rt_version_t; // FIXME: perhaps also store abi version here? extern "C" { SANITIZER_INTERFACE_ATTRIBUTE asan_rt_version_t __asan_rt_version; } namespace __asan { void InitializePlatformInterceptors() {} void InitializePlatformExceptionHandlers() {} bool IsSystemHeapAddress(uptr addr) { return false; } void *AsanDoesNotSupportStaticLinkage() { // This will fail to link with -static. return &_DYNAMIC; } # if ASAN_PREMAP_SHADOW uptr FindPremappedShadowStart(uptr shadow_size_bytes) { uptr granularity = GetMmapGranularity(); uptr shadow_start = reinterpret_cast(&__asan_shadow); uptr premap_shadow_size = PremapShadowSize(); uptr shadow_size = RoundUpTo(shadow_size_bytes, granularity); // We may have mapped too much. Release extra memory. UnmapFromTo(shadow_start + shadow_size, shadow_start + premap_shadow_size); return shadow_start; } # endif uptr FindDynamicShadowStart() { uptr shadow_size_bytes = MemToShadowSize(kHighMemEnd); # if ASAN_PREMAP_SHADOW if (!PremapShadowFailed()) return FindPremappedShadowStart(shadow_size_bytes); # endif return MapDynamicShadow(shadow_size_bytes, ASAN_SHADOW_SCALE, /*min_shadow_base_alignment*/ 0, kHighMemEnd); } void AsanApplyToGlobals(globals_op_fptr op, const void *needle) { UNIMPLEMENTED(); } void FlushUnneededASanShadowMemory(uptr p, uptr size) { // Since asan's mapping is compacting, the shadow chunk may be // not page-aligned, so we only flush the page-aligned portion. ReleaseMemoryPagesToOS(MemToShadow(p), MemToShadow(p + size)); } # if SANITIZER_ANDROID // FIXME: should we do anything for Android? void AsanCheckDynamicRTPrereqs() {} void AsanCheckIncompatibleRT() {} # else static int FindFirstDSOCallback(struct dl_phdr_info *info, size_t size, void *data) { VReport(2, "info->dlpi_name = %s\tinfo->dlpi_addr = %p\n", info->dlpi_name, (void *)info->dlpi_addr); const char **name = (const char **)data; // Ignore first entry (the main program) if (!*name) { *name = ""; return 0; } # if SANITIZER_LINUX // Ignore vDSO. glibc versions earlier than 2.15 (and some patched // by distributors) return an empty name for the vDSO entry, so // detect this as well. if (!info->dlpi_name[0] || internal_strncmp(info->dlpi_name, "linux-", sizeof("linux-") - 1) == 0) return 0; # endif *name = info->dlpi_name; return 1; } static bool IsDynamicRTName(const char *libname) { return internal_strstr(libname, "libclang_rt.asan") || internal_strstr(libname, "libasan.so"); } static void ReportIncompatibleRT() { Report("Your application is linked against incompatible ASan runtimes.\n"); Die(); } void AsanCheckDynamicRTPrereqs() { if (!ASAN_DYNAMIC || !flags()->verify_asan_link_order) return; // Ensure that dynamic RT is the first DSO in the list const char *first_dso_name = nullptr; dl_iterate_phdr(FindFirstDSOCallback, &first_dso_name); if (first_dso_name && first_dso_name[0] && !IsDynamicRTName(first_dso_name)) { Report( "ASan runtime does not come first in initial library list; " "you should either link runtime to your application or " "manually preload it with LD_PRELOAD.\n"); Die(); } } void AsanCheckIncompatibleRT() { if (ASAN_DYNAMIC) { if (__asan_rt_version == ASAN_RT_VERSION_UNDEFINED) { __asan_rt_version = ASAN_RT_VERSION_DYNAMIC; } else if (__asan_rt_version != ASAN_RT_VERSION_DYNAMIC) { ReportIncompatibleRT(); } } else { if (__asan_rt_version == ASAN_RT_VERSION_UNDEFINED) { // Ensure that dynamic runtime is not present. We should detect it // as early as possible, otherwise ASan interceptors could bind to // the functions in dynamic ASan runtime instead of the functions in // system libraries, causing crashes later in ASan initialization. MemoryMappingLayout proc_maps(/*cache_enabled*/ true); char filename[PATH_MAX]; MemoryMappedSegment segment(filename, sizeof(filename)); while (proc_maps.Next(&segment)) { if (IsDynamicRTName(segment.filename)) { Report( "Your application is linked against " "incompatible ASan runtimes.\n"); Die(); } } __asan_rt_version = ASAN_RT_VERSION_STATIC; } else if (__asan_rt_version != ASAN_RT_VERSION_STATIC) { ReportIncompatibleRT(); } } } # endif // SANITIZER_ANDROID # if ASAN_INTERCEPT_SWAPCONTEXT constexpr u32 kAsanContextStackFlagsMagic = 0x51260eea; static int HashContextStack(const ucontext_t &ucp) { MurMur2Hash64Builder hash(kAsanContextStackFlagsMagic); hash.add(reinterpret_cast(ucp.uc_stack.ss_sp)); hash.add(ucp.uc_stack.ss_size); return static_cast(hash.get()); } void SignContextStack(void *context) { ucontext_t *ucp = reinterpret_cast(context); ucp->uc_stack.ss_flags = HashContextStack(*ucp); } void ReadContextStack(void *context, uptr *stack, uptr *ssize) { const ucontext_t *ucp = reinterpret_cast(context); if (HashContextStack(*ucp) == ucp->uc_stack.ss_flags) { *stack = reinterpret_cast(ucp->uc_stack.ss_sp); *ssize = ucp->uc_stack.ss_size; return; } *stack = 0; *ssize = 0; } # endif // ASAN_INTERCEPT_SWAPCONTEXT void *AsanDlSymNext(const char *sym) { return dlsym(RTLD_NEXT, sym); } bool HandleDlopenInit() { // Not supported on this platform. static_assert(!SANITIZER_SUPPORTS_INIT_FOR_DLOPEN, "Expected SANITIZER_SUPPORTS_INIT_FOR_DLOPEN to be false"); return false; } } // namespace __asan #endif // SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || // SANITIZER_SOLARIS @ 1.3 log @make this actually be GCC 12.3.0's libsanitizer. the libsanitizer we used with GCC 9 and GCC 10 was significantly ahead of the GCC 9 and GCC 10 provided versions. @ text @d18 37 a54 36 #include "asan_interceptors.h" #include "asan_internal.h" #include "asan_premap_shadow.h" #include "asan_thread.h" #include "sanitizer_common/sanitizer_flags.h" #include "sanitizer_common/sanitizer_freebsd.h" #include "sanitizer_common/sanitizer_libc.h" #include "sanitizer_common/sanitizer_procmaps.h" #include #include #include #include #include #include #include #include #include #include #include #include #if SANITIZER_FREEBSD #include #endif #if SANITIZER_SOLARIS #include #endif #if SANITIZER_ANDROID || SANITIZER_FREEBSD || SANITIZER_SOLARIS #include extern "C" void* _DYNAMIC; #elif SANITIZER_NETBSD #include #include d56 3 a58 3 #else #include #include d60 1 a60 1 #endif d64 4 a67 4 #if SANITIZER_FREEBSD && (SANITIZER_WORDSIZE == 32) && \ __FreeBSD_version <= 902001 // v9.2 #define ucontext_t xucontext_t #endif d78 1 a78 1 asan_rt_version_t __asan_rt_version; d85 1 a85 1 bool IsSystemHeapAddress (uptr addr) { return false; } d92 1 a92 1 #if ASAN_PREMAP_SHADOW d102 1 a102 1 #endif d106 1 a106 1 #if ASAN_PREMAP_SHADOW d109 1 a109 1 #endif d111 1 a111 1 return MapDynamicShadow(shadow_size_bytes, SHADOW_SCALE, d125 1 a125 1 #if SANITIZER_ANDROID d129 1 a129 1 #else d135 1 a135 7 // Continue until the first dynamic library is found if (!info->dlpi_name || info->dlpi_name[0] == 0) return 0; // Ignore vDSO if (internal_strncmp(info->dlpi_name, "linux-", sizeof("linux-") - 1) == 0) return 0; a136 1 #if SANITIZER_FREEBSD || SANITIZER_NETBSD d138 2 a139 3 char **p = (char **)data; if (!(*p)) { *p = (char *)-1; a141 1 #endif d143 6 a148 3 #if SANITIZER_SOLARIS // Ignore executable on Solaris if (info->dlpi_addr == 0) d150 1 a150 1 #endif d152 1 a152 1 *(const char **)data = info->dlpi_name; d158 1 a158 1 internal_strstr(libname, "libasan.so"); d173 5 a177 4 if (first_dso_name && !IsDynamicRTName(first_dso_name)) { Report("ASan runtime does not come first in initial library list; " "you should either link runtime to your application or " "manually preload it with LD_PRELOAD.\n"); d195 1 a195 1 MemoryMappingLayout proc_maps(/*cache_enabled*/true); d200 3 a202 2 Report("Your application is linked against " "incompatible ASan runtimes.\n"); d212 11 a222 1 #endif // SANITIZER_ANDROID d224 3 a226 5 #if !SANITIZER_ANDROID void ReadContextStack(void *context, uptr *stack, uptr *ssize) { ucontext_t *ucp = (ucontext_t*)context; *stack = (uptr)ucp->uc_stack.ss_sp; *ssize = ucp->uc_stack.ss_size; d228 1 a228 1 #else d230 8 a237 1 UNIMPLEMENTED(); d239 1 a239 1 #endif d241 1 a241 3 void *AsanDlSymNext(const char *sym) { return dlsym(RTLD_NEXT, sym); } d250 1 a250 1 } // namespace __asan @ 1.2 log @revert sanitizer back to the version we were using with GCC 9, since that one was already newer than the GCC 10 version. @ text @d58 1 d88 1 a88 14 return &_DYNAMIC; // defined in link.h } static void UnmapFromTo(uptr from, uptr to) { CHECK(to >= from); if (to == from) return; uptr res = internal_munmap(reinterpret_cast(from), to - from); if (UNLIKELY(internal_iserror(res))) { Report( "ERROR: AddresSanitizer failed to unmap 0x%zx (%zd) bytes at address " "%p\n", to - from, to - from, from); CHECK("unable to unmap" && 0); } d92 1 a92 1 uptr FindPremappedShadowStart() { d96 1 a96 1 uptr shadow_size = RoundUpTo(kHighShadowEnd, granularity); d104 1 d107 1 a107 1 return FindPremappedShadowStart(); d110 2 a111 14 uptr granularity = GetMmapGranularity(); uptr alignment = granularity * 8; uptr left_padding = granularity; uptr shadow_size = RoundUpTo(kHighShadowEnd, granularity); uptr map_size = shadow_size + left_padding + alignment; uptr map_start = (uptr)MmapNoAccess(map_size); CHECK_NE(map_start, ~(uptr)0); uptr shadow_start = RoundUpTo(map_start + left_padding, alignment); UnmapFromTo(map_start, shadow_start - left_padding); UnmapFromTo(shadow_start + shadow_size, map_start + map_size); return shadow_start; d118 6 d131 2 a132 2 VReport(2, "info->dlpi_name = %s\tinfo->dlpi_addr = %p\n", info->dlpi_name, info->dlpi_addr); @ 1.1 log @Initial revision @ text @@ 1.1.1.1 log @initial import of GCC 10.3.0. main changes include: caveats: - ABI issue between c++14 and c++17 fixed - profile mode is removed from libstdc++ - -fno-common is now the default new features: - new flags -fallocation-dce, -fprofile-partial-training, -fprofile-reproducible, -fprofile-prefix-path, and -fanalyzer - many new compile and link time optimisations - enhanced drive optimisations - openacc 2.6 support - openmp 5.0 features - new warnings: -Wstring-compare and -Wzero-length-bounds - extended warnings: -Warray-bounds, -Wformat-overflow, -Wrestrict, -Wreturn-local-addr, -Wstringop-overflow, -Warith-conversion, -Wmismatched-tags, and -Wredundant-tags - some likely C2X features implemented - more C++20 implemented - many new arm & intel CPUs known hundreds of reported bugs are fixed. full list of changes can be found at: https://gcc.gnu.org/gcc-10/changes.html @ text @@ 1.1.1.2 log @initial import of GCC 12.3.0. major changes in GCC 11 included: - The default mode for C++ is now -std=gnu++17 instead of -std=gnu++14. - When building GCC itself, the host compiler must now support C++11, rather than C++98. - Some short options of the gcov tool have been renamed: -i to -j and -j to -H. - ThreadSanitizer improvements. - Introduce Hardware-assisted AddressSanitizer support. - For targets that produce DWARF debugging information GCC now defaults to DWARF version 5. This can produce up to 25% more compact debug information compared to earlier versions. - Many optimisations. - The existing malloc attribute has been extended so that it can be used to identify allocator/deallocator API pairs. A pair of new -Wmismatched-dealloc and -Wmismatched-new-delete warnings are added. - Other new warnings: -Wsizeof-array-div, enabled by -Wall, warns about divisions of two sizeof operators when the first one is applied to an array and the divisor does not equal the size of the array element. -Wstringop-overread, enabled by default, warns about calls to string functions reading past the end of the arrays passed to them as arguments. -Wtsan, enabled by default, warns about unsupported features in ThreadSanitizer (currently std::atomic_thread_fence). - Enchanced warnings: -Wfree-nonheap-object detects many more instances of calls to deallocation functions with pointers not returned from a dynamic memory allocation function. -Wmaybe-uninitialized diagnoses passing pointers or references to uninitialized memory to functions taking const-qualified arguments. -Wuninitialized detects reads from uninitialized dynamically allocated memory. -Warray-parameter warns about functions with inconsistent array forms. -Wvla-parameter warns about functions with inconsistent VLA forms. - Several new features from the upcoming C2X revision of the ISO C standard are supported with -std=c2x and -std=gnu2x. - Several C++20 features have been implemented. - The C++ front end has experimental support for some of the upcoming C++23 draft. - Several new C++ warnings. - Enhanced Arm, AArch64, x86, and RISC-V CPU support. - The implementation of how program state is tracked within -fanalyzer has been completely rewritten with many enhancements. see https://gcc.gnu.org/gcc-11/changes.html for a full list. major changes in GCC 12 include: - An ABI incompatibility between C and C++ when passing or returning by value certain aggregates containing zero width bit-fields has been discovered on various targets. x86-64, ARM and AArch64 will always ignore them (so there is a C ABI incompatibility between GCC 11 and earlier with GCC 12 or later), PowerPC64 ELFv2 always take them into account (so there is a C++ ABI incompatibility, GCC 4.4 and earlier compatible with GCC 12 or later, incompatible with GCC 4.5 through GCC 11). RISC-V has changed the handling of these already starting with GCC 10. As the ABI requires, MIPS takes them into account handling function return values so there is a C++ ABI incompatibility with GCC 4.5 through 11. - STABS: Support for emitting the STABS debugging format is deprecated and will be removed in the next release. All ports now default to emit DWARF (version 2 or later) debugging info or are obsoleted. - Vectorization is enabled at -O2 which is now equivalent to the original -O2 -ftree-vectorize -fvect-cost-model=very-cheap. - GCC now supports the ShadowCallStack sanitizer. - Support for __builtin_shufflevector compatible with the clang language extension was added. - Support for attribute unavailable was added. - Support for __builtin_dynamic_object_size compatible with the clang language extension was added. - New warnings: -Wbidi-chars warns about potentially misleading UTF-8 bidirectional control characters. -Warray-compare warns about comparisons between two operands of array type. - Some new features from the upcoming C2X revision of the ISO C standard are supported with -std=c2x and -std=gnu2x. - Several C++23 features have been implemented. - Many C++ enhancements across warnings and -f options. see https://gcc.gnu.org/gcc-12/changes.html for a full list. @ text @a57 1 extern ElfW(Dyn) _DYNAMIC[]; d87 14 a100 1 return &_DYNAMIC; d104 1 a104 1 uptr FindPremappedShadowStart(uptr shadow_size_bytes) { d108 1 a108 1 uptr shadow_size = RoundUpTo(shadow_size_bytes, granularity); a115 1 uptr shadow_size_bytes = MemToShadowSize(kHighMemEnd); d118 1 a118 1 return FindPremappedShadowStart(shadow_size_bytes); d121 14 a134 2 return MapDynamicShadow(shadow_size_bytes, SHADOW_SCALE, /*min_shadow_base_alignment*/ 0, kHighMemEnd); a140 6 void FlushUnneededASanShadowMemory(uptr p, uptr size) { // Since asan's mapping is compacting, the shadow chunk may be // not page-aligned, so we only flush the page-aligned portion. ReleaseMemoryPagesToOS(MemToShadow(p), MemToShadow(p + size)); } d148 2 a149 2 VReport(2, "info->dlpi_name = %s\tinfo->dlpi_addr = %p\n", info->dlpi_name, (void *)info->dlpi_addr); @ 1.1.1.3 log @initial import of GCC 14.3.0. major changes in GCC 13: - improved sanitizer - zstd debug info compression - LTO improvements - SARIF based diagnostic support - new warnings: -Wxor-used-as-pow, -Wenum-int-mismatch, -Wself-move, -Wdangling-reference - many new -Wanalyzer* specific warnings - enhanced warnings: -Wpessimizing-move, -Wredundant-move - new attributes to mark file descriptors, c++23 "assume" - several C23 features added - several C++23 features added - many new features for Arm, x86, RISC-V major changes in GCC 14: - more strict C99 or newer support - ia64* marked deprecated (but seemingly still in GCC 15.) - several new hardening features - support for "hardbool", which can have user supplied values of true/false - explicit support for stack scrubbing upon function exit - better auto-vectorisation support - added clang-compatible __has_feature and __has_extension - more C23, including -std=c23 - several C++26 features added - better diagnostics in C++ templates - new warnings: -Wnrvo, Welaborated-enum-base - many new features for Arm, x86, RISC-V - possible ABI breaking change for SPARC64 and small structures with arrays of floats. @ text @d18 36 a53 37 # include # include # include # include # include # include # include # include # include # include # include # include # include "asan_interceptors.h" # include "asan_internal.h" # include "asan_premap_shadow.h" # include "asan_thread.h" # include "sanitizer_common/sanitizer_flags.h" # include "sanitizer_common/sanitizer_freebsd.h" # include "sanitizer_common/sanitizer_hash.h" # include "sanitizer_common/sanitizer_libc.h" # include "sanitizer_common/sanitizer_procmaps.h" # if SANITIZER_FREEBSD # include # endif # if SANITIZER_SOLARIS # include # endif # if SANITIZER_ANDROID || SANITIZER_FREEBSD || SANITIZER_SOLARIS # include extern "C" void *_DYNAMIC; # elif SANITIZER_NETBSD # include # include d55 3 a57 3 # else # include # include d59 1 a59 1 # endif d63 4 a66 4 # if SANITIZER_FREEBSD && (SANITIZER_WORDSIZE == 32) && \ __FreeBSD_version <= 902001 // v9.2 # define ucontext_t xucontext_t # endif d77 1 a77 1 asan_rt_version_t __asan_rt_version; d84 1 a84 1 bool IsSystemHeapAddress(uptr addr) { return false; } d91 1 a91 1 # if ASAN_PREMAP_SHADOW d101 1 a101 1 # endif d105 1 a105 1 # if ASAN_PREMAP_SHADOW d108 1 a108 1 # endif d110 1 a110 1 return MapDynamicShadow(shadow_size_bytes, ASAN_SHADOW_SCALE, d124 1 a124 1 # if SANITIZER_ANDROID d128 1 a128 1 # else d134 7 a140 1 const char **name = (const char **)data; d142 1 d144 3 a146 2 if (!*name) { *name = ""; d149 1 d151 3 a153 6 # if SANITIZER_LINUX // Ignore vDSO. glibc versions earlier than 2.15 (and some patched // by distributors) return an empty name for the vDSO entry, so // detect this as well. if (!info->dlpi_name[0] || internal_strncmp(info->dlpi_name, "linux-", sizeof("linux-") - 1) == 0) d155 1 a155 1 # endif d157 1 a157 1 *name = info->dlpi_name; d163 1 a163 1 internal_strstr(libname, "libasan.so"); d178 4 a181 5 if (first_dso_name && first_dso_name[0] && !IsDynamicRTName(first_dso_name)) { Report( "ASan runtime does not come first in initial library list; " "you should either link runtime to your application or " "manually preload it with LD_PRELOAD.\n"); d199 1 a199 1 MemoryMappingLayout proc_maps(/*cache_enabled*/ true); d204 2 a205 3 Report( "Your application is linked against " "incompatible ASan runtimes.\n"); d215 1 a215 1 # endif // SANITIZER_ANDROID d217 5 a221 8 # if ASAN_INTERCEPT_SWAPCONTEXT constexpr u32 kAsanContextStackFlagsMagic = 0x51260eea; static int HashContextStack(const ucontext_t &ucp) { MurMur2Hash64Builder hash(kAsanContextStackFlagsMagic); hash.add(reinterpret_cast(ucp.uc_stack.ss_sp)); hash.add(ucp.uc_stack.ss_size); return static_cast(hash.get()); d223 3 a225 4 void SignContextStack(void *context) { ucontext_t *ucp = reinterpret_cast(context); ucp->uc_stack.ss_flags = HashContextStack(*ucp); d227 1 d229 2 a230 9 void ReadContextStack(void *context, uptr *stack, uptr *ssize) { const ucontext_t *ucp = reinterpret_cast(context); if (HashContextStack(*ucp) == ucp->uc_stack.ss_flags) { *stack = reinterpret_cast(ucp->uc_stack.ss_sp); *ssize = ucp->uc_stack.ss_size; return; } *stack = 0; *ssize = 0; a231 3 # endif // ASAN_INTERCEPT_SWAPCONTEXT void *AsanDlSymNext(const char *sym) { return dlsym(RTLD_NEXT, sym); } d240 1 a240 1 } // namespace __asan @