Commit ac2050609055d76a58b058b064f0b0c4d54e2faa | zig

lib/libtsan/builtins/assembly.h+42-15

 @@ -61,7 +61,7 @@
 #define LOCAL_LABEL(name) .L ## name
 #define FILE_LEVEL_DIRECTIVE
 #define SYMBOL_IS_FUNC(name)                                                   \
-  .def name SEPARATOR                                                          \
+  .def FUNC_SYMBOL(name) SEPARATOR                                             \
     .scl 2 SEPARATOR                                                           \
     .type 32 SEPARATOR                                                         \
   .endef
 @@ -71,7 +71,7 @@
 #endif
-#if defined(__arm__) || defined(__aarch64__)
+#if defined(__arm__) || defined(__aarch64__) || defined(__arm64ec__)
 #define FUNC_ALIGN                                                             \
   .text SEPARATOR                                                              \
   .balign 16 SEPARATOR
 @@ -194,6 +194,23 @@
 #else
 #define WIDE(op) op
 #endif
+#if defined(__ARM_FEATURE_PAC_DEFAULT) && defined(__ARM_FEATURE_BTI_DEFAULT)
+#define PACBTI_LANDING pacbti r12, lr, sp
+#elif defined(__ARM_FEATURE_PAC_DEFAULT)
+#define PACBTI_LANDING pac r12, lr, sp
+#elif defined(__ARM_FEATURE_BTI_DEFAULT)
+#define PACBTI_LANDING bti
+#else
+#define PACBTI_LANDING
+#endif
+#if defined(__ARM_FEATURE_PAUTH)
+#define PAC_RETURN bxaut r12, lr, sp
+#else
+#define PAC_RETURN aut r12, lr, sp SEPARATOR bx lr
+#endif
 #else // !defined(__arm)
 #define DECLARE_FUNC_ENCODING
 #define DEFINE_CODE_STATE
 @@ -208,6 +225,16 @@
 #define GLUE4(a, b, c, d) GLUE4_(a, b, c, d)
 #define SYMBOL_NAME(name) GLUE(__USER_LABEL_PREFIX__, name)
+#ifndef __arm64ec__
+#define FUNC_SYMBOL(name) name
+#else
+// On ARM64EC, function names and calls (but not address-taking or data symbol
+// references) use symbols prefixed with "#".
+#define QUOTE(a) #a
+#define STR(a) QUOTE(a)
+#define HASH #
+#define FUNC_SYMBOL(name) STR(GLUE2(HASH, name))
+#endif
 #ifdef VISIBILITY_HIDDEN
 #define DECLARE_SYMBOL_VISIBILITY(name)                                        \
 @@ -222,54 +249,54 @@
 #define DEFINE_COMPILERRT_FUNCTION(name)                                       \
   DEFINE_CODE_STATE                                                            \
   FILE_LEVEL_DIRECTIVE SEPARATOR                                               \
-  .globl SYMBOL_NAME(name) SEPARATOR                                           \
+  .globl FUNC_SYMBOL(SYMBOL_NAME(name)) SEPARATOR                              \
   SYMBOL_IS_FUNC(SYMBOL_NAME(name)) SEPARATOR                                  \
   DECLARE_SYMBOL_VISIBILITY(name)                                              \
   DECLARE_FUNC_ENCODING                                                        \
-  SYMBOL_NAME(name):
+  FUNC_SYMBOL(SYMBOL_NAME(name)):
 #define DEFINE_COMPILERRT_THUMB_FUNCTION(name)                                 \
   DEFINE_CODE_STATE                                                            \
   FILE_LEVEL_DIRECTIVE SEPARATOR                                               \
-  .globl SYMBOL_NAME(name) SEPARATOR                                           \
+  .globl FUNC_SYMBOL(SYMBOL_NAME(name)) SEPARATOR                              \
   SYMBOL_IS_FUNC(SYMBOL_NAME(name)) SEPARATOR                                  \
   DECLARE_SYMBOL_VISIBILITY(name) SEPARATOR                                    \
   .thumb_func SEPARATOR                                                        \
-  SYMBOL_NAME(name):
+  FUNC_SYMBOL(SYMBOL_NAME(name)):
 #define DEFINE_COMPILERRT_PRIVATE_FUNCTION(name)                               \
   DEFINE_CODE_STATE                                                            \
   FILE_LEVEL_DIRECTIVE SEPARATOR                                               \
-  .globl SYMBOL_NAME(name) SEPARATOR                                           \
+  .globl FUNC_SYMBOL(SYMBOL_NAME(name)) SEPARATOR                              \
   SYMBOL_IS_FUNC(SYMBOL_NAME(name)) SEPARATOR                                  \
   HIDDEN(SYMBOL_NAME(name)) SEPARATOR                                          \
   DECLARE_FUNC_ENCODING                                                        \
-  SYMBOL_NAME(name):
+  FUNC_SYMBOL(SYMBOL_NAME(name)):
 #define DEFINE_COMPILERRT_PRIVATE_FUNCTION_UNMANGLED(name)                     \
   DEFINE_CODE_STATE                                                            \
-  .globl name SEPARATOR                                                        \
+  .globl FUNC_SYMBOL(name) SEPARATOR                                           \
   SYMBOL_IS_FUNC(name) SEPARATOR                                               \
   HIDDEN(name) SEPARATOR                                                       \
   DECLARE_FUNC_ENCODING                                                        \
-  name:
+  FUNC_SYMBOL(name):
 #define DEFINE_COMPILERRT_OUTLINE_FUNCTION_UNMANGLED(name)                     \
   DEFINE_CODE_STATE                                                            \
   FUNC_ALIGN                                                                   \
-  .globl name SEPARATOR                                                        \
+  .globl FUNC_SYMBOL(name) SEPARATOR                                           \
   SYMBOL_IS_FUNC(name) SEPARATOR                                               \
-  DECLARE_SYMBOL_VISIBILITY_UNMANGLED(name) SEPARATOR                          \
+  DECLARE_SYMBOL_VISIBILITY_UNMANGLED(FUNC_SYMBOL(name)) SEPARATOR             \
   DECLARE_FUNC_ENCODING                                                        \
-  name:                                                                        \
+  FUNC_SYMBOL(name):                                                           \
   SEPARATOR CFI_START                                                          \
   SEPARATOR BTI_C
 #define DEFINE_COMPILERRT_FUNCTION_ALIAS(name, target)                         \
-  .globl SYMBOL_NAME(name) SEPARATOR                                           \
+  .globl FUNC_SYMBOL(SYMBOL_NAME(name)) SEPARATOR                              \
   SYMBOL_IS_FUNC(SYMBOL_NAME(name)) SEPARATOR                                  \
   DECLARE_SYMBOL_VISIBILITY(name) SEPARATOR                                    \
-  .set SYMBOL_NAME(name), SYMBOL_NAME(target) SEPARATOR
+  .set FUNC_SYMBOL(SYMBOL_NAME(name)), FUNC_SYMBOL(target) SEPARATOR
 #if defined(__ARM_EABI__)
 #define DEFINE_AEABI_FUNCTION_ALIAS(aeabi_name, name)                          \

lib/libtsan/interception/interception.h+21-6

...	@@ -19,7 +19,7 @@	...	@@ -19,7 +19,7 @@
19		19
20	#if !SANITIZER_LINUX && !SANITIZER_FREEBSD && !SANITIZER_APPLE && \	20	#if !SANITIZER_LINUX && !SANITIZER_FREEBSD && !SANITIZER_APPLE && \
21	!SANITIZER_NETBSD && !SANITIZER_WINDOWS && !SANITIZER_FUCHSIA && \	21	!SANITIZER_NETBSD && !SANITIZER_WINDOWS && !SANITIZER_FUCHSIA && \
22	!SANITIZER_SOLARIS	22	!SANITIZER_SOLARIS && !SANITIZER_HAIKU && !SANITIZER_AIX
23	# error "Interception doesn't work on this operating system."	23	# error "Interception doesn't work on this operating system."
24	#endif	24	#endif
25		25
...	@@ -168,6 +168,16 @@ const interpose_substitution substitution_##func_name[] \	...	@@ -168,6 +168,16 @@ const interpose_substitution substitution_##func_name[] \
168	extern "C" ret_type func(__VA_ARGS__);	168	extern "C" ret_type func(__VA_ARGS__);
169	# define DECLARE_WRAPPER_WINAPI(ret_type, func, ...) \	169	# define DECLARE_WRAPPER_WINAPI(ret_type, func, ...) \
170	extern "C" __declspec(dllimport) ret_type __stdcall func(__VA_ARGS__);	170	extern "C" __declspec(dllimport) ret_type __stdcall func(__VA_ARGS__);
		171	#elif SANITIZER_AIX
		172	# define WRAP(x) __interceptor_##x
		173	# define TRAMPOLINE(x) WRAP(x)
		174	// # define WRAPPER_NAME(x) "__interceptor_" #x
		175	# define INTERCEPTOR_ATTRIBUTE __attribute__((visibility("default")))
		176	// AIX's linker will not select the weak symbol, so don't use weak for the
		177	// interceptors.
		178	# define DECLARE_WRAPPER(ret_type, func, ...) \
		179	extern "C" ret_type func(__VA_ARGS__) \
		180	__attribute__((alias("__interceptor_" #func), visibility("default")));
171	#elif !SANITIZER_FUCHSIA // LINUX, FREEBSD, NETBSD, SOLARIS	181	#elif !SANITIZER_FUCHSIA // LINUX, FREEBSD, NETBSD, SOLARIS
172	# define INTERCEPTOR_ATTRIBUTE __attribute__((visibility("default")))	182	# define INTERCEPTOR_ATTRIBUTE __attribute__((visibility("default")))
173	# if ASM_INTERCEPTOR_TRAMPOLINE_SUPPORT	183	# if ASM_INTERCEPTOR_TRAMPOLINE_SUPPORT
...	@@ -367,12 +377,17 @@ inline void DoesNotSupportStaticLinking() {}	...	@@ -367,12 +377,17 @@ inline void DoesNotSupportStaticLinking() {}
367		377
368	#define INCLUDED_FROM_INTERCEPTION_LIB	378	#define INCLUDED_FROM_INTERCEPTION_LIB
369		379
370	#if SANITIZER_LINUX \|\| SANITIZER_FREEBSD \|\| SANITIZER_NETBSD \|\| \	380	#if SANITIZER_AIX
371	SANITIZER_SOLARIS	381	# include "interception_aix.h"
		382	# define INTERCEPT_FUNCTION(func) INTERCEPT_FUNCTION_AIX(func)
		383	# define INTERCEPT_FUNCTION_VER(func, symver) INTERCEPT_FUNCTION_AIX(func)
372		384
373	# include "interception_linux.h"	385	#elif SANITIZER_LINUX \|\| SANITIZER_FREEBSD \|\| SANITIZER_NETBSD \|\| \
374	# define INTERCEPT_FUNCTION(func) INTERCEPT_FUNCTION_LINUX_OR_FREEBSD(func)	386	SANITIZER_SOLARIS \|\| SANITIZER_HAIKU
375	# define INTERCEPT_FUNCTION_VER(func, symver) \	387
		388	# include "interception_linux.h"
		389	# define INTERCEPT_FUNCTION(func) INTERCEPT_FUNCTION_LINUX_OR_FREEBSD(func)
		390	# define INTERCEPT_FUNCTION_VER(func, symver) \
376	INTERCEPT_FUNCTION_VER_LINUX_OR_FREEBSD(func, symver)	391	INTERCEPT_FUNCTION_VER_LINUX_OR_FREEBSD(func, symver)
377	#elif SANITIZER_APPLE	392	#elif SANITIZER_APPLE
378	# include "interception_mac.h"	393	# include "interception_mac.h"

lib/libtsan/interception/interception_aix.cpp created+45

...	@@ -0,0 +1,45 @@
1	//===-- interception_aix.cpp ------------------------------------- C++ --===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8	//
9	// This file is a part of AddressSanitizer, an address sanity checker.
10	//
11	// AIX-specific interception methods.
12	//===----------------------------------------------------------------------===//
13
14	#include "interception.h"
15	#include "sanitizer_common/sanitizer_common.h"
16
17	#if SANITIZER_AIX
18
19	# include <dlfcn.h> // for dlsym()
20
21	namespace __interception {
22
23	static void GetFuncAddr(const char name, uptr wrapper_addr) {
24	// AIX dlsym can only defect the functions that are exported, so
25	// on AIX, we can not intercept some basic functions like memcpy.
26	// FIXME: if we are going to ship dynamic asan library, we may need to search
27	// all the loaded modules with RTLD_DEFAULT if RTLD_NEXT failed.
28	void *addr = dlsym(RTLD_NEXT, name);
29
30	// In case `name' is not loaded, dlsym ends up finding the actual wrapper.
31	// We don't want to intercept the wrapper and have it point to itself.
32	if ((uptr)addr == wrapper_addr)
33	addr = nullptr;
34	return addr;
35	}
36
37	bool InterceptFunction(const char name, uptr ptr_to_real, uptr func,
38	uptr wrapper) {
39	void *addr = GetFuncAddr(name, wrapper);
40	*ptr_to_real = (uptr)addr;
41	return addr && (func == wrapper);
42	}
43
44	} // namespace __interception
45	#endif // SANITIZER_AIX

lib/libtsan/interception/interception_aix.h created+36

...	@@ -0,0 +1,36 @@
1	//===-- interception_aix.h --------------------------------------- C++ --===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8	//
9	// This file is a part of AddressSanitizer, an address sanity checker.
10	//
11	// AIX-specific interception methods.
12	//===----------------------------------------------------------------------===//
13
14	#if SANITIZER_AIX
15
16	# if !defined(INCLUDED_FROM_INTERCEPTION_LIB)
17	# error \
18	"interception_aix.h should be included from interception library only"
19	# endif
20
21	# ifndef INTERCEPTION_AIX_H
22	# define INTERCEPTION_AIX_H
23
24	namespace __interception {
25	bool InterceptFunction(const char name, uptr ptr_to_real, uptr func,
26	uptr wrapper);
27	} // namespace __interception
28
29	# define INTERCEPT_FUNCTION_AIX(func) \
30	::__interception::InterceptFunction( \
31	#func, (::__interception::uptr *)&REAL(func), \
32	(::__interception::uptr) & (func), \
33	(::__interception::uptr) & WRAP(func))
34
35	# endif // INTERCEPTION_AIX_H
36	#endif // SANITIZER_AIX

lib/libtsan/interception/interception_linux.cpp+2-2

...	@@ -14,7 +14,7 @@	...	@@ -14,7 +14,7 @@
14	#include "interception.h"	14	#include "interception.h"
15		15
16	#if SANITIZER_LINUX \|\| SANITIZER_FREEBSD \|\| SANITIZER_NETBSD \|\| \	16	#if SANITIZER_LINUX \|\| SANITIZER_FREEBSD \|\| SANITIZER_NETBSD \|\| \
17	SANITIZER_SOLARIS	17	SANITIZER_SOLARIS \|\| SANITIZER_HAIKU
18		18
19	#include <dlfcn.h> // for dlsym() and dlvsym()	19	#include <dlfcn.h> // for dlsym() and dlvsym()
20		20
...	@@ -80,4 +80,4 @@ bool InterceptFunction(const char name, const char ver, uptr *ptr_to_real,	...	@@ -80,4 +80,4 @@ bool InterceptFunction(const char name, const char ver, uptr *ptr_to_real,
80	} // namespace __interception	80	} // namespace __interception
81		81
82	#endif // SANITIZER_LINUX \|\| SANITIZER_FREEBSD \|\| SANITIZER_NETBSD \|\|	82	#endif // SANITIZER_LINUX \|\| SANITIZER_FREEBSD \|\| SANITIZER_NETBSD \|\|
83	// SANITIZER_SOLARIS	83	// SANITIZER_SOLARIS \|\| SANITIZER_HAIKU

lib/libtsan/interception/interception_linux.h+2-2

...	@@ -12,7 +12,7 @@	...	@@ -12,7 +12,7 @@
12	//===----------------------------------------------------------------------===//	12	//===----------------------------------------------------------------------===//
13		13
14	#if SANITIZER_LINUX \|\| SANITIZER_FREEBSD \|\| SANITIZER_NETBSD \|\| \	14	#if SANITIZER_LINUX \|\| SANITIZER_FREEBSD \|\| SANITIZER_NETBSD \|\| \
15	SANITIZER_SOLARIS	15	SANITIZER_SOLARIS \|\| SANITIZER_HAIKU
16		16
17	#if !defined(INCLUDED_FROM_INTERCEPTION_LIB)	17	#if !defined(INCLUDED_FROM_INTERCEPTION_LIB)
18	# error interception_linux.h should be included from interception library only	18	# error interception_linux.h should be included from interception library only
...	@@ -52,4 +52,4 @@ bool InterceptFunction(const char name, const char ver, uptr *ptr_to_real,	...	@@ -52,4 +52,4 @@ bool InterceptFunction(const char name, const char ver, uptr *ptr_to_real,
52		52
53	#endif // INTERCEPTION_LINUX_H	53	#endif // INTERCEPTION_LINUX_H
54	#endif // SANITIZER_LINUX \|\| SANITIZER_FREEBSD \|\| SANITIZER_NETBSD \|\|	54	#endif // SANITIZER_LINUX \|\| SANITIZER_FREEBSD \|\| SANITIZER_NETBSD \|\|
55	// SANITIZER_SOLARIS	55	// SANITIZER_SOLARIS \|\| SANITIZER_HAIKU

lib/libtsan/interception/interception_win.cpp+8-1

...	@@ -646,6 +646,7 @@ static size_t GetInstructionSize(uptr address, size_t* rel_offset = nullptr) {	...	@@ -646,6 +646,7 @@ static size_t GetInstructionSize(uptr address, size_t* rel_offset = nullptr) {
646	case 0xC033: // 33 C0 : xor eax, eax	646	case 0xC033: // 33 C0 : xor eax, eax
647	case 0xC933: // 33 C9 : xor ecx, ecx	647	case 0xC933: // 33 C9 : xor ecx, ecx
648	case 0xD233: // 33 D2 : xor edx, edx	648	case 0xD233: // 33 D2 : xor edx, edx
		649	case 0x9066: // 66 90 : xchg %ax,%ax (Two-byte NOP)
649	case 0xDB84: // 84 DB : test bl,bl	650	case 0xDB84: // 84 DB : test bl,bl
650	case 0xC084: // 84 C0 : test al,al	651	case 0xC084: // 84 C0 : test al,al
651	case 0xC984: // 84 C9 : test cl,cl	652	case 0xC984: // 84 C9 : test cl,cl
...	@@ -726,7 +727,6 @@ static size_t GetInstructionSize(uptr address, size_t* rel_offset = nullptr) {	...	@@ -726,7 +727,6 @@ static size_t GetInstructionSize(uptr address, size_t* rel_offset = nullptr) {
726	case 0x5541: // push r13	727	case 0x5541: // push r13
727	case 0x5641: // push r14	728	case 0x5641: // push r14
728	case 0x5741: // push r15	729	case 0x5741: // push r15
729	case 0x9066: // Two-byte NOP
730	case 0xc084: // test al, al	730	case 0xc084: // test al, al
731	case 0x018a: // mov al, byte ptr [rcx]	731	case 0x018a: // mov al, byte ptr [rcx]
732	return 2;	732	return 2;
...	@@ -743,6 +743,7 @@ static size_t GetInstructionSize(uptr address, size_t* rel_offset = nullptr) {	...	@@ -743,6 +743,7 @@ static size_t GetInstructionSize(uptr address, size_t* rel_offset = nullptr) {
743	case 0x058B: // 8B 05 XX XX XX XX : mov eax, dword ptr [XX XX XX XX]	743	case 0x058B: // 8B 05 XX XX XX XX : mov eax, dword ptr [XX XX XX XX]
744	if (rel_offset)	744	if (rel_offset)
745	*rel_offset = 2;	745	*rel_offset = 2;
		746	FALLTHROUGH;
746	case 0xB841: // 41 B8 XX XX XX XX : mov r8d, XX XX XX XX	747	case 0xB841: // 41 B8 XX XX XX XX : mov r8d, XX XX XX XX
747	return 6;	748	return 6;
748		749
...	@@ -753,6 +754,12 @@ static size_t GetInstructionSize(uptr address, size_t* rel_offset = nullptr) {	...	@@ -753,6 +754,12 @@ static size_t GetInstructionSize(uptr address, size_t* rel_offset = nullptr) {
753	case 0x7B81: // 81 7B YY XX XX XX XX cmp DWORD PTR [rbx+YY], XX XX XX XX	754	case 0x7B81: // 81 7B YY XX XX XX XX cmp DWORD PTR [rbx+YY], XX XX XX XX
754	case 0x7981: // 81 79 YY XX XX XX XX cmp dword ptr [rcx+YY], XX XX XX XX	755	case 0x7981: // 81 79 YY XX XX XX XX cmp dword ptr [rcx+YY], XX XX XX XX
755	return 7;	756	return 7;
		757
		758	case 0xb848: // 48 b8 XX XX XX XX XX XX XX XX :
		759	// movabsq XX XX XX XX XX XX XX XX, rax
		760	case 0xba48: // 48 ba XX XX XX XX XX XX XX XX :
		761	// movabsq XX XX XX XX XX XX XX XX, rdx
		762	return 10;
756	}	763	}
757		764
758	switch (0x00FFFFFF & (u32 )address) {	765	switch (0x00FFFFFF & (u32 )address) {

lib/libtsan/sanitizer_common/sanitizer_allocator_internal.h+1-1

...	@@ -23,7 +23,7 @@ namespace __sanitizer {	...	@@ -23,7 +23,7 @@ namespace __sanitizer {
23	typedef CompactSizeClassMap InternalSizeClassMap;	23	typedef CompactSizeClassMap InternalSizeClassMap;
24		24
25	struct AP32 {	25	struct AP32 {
26	static const uptr kSpaceBeg = 0;	26	static const uptr kSpaceBeg = SANITIZER_MMAP_BEGIN;
27	static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;	27	static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
28	static const uptr kMetadataSize = 0;	28	static const uptr kMetadataSize = 0;
29	typedef InternalSizeClassMap SizeClassMap;	29	typedef InternalSizeClassMap SizeClassMap;

lib/libtsan/sanitizer_common/sanitizer_allocator_local_cache.h+1-1

...	@@ -166,7 +166,7 @@ struct SizeClassAllocator32LocalCache {	...	@@ -166,7 +166,7 @@ struct SizeClassAllocator32LocalCache {
166	DCHECK_GT(c->count, 0);	166	DCHECK_GT(c->count, 0);
167	}	167	}
168	void *res = c->batch[--c->count];	168	void *res = c->batch[--c->count];
169	PREFETCH(c->batch[c->count - 1]);	169	PREFETCH(c->batch[c->count > 0 ? c->count - 1 : 0]);
170	stats_.Add(AllocatorStatAllocated, c->class_size);	170	stats_.Add(AllocatorStatAllocated, c->class_size);
171	return res;	171	return res;
172	}	172	}

lib/libtsan/sanitizer_common/sanitizer_atomic_clang.h+15

 @@ -14,6 +14,18 @@
 #ifndef SANITIZER_ATOMIC_CLANG_H
 #define SANITIZER_ATOMIC_CLANG_H
+// Helper to suppress warnings related to 8-byte atomic accesses when the target
+// is 32-bit AIX (where such accesses use libatomic).
+#if defined(_AIX) && !defined(__powerpc64__) && defined(__clang__)
+#  define SANITIZER_IGNORE_ATOMIC_ALIGNMENT_BEGIN \
+    _Pragma("clang diagnostic push")              \
+        _Pragma("clang diagnostic ignored \"-Watomic-alignment\"")
+#  define SANITIZER_IGNORE_ATOMIC_ALIGNMENT_END _Pragma("clang diagnostic pop")
+#else
+#  define SANITIZER_IGNORE_ATOMIC_ALIGNMENT_BEGIN
+#  define SANITIZER_IGNORE_ATOMIC_ALIGNMENT_END
+#endif
 namespace __sanitizer {
 // We use the compiler builtin atomic operations for loads and stores, which
 @@ -35,6 +47,7 @@ inline void proc_yield(int cnt) {
 #endif
 }
+SANITIZER_IGNORE_ATOMIC_ALIGNMENT_BEGIN
 template <typename T>
 inline typename T::Type atomic_load(const volatile T *a, memory_order mo) {
   DCHECK(mo == memory_order_relaxed || mo == memory_order_consume ||
 @@ -92,6 +105,8 @@ inline bool atomic_compare_exchange_weak(volatile T *a, typename T::Type *cmp,
   return atomic_compare_exchange_strong(a, cmp, xchg, mo);
 }
+SANITIZER_IGNORE_ATOMIC_ALIGNMENT_END
 }  // namespace __sanitizer
 #undef ATOMIC_ORDER

lib/libtsan/sanitizer_common/sanitizer_common.h+2-19

 @@ -166,7 +166,7 @@ uptr FindAvailableMemoryRange(uptr size, uptr alignment, uptr left_padding,
 // Used to check if we can map shadow memory to a fixed location.
 bool MemoryRangeIsAvailable(uptr range_start, uptr range_end);
-// Releases memory pages entirely within the [beg, end] address range. Noop if
+// Releases memory pages entirely within the [beg, end) address range. Noop if
 // the provided range does not contain at least one entire page.
 void ReleaseMemoryPagesToOS(uptr beg, uptr end);
 void IncreaseTotalMmap(uptr size);
 @@ -925,12 +925,6 @@ class ListOfModules {
 // Callback type for iterating over a set of memory ranges.
 typedef void (*RangeIteratorCallback)(uptr begin, uptr end, void *arg);
-enum AndroidApiLevel {
-  ANDROID_NOT_ANDROID = 0,
-  ANDROID_LOLLIPOP_MR1 = 22,
-  ANDROID_POST_LOLLIPOP = 23
-};
 void WriteToSyslog(const char *buffer);
 #if defined(SANITIZER_WINDOWS) && defined(_MSC_VER) && !defined(__clang__)
 @@ -963,19 +957,8 @@ inline void AndroidLogInit() {}
 inline void SetAbortMessage(const char *) {}
 #endif
-#if SANITIZER_ANDROID
-void SanitizerInitializeUnwinder();
-AndroidApiLevel AndroidGetApiLevel();
-#else
-inline void AndroidLogWrite(const char *buffer_unused) {}
-inline void SanitizerInitializeUnwinder() {}
-inline AndroidApiLevel AndroidGetApiLevel() { return ANDROID_NOT_ANDROID; }
-#endif
 inline uptr GetPthreadDestructorIterations() {
-#if SANITIZER_ANDROID
+#if SANITIZER_POSIX
-  return (AndroidGetApiLevel() == ANDROID_LOLLIPOP_MR1) ? 8 : 4;
-#elif SANITIZER_POSIX
   return 4;
 #else
 // Unused on Windows.

lib/libtsan/sanitizer_common/sanitizer_common_interceptors.inc+127-24

...	@@ -481,7 +481,8 @@ INTERCEPTOR(char, textdomain, const char domainname) {	...	@@ -481,7 +481,8 @@ INTERCEPTOR(char, textdomain, const char domainname) {
481	#endif	481	#endif
482		482
483	#if SANITIZER_INTERCEPT_STRCMP \|\| SANITIZER_INTERCEPT_MEMCMP	483	#if SANITIZER_INTERCEPT_STRCMP \|\| SANITIZER_INTERCEPT_MEMCMP
484	static inline int CharCmpX(unsigned char c1, unsigned char c2) {	484	[[maybe_unused]] static inline int CharCmpX(unsigned char c1,
		485	unsigned char c2) {
485	return (c1 == c2) ? 0 : (c1 < c2) ? -1 : 1;	486	return (c1 == c2) ? 0 : (c1 < c2) ? -1 : 1;
486	}	487	}
487	#endif	488	#endif
...	@@ -953,7 +954,7 @@ INTERCEPTOR(double, frexp, double x, int *exp) {	...	@@ -953,7 +954,7 @@ INTERCEPTOR(double, frexp, double x, int *exp) {
953	#define INIT_FREXP	954	#define INIT_FREXP
954	#endif // SANITIZER_INTERCEPT_FREXP	955	#endif // SANITIZER_INTERCEPT_FREXP
955		956
956	#if SANITIZER_INTERCEPT_FREXPF_FREXPL	957	#if SANITIZER_INTERCEPT_FREXPF
957	INTERCEPTOR(float, frexpf, float x, int *exp) {	958	INTERCEPTOR(float, frexpf, float x, int *exp) {
958	void *ctx;	959	void *ctx;
959	COMMON_INTERCEPTOR_ENTER(ctx, frexpf, x, exp);	960	COMMON_INTERCEPTOR_ENTER(ctx, frexpf, x, exp);
...	@@ -963,6 +964,12 @@ INTERCEPTOR(float, frexpf, float x, int *exp) {	...	@@ -963,6 +964,12 @@ INTERCEPTOR(float, frexpf, float x, int *exp) {
963	return res;	964	return res;
964	}	965	}
965		966
		967	# define INIT_FREXPF COMMON_INTERCEPT_FUNCTION(frexpf);
		968	#else
		969	# define INIT_FREXPF
		970	#endif
		971
		972	#if SANITIZER_INTERCEPT_FREXPL
966	INTERCEPTOR(long double, frexpl, long double x, int *exp) {	973	INTERCEPTOR(long double, frexpl, long double x, int *exp) {
967	void *ctx;	974	void *ctx;
968	COMMON_INTERCEPTOR_ENTER(ctx, frexpl, x, exp);	975	COMMON_INTERCEPTOR_ENTER(ctx, frexpl, x, exp);
...	@@ -972,12 +979,10 @@ INTERCEPTOR(long double, frexpl, long double x, int *exp) {	...	@@ -972,12 +979,10 @@ INTERCEPTOR(long double, frexpl, long double x, int *exp) {
972	return res;	979	return res;
973	}	980	}
974		981
975	#define INIT_FREXPF_FREXPL \	982	# define INIT_FREXPL COMMON_INTERCEPT_FUNCTION_LDBL(frexpl)
976	COMMON_INTERCEPT_FUNCTION(frexpf); \
977	COMMON_INTERCEPT_FUNCTION_LDBL(frexpl)
978	#else	983	#else
979	#define INIT_FREXPF_FREXPL	984	# define INIT_FREXPL
980	#endif // SANITIZER_INTERCEPT_FREXPF_FREXPL	985	#endif
981		986
982	#if SI_POSIX	987	#if SI_POSIX
983	static void write_iovec(void ctx, struct __sanitizer_iovec iovec,	988	static void write_iovec(void ctx, struct __sanitizer_iovec iovec,
...	@@ -1346,7 +1351,8 @@ INTERCEPTOR(unsigned long, time, unsigned long *t) {	...	@@ -1346,7 +1351,8 @@ INTERCEPTOR(unsigned long, time, unsigned long *t) {
1346	#if SANITIZER_INTERCEPT_LOCALTIME_AND_FRIENDS	1351	#if SANITIZER_INTERCEPT_LOCALTIME_AND_FRIENDS
1347	static void unpoison_tm(void ctx, __sanitizer_tm tm) {	1352	static void unpoison_tm(void ctx, __sanitizer_tm tm) {
1348	COMMON_INTERCEPTOR_WRITE_RANGE(ctx, tm, sizeof(*tm));	1353	COMMON_INTERCEPTOR_WRITE_RANGE(ctx, tm, sizeof(*tm));
1349	#if !SANITIZER_SOLARIS	1354	// AIX tm struct does not have tm_zone field.
		1355	# if !SANITIZER_SOLARIS && !SANITIZER_AIX
1350	if (tm->tm_zone) {	1356	if (tm->tm_zone) {
1351	// Can not use COMMON_INTERCEPTOR_WRITE_RANGE here, because tm->tm_zone	1357	// Can not use COMMON_INTERCEPTOR_WRITE_RANGE here, because tm->tm_zone
1352	// can point to shared memory and tsan would report a data race.	1358	// can point to shared memory and tsan would report a data race.
...	@@ -1731,10 +1737,12 @@ INTERCEPTOR(int, __vsprintf_chk, char *str, int flag, SIZE_T size_to,	...	@@ -1731,10 +1737,12 @@ INTERCEPTOR(int, __vsprintf_chk, char *str, int flag, SIZE_T size_to,
1731	VSPRINTF_INTERCEPTOR_IMPL(vsprintf, str, format, ap)	1737	VSPRINTF_INTERCEPTOR_IMPL(vsprintf, str, format, ap)
1732	#endif	1738	#endif
1733		1739
		1740	# if SANITIZER_INTERCEPT_VASPRINTF
1734	INTERCEPTOR(int, vasprintf, char *strp, const char format, va_list ap)	1741	INTERCEPTOR(int, vasprintf, char *strp, const char format, va_list ap)
1735	VASPRINTF_INTERCEPTOR_IMPL(vasprintf, strp, format, ap)	1742	VASPRINTF_INTERCEPTOR_IMPL(vasprintf, strp, format, ap)
		1743	# endif
1736		1744
1737	#if SANITIZER_INTERCEPT_ISOC99_PRINTF	1745	# if SANITIZER_INTERCEPT_ISOC99_PRINTF
1738	INTERCEPTOR(int, __isoc99_vprintf, const char *format, va_list ap)	1746	INTERCEPTOR(int, __isoc99_vprintf, const char *format, va_list ap)
1739	VPRINTF_INTERCEPTOR_IMPL(__isoc99_vprintf, format, ap)	1747	VPRINTF_INTERCEPTOR_IMPL(__isoc99_vprintf, format, ap)
1740		1748
...	@@ -1783,10 +1791,12 @@ INTERCEPTOR(int, __snprintf_chk, char *str, SIZE_T size, int flag,	...	@@ -1783,10 +1791,12 @@ INTERCEPTOR(int, __snprintf_chk, char *str, SIZE_T size, int flag,
1783	FORMAT_INTERCEPTOR_IMPL(__snprintf_chk, vsnprintf, str, size, format)	1791	FORMAT_INTERCEPTOR_IMPL(__snprintf_chk, vsnprintf, str, size, format)
1784	#endif	1792	#endif
1785		1793
		1794	# if SANITIZER_INTERCEPT_ASPRINTF
1786	INTERCEPTOR(int, asprintf, char *strp, const char format, ...)	1795	INTERCEPTOR(int, asprintf, char *strp, const char format, ...)
1787	FORMAT_INTERCEPTOR_IMPL(asprintf, vasprintf, strp, format)	1796	FORMAT_INTERCEPTOR_IMPL(asprintf, vasprintf, strp, format)
		1797	# endif
1788		1798
1789	#if SANITIZER_INTERCEPT_ISOC99_PRINTF	1799	# if SANITIZER_INTERCEPT_ISOC99_PRINTF
1790	INTERCEPTOR(int, __isoc99_printf, const char *format, ...)	1800	INTERCEPTOR(int, __isoc99_printf, const char *format, ...)
1791	FORMAT_INTERCEPTOR_IMPL(__isoc99_printf, __isoc99_vprintf, format)	1801	FORMAT_INTERCEPTOR_IMPL(__isoc99_printf, __isoc99_vprintf, format)
1792		1802
...	@@ -1807,17 +1817,24 @@ FORMAT_INTERCEPTOR_IMPL(__isoc99_snprintf, __isoc99_vsnprintf, str, size,	...	@@ -1807,17 +1817,24 @@ FORMAT_INTERCEPTOR_IMPL(__isoc99_snprintf, __isoc99_vsnprintf, str, size,
1807	#endif // SANITIZER_INTERCEPT_PRINTF	1817	#endif // SANITIZER_INTERCEPT_PRINTF
1808		1818
1809	#if SANITIZER_INTERCEPT_PRINTF	1819	#if SANITIZER_INTERCEPT_PRINTF
1810	#define INIT_PRINTF \	1820	# define INIT_PRINTF_COMMON \
1811	COMMON_INTERCEPT_FUNCTION_LDBL(printf); \	1821	COMMON_INTERCEPT_FUNCTION_LDBL(printf); \
1812	COMMON_INTERCEPT_FUNCTION_LDBL(sprintf); \	1822	COMMON_INTERCEPT_FUNCTION_LDBL(sprintf); \
1813	COMMON_INTERCEPT_FUNCTION_LDBL(snprintf); \	1823	COMMON_INTERCEPT_FUNCTION_LDBL(snprintf); \
1814	COMMON_INTERCEPT_FUNCTION_LDBL(asprintf); \	1824	COMMON_INTERCEPT_FUNCTION_LDBL(fprintf); \
1815	COMMON_INTERCEPT_FUNCTION_LDBL(fprintf); \	1825	COMMON_INTERCEPT_FUNCTION_LDBL(vprintf); \
1816	COMMON_INTERCEPT_FUNCTION_LDBL(vprintf); \	1826	COMMON_INTERCEPT_FUNCTION_LDBL(vsprintf); \
1817	COMMON_INTERCEPT_FUNCTION_LDBL(vsprintf); \	1827	COMMON_INTERCEPT_FUNCTION_LDBL(vsnprintf); \
1818	COMMON_INTERCEPT_FUNCTION_LDBL(vsnprintf); \	1828	COMMON_INTERCEPT_FUNCTION_LDBL(vfprintf);
1819	COMMON_INTERCEPT_FUNCTION_LDBL(vasprintf); \	1829	# if !SANITIZER_AIX
1820	COMMON_INTERCEPT_FUNCTION_LDBL(vfprintf);	1830	// AIX does not have [v]asprintf.
		1831	# define INIT_PRINTF_EXTRA \
		1832	COMMON_INTERCEPT_FUNCTION_LDBL(asprintf); \
		1833	COMMON_INTERCEPT_FUNCTION_LDBL(vasprintf);
		1834	# else
		1835	# define INIT_PRINTF_EXTRA
		1836	# endif
		1837	# define INIT_PRINTF INIT_PRINTF_COMMON INIT_PRINTF_EXTRA
1821	#else	1838	#else
1822	#define INIT_PRINTF	1839	#define INIT_PRINTF
1823	#endif	1840	#endif
...	@@ -1855,6 +1872,22 @@ FORMAT_INTERCEPTOR_IMPL(__isoc99_snprintf, __isoc99_vsnprintf, str, size,	...	@@ -1855,6 +1872,22 @@ FORMAT_INTERCEPTOR_IMPL(__isoc99_snprintf, __isoc99_vsnprintf, str, size,
1855	#define INIT_ISOC99_PRINTF	1872	#define INIT_ISOC99_PRINTF
1856	#endif	1873	#endif
1857		1874
		1875	#if SANITIZER_INTERCEPT_SETPROCTITLE
		1876	INTERCEPTOR(void, setproctitle, const char *fmt, ...) {
		1877	void *ctx;
		1878	va_list ap;
		1879	va_start(ap, fmt);
		1880	COMMON_INTERCEPTOR_ENTER(ctx, setproctitle, fmt, ap);
		1881	if (common_flags()->check_printf)
		1882	printf_common(ctx, fmt, ap);
		1883	REAL(setproctitle)(fmt, ap);
		1884	va_end(ap);
		1885	}
		1886	# define INIT_SETPROCTITLE COMMON_INTERCEPT_FUNCTION(setproctitle);
		1887	#else
		1888	# define INIT_SETPROCTITLE
		1889	#endif
		1890
1858	#if SANITIZER_INTERCEPT_IOCTL	1891	#if SANITIZER_INTERCEPT_IOCTL
1859	#include "sanitizer_common_interceptors_ioctl.inc"	1892	#include "sanitizer_common_interceptors_ioctl.inc"
1860	#include "sanitizer_interceptors_ioctl_netbsd.inc"	1893	#include "sanitizer_interceptors_ioctl_netbsd.inc"
...	@@ -3901,7 +3934,7 @@ INTERCEPTOR(SIZE_T, wcrtomb, char dest, wchar_t src, void ps) {	...	@@ -3901,7 +3934,7 @@ INTERCEPTOR(SIZE_T, wcrtomb, char dest, wchar_t src, void ps) {
3901	if (res != ((SIZE_T)-1)) {	3934	if (res != ((SIZE_T)-1)) {
3902	CHECK_LE(res, sizeof(local_dest));	3935	CHECK_LE(res, sizeof(local_dest));
3903	COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dest, res);	3936	COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dest, res);
3904	REAL(memcpy)(dest, local_dest, res);	3937	internal_memcpy(dest, local_dest, res);
3905	}	3938	}
3906	return res;	3939	return res;
3907	}	3940	}
...	@@ -3923,7 +3956,7 @@ INTERCEPTOR(int, wctomb, char *dest, wchar_t src) {	...	@@ -3923,7 +3956,7 @@ INTERCEPTOR(int, wctomb, char *dest, wchar_t src) {
3923	if (res != -1) {	3956	if (res != -1) {
3924	CHECK_LE(res, sizeof(local_dest));	3957	CHECK_LE(res, sizeof(local_dest));
3925	COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dest, res);	3958	COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dest, res);
3926	REAL(memcpy)(dest, local_dest, res);	3959	internal_memcpy(dest, local_dest, res);
3927	}	3960	}
3928	return res;	3961	return res;
3929	}	3962	}
...	@@ -10263,6 +10296,71 @@ INTERCEPTOR(SSIZE_T, freadlink, int fd, char *buf, SIZE_T bufsiz) {	...	@@ -10263,6 +10296,71 @@ INTERCEPTOR(SSIZE_T, freadlink, int fd, char *buf, SIZE_T bufsiz) {
10263	# define INIT_FREADLINK	10296	# define INIT_FREADLINK
10264	#endif	10297	#endif
10265		10298
		10299	#if SANITIZER_INTERCEPT_GETSERVENT_R \|\| SANITIZER_INTERCEPT_GETSERVBYNAME_R \|\| \
		10300	SANITIZER_INTERCEPT_GETSERVBYPORT_R
		10301
		10302	UNUSED static void HandleGetServentReentrantResult(
		10303	void ctx, int res, struct __sanitizer_servent result_buf, char *buf,
		10304	SIZE_T buflen, struct __sanitizer_servent **result) {
		10305	COMMON_INTERCEPTOR_WRITE_RANGE(ctx, (char )result, sizeof(void ));
		10306	if (res)
		10307	return;
		10308	if (*result) {
		10309	COMMON_INTERCEPTOR_WRITE_RANGE(ctx, (char )result,
		10310	sizeof(__sanitizer_servent));
		10311	COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, buflen);
		10312	}
		10313	}
		10314
		10315	#endif
		10316
		10317	#if SANITIZER_INTERCEPT_GETSERVENT_R
		10318	INTERCEPTOR(int, getservent_r, struct __sanitizer_servent *result_buf,
		10319	char buf, SIZE_T buflen, struct __sanitizer_servent *result) {
		10320	void *ctx;
		10321	COMMON_INTERCEPTOR_ENTER(ctx, getservent_r, result_buf, buf, buflen, result);
		10322	int res = REAL(getservent_r)(result_buf, buf, buflen, result);
		10323	HandleGetServentReentrantResult(ctx, res, result_buf, buf, buflen, result);
		10324	return res;
		10325	}
		10326	# define INIT_GETSERVENT_R COMMON_INTERCEPT_FUNCTION(getservent_r)
		10327	#else
		10328	# define INIT_GETSERVENT_R
		10329	#endif
		10330
		10331	#if SANITIZER_INTERCEPT_GETSERVBYNAME_R
		10332	INTERCEPTOR(int, getservbyname_r, const char name, const char proto,
		10333	struct __sanitizer_servent result_buf, char buf, SIZE_T buflen,
		10334	struct __sanitizer_servent **result) {
		10335	void *ctx;
		10336	COMMON_INTERCEPTOR_ENTER(ctx, getservbyname_r, name, proto, result_buf, buf,
		10337	buflen, result);
		10338	COMMON_INTERCEPTOR_READ_STRING(ctx, name, internal_strlen(name));
		10339	int res = REAL(getservbyname_r)(name, proto, result_buf, buf, buflen, result);
		10340	HandleGetServentReentrantResult(ctx, res, result_buf, buf, buflen, result);
		10341	return res;
		10342	}
		10343	# define INIT_GETSERVBYNAME_R COMMON_INTERCEPT_FUNCTION(getservbyname_r)
		10344	#else
		10345	# define INIT_GETSERVBYNAME_R
		10346	#endif
		10347
		10348	#if SANITIZER_INTERCEPT_GETSERVBYPORT_R
		10349	INTERCEPTOR(int, getservbyport_r, int port, const char *proto,
		10350	struct __sanitizer_servent result_buf, char buf, SIZE_T buflen,
		10351	struct __sanitizer_servent **result) {
		10352	void *ctx;
		10353	COMMON_INTERCEPTOR_ENTER(ctx, getservbyport_r, port, proto, result_buf, buf,
		10354	buflen, result);
		10355	int res = REAL(getservbyport_r)(port, proto, result_buf, buf, buflen, result);
		10356	HandleGetServentReentrantResult(ctx, res, result_buf, buf, buflen, result);
		10357	return res;
		10358	}
		10359	# define INIT_GETSERVBYPORT_R COMMON_INTERCEPT_FUNCTION(getservbyport_r)
		10360	#else
		10361	# define INIT_GETSERVBYPORT_R
		10362	#endif
		10363
10266	#include "sanitizer_common_interceptors_netbsd_compat.inc"	10364	#include "sanitizer_common_interceptors_netbsd_compat.inc"
10267		10365
10268	namespace __sanitizer {	10366	namespace __sanitizer {
...	@@ -10328,8 +10426,10 @@ static void InitializeCommonInterceptors() {	...	@@ -10328,8 +10426,10 @@ static void InitializeCommonInterceptors() {
10328	INIT_PRINTF;	10426	INIT_PRINTF;
10329	INIT_PRINTF_L;	10427	INIT_PRINTF_L;
10330	INIT_ISOC99_PRINTF;	10428	INIT_ISOC99_PRINTF;
		10429	INIT_SETPROCTITLE;
10331	INIT_FREXP;	10430	INIT_FREXP;
10332	INIT_FREXPF_FREXPL;	10431	INIT_FREXPF;
		10432	INIT_FREXPL;
10333	INIT_GETPWNAM_AND_FRIENDS;	10433	INIT_GETPWNAM_AND_FRIENDS;
10334	INIT_GETPWNAM_R_AND_FRIENDS;	10434	INIT_GETPWNAM_R_AND_FRIENDS;
10335	INIT_GETPWENT;	10435	INIT_GETPWENT;
...	@@ -10587,4 +10687,7 @@ static void InitializeCommonInterceptors() {	...	@@ -10587,4 +10687,7 @@ static void InitializeCommonInterceptors() {
10587	INIT_FREADLINK;	10687	INIT_FREADLINK;
10588		10688
10589	INIT___PRINTF_CHK;	10689	INIT___PRINTF_CHK;
		10690	INIT_GETSERVENT_R;
		10691	INIT_GETSERVBYNAME_R;
		10692	INIT_GETSERVBYPORT_R;
10590	}	10693	}

lib/libtsan/sanitizer_common/sanitizer_common_interceptors_format.inc+4

 @@ -67,6 +67,10 @@ static const char *maybe_parse_length_modifier(const char *p, char ll[2]) {
 // Returns true if the character is an integer conversion specifier.
 static bool format_is_integer_conv(char c) {
+#if SANITIZER_GLIBC
+  if (char_is_one_of(c, "bB"))
+    return true;
+#endif
   return char_is_one_of(c, "diouxXn");
 }

lib/libtsan/sanitizer_common/sanitizer_common_interceptors_ioctl.inc+13-7

 @@ -48,35 +48,41 @@ static void ioctl_table_fill() {
     ++ioctl_table_size;                                  \
   }
+  _(FIONBIO, READ, sizeof(int));
+#if !SANITIZER_HAIKU
   _(FIOASYNC, READ, sizeof(int));
   _(FIOCLEX, NONE, 0);
   _(FIOGETOWN, WRITE, sizeof(int));
-  _(FIONBIO, READ, sizeof(int));
   _(FIONCLEX, NONE, 0);
   _(FIOSETOWN, READ, sizeof(int));
+#endif
   _(SIOCATMARK, WRITE, sizeof(int));
   _(SIOCGIFCONF, CUSTOM, 0);
   _(SIOCGPGRP, WRITE, sizeof(int));
   _(SIOCSPGRP, READ, sizeof(int));
-#if !SANITIZER_SOLARIS
+#if !SANITIZER_SOLARIS && !SANITIZER_HAIKU
   _(TIOCCONS, NONE, 0);
 #endif
-  _(TIOCEXCL, NONE, 0);
+#if !SANITIZER_HAIKU
   _(TIOCGETD, WRITE, sizeof(int));
+  _(TIOCNOTTY, NONE, 0);
+  _(TIOCPKT, READ, sizeof(int));
+  _(TIOCSETD, READ, sizeof(int));
+  _(TIOCSTI, READ, sizeof(char));
+#endif
+  _(TIOCEXCL, NONE, 0);
   _(TIOCGPGRP, WRITE, pid_t_sz);
   _(TIOCGWINSZ, WRITE, struct_winsize_sz);
   _(TIOCMBIC, READ, sizeof(int));
   _(TIOCMBIS, READ, sizeof(int));
   _(TIOCMGET, WRITE, sizeof(int));
   _(TIOCMSET, READ, sizeof(int));
-  _(TIOCNOTTY, NONE, 0);
   _(TIOCNXCL, NONE, 0);
   _(TIOCOUTQ, WRITE, sizeof(int));
-  _(TIOCPKT, READ, sizeof(int));
+#  if !SANITIZER_AIX
   _(TIOCSCTTY, NONE, 0);
-  _(TIOCSETD, READ, sizeof(int));
+#  endif
   _(TIOCSPGRP, READ, pid_t_sz);
-  _(TIOCSTI, READ, sizeof(char));
   _(TIOCSWINSZ, READ, struct_winsize_sz);
 #if !SANITIZER_IOS

lib/libtsan/sanitizer_common/sanitizer_common_interceptors_memintrinsics.inc+5-3

 @@ -33,11 +33,13 @@
 // Platform-specific options.
 #if SANITIZER_APPLE
-#define PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE 0
+#  define PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE 0
 #elif SANITIZER_WINDOWS64
-#define PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE 0
+#  define PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE 0
+#elif SANITIZER_AIX
+#  define PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE 0
 #else
-#define PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE 1
+#  define PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE 1
 #endif  // SANITIZER_APPLE
 #ifndef COMMON_INTERCEPTOR_MEMSET_IMPL

lib/libtsan/sanitizer_common/sanitizer_common_syscalls.inc+22

...	@@ -3205,6 +3205,28 @@ POST_SYSCALL(futex)	...	@@ -3205,6 +3205,28 @@ POST_SYSCALL(futex)
3205	COMMON_SYSCALL_BLOCKING_END();	3205	COMMON_SYSCALL_BLOCKING_END();
3206	}	3206	}
3207		3207
		3208	PRE_SYSCALL(copy_file_range)
		3209	(int fdin, __sanitizer___kernel_off_t *offin, int fdout,
		3210	__sanitizer___kernel_off_t *offout, SIZE_T size, unsigned int flags) {
		3211	if (offin != nullptr) {
		3212	PRE_READ(offin, sizeof(*offin));
		3213	}
		3214	if (offout != nullptr) {
		3215	PRE_READ(offout, sizeof(*offout));
		3216	}
		3217	}
		3218
		3219	POST_SYSCALL(copy_file_range)
		3220	(SSIZE_T, int fdin, __sanitizer___kernel_off_t *offin, int fdout,
		3221	__sanitizer___kernel_off_t *offout, SIZE_T size, unsigned int flags) {
		3222	if (offin != nullptr) {
		3223	POST_WRITE(offin, sizeof(*offin));
		3224	}
		3225	if (offout != nullptr) {
		3226	POST_WRITE(offout, sizeof(*offout));
		3227	}
		3228	}
		3229
3208	} // extern "C"	3230	} // extern "C"
3209		3231
3210	# undef PRE_SYSCALL	3232	# undef PRE_SYSCALL

lib/libtsan/sanitizer_common/sanitizer_errno.h+2

...	@@ -29,6 +29,8 @@	...	@@ -29,6 +29,8 @@
29	# define __errno_location ___errno	29	# define __errno_location ___errno
30	#elif SANITIZER_WINDOWS	30	#elif SANITIZER_WINDOWS
31	# define __errno_location _errno	31	# define __errno_location _errno
		32	#elif SANITIZER_HAIKU
		33	# define __errno_location _errnop
32	#endif	34	#endif
33		35
34	extern "C" int *__errno_location();	36	extern "C" int *__errno_location();

lib/libtsan/sanitizer_common/sanitizer_errno_codes.h+15-6

 @@ -21,12 +21,21 @@
 namespace __sanitizer {
-#define errno_ENOMEM 12
+#ifdef __HAIKU__
-#define errno_EBUSY 16
+#  define errno_ENOMEM (0x80000000)
-#define errno_EINVAL 22
+#  define errno_EBUSY (0x80000000 + 14)
-#define errno_ERANGE 34
+#  define errno_EINVAL (0x80000000 + 5)
-#define errno_ENAMETOOLONG 36
+#  define errno_ERANGE (0x80007000 + 17)
-#define errno_ENOSYS 38
+#  define errno_ENAMETOOLONG (0x80000000 + 0x6004)
+#  define errno_ENOSYS (0x80007009)
+#else
+#  define errno_ENOMEM 12
+#  define errno_EBUSY 16
+#  define errno_EINVAL 22
+#  define errno_ERANGE 34
+#  define errno_ENAMETOOLONG 36
+#  define errno_ENOSYS 38
+#endif
 // Those might not present or their value differ on different platforms.
 extern const int errno_EOWNERDEAD;

lib/libtsan/sanitizer_common/sanitizer_file.cpp+67-3

...	@@ -96,12 +96,76 @@ static void RecursiveCreateParentDirs(char *path) {	...	@@ -96,12 +96,76 @@ static void RecursiveCreateParentDirs(char *path) {
96	}	96	}
97	}	97	}
98		98
		99	/// Parse the report path \p pattern and copy the parsed path to \p dest.
		100	///
		101	/// * `%%` becomes `%`
		102	/// * `%H` expands to the environment variable `HOME`
		103	/// * `%t` expands to the environment variable `TMPDIR`
		104	/// * `%p` expands to the process ID (PID)
		105	static void ParseAndSetPath(const char pattern, char dest,
		106	const uptr dest_size) {
		107	CHECK(pattern);
		108	CHECK(dest);
		109	CHECK_GE(dest_size, 1);
		110	dest[0] = '\0';
		111	uptr next_substr_start_idx = 0;
		112	for (uptr i = 0; i < internal_strlen(pattern) - 1; i++) {
		113	if (pattern[i] != '%')
		114	continue;
		115	int bytes_to_copy = i - next_substr_start_idx;
		116	// Copy over previous substring.
		117	CHECK_LT(internal_strlcat(dest, pattern + next_substr_start_idx,
		118	internal_strlen(dest) + bytes_to_copy + 1),
		119	dest_size);
		120	const char *str_to_concat;
		121	switch (pattern[++i]) {
		122	case '%':
		123	str_to_concat = "%";
		124	break;
		125	case 'H':
		126	str_to_concat = GetEnv("HOME");
		127	break;
		128	case 't':
		129	str_to_concat = GetEnv("TMPDIR");
		130	break;
		131	case 'p': {
		132	// Use printf directly to write the PID since it's not a static string.
		133	int remaining_capacity = dest_size - internal_strlen(dest);
		134	int bytes_copied =
		135	internal_snprintf(dest + internal_strlen(dest), remaining_capacity,
		136	"%ld", internal_getpid());
		137	CHECK_GT(bytes_copied, 0);
		138	CHECK_LT(bytes_copied, remaining_capacity);
		139	str_to_concat = "";
		140	break;
		141	}
		142	default: {
		143	// Invalid pattern: fallback to original pattern.
		144	const char *message = "ERROR: Unexpected pattern: ";
		145	WriteToFile(kStderrFd, message, internal_strlen(message));
		146	WriteToFile(kStderrFd, pattern, internal_strlen(pattern));
		147	WriteToFile(kStderrFd, "\n", internal_strlen("\n"));
		148	CHECK_LT(internal_strlcpy(dest, pattern, dest_size), dest_size);
		149	return;
		150	}
		151	}
		152	CHECK(str_to_concat);
		153	CHECK_LT(internal_strlcat(dest, str_to_concat, dest_size), dest_size);
		154	next_substr_start_idx = i + 1;
		155	}
		156	CHECK_LT(internal_strlcat(dest, pattern + next_substr_start_idx, dest_size),
		157	dest_size);
		158	}
		159
99	void ReportFile::SetReportPath(const char *path) {	160	void ReportFile::SetReportPath(const char *path) {
100	if (path) {	161	if (path) {
101	uptr len = internal_strlen(path);	162	uptr len = internal_strlen(path);
102	if (len > sizeof(path_prefix) - 100) {	163	if (len > sizeof(path_prefix) - 100) {
103	Report("ERROR: Path is too long: %c%c%c%c%c%c%c%c...\n", path[0], path[1],	164	const char *message = "ERROR: Path is too long: ";
104	path[2], path[3], path[4], path[5], path[6], path[7]);	165	WriteToFile(kStderrFd, message, internal_strlen(message));
		166	WriteToFile(kStderrFd, path, 8);
		167	message = "...\n";
		168	WriteToFile(kStderrFd, message, internal_strlen(message));
105	Die();	169	Die();
106	}	170	}
107	}	171	}
...	@@ -115,7 +179,7 @@ void ReportFile::SetReportPath(const char *path) {	...	@@ -115,7 +179,7 @@ void ReportFile::SetReportPath(const char *path) {
115	} else if (internal_strcmp(path, "stdout") == 0) {	179	} else if (internal_strcmp(path, "stdout") == 0) {
116	fd = kStdoutFd;	180	fd = kStdoutFd;
117	} else {	181	} else {
118	internal_snprintf(path_prefix, kMaxPathLength, "%s", path);	182	ParseAndSetPath(path, path_prefix, kMaxPathLength);
119	RecursiveCreateParentDirs(path_prefix);	183	RecursiveCreateParentDirs(path_prefix);
120	}	184	}
121	}	185	}

lib/libtsan/sanitizer_common/sanitizer_fuchsia.cpp+2

...	@@ -547,6 +547,8 @@ void __sanitizer_startup_hook(int argc, char argv, char envp,	...	@@ -547,6 +547,8 @@ void __sanitizer_startup_hook(int argc, char argv, char envp,
547	__sanitizer::StoredEnviron = envp;	547	__sanitizer::StoredEnviron = envp;
548	__sanitizer::MainThreadStackBase = reinterpret_cast<uintptr_t>(stack_base);	548	__sanitizer::MainThreadStackBase = reinterpret_cast<uintptr_t>(stack_base);
549	__sanitizer::MainThreadStackSize = stack_size;	549	__sanitizer::MainThreadStackSize = stack_size;
		550
		551	EarlySanitizerInit();
550	}	552	}
551		553
552	void __sanitizer_set_report_path(const char *path) {	554	void __sanitizer_set_report_path(const char *path) {

lib/libtsan/sanitizer_common/sanitizer_fuchsia.h+7

...	@@ -32,6 +32,13 @@ struct MemoryMappingLayoutData {	...	@@ -32,6 +32,13 @@ struct MemoryMappingLayoutData {
32		32
33	void InitShadowBounds();	33	void InitShadowBounds();
34		34
		35	// Individual sanitizers can define this to explicitly run something at the end
		36	// of `__sanitizer_startup_hook`. This can be useful if a sanitizer needs to do
		37	// extra work after the common startup hook code is called and before module
		38	// ctors are invoked. For example, hwasan can explicitly call its initializing
		39	// function here so it can be set up before libc extensions are initialized.
		40	void EarlySanitizerInit();
		41
35	} // namespace __sanitizer	42	} // namespace __sanitizer
36		43
37	#endif // SANITIZER_FUCHSIA	44	#endif // SANITIZER_FUCHSIA

lib/libtsan/sanitizer_common/sanitizer_haiku.cpp created+361

...	@@ -0,0 +1,361 @@
1	//===-- sanitizer_haiku.cpp -----------------------------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8	//
9	// This file is shared between Sanitizer run-time libraries and implements
10	// Haiku-specific functions from sanitizer_libc.h.
11	//===----------------------------------------------------------------------===//
12
13	#include "sanitizer_platform.h"
14
15	#if SANITIZER_HAIKU
16
17	# include "sanitizer_common.h"
18	# include "sanitizer_flags.h"
19	# include "sanitizer_getauxval.h"
20	# include "sanitizer_internal_defs.h"
21	# include "sanitizer_libc.h"
22	# include "sanitizer_linux.h"
23	# include "sanitizer_mutex.h"
24	# include "sanitizer_placement_new.h"
25	# include "sanitizer_procmaps.h"
26
27	# include <sys/param.h>
28	# include <sys/types.h>
29
30	# include <sys/mman.h>
31	# include <sys/resource.h>
32	# include <sys/stat.h>
33	# include <sys/time.h>
34
35	# include <dlfcn.h>
36	# include <errno.h>
37	# include <fcntl.h>
38	# include <limits.h>
39	# include <link.h>
40	# include <pthread.h>
41	# include <sched.h>
42	# include <signal.h>
43	# include <unistd.h>
44
45	# include "system/vm_defs.h"
46	# include "system/syscalls.h"
47	# include "shared/syscall_utils.h"
48
49	namespace __sanitizer {
50
51	static void GetRealLibcAddress(const char symbol) {
52	void *real = dlsym(RTLD_NEXT, symbol);
53	if (!real)
54	real = dlsym(RTLD_DEFAULT, symbol);
55	if (!real) {
56	Printf("GetRealLibcAddress failed for symbol=%s", symbol);
57	Die();
58	}
59	return real;
60	}
61
62	# define _REAL(func, ...) real##_##func(__VA_ARGS__)
63	# define DEFINE__REAL(ret_type, func, ...) \
64	static ret_type (*real_##func)(__VA_ARGS__) = NULL; \
65	if (!real_##func) { \
66	real_##func = (ret_type(*)(__VA_ARGS__))GetRealLibcAddress(#func); \
67	} \
68	CHECK(real_##func);
69
70	// --------------- sanitizer_libc.h
71	uptr internal_mmap(void *addr, uptr length, int prot, int flags, int fd,
72	u64 offset) {
73	if ((flags & MAP_ANONYMOUS) != 0)
74	fd = -1;
75
76	int mapping =
77	(flags & MAP_SHARED) != 0 ? REGION_NO_PRIVATE_MAP : REGION_PRIVATE_MAP;
78
79	uint32 addressSpec;
80	if ((flags & MAP_FIXED) != 0)
81	addressSpec = B_EXACT_ADDRESS;
82	else if (addr != NULL)
83	addressSpec = B_BASE_ADDRESS;
84	else
85	addressSpec = B_RANDOMIZED_ANY_ADDRESS;
86
87	uint32 areaProtection = 0;
88	if ((prot & PROT_READ) != 0)
89	areaProtection \|= B_READ_AREA;
90	if ((prot & PROT_WRITE) != 0)
91	areaProtection \|= B_WRITE_AREA;
92	if ((prot & PROT_EXEC) != 0)
93	areaProtection \|= B_EXECUTE_AREA;
94
95	if ((flags & MAP_NORESERVE) != 0)
96	areaProtection \|= B_OVERCOMMITTING_AREA;
97
98	area_id area = _kern_map_file("sanitizer mmap", &addr, addressSpec, length,
99	areaProtection, mapping, true, fd, offset);
100	if (area < 0)
101	RETURN_AND_SET_ERRNO(area);
102	return (uptr)addr;
103	}
104
105	uptr internal_munmap(void *addr, uptr length) {
106	DEFINE__REAL(int, munmap, void *a, uptr b);
107	return _REAL(munmap, addr, length);
108	}
109
110	uptr internal_mremap(void *old_address, uptr old_size, uptr new_size, int flags,
111	void *new_address) {
112	CHECK(false && "internal_mremap is unimplemented on Haiku");
113	return 0;
114	}
115
116	int internal_mprotect(void *addr, uptr length, int prot) {
117	DEFINE__REAL(int, mprotect, void *a, uptr b, int c);
118	return _REAL(mprotect, addr, length, prot);
119	}
120
121	int internal_madvise(uptr addr, uptr length, int advice) {
122	DEFINE__REAL(int, madvise, void *a, uptr b, int c);
123	return _REAL(madvise, (void *)addr, length, advice);
124	}
125
126	uptr internal_close(fd_t fd) {
127	CHECK(&_kern_close);
128	RETURN_AND_SET_ERRNO(_kern_close(fd));
129	}
130
131	uptr internal_open(const char *filename, int flags) {
132	CHECK(&_kern_open);
133	RETURN_AND_SET_ERRNO(_kern_open(-1, filename, flags, 0));
134	}
135
136	uptr internal_open(const char *filename, int flags, u32 mode) {
137	CHECK(&_kern_open);
138	RETURN_AND_SET_ERRNO(_kern_open(-1, filename, flags, mode));
139	}
140
141	uptr internal_read(fd_t fd, void *buf, uptr count) {
142	sptr res;
143	CHECK(&_kern_read);
144	HANDLE_EINTR(res, (sptr)_kern_read(fd, -1, buf, (size_t)count));
145	RETURN_AND_SET_ERRNO(res);
146	return res;
147	}
148
149	uptr internal_write(fd_t fd, const void *buf, uptr count) {
150	sptr res;
151	CHECK(&_kern_write);
152	HANDLE_EINTR(res, (sptr)_kern_write(fd, -1, buf, count));
153	RETURN_AND_SET_ERRNO(res);
154	return res;
155	}
156
157	uptr internal_ftruncate(fd_t fd, uptr size) {
158	sptr res;
159	DEFINE__REAL(int, ftruncate, int, off_t);
160	return _REAL(ftruncate, fd, size);
161	return res;
162	}
163
164	uptr internal_stat(const char path, void buf) {
165	DEFINE__REAL(int, _stat_current, const char a, void b);
166	return _REAL(_stat_current, path, buf);
167	}
168
169	uptr internal_lstat(const char path, void buf) {
170	DEFINE__REAL(int, _lstat_current, const char a, void b);
171	return _REAL(_lstat_current, path, buf);
172	}
173
174	uptr internal_fstat(fd_t fd, void *buf) {
175	DEFINE__REAL(int, _fstat_current, int a, void *b);
176	return _REAL(_fstat_current, fd, buf);
177	}
178
179	uptr internal_filesize(fd_t fd) {
180	struct stat st;
181	if (internal_fstat(fd, &st))
182	return -1;
183	return (uptr)st.st_size;
184	}
185
186	uptr internal_dup(int oldfd) {
187	DEFINE__REAL(int, dup, int a);
188	return _REAL(dup, oldfd);
189	}
190
191	uptr internal_dup2(int oldfd, int newfd) {
192	DEFINE__REAL(int, dup2, int a, int b);
193	return _REAL(dup2, oldfd, newfd);
194	}
195
196	uptr internal_readlink(const char path, char buf, uptr bufsize) {
197	CHECK(&_kern_read_link);
198	RETURN_AND_SET_ERRNO(_kern_read_link(-1, path, buf, &bufsize));
199	}
200
201	uptr internal_unlink(const char *path) {
202	DEFINE__REAL(int, unlink, const char *a);
203	return _REAL(unlink, path);
204	}
205
206	uptr internal_rename(const char oldpath, const char newpath) {
207	DEFINE__REAL(int, rename, const char a, const char b);
208	return _REAL(rename, oldpath, newpath);
209	}
210
211	uptr internal_sched_yield() {
212	CHECK(&_kern_thread_yield);
213	_kern_thread_yield();
214	return 0;
215	}
216
217	void internal__exit(int exitcode) {
218	DEFINE__REAL(void, _exit, int a);
219	_REAL(_exit, exitcode);
220	Die(); // Unreachable.
221	}
222
223	void internal_usleep(u64 useconds) {
224	_kern_snooze_etc(useconds, B_SYSTEM_TIMEBASE, B_RELATIVE_TIMEOUT, NULL);
225	}
226
227	uptr internal_execve(const char filename, char const argv[],
228	char *const envp[]) {
229	DEFINE__REAL(int, execve, const char , char const[], char *const[]);
230	return _REAL(execve, filename, argv, envp);
231	}
232
233	# if 0
234	tid_t GetTid() {
235	DEFINE__REAL(int, _lwp_self);
236	return _REAL(_lwp_self);
237	}
238
239	int TgKill(pid_t pid, tid_t tid, int sig) {
240	DEFINE__REAL(int, _lwp_kill, int a, int b);
241	(void)pid;
242	return _REAL(_lwp_kill, tid, sig);
243	}
244
245	u64 NanoTime() {
246	timeval tv;
247	DEFINE__REAL(int, __gettimeofday50, void a, void b);
248	internal_memset(&tv, 0, sizeof(tv));
249	_REAL(__gettimeofday50, &tv, 0);
250	return (u64)tv.tv_sec * 1000 * 1000 * 1000 + tv.tv_usec * 1000;
251	}
252	# endif
253
254	uptr internal_clock_gettime(__sanitizer_clockid_t clk_id, void *tp) {
255	DEFINE__REAL(int, __clock_gettime50, __sanitizer_clockid_t a, void *b);
256	return _REAL(__clock_gettime50, clk_id, tp);
257	}
258
259	uptr internal_ptrace(int request, int pid, void *addr, int data) {
260	DEFINE__REAL(int, ptrace, int a, int b, void *c, int d);
261	return _REAL(ptrace, request, pid, addr, data);
262	}
263
264	uptr internal_waitpid(int pid, int *status, int options) {
265	DEFINE__REAL(int, waitpid, pid_t, int *, int);
266	return _REAL(waitpid, pid, status, options);
267	}
268
269	uptr internal_getpid() {
270	DEFINE__REAL(int, getpid);
271	return _REAL(getpid);
272	}
273
274	uptr internal_getppid() {
275	DEFINE__REAL(int, getppid);
276	return _REAL(getppid);
277	}
278
279	int internal_dlinfo(void handle, int request, void p) {
280	DEFINE__REAL(int, dlinfo, void a, int b, void c);
281	return _REAL(dlinfo, handle, request, p);
282	}
283
284	uptr internal_getdents(fd_t fd, void *dirp, unsigned int count) {
285	DEFINE__REAL(int, __getdents30, int a, void *b, size_t c);
286	return _REAL(__getdents30, fd, dirp, count);
287	}
288
289	uptr internal_lseek(fd_t fd, OFF_T offset, int whence) {
290	CHECK(&_kern_seek);
291	off_t result = _kern_seek(fd, offset, whence);
292	if (result < 0) {
293	errno = result;
294	return -1;
295	}
296	return result;
297	}
298
299	uptr internal_prctl(int option, uptr arg2, uptr arg3, uptr arg4, uptr arg5) {
300	Printf("internal_prctl not implemented for Haiku");
301	Die();
302	return 0;
303	}
304
305	uptr internal_sigaltstack(const void ss, void oss) {
306	DEFINE__REAL(int, __sigaltstack14, const void a, void b);
307	return _REAL(__sigaltstack14, ss, oss);
308	}
309
310	int internal_fork() {
311	DEFINE__REAL(int, fork);
312	return _REAL(fork);
313	}
314
315	# if 0
316	int internal_sysctl(const int name, unsigned int namelen, void oldp,
317	uptr oldlenp, const void newp, uptr newlen) {
318	CHECK(&__sysctl);
319	return __sysctl(name, namelen, oldp, (size_t *)oldlenp, newp, (size_t)newlen);
320	}
321	# endif
322
323	int internal_sysctlbyname(const char sname, void oldp, uptr *oldlenp,
324	const void *newp, uptr newlen) {
325	DEFINE__REAL(int, sysctlbyname, const char a, void b, size_t *c,
326	const void *d, size_t e);
327	return _REAL(sysctlbyname, sname, oldp, (size_t *)oldlenp, newp,
328	(size_t)newlen);
329	}
330
331	uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set,
332	__sanitizer_sigset_t *oldset) {
333	CHECK(&_kern_set_signal_mask);
334	return _kern_set_signal_mask(how, set, oldset);
335	}
336
337	void internal_sigfillset(__sanitizer_sigset_t *set) {
338	DEFINE__REAL(int, __sigfillset14, const void *a);
339	(void)_REAL(__sigfillset14, set);
340	}
341
342	void internal_sigemptyset(__sanitizer_sigset_t *set) {
343	DEFINE__REAL(int, __sigemptyset14, const void *a);
344	(void)_REAL(__sigemptyset14, set);
345	}
346
347	void internal_sigdelset(__sanitizer_sigset_t *set, int signo) {
348	DEFINE__REAL(int, __sigdelset14, const void *a, int b);
349	(void)_REAL(__sigdelset14, set, signo);
350	}
351
352	uptr internal_clone(int (fn)(void ), void *child_stack, int flags,
353	void *arg) {
354	DEFINE__REAL(int, clone, int (a)(void b), void c, int d, void e);
355
356	return _REAL(clone, fn, child_stack, flags, arg);
357	}
358
359	} // namespace __sanitizer
360
361	#endif

lib/libtsan/sanitizer_common/sanitizer_linux.cpp+75-68

 @@ -14,7 +14,7 @@
 #include "sanitizer_platform.h"
 #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \
-    SANITIZER_SOLARIS
+    SANITIZER_SOLARIS || SANITIZER_HAIKU
 #  include "sanitizer_common.h"
 #  include "sanitizer_flags.h"
 @@ -63,15 +63,17 @@
 #  include <sched.h>
 #  include <signal.h>
 #  include <sys/mman.h>
-#  if !SANITIZER_SOLARIS
+#  if !SANITIZER_SOLARIS && !SANITIZER_HAIKU
 #    include <sys/ptrace.h>
 #  endif
 #  include <sys/resource.h>
 #  include <sys/stat.h>
-#  include <sys/syscall.h>
+#  if !SANITIZER_HAIKU
+#    include <sys/syscall.h>
+#    include <ucontext.h>
+#  endif
 #  include <sys/time.h>
 #  include <sys/types.h>
-#  include <ucontext.h>
 #  include <unistd.h>
 #  if SANITIZER_LINUX
 @@ -82,6 +84,12 @@
 #    include <sys/personality.h>
 #  endif
+#  if SANITIZER_ANDROID && __ANDROID_API__ < 35
+// The weak `strerrorname_np` (introduced in API level 35) definition,
+// allows for checking the API level at runtime.
+extern "C" SANITIZER_WEAK_ATTRIBUTE const char *strerrorname_np(int);
+#  endif
 #  if SANITIZER_LINUX && defined(__loongarch__)
 #    include <sys/sysmacros.h>
 #  endif
 @@ -118,6 +126,13 @@ extern struct ps_strings *__ps_strings;
 #    define environ _environ
 #  endif
+#  if SANITIZER_HAIKU
+#    include <OS.h>
+#    include <elf.h>
+#    include <image.h>
+extern "C" char **__libc_argv;
+#  endif
 extern char **environ;
 #  if SANITIZER_LINUX
 @@ -246,7 +261,7 @@ ScopedBlockSignals::~ScopedBlockSignals() { SetSigProcMask(&saved_, nullptr); }
 #  endif
 // --------------- sanitizer_libc.h
-#  if !SANITIZER_SOLARIS && !SANITIZER_NETBSD
+#  if !SANITIZER_SOLARIS && !SANITIZER_NETBSD && !SANITIZER_HAIKU
 #    if !SANITIZER_S390
 uptr internal_mmap(void *addr, uptr length, int prot, int flags, int fd,
                    u64 offset) {
 @@ -591,9 +606,9 @@ uptr internal_execve(const char *filename, char *const argv[],
   return internal_syscall(SYSCALL(execve), (uptr)filename, (uptr)argv,
                           (uptr)envp);
 }
-#  endif  // !SANITIZER_SOLARIS && !SANITIZER_NETBSD
+#  endif  // !SANITIZER_SOLARIS && !SANITIZER_NETBSD && !SANITIZER_HAIKU
-#  if !SANITIZER_NETBSD
+#  if !SANITIZER_NETBSD && !SANITIZER_HAIKU
 void internal__exit(int exitcode) {
 #    if SANITIZER_FREEBSD || SANITIZER_SOLARIS
   internal_syscall(SYSCALL(exit), exitcode);
 @@ -602,7 +617,7 @@ void internal__exit(int exitcode) {
 #    endif
   Die();  // Unreachable.
 }
-#  endif  // !SANITIZER_NETBSD
+#  endif  // !SANITIZER_NETBSD && !SANITIZER_HAIKU
 // ----------------- sanitizer_common.h
 bool FileExists(const char *filename) {
 @@ -630,6 +645,8 @@ tid_t GetTid() {
   return Tid;
 #    elif SANITIZER_SOLARIS
   return thr_self();
+#    elif SANITIZER_HAIKU
+  return find_thread(NULL);
 #    else
   return internal_syscall(SYSCALL(gettid));
 #    endif
 @@ -645,6 +662,8 @@ int TgKill(pid_t pid, tid_t tid, int sig) {
   errno = thr_kill(tid, sig);
   // TgKill is expected to return -1 on error, not an errno.
   return errno != 0 ? -1 : 0;
+#    elif SANITIZER_HAIKU
+  return kill_thread(tid);
 #    endif
 }
 #  endif
 @@ -672,7 +691,8 @@ u64 NanoTime() {
 // 'environ' array (on some others) and does not use libc. This function
 // should be called first inside __asan_init.
 const char *GetEnv(const char *name) {
-#  if SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_SOLARIS
+#  if SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_SOLARIS || \
+      SANITIZER_HAIKU
   if (::environ != 0) {
     uptr NameLen = internal_strlen(name);
     for (char **Env = ::environ; *Env != 0; Env++) {
 @@ -710,13 +730,14 @@ const char *GetEnv(const char *name) {
 #  endif
 }
-#  if !SANITIZER_FREEBSD && !SANITIZER_NETBSD && !SANITIZER_GO
+#  if !SANITIZER_HAIKU && !SANITIZER_FREEBSD && !SANITIZER_NETBSD && \
+      !SANITIZER_GO
 extern "C" {
 SANITIZER_WEAK_ATTRIBUTE extern void *__libc_stack_end;
 }
 #  endif
-#  if !SANITIZER_FREEBSD && !SANITIZER_NETBSD
+#  if !SANITIZER_HAIKU && !SANITIZER_FREEBSD && !SANITIZER_NETBSD
 static void ReadNullSepFileToArray(const char *path, char ***arr,
                                    int arr_size) {
   char *buff;
 @@ -743,7 +764,10 @@ static void ReadNullSepFileToArray(const char *path, char ***arr,
 #  endif
 static void GetArgsAndEnv(char ***argv, char ***envp) {
-#  if SANITIZER_FREEBSD
+#  if SANITIZER_HAIKU
+  *argv = __libc_argv;
+  *envp = environ;
+#  elif SANITIZER_FREEBSD
   // On FreeBSD, retrieving the argument and environment arrays is done via the
   // kern.ps_strings sysctl, which returns a pointer to a structure containing
   // this information. See also <sys/exec.h>.
 @@ -783,7 +807,7 @@ static void GetArgsAndEnv(char ***argv, char ***envp) {
 #    if !SANITIZER_GO
   }
 #    endif  // !SANITIZER_GO
-#  endif    // SANITIZER_FREEBSD
+#  endif    // SANITIZER_HAIKU
 }
 char **GetArgv() {
 @@ -802,7 +826,7 @@ char **GetEnviron() {
 void FutexWait(atomic_uint32_t *p, u32 cmp) {
 #    if SANITIZER_FREEBSD
   _umtx_op(p, UMTX_OP_WAIT_UINT, cmp, 0, 0);
-#    elif SANITIZER_NETBSD
+#    elif SANITIZER_NETBSD || SANITIZER_HAIKU
   sched_yield(); /* No userspace futex-like synchronization */
 #    else
   internal_syscall(SYSCALL(futex), (uptr)p, FUTEX_WAIT_PRIVATE, cmp, 0, 0, 0);
 @@ -812,7 +836,7 @@ void FutexWait(atomic_uint32_t *p, u32 cmp) {
 void FutexWake(atomic_uint32_t *p, u32 count) {
 #    if SANITIZER_FREEBSD
   _umtx_op(p, UMTX_OP_WAKE, count, 0, 0);
-#    elif SANITIZER_NETBSD
+#    elif SANITIZER_NETBSD || SANITIZER_HAIKU
   /* No userspace futex-like synchronization */
 #    else
   internal_syscall(SYSCALL(futex), (uptr)p, FUTEX_WAKE_PRIVATE, count, 0, 0, 0);
 @@ -844,7 +868,7 @@ struct linux_dirent {
 };
 #  endif
-#  if !SANITIZER_SOLARIS && !SANITIZER_NETBSD
+#  if !SANITIZER_SOLARIS && !SANITIZER_NETBSD && !SANITIZER_HAIKU
 // Syscall wrappers.
 uptr internal_ptrace(int request, int pid, void *addr, void *data) {
   return internal_syscall(SYSCALL(ptrace), request, pid, (uptr)addr,
 @@ -1058,7 +1082,7 @@ bool internal_sigismember(__sanitizer_sigset_t *set, int signum) {
 #    endif
 #  endif  // !SANITIZER_SOLARIS
-#  if !SANITIZER_NETBSD
+#  if !SANITIZER_NETBSD && !SANITIZER_HAIKU
 // ThreadLister implementation.
 ThreadLister::ThreadLister(pid_t pid) : buffer_(4096) {
   task_path_.AppendF("/proc/%d/task", pid);
 @@ -1244,6 +1268,16 @@ uptr GetPageSize() {
   CHECK_EQ(rv, 0);
   return (uptr)pz;
 #    elif SANITIZER_USE_GETAUXVAL
+#      if SANITIZER_ANDROID && __ANDROID_API__ < 35
+  // The 16 KB page size was introduced in Android 15 (API level 35), while
+  // earlier versions of Android always used a 4 KB page size.
+  // We are checking the weak definition of `strerrorname_np` (introduced in API
+  // level 35) because some earlier API levels crashed when
+  // `getauxval(AT_PAGESZ)` was called from the `.preinit_array`.
+  if (!strerrorname_np)
+    return 4096;
+#      endif
   return getauxval(AT_PAGESZ);
 #    else
   return sysconf(_SC_PAGESIZE);  // EXEC_PAGESIZE may not be trustworthy.
 @@ -1252,7 +1286,19 @@ uptr GetPageSize() {
 #  endif
 uptr ReadBinaryName(/*out*/ char *buf, uptr buf_len) {
-#  if SANITIZER_SOLARIS
+#  if SANITIZER_HAIKU
+  int cookie = 0;
+  image_info info;
+  const char *argv0 = "<UNKNOWN>";
+  while (get_next_image_info(B_CURRENT_TEAM, &cookie, &info) == B_OK) {
+    if (info.type != B_APP_IMAGE)
+      continue;
+    argv0 = info.name;
+    break;
+  }
+  internal_strncpy(buf, argv0, buf_len);
+  return internal_strlen(buf);
+#  elif SANITIZER_SOLARIS
   const char *default_module_name = getexecname();
   CHECK_NE(default_module_name, NULL);
   return internal_snprintf(buf, buf_len, "%s", default_module_name);
 @@ -1318,11 +1364,11 @@ bool LibraryNameIs(const char *full_name, const char *base_name) {
   return (name[base_name_length] == '-' || name[base_name_length] == '.');
 }
-#  if !SANITIZER_ANDROID
+#  if !SANITIZER_ANDROID && !SANITIZER_HAIKU
 // Call cb for each region mapped by map.
 void ForEachMappedRegion(link_map *map, void (*cb)(const void *, uptr)) {
   CHECK_NE(map, nullptr);
-#    if !SANITIZER_FREEBSD
+#    if !SANITIZER_FREEBSD && !SANITIZER_HAIKU
   typedef ElfW(Phdr) Elf_Phdr;
   typedef ElfW(Ehdr) Elf_Ehdr;
 #    endif  // !SANITIZER_FREEBSD
 @@ -1855,54 +1901,6 @@ int internal_uname(struct utsname *buf) {
 }
 #  endif
-#  if SANITIZER_ANDROID
-static int dl_iterate_phdr_test_cb(struct dl_phdr_info *info, size_t size,
-                                   void *data) {
-  // Any name starting with "lib" indicates a bug in L where library base names
-  // are returned instead of paths.
-  if (info->dlpi_name && info->dlpi_name[0] == 'l' &&
-      info->dlpi_name[1] == 'i' && info->dlpi_name[2] == 'b') {
-    *(bool *)data = true;
-    return 1;
-  }
-  return 0;
-}
-static atomic_uint32_t android_api_level;
-static AndroidApiLevel AndroidDetectApiLevelStatic() {
-#    if __ANDROID_API__ <= 22
-  return ANDROID_LOLLIPOP_MR1;
-#    else
-  return ANDROID_POST_LOLLIPOP;
-#    endif
-}
-static AndroidApiLevel AndroidDetectApiLevel() {
-  bool base_name_seen = false;
-  dl_iterate_phdr(dl_iterate_phdr_test_cb, &base_name_seen);
-  if (base_name_seen)
-    return ANDROID_LOLLIPOP_MR1;  // L MR1
-  return ANDROID_POST_LOLLIPOP;   // post-L
-  // Plain L (API level 21) is completely broken wrt ASan and not very
-  // interesting to detect.
-}
-extern "C" __attribute__((weak)) void *_DYNAMIC;
-AndroidApiLevel AndroidGetApiLevel() {
-  AndroidApiLevel level =
-      (AndroidApiLevel)atomic_load(&android_api_level, memory_order_relaxed);
-  if (level)
-    return level;
-  level = &_DYNAMIC == nullptr ? AndroidDetectApiLevelStatic()
-                               : AndroidDetectApiLevel();
-  atomic_store(&android_api_level, level, memory_order_relaxed);
-  return level;
-}
-#  endif
 static HandleSignalMode GetHandleSignalModeImpl(int signum) {
   switch (signum) {
     case SIGABRT:
 @@ -1981,11 +1979,15 @@ using Context = ucontext_t;
 SignalContext::WriteFlag SignalContext::GetWriteFlag() const {
   Context *ucontext = (Context *)context;
 #  if defined(__x86_64__) || defined(__i386__)
+#    if !SANITIZER_HAIKU
   static const uptr PF_WRITE = 1U << 1;
+#    endif
 #    if SANITIZER_FREEBSD
   uptr err = ucontext->uc_mcontext.mc_err;
 #    elif SANITIZER_NETBSD
   uptr err = ucontext->uc_mcontext.__gregs[_REG_ERR];
+#    elif SANITIZER_HAIKU
+  uptr err = ucontext->uc_mcontext.r13;
 #    elif SANITIZER_SOLARIS && defined(__i386__)
   const int Err = 13;
   uptr err = ucontext->uc_mcontext.gregs[Err];
 @@ -2598,6 +2600,11 @@ static void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp) {
   *pc = ucontext->uc_mcontext.mc_rip;
   *bp = ucontext->uc_mcontext.mc_rbp;
   *sp = ucontext->uc_mcontext.mc_rsp;
+#    elif SANITIZER_HAIKU
+  ucontext_t *ucontext = (ucontext_t *)context;
+  *pc = ucontext->uc_mcontext.rip;
+  *bp = ucontext->uc_mcontext.rbp;
+  *sp = ucontext->uc_mcontext.rsp;
 #    else
   ucontext_t *ucontext = (ucontext_t *)context;
   *pc = ucontext->uc_mcontext.gregs[REG_RIP];

lib/libtsan/sanitizer_common/sanitizer_linux.h+8-2

...	@@ -14,7 +14,7 @@	...	@@ -14,7 +14,7 @@
14		14
15	#include "sanitizer_platform.h"	15	#include "sanitizer_platform.h"
16	#if SANITIZER_FREEBSD \|\| SANITIZER_LINUX \|\| SANITIZER_NETBSD \|\| \	16	#if SANITIZER_FREEBSD \|\| SANITIZER_LINUX \|\| SANITIZER_NETBSD \|\| \
17	SANITIZER_SOLARIS	17	SANITIZER_SOLARIS \|\| SANITIZER_HAIKU
18	# include "sanitizer_common.h"	18	# include "sanitizer_common.h"
19	# include "sanitizer_internal_defs.h"	19	# include "sanitizer_internal_defs.h"
20	# include "sanitizer_platform_limits_freebsd.h"	20	# include "sanitizer_platform_limits_freebsd.h"
...	@@ -31,6 +31,11 @@ namespace __sanitizer {	...	@@ -31,6 +31,11 @@ namespace __sanitizer {
31	// the one in <dirent.h>, which is used by readdir().	31	// the one in <dirent.h>, which is used by readdir().
32	struct linux_dirent;	32	struct linux_dirent;
33		33
		34	# if SANITIZER_HAIKU
		35	struct MemoryMappingLayoutData {
		36	long signed int cookie;
		37	};
		38	# else
34	struct ProcSelfMapsBuff {	39	struct ProcSelfMapsBuff {
35	char *data;	40	char *data;
36	uptr mmaped_size;	41	uptr mmaped_size;
...	@@ -43,6 +48,7 @@ struct MemoryMappingLayoutData {	...	@@ -43,6 +48,7 @@ struct MemoryMappingLayoutData {
43	};	48	};
44		49
45	void ReadProcMaps(ProcSelfMapsBuff *proc_maps);	50	void ReadProcMaps(ProcSelfMapsBuff *proc_maps);
		51	# endif // SANITIZER_HAIKU
46		52
47	// Syscall wrappers.	53	// Syscall wrappers.
48	uptr internal_getdents(fd_t fd, struct linux_dirent *dirp, unsigned int count);	54	uptr internal_getdents(fd_t fd, struct linux_dirent *dirp, unsigned int count);
...	@@ -124,7 +130,7 @@ bool LibraryNameIs(const char full_name, const char base_name);	...	@@ -124,7 +130,7 @@ bool LibraryNameIs(const char full_name, const char base_name);
124	// Call cb for each region mapped by map.	130	// Call cb for each region mapped by map.
125	void ForEachMappedRegion(link_map map, void (cb)(const void *, uptr));	131	void ForEachMappedRegion(link_map map, void (cb)(const void *, uptr));
126		132
127	// Releases memory pages entirely within the [beg, end] address range.	133	// Releases memory pages entirely within the [beg, end) address range.
128	// The pages no longer count toward RSS; reads are guaranteed to return 0.	134	// The pages no longer count toward RSS; reads are guaranteed to return 0.
129	// Requires (but does not verify!) that pages are MAP_PRIVATE.	135	// Requires (but does not verify!) that pages are MAP_PRIVATE.
130	inline void ReleaseMemoryPagesToOSAndZeroFill(uptr beg, uptr end) {	136	inline void ReleaseMemoryPagesToOSAndZeroFill(uptr beg, uptr end) {

lib/libtsan/sanitizer_common/sanitizer_linux_libcdep.cpp+33-82

 @@ -14,7 +14,7 @@
 #include "sanitizer_platform.h"
 #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \
-    SANITIZER_SOLARIS
+    SANITIZER_SOLARIS || SANITIZER_HAIKU
 #  include "sanitizer_allocator_internal.h"
 #  include "sanitizer_atomic.h"
 @@ -28,8 +28,19 @@
 #  include "sanitizer_procmaps.h"
 #  include "sanitizer_solaris.h"
+#  if SANITIZER_HAIKU
+#    define _DEFAULT_SOURCE
+#  endif
 #  if SANITIZER_NETBSD
-#    define _RTLD_SOURCE  // for __lwp_gettcb_fast() / __lwp_getprivate_fast()
+#    // for __lwp_gettcb_fast() / __lwp_getprivate_fast()
+#    define _RTLD_SOURCE
+#    include <machine/mcontext.h>
+#    undef _RTLD_SOURCE
+#    include <sys/param.h>
+#    if __NetBSD_Version__ >= 1099001200
+#      include <machine/lwp_private.h>
+#    endif
 #  endif
 #  include <dlfcn.h>  // for dlsym()
 @@ -74,18 +85,9 @@ extern "C" int __sys_sigaction(int signum, const struct sigaction *act,
 #    include <thread.h>
 #  endif
-#  if SANITIZER_ANDROID
+#  if SANITIZER_HAIKU
-#    include <android/api-level.h>
+#    include <kernel/OS.h>
-#    if !defined(CPU_COUNT) && !defined(__aarch64__)
+#    include <sys/link_elf.h>
-#      include <dirent.h>
-#      include <fcntl.h>
-struct __sanitizer::linux_dirent {
-  long d_ino;
-  off_t d_off;
-  unsigned short d_reclen;
-  char d_name[];
-};
-#    endif
 #  endif
 #  if !SANITIZER_ANDROID
 @@ -651,6 +653,7 @@ static void GetTls(uptr *addr, uptr *size) {
       *addr = (uptr)tcb->tcb_dtv[1];
     }
   }
+#    elif SANITIZER_HAIKU
 #    else
 #      error "Unknown OS"
 #    endif
 @@ -721,8 +724,13 @@ static int AddModuleSegments(const char *module_name, dl_phdr_info *info,
     if (phdr->p_type == PT_LOAD) {
       uptr cur_beg = info->dlpi_addr + phdr->p_vaddr;
       uptr cur_end = cur_beg + phdr->p_memsz;
+#  if SANITIZER_HAIKU
+      bool executable = phdr->p_flags & PF_EXECUTE;
+      bool writable = phdr->p_flags & PF_WRITE;
+#  else
       bool executable = phdr->p_flags & PF_X;
       bool writable = phdr->p_flags & PF_W;
+#  endif
       cur_module.addAddressRange(cur_beg, cur_end, executable, writable);
     } else if (phdr->p_type == PT_NOTE) {
 #  ifdef NT_GNU_BUILD_ID
 @@ -774,42 +782,13 @@ static int dl_iterate_phdr_cb(dl_phdr_info *info, size_t size, void *arg) {
   return 0;
 }
-static bool requiresProcmaps() {
-#  if SANITIZER_ANDROID && __ANDROID_API__ <= 22
-  // Fall back to /proc/maps if dl_iterate_phdr is unavailable or broken.
-  // The runtime check allows the same library to work with
-  // both K and L (and future) Android releases.
-  return AndroidGetApiLevel() <= ANDROID_LOLLIPOP_MR1;
-#  else
-  return false;
-#  endif
-}
-static void procmapsInit(InternalMmapVectorNoCtor<LoadedModule> *modules) {
-  MemoryMappingLayout memory_mapping(/*cache_enabled*/ true);
-  memory_mapping.DumpListOfModules(modules);
-}
 void ListOfModules::init() {
   clearOrInit();
-  if (requiresProcmaps()) {
+  DlIteratePhdrData data = {&modules_, true};
-    procmapsInit(&modules_);
+  dl_iterate_phdr(dl_iterate_phdr_cb, &data);
-  } else {
-    DlIteratePhdrData data = {&modules_, true};
-    dl_iterate_phdr(dl_iterate_phdr_cb, &data);
-  }
 }
-// When a custom loader is used, dl_iterate_phdr may not contain the full
+void ListOfModules::fallbackInit() { clear(); }
-// list of modules. Allow callers to fall back to using procmaps.
-void ListOfModules::fallbackInit() {
-  if (!requiresProcmaps()) {
-    clearOrInit();
-    procmapsInit(&modules_);
-  } else {
-    clear();
-  }
-}
 // getrusage does not give us the current RSS, only the max RSS.
 // Still, this is better than nothing if /proc/self/statm is not available
 @@ -855,45 +834,17 @@ u32 GetNumberOfCPUs() {
   int req[2];
   uptr len = sizeof(ncpu);
   req[0] = CTL_HW;
+#    ifdef HW_NCPUONLINE
+  req[1] = HW_NCPUONLINE;
+#    else
   req[1] = HW_NCPU;
+#    endif
   CHECK_EQ(internal_sysctl(req, 2, &ncpu, &len, NULL, 0), 0);
   return ncpu;
-#  elif SANITIZER_ANDROID && !defined(CPU_COUNT) && !defined(__aarch64__)
+#  elif SANITIZER_HAIKU
-  // Fall back to /sys/devices/system/cpu on Android when cpu_set_t doesn't
+  system_info info;
-  // exist in sched.h. That is the case for toolchains generated with older
+  get_system_info(&info);
-  // NDKs.
+  return info.cpu_count;
-  // This code doesn't work on AArch64 because internal_getdents makes use of
-  // the 64bit getdents syscall, but cpu_set_t seems to always exist on AArch64.
-  uptr fd = internal_open("/sys/devices/system/cpu", O_RDONLY | O_DIRECTORY);
-  if (internal_iserror(fd))
-    return 0;
-  InternalMmapVector<u8> buffer(4096);
-  uptr bytes_read = buffer.size();
-  uptr n_cpus = 0;
-  u8 *d_type;
-  struct linux_dirent *entry = (struct linux_dirent *)&buffer[bytes_read];
-  while (true) {
-    if ((u8 *)entry >= &buffer[bytes_read]) {
-      bytes_read = internal_getdents(fd, (struct linux_dirent *)buffer.data(),
-                                     buffer.size());
-      if (internal_iserror(bytes_read) || !bytes_read)
-        break;
-      entry = (struct linux_dirent *)buffer.data();
-    }
-    d_type = (u8 *)entry + entry->d_reclen - 1;
-    if (d_type >= &buffer[bytes_read] ||
-        (u8 *)&entry->d_name[3] >= &buffer[bytes_read])
-      break;
-    if (entry->d_ino != 0 && *d_type == DT_DIR) {
-      if (entry->d_name[0] == 'c' && entry->d_name[1] == 'p' &&
-          entry->d_name[2] == 'u' && entry->d_name[3] >= '0' &&
-          entry->d_name[3] <= '9')
-        n_cpus++;
-    }
-    entry = (struct linux_dirent *)(((u8 *)entry) + entry->d_reclen);
-  }
-  internal_close(fd);
-  return n_cpus;
 #  elif SANITIZER_SOLARIS
   return sysconf(_SC_NPROCESSORS_ONLN);
 #  else

lib/libtsan/sanitizer_common/sanitizer_mac.cpp+29-38

...	@@ -38,13 +38,6 @@	...	@@ -38,13 +38,6 @@
38	extern char **environ;	38	extern char **environ;
39	# endif	39	# endif
40		40
41	# if defined(__has_include) && __has_include(<os/trace.h>)
42	# define SANITIZER_OS_TRACE 1
43	# include <os/trace.h>
44	# else
45	# define SANITIZER_OS_TRACE 0
46	# endif
47
48	// Integrate with CrashReporter library if available	41	// Integrate with CrashReporter library if available
49	# if defined(__has_include) && __has_include(<CrashReporterClient.h>)	42	# if defined(__has_include) && __has_include(<CrashReporterClient.h>)
50	# define HAVE_CRASHREPORTERCLIENT_H 1	43	# define HAVE_CRASHREPORTERCLIENT_H 1
...	@@ -843,31 +836,23 @@ void LogMessageOnPrintf(const char *str) {	...	@@ -843,31 +836,23 @@ void LogMessageOnPrintf(const char *str) {
843	}	836	}
844		837
845	void LogFullErrorReport(const char *buffer) {	838	void LogFullErrorReport(const char *buffer) {
846	#if !SANITIZER_GO	839	# if !SANITIZER_GO
847	// Log with os_trace. This will make it into the crash log.	840	// Log with os_log_error. This will make it into the crash log.
848	#if SANITIZER_OS_TRACE	841	if (internal_strncmp(SanitizerToolName, "AddressSanitizer",
849	#pragma clang diagnostic push	842	sizeof("AddressSanitizer") - 1) == 0)
850	// os_trace is deprecated.	843	os_log_error(OS_LOG_DEFAULT, "Address Sanitizer reported a failure.");
851	#pragma clang diagnostic ignored "-Wdeprecated-declarations"	844	else if (internal_strncmp(SanitizerToolName, "UndefinedBehaviorSanitizer",
852	if (GetMacosAlignedVersion() >= MacosVersion(10, 10)) {	845	sizeof("UndefinedBehaviorSanitizer") - 1) == 0)
853	// os_trace requires the message (format parameter) to be a string literal.	846	os_log_error(OS_LOG_DEFAULT,
854	if (internal_strncmp(SanitizerToolName, "AddressSanitizer",	847	"Undefined Behavior Sanitizer reported a failure.");
855	sizeof("AddressSanitizer") - 1) == 0)	848	else if (internal_strncmp(SanitizerToolName, "ThreadSanitizer",
856	os_trace("Address Sanitizer reported a failure.");	849	sizeof("ThreadSanitizer") - 1) == 0)
857	else if (internal_strncmp(SanitizerToolName, "UndefinedBehaviorSanitizer",	850	os_log_error(OS_LOG_DEFAULT, "Thread Sanitizer reported a failure.");
858	sizeof("UndefinedBehaviorSanitizer") - 1) == 0)	851	else
859	os_trace("Undefined Behavior Sanitizer reported a failure.");	852	os_log_error(OS_LOG_DEFAULT, "Sanitizer tool reported a failure.");
860	else if (internal_strncmp(SanitizerToolName, "ThreadSanitizer",	853
861	sizeof("ThreadSanitizer") - 1) == 0)	854	if (common_flags()->log_to_syslog)
862	os_trace("Thread Sanitizer reported a failure.");	855	os_log_error(OS_LOG_DEFAULT, "Consult syslog for more information.");
863	else
864	os_trace("Sanitizer tool reported a failure.");
865
866	if (common_flags()->log_to_syslog)
867	os_trace("Consult syslog for more information.");
868	}
869	#pragma clang diagnostic pop
870	#endif
871		856
872	// Log to syslog.	857	// Log to syslog.
873	// The logging on OS X may call pthread_create so we need the threading	858	// The logging on OS X may call pthread_create so we need the threading
...	@@ -881,7 +866,7 @@ void LogFullErrorReport(const char *buffer) {	...	@@ -881,7 +866,7 @@ void LogFullErrorReport(const char *buffer) {
881	WriteToSyslog(buffer);	866	WriteToSyslog(buffer);
882		867
883	// The report is added to CrashLog as part of logging all of Printf output.	868	// The report is added to CrashLog as part of logging all of Printf output.
884	#endif	869	# endif // !SANITIZER_GO
885	}	870	}
886		871
887	SignalContext::WriteFlag SignalContext::GetWriteFlag() const {	872	SignalContext::WriteFlag SignalContext::GetWriteFlag() const {
...	@@ -1203,13 +1188,14 @@ uptr MapDynamicShadow(uptr shadow_size_bytes, uptr shadow_scale,	...	@@ -1203,13 +1188,14 @@ uptr MapDynamicShadow(uptr shadow_size_bytes, uptr shadow_scale,
1203	const uptr left_padding =	1188	const uptr left_padding =
1204	Max<uptr>(granularity, 1ULL << min_shadow_base_alignment);	1189	Max<uptr>(granularity, 1ULL << min_shadow_base_alignment);
1205		1190
1206	uptr space_size = shadow_size_bytes + left_padding;	1191	uptr space_size = shadow_size_bytes;
1207		1192
1208	uptr largest_gap_found = 0;	1193	uptr largest_gap_found = 0;
1209	uptr max_occupied_addr = 0;	1194	uptr max_occupied_addr = 0;
		1195
1210	VReport(2, "FindDynamicShadowStart, space_size = %p\n", (void *)space_size);	1196	VReport(2, "FindDynamicShadowStart, space_size = %p\n", (void *)space_size);
1211	uptr shadow_start =	1197	uptr shadow_start =
1212	FindAvailableMemoryRange(space_size, alignment, granularity,	1198	FindAvailableMemoryRange(space_size, alignment, left_padding,
1213	&largest_gap_found, &max_occupied_addr);	1199	&largest_gap_found, &max_occupied_addr);
1214	// If the shadow doesn't fit, restrict the address space to make it fit.	1200	// If the shadow doesn't fit, restrict the address space to make it fit.
1215	if (shadow_start == 0) {	1201	if (shadow_start == 0) {
...	@@ -1229,9 +1215,9 @@ uptr MapDynamicShadow(uptr shadow_size_bytes, uptr shadow_scale,	...	@@ -1229,9 +1215,9 @@ uptr MapDynamicShadow(uptr shadow_size_bytes, uptr shadow_scale,
1229	}	1215	}
1230	RestrictMemoryToMaxAddress(new_max_vm);	1216	RestrictMemoryToMaxAddress(new_max_vm);
1231	high_mem_end = new_max_vm - 1;	1217	high_mem_end = new_max_vm - 1;
1232	space_size = (high_mem_end >> shadow_scale) + left_padding;	1218	space_size = (high_mem_end >> shadow_scale);
1233	VReport(2, "FindDynamicShadowStart, space_size = %p\n", (void *)space_size);	1219	VReport(2, "FindDynamicShadowStart, space_size = %p\n", (void *)space_size);
1234	shadow_start = FindAvailableMemoryRange(space_size, alignment, granularity,	1220	shadow_start = FindAvailableMemoryRange(space_size, alignment, left_padding,
1235	nullptr, nullptr);	1221	nullptr, nullptr);
1236	if (shadow_start == 0) {	1222	if (shadow_start == 0) {
1237	Report("Unable to find a memory range after restricting VM.\n");	1223	Report("Unable to find a memory range after restricting VM.\n");
...	@@ -1272,10 +1258,15 @@ uptr FindAvailableMemoryRange(uptr size, uptr alignment, uptr left_padding,	...	@@ -1272,10 +1258,15 @@ uptr FindAvailableMemoryRange(uptr size, uptr alignment, uptr left_padding,
1272	mach_msg_type_number_t count = kRegionInfoSize;	1258	mach_msg_type_number_t count = kRegionInfoSize;
1273	kr = mach_vm_region_recurse(mach_task_self(), &address, &vmsize, &depth,	1259	kr = mach_vm_region_recurse(mach_task_self(), &address, &vmsize, &depth,
1274	(vm_region_info_t)&vminfo, &count);	1260	(vm_region_info_t)&vminfo, &count);
1275	if (kr == KERN_INVALID_ADDRESS) {	1261
		1262	// There are cases where going beyond the processes' max vm does
		1263	// not return KERN_INVALID_ADDRESS so we check for going beyond that
		1264	// max address as well.
		1265	if (kr == KERN_INVALID_ADDRESS \|\| address > max_vm_address) {
1276	// No more regions beyond "address", consider the gap at the end of VM.	1266	// No more regions beyond "address", consider the gap at the end of VM.
1277	address = max_vm_address;	1267	address = max_vm_address;
1278	vmsize = 0;	1268	vmsize = 0;
		1269	kr = -1; // break after this iteration.
1279	} else {	1270	} else {
1280	if (max_occupied_addr) *max_occupied_addr = address + vmsize;	1271	if (max_occupied_addr) *max_occupied_addr = address + vmsize;
1281	}	1272	}

lib/libtsan/sanitizer_common/sanitizer_mac.h+6-3

 @@ -37,9 +37,6 @@ struct VersionBase {
   VersionBase(u16 major, u16 minor) : major(major), minor(minor) {}
-  bool operator==(const VersionType &other) const {
-    return major == other.major && minor == other.minor;
-  }
   bool operator>=(const VersionType &other) const {
     return major > other.major ||
            (major == other.major && minor >= other.minor);
 @@ -47,6 +44,12 @@ struct VersionBase {
   bool operator<(const VersionType &other) const { return !(*this >= other); }
 };
+template <typename VersionType>
+bool operator==(const VersionBase<VersionType> &self,
+                const VersionBase<VersionType> &other) {
+  return self.major == other.major && self.minor == other.minor;
+}
 struct MacosVersion : VersionBase<MacosVersion> {
   MacosVersion(u16 major, u16 minor) : VersionBase(major, minor) {}
 };

lib/libtsan/sanitizer_common/sanitizer_malloc_mac.inc+16

...	@@ -144,6 +144,22 @@ INTERCEPTOR(void, free, void *ptr) {	...	@@ -144,6 +144,22 @@ INTERCEPTOR(void, free, void *ptr) {
144	COMMON_MALLOC_FREE(ptr);	144	COMMON_MALLOC_FREE(ptr);
145	}	145	}
146		146
		147	#if SANITIZER_INTERCEPT_FREE_SIZED && defined(COMMON_MALLOC_FREE_SIZED)
		148	INTERCEPTOR(void, free_sized, void *ptr, size_t size) {
		149	COMMON_MALLOC_ENTER();
		150	COMMON_MALLOC_FREE_SIZED(ptr, size);
		151	}
		152	#endif
		153
		154	#if SANITIZER_INTERCEPT_FREE_ALIGNED_SIZED && \
		155	defined(COMMON_MALLOC_FREE_ALIGNED_SIZED)
		156	INTERCEPTOR(void, free_aligned_sized, void *ptr, size_t alignment,
		157	size_t size) {
		158	COMMON_MALLOC_ENTER();
		159	COMMON_MALLOC_FREE_ALIGNED_SIZED(ptr, alignment, size);
		160	}
		161	#endif
		162
147	INTERCEPTOR(void , realloc, void ptr, size_t size) {	163	INTERCEPTOR(void , realloc, void ptr, size_t size) {
148	COMMON_MALLOC_ENTER();	164	COMMON_MALLOC_ENTER();
149	COMMON_MALLOC_REALLOC(ptr, size);	165	COMMON_MALLOC_REALLOC(ptr, size);

lib/libtsan/sanitizer_common/sanitizer_platform.h+21-4

 @@ -14,7 +14,8 @@
 #if !defined(__linux__) && !defined(__FreeBSD__) && !defined(__NetBSD__) && \
     !defined(__APPLE__) && !defined(_WIN32) && !defined(__Fuchsia__) &&     \
-    !(defined(__sun__) && defined(__svr4__))
+    !(defined(__sun__) && defined(__svr4__)) && !defined(__HAIKU__) &&      \
+    !defined(__wasi__)
 #  error "This operating system is not supported"
 #endif
 @@ -55,6 +56,18 @@
 #  define SANITIZER_SOLARIS 0
 #endif
+#if defined(__HAIKU__)
+#  define SANITIZER_HAIKU 1
+#else
+#  define SANITIZER_HAIKU 0
+#endif
+#if defined(__wasi__)
+#  define SANITIZER_WASI 1
+#else
+#  define SANITIZER_WASI 0
+#endif
 // - SANITIZER_APPLE: all Apple code
 //   - TARGET_OS_OSX: macOS
 //   - SANITIZER_IOS: devices (iOS and iOS-like)
 @@ -136,9 +149,9 @@
 #  define SANITIZER_MUSL 0
 #endif
-#define SANITIZER_POSIX                                     \
+#define SANITIZER_POSIX                                       \
   (SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_APPLE || \
-   SANITIZER_NETBSD || SANITIZER_SOLARIS)
+   SANITIZER_NETBSD || SANITIZER_SOLARIS || SANITIZER_HAIKU)
 #if __LP64__ || defined(_WIN64)
 #  define SANITIZER_WORDSIZE 64
 @@ -305,6 +318,9 @@
 #  endif
 #endif
+// The first address that can be returned by mmap.
+#define SANITIZER_MMAP_BEGIN 0
 // The range of addresses which can be returned my mmap.
 // FIXME: this value should be different on different platforms.  Larger values
 // will still work but will consume more memory for TwoLevelByteMap.
 @@ -410,7 +426,8 @@
 #  define SANITIZER_SUPPRESS_LEAK_ON_PTHREAD_EXIT 0
 #endif
-#if SANITIZER_FREEBSD || SANITIZER_APPLE || SANITIZER_NETBSD || SANITIZER_SOLARIS
+#if SANITIZER_FREEBSD || SANITIZER_APPLE || SANITIZER_NETBSD || \
+    SANITIZER_SOLARIS || SANITIZER_HAIKU
 #  define SANITIZER_MADVISE_DONTNEED MADV_FREE
 #else
 #  define SANITIZER_MADVISE_DONTNEED MADV_DONTNEED

lib/libtsan/sanitizer_common/sanitizer_platform_interceptors.h+59-25

 @@ -129,8 +129,10 @@ SANITIZER_WEAK_IMPORT void *aligned_alloc(__sanitizer::usize __alignment,
 #if SANITIZER_FUCHSIA
 #define SI_NOT_FUCHSIA 0
+#define SI_FUCHSIA 1
 #else
 #define SI_NOT_FUCHSIA 1
+#define SI_FUCHSIA 0
 #endif
 #if SANITIZER_SOLARIS
 @@ -139,6 +141,12 @@ SANITIZER_WEAK_IMPORT void *aligned_alloc(__sanitizer::usize __alignment,
 #define SI_SOLARIS 0
 #endif
+#if SANITIZER_AIX
+#  define SI_NOT_AIX 0
+#else
+#  define SI_NOT_AIX 1
+#endif
 #if SANITIZER_SOLARIS32
 #define SI_SOLARIS32 1
 #else
 @@ -159,20 +167,20 @@ SANITIZER_WEAK_IMPORT void *aligned_alloc(__sanitizer::usize __alignment,
 #define SANITIZER_INTERCEPT_STRLEN SI_NOT_FUCHSIA
 #define SANITIZER_INTERCEPT_STRNLEN (SI_NOT_MAC && SI_NOT_FUCHSIA)
-#define SANITIZER_INTERCEPT_STRCMP SI_NOT_FUCHSIA
+#define SANITIZER_INTERCEPT_STRCMP (SI_NOT_FUCHSIA && SI_NOT_AIX)
 #define SANITIZER_INTERCEPT_STRSTR SI_NOT_FUCHSIA
-#define SANITIZER_INTERCEPT_STRCASESTR SI_POSIX
+#define SANITIZER_INTERCEPT_STRCASESTR (SI_POSIX && SI_NOT_AIX)
 #define SANITIZER_INTERCEPT_STRTOK SI_NOT_FUCHSIA
 #define SANITIZER_INTERCEPT_STRCHR SI_NOT_FUCHSIA
-#define SANITIZER_INTERCEPT_STRCHRNUL SI_POSIX_NOT_MAC
+#define SANITIZER_INTERCEPT_STRCHRNUL (SI_POSIX_NOT_MAC && SI_NOT_AIX)
 #define SANITIZER_INTERCEPT_STRRCHR SI_NOT_FUCHSIA
 #define SANITIZER_INTERCEPT_STRSPN SI_NOT_FUCHSIA
 #define SANITIZER_INTERCEPT_STRPBRK SI_NOT_FUCHSIA
 #define SANITIZER_INTERCEPT_TEXTDOMAIN SI_LINUX_NOT_ANDROID || SI_SOLARIS
 #define SANITIZER_INTERCEPT_STRCASECMP SI_POSIX
 #define SANITIZER_INTERCEPT_MEMSET 1
-#define SANITIZER_INTERCEPT_MEMMOVE 1
+#define SANITIZER_INTERCEPT_MEMMOVE SI_NOT_AIX
-#define SANITIZER_INTERCEPT_MEMCPY 1
+#define SANITIZER_INTERCEPT_MEMCPY SI_NOT_AIX
 #define SANITIZER_INTERCEPT_MEMCMP SI_NOT_FUCHSIA
 #define SANITIZER_INTERCEPT_BCMP \
   SANITIZER_INTERCEPT_MEMCMP &&  \
 @@ -231,16 +239,22 @@ SANITIZER_WEAK_IMPORT void *aligned_alloc(__sanitizer::usize __alignment,
 #define SANITIZER_INTERCEPT_ISOC99_SCANF SI_GLIBC
 #ifndef SANITIZER_INTERCEPT_PRINTF
-#define SANITIZER_INTERCEPT_PRINTF SI_POSIX
+#  define SANITIZER_INTERCEPT_ASPRINTF SI_NOT_AIX
-#define SANITIZER_INTERCEPT_PRINTF_L (SI_FREEBSD || SI_NETBSD)
+#  define SANITIZER_INTERCEPT_VASPRINTF SI_NOT_AIX
-#define SANITIZER_INTERCEPT_ISOC99_PRINTF SI_GLIBC
+#  define SANITIZER_INTERCEPT_PRINTF SI_POSIX
+#  define SANITIZER_INTERCEPT_PRINTF_L (SI_FREEBSD || SI_NETBSD)
+#  define SANITIZER_INTERCEPT_ISOC99_PRINTF SI_GLIBC
 #endif
+#define SANITIZER_INTERCEPT_SETPROCTITLE (SI_FREEBSD || SI_NETBSD)
 #define SANITIZER_INTERCEPT___PRINTF_CHK \
   (SANITIZER_INTERCEPT_PRINTF && SI_GLIBC)
-#define SANITIZER_INTERCEPT_FREXP SI_NOT_FUCHSIA
+// AIX libc does not export FREXP and FREXPF.
-#define SANITIZER_INTERCEPT_FREXPF_FREXPL SI_POSIX
+#define SANITIZER_INTERCEPT_FREXP (SI_NOT_FUCHSIA && SI_NOT_AIX)
+#define SANITIZER_INTERCEPT_FREXPF (SI_POSIX && SI_NOT_AIX)
+#define SANITIZER_INTERCEPT_FREXPL SI_POSIX
 #define SANITIZER_INTERCEPT_GETPWNAM_AND_FRIENDS SI_POSIX
 #define SANITIZER_INTERCEPT_GETPWNAM_R_AND_FRIENDS \
 @@ -289,7 +303,7 @@ SANITIZER_WEAK_IMPORT void *aligned_alloc(__sanitizer::usize __alignment,
 #define SANITIZER_INTERCEPT_ACCEPT4 \
   (SI_LINUX_NOT_ANDROID || SI_NETBSD || SI_FREEBSD)
 #define SANITIZER_INTERCEPT_PACCEPT SI_NETBSD
-#define SANITIZER_INTERCEPT_MODF SI_POSIX
+#define SANITIZER_INTERCEPT_MODF (SI_POSIX && SI_NOT_AIX)
 #define SANITIZER_INTERCEPT_RECVMSG SI_POSIX
 #define SANITIZER_INTERCEPT_SENDMSG SI_POSIX
 #define SANITIZER_INTERCEPT_RECVMMSG SI_LINUX
 @@ -324,8 +338,9 @@ SANITIZER_WEAK_IMPORT void *aligned_alloc(__sanitizer::usize __alignment,
 #define SANITIZER_INTERCEPT___WCSXFRM_L SI_LINUX
 #define SANITIZER_INTERCEPT_WCSNRTOMBS \
   (SI_FREEBSD || SI_NETBSD || SI_MAC || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
-#define SANITIZER_INTERCEPT_WCRTOMB \
+#define SANITIZER_INTERCEPT_WCRTOMB                                           \
-  (SI_FREEBSD || SI_NETBSD || SI_MAC || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
+  (SI_FREEBSD || SI_NETBSD || SI_MAC || SI_LINUX_NOT_ANDROID || SI_SOLARIS || \
+   !SI_NOT_AIX)
 #define SANITIZER_INTERCEPT_WCTOMB \
   (SI_FREEBSD || SI_NETBSD || SI_MAC || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_TCGETATTR SI_LINUX_NOT_ANDROID || SI_SOLARIS
 @@ -365,7 +380,8 @@ SANITIZER_WEAK_IMPORT void *aligned_alloc(__sanitizer::usize __alignment,
 #define SANITIZER_INTERCEPT_GETMNTENT_R SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_STATFS \
   (SI_FREEBSD || SI_MAC || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
-#define SANITIZER_INTERCEPT_STATFS64 SI_GLIBC && SANITIZER_HAS_STATFS64
+#define SANITIZER_INTERCEPT_STATFS64 \
+  ((SI_GLIBC || !SI_NOT_AIX) && SANITIZER_HAS_STATFS64)
 #define SANITIZER_INTERCEPT_STATVFS \
   (SI_FREEBSD || SI_NETBSD || SI_LINUX_NOT_ANDROID)
 #define SANITIZER_INTERCEPT_STATVFS64 SI_GLIBC
 @@ -414,10 +430,10 @@ SANITIZER_WEAK_IMPORT void *aligned_alloc(__sanitizer::usize __alignment,
 #define SANITIZER_INTERCEPT_TTYNAME_R SI_POSIX
 #define SANITIZER_INTERCEPT_TEMPNAM SI_POSIX
 #define SANITIZER_INTERCEPT_SINCOS SI_LINUX || SI_SOLARIS
-#define SANITIZER_INTERCEPT_REMQUO SI_POSIX
+#define SANITIZER_INTERCEPT_REMQUO (SI_POSIX && SI_NOT_AIX)
-#define SANITIZER_INTERCEPT_REMQUOL (SI_POSIX && !SI_NETBSD)
+#define SANITIZER_INTERCEPT_REMQUOL (SI_POSIX && !SI_NETBSD && SI_NOT_AIX)
-#define SANITIZER_INTERCEPT_LGAMMA SI_POSIX
+#define SANITIZER_INTERCEPT_LGAMMA (SI_POSIX && SI_NOT_AIX)
-#define SANITIZER_INTERCEPT_LGAMMAL (SI_POSIX && !SI_NETBSD)
+#define SANITIZER_INTERCEPT_LGAMMAL (SI_POSIX && !SI_NETBSD && SI_NOT_AIX)
 #define SANITIZER_INTERCEPT_LGAMMA_R (SI_FREEBSD || SI_LINUX || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_LGAMMAL_R SI_LINUX_NOT_ANDROID || SI_SOLARIS
 #define SANITIZER_INTERCEPT_DRAND48_R SI_GLIBC
 @@ -500,11 +516,13 @@ SANITIZER_WEAK_IMPORT void *aligned_alloc(__sanitizer::usize __alignment,
 #define SANITIZER_INTERCEPT_EVENTFD_READ_WRITE (SI_LINUX || SI_FREEBSD)
 #define SI_STAT_LINUX (SI_LINUX && __GLIBC_PREREQ(2, 33))
-#define SANITIZER_INTERCEPT_STAT                                        \
+#define SANITIZER_INTERCEPT_STAT                                    \
-  (SI_FREEBSD || SI_MAC || SI_ANDROID || SI_NETBSD || SI_SOLARIS ||     \
+  (SI_FREEBSD || SI_MAC || SI_ANDROID || SI_NETBSD || SI_SOLARIS || \
-   SI_STAT_LINUX)
+   SI_STAT_LINUX || !SI_NOT_AIX)
-#define SANITIZER_INTERCEPT_STAT64 SI_STAT_LINUX && SANITIZER_HAS_STAT64
+#define SANITIZER_INTERCEPT_STAT64 \
-#define SANITIZER_INTERCEPT_LSTAT (SI_NETBSD || SI_FREEBSD || SI_STAT_LINUX)
+  ((SI_STAT_LINUX || !SI_NOT_AIX) && SANITIZER_HAS_STAT64)
+#define SANITIZER_INTERCEPT_LSTAT \
+  (SI_NETBSD || SI_FREEBSD || SI_STAT_LINUX || !SI_NOT_AIX)
 #define SANITIZER_INTERCEPT___XSTAT \
   ((!SANITIZER_INTERCEPT_STAT && SI_POSIX) || SI_STAT_LINUX)
 #define SANITIZER_INTERCEPT___XSTAT64 SI_GLIBC
 @@ -521,7 +539,8 @@ SANITIZER_WEAK_IMPORT void *aligned_alloc(__sanitizer::usize __alignment,
 #define SANITIZER_INTERCEPT_MMAP SI_POSIX
 #define SANITIZER_INTERCEPT_MMAP64 SI_GLIBC || SI_SOLARIS
-#define SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO (SI_GLIBC || SI_ANDROID)
+#define SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO \
+  (SI_GLIBC || SI_ANDROID || SI_FUCHSIA)
 #define SANITIZER_INTERCEPT_MEMALIGN (!SI_FREEBSD && !SI_MAC && !SI_NETBSD)
 #define SANITIZER_INTERCEPT___LIBC_MEMALIGN SI_GLIBC
 #define SANITIZER_INTERCEPT_PVALLOC (SI_GLIBC || SI_ANDROID)
 @@ -572,7 +591,7 @@ SANITIZER_WEAK_IMPORT void *aligned_alloc(__sanitizer::usize __alignment,
 #define SANITIZER_INTERCEPT_PROTOENT_R SI_GLIBC
 #define SANITIZER_INTERCEPT_NETENT (SI_LINUX || SI_NETBSD || SI_FREEBSD)
 #define SANITIZER_INTERCEPT_SETVBUF \
-  (SI_NETBSD || SI_FREEBSD || SI_LINUX || SI_MAC)
+  (SI_NETBSD || SI_FREEBSD || SI_LINUX || SI_MAC || !SI_NOT_AIX)
 #define SANITIZER_INTERCEPT_GETMNTINFO (SI_NETBSD || SI_FREEBSD || SI_MAC)
 #define SANITIZER_INTERCEPT_MI_VECTOR_HASH SI_NETBSD
 #define SANITIZER_INTERCEPT_GETVFSSTAT SI_NETBSD
 @@ -640,6 +659,21 @@ SANITIZER_WEAK_IMPORT void *aligned_alloc(__sanitizer::usize __alignment,
 #  define SI_MAC_OS_DEPLOYMENT_MIN_13_00 0
 #endif
 #define SANITIZER_INTERCEPT_FREADLINK (SI_MAC && SI_MAC_OS_DEPLOYMENT_MIN_13_00)
+#define SANITIZER_INTERCEPT_GETSERVENT_R SI_GLIBC
+#define SANITIZER_INTERCEPT_GETSERVBYNAME_R SI_GLIBC
+#define SANITIZER_INTERCEPT_GETSERVBYPORT_R SI_GLIBC
+// Until free_sized and free_aligned_sized are more generally available,
+// we can only unconditionally intercept on ELF-based platforms where it
+// is okay to have undefined weak symbols.
+#ifdef __ELF__
+#  define SANITIZER_INTERCEPT_FREE_SIZED 1
+#  define SANITIZER_INTERCEPT_FREE_ALIGNED_SIZED 1
+#else
+#  define SANITIZER_INTERCEPT_FREE_SIZED 0
+#  define SANITIZER_INTERCEPT_FREE_ALIGNED_SIZED 0
+#endif
 // This macro gives a way for downstream users to override the above
 // interceptor macros irrespective of the platform they are on. They have
 // to do two things:

lib/libtsan/sanitizer_common/sanitizer_platform_limits_freebsd.cpp+1-9

...	@@ -29,6 +29,7 @@	...	@@ -29,6 +29,7 @@
29	#include <sys/mtio.h>	29	#include <sys/mtio.h>
30	#include <sys/ptrace.h>	30	#include <sys/ptrace.h>
31	#include <sys/resource.h>	31	#include <sys/resource.h>
		32	#include <sys/shm.h>
32	#include <sys/signal.h>	33	#include <sys/signal.h>
33	#include <sys/socket.h>	34	#include <sys/socket.h>
34	#include <sys/sockio.h>	35	#include <sys/sockio.h>
...	@@ -81,10 +82,6 @@	...	@@ -81,10 +82,6 @@
81	#include <wchar.h>	82	#include <wchar.h>
82	#include <wordexp.h>	83	#include <wordexp.h>
83		84
84	#define _KERNEL // to declare 'shminfo' structure
85	#include <sys/shm.h>
86	#undef _KERNEL
87
88	#undef IOC_DIRMASK	85	#undef IOC_DIRMASK
89		86
90	// Include these after system headers to avoid name clashes and ambiguities.	87	// Include these after system headers to avoid name clashes and ambiguities.
...	@@ -135,8 +132,6 @@ unsigned struct_timeb_sz = sizeof(struct timeb);	...	@@ -135,8 +132,6 @@ unsigned struct_timeb_sz = sizeof(struct timeb);
135	unsigned struct_msqid_ds_sz = sizeof(struct msqid_ds);	132	unsigned struct_msqid_ds_sz = sizeof(struct msqid_ds);
136	unsigned struct_mq_attr_sz = sizeof(struct mq_attr);	133	unsigned struct_mq_attr_sz = sizeof(struct mq_attr);
137	unsigned struct_statvfs_sz = sizeof(struct statvfs);	134	unsigned struct_statvfs_sz = sizeof(struct statvfs);
138	unsigned struct_shminfo_sz = sizeof(struct shminfo);
139	unsigned struct_shm_info_sz = sizeof(struct shm_info);
140	unsigned struct_regmatch_sz = sizeof(regmatch_t);	135	unsigned struct_regmatch_sz = sizeof(regmatch_t);
141	unsigned struct_regex_sz = sizeof(regex_t);	136	unsigned struct_regex_sz = sizeof(regex_t);
142	unsigned struct_fstab_sz = sizeof(struct fstab);	137	unsigned struct_fstab_sz = sizeof(struct fstab);
...	@@ -150,9 +145,6 @@ const uptr sig_err = (uptr)SIG_ERR;	...	@@ -150,9 +145,6 @@ const uptr sig_err = (uptr)SIG_ERR;
150	const uptr sa_siginfo = (uptr)SA_SIGINFO;	145	const uptr sa_siginfo = (uptr)SA_SIGINFO;
151		146
152	int shmctl_ipc_stat = (int)IPC_STAT;	147	int shmctl_ipc_stat = (int)IPC_STAT;
153	int shmctl_ipc_info = (int)IPC_INFO;
154	int shmctl_shm_info = (int)SHM_INFO;
155	int shmctl_shm_stat = (int)SHM_STAT;
156	unsigned struct_utmpx_sz = sizeof(struct utmpx);	148	unsigned struct_utmpx_sz = sizeof(struct utmpx);
157		149
158	int map_fixed = MAP_FIXED;	150	int map_fixed = MAP_FIXED;

lib/libtsan/sanitizer_common/sanitizer_platform_limits_freebsd.h+7-5

...	@@ -419,12 +419,14 @@ struct __sanitizer_wordexp_t {	...	@@ -419,12 +419,14 @@ struct __sanitizer_wordexp_t {
419		419
420	typedef void __sanitizer_FILE;	420	typedef void __sanitizer_FILE;
421		421
422	extern unsigned struct_shminfo_sz;
423	extern unsigned struct_shm_info_sz;
424	extern int shmctl_ipc_stat;	422	extern int shmctl_ipc_stat;
425	extern int shmctl_ipc_info;	423
426	extern int shmctl_shm_info;	424	// This simplifies generic code
427	extern int shmctl_shm_stat;	425	#define struct_shminfo_sz -1
		426	#define struct_shm_info_sz -1
		427	#define shmctl_shm_stat -1
		428	#define shmctl_ipc_info -1
		429	#define shmctl_shm_info -1
428		430
429	extern unsigned struct_utmpx_sz;	431	extern unsigned struct_utmpx_sz;
430		432

lib/libtsan/sanitizer_common/sanitizer_platform_limits_posix.cpp+36-17

 @@ -24,7 +24,7 @@
 // Must go after undef _FILE_OFFSET_BITS.
 #include "sanitizer_platform.h"
-#if SANITIZER_LINUX || SANITIZER_APPLE
+#if SANITIZER_LINUX || SANITIZER_APPLE || SANITIZER_HAIKU
 // Must go after undef _FILE_OFFSET_BITS.
 #include "sanitizer_glibc_version.h"
 @@ -52,7 +52,7 @@
 #include <time.h>
 #include <wchar.h>
 #include <regex.h>
-#if !SANITIZER_APPLE
+#if !SANITIZER_APPLE && !SANITIZER_HAIKU
 #include <utmp.h>
 #endif
 @@ -61,7 +61,9 @@
 #endif
 #if !SANITIZER_ANDROID
+#if !SANITIZER_HAIKU
 #include <sys/mount.h>
+#endif
 #include <sys/timeb.h>
 #include <utmpx.h>
 #endif
 @@ -111,9 +113,11 @@ typedef struct user_fpregs elf_fpregset_t;
 #if !SANITIZER_ANDROID
 #include <ifaddrs.h>
+#if !SANITIZER_HAIKU
 #include <sys/ucontext.h>
 #include <wordexp.h>
 #endif
+#endif
 #if SANITIZER_LINUX
 #if SANITIZER_GLIBC
 @@ -163,7 +167,7 @@ typedef struct user_fpregs elf_fpregset_t;
 #include <sys/vfs.h>
 #include <sys/epoll.h>
 #include <linux/capability.h>
-#else
+#elif !SANITIZER_HAIKU
 #include <fstab.h>
 #endif // SANITIZER_LINUX
 @@ -173,6 +177,11 @@ typedef struct user_fpregs elf_fpregset_t;
 #include <sys/sockio.h>
 #endif
+#if SANITIZER_HAIKU
+#include <sys/sockio.h>
+#include <sys/ioctl.h>
+#endif
 // Include these after system headers to avoid name clashes and ambiguities.
 #  include "sanitizer_common.h"
 #  include "sanitizer_internal_defs.h"
 @@ -217,7 +226,7 @@ namespace __sanitizer {
   unsigned struct_fstab_sz = sizeof(struct fstab);
 #endif  // SANITIZER_GLIBC || SANITIZER_FREEBSD || SANITIZER_NETBSD ||
         // SANITIZER_APPLE
-#if !SANITIZER_ANDROID
+#if !SANITIZER_ANDROID && !SANITIZER_HAIKU
   unsigned struct_statfs_sz = sizeof(struct statfs);
   unsigned struct_sockaddr_sz = sizeof(struct sockaddr);
 @@ -324,7 +333,7 @@ namespace __sanitizer {
   int shmctl_shm_stat = (int)SHM_STAT;
 #endif
-#if !SANITIZER_APPLE && !SANITIZER_FREEBSD
+#if !SANITIZER_APPLE && !SANITIZER_FREEBSD && !SANITIZER_HAIKU
   unsigned struct_utmp_sz = sizeof(struct utmp);
 #endif
 #if !SANITIZER_ANDROID
 @@ -356,9 +365,9 @@ unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr);
   int glob_altdirfunc = GLOB_ALTDIRFUNC;
 #endif
-#  if !SANITIZER_ANDROID
+#  if !SANITIZER_ANDROID && !SANITIZER_HAIKU
   const int wordexp_wrde_dooffs = WRDE_DOOFFS;
-#  endif  // !SANITIZER_ANDROID
+#  endif  // !SANITIZER_ANDROID && !SANITIZER_HAIKU
 #  if SANITIZER_LINUX && !SANITIZER_ANDROID &&                               \
       (defined(__i386) || defined(__x86_64) || defined(__mips64) ||          \
 @@ -537,7 +546,7 @@ unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr);
   unsigned struct_sock_fprog_sz = sizeof(struct sock_fprog);
 #  endif  // SANITIZER_GLIBC
-#  if !SANITIZER_ANDROID && !SANITIZER_APPLE
+#  if !SANITIZER_ANDROID && !SANITIZER_APPLE && !SANITIZER_HAIKU
   unsigned struct_sioc_sg_req_sz = sizeof(struct sioc_sg_req);
   unsigned struct_sioc_vif_req_sz = sizeof(struct sioc_vif_req);
 #endif
 @@ -548,12 +557,14 @@ unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr);
   const unsigned IOCTL_NOT_PRESENT = 0;
+  unsigned IOCTL_FIONBIO = FIONBIO;
+#if !SANITIZER_HAIKU
   unsigned IOCTL_FIOASYNC = FIOASYNC;
   unsigned IOCTL_FIOCLEX = FIOCLEX;
   unsigned IOCTL_FIOGETOWN = FIOGETOWN;
-  unsigned IOCTL_FIONBIO = FIONBIO;
   unsigned IOCTL_FIONCLEX = FIONCLEX;
   unsigned IOCTL_FIOSETOWN = FIOSETOWN;
+#endif
   unsigned IOCTL_SIOCADDMULTI = SIOCADDMULTI;
   unsigned IOCTL_SIOCATMARK = SIOCATMARK;
   unsigned IOCTL_SIOCDELMULTI = SIOCDELMULTI;
 @@ -574,23 +585,27 @@ unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr);
   unsigned IOCTL_SIOCSIFMTU = SIOCSIFMTU;
   unsigned IOCTL_SIOCSIFNETMASK = SIOCSIFNETMASK;
   unsigned IOCTL_SIOCSPGRP = SIOCSPGRP;
+#if !SANITIZER_HAIKU
   unsigned IOCTL_TIOCCONS = TIOCCONS;
-  unsigned IOCTL_TIOCEXCL = TIOCEXCL;
   unsigned IOCTL_TIOCGETD = TIOCGETD;
+  unsigned IOCTL_TIOCNOTTY = TIOCNOTTY;
+  unsigned IOCTL_TIOCPKT = TIOCPKT;
+  unsigned IOCTL_TIOCSETD = TIOCSETD;
+  unsigned IOCTL_TIOCSTI = TIOCSTI;
+#endif
+  unsigned IOCTL_TIOCEXCL = TIOCEXCL;
   unsigned IOCTL_TIOCGPGRP = TIOCGPGRP;
   unsigned IOCTL_TIOCGWINSZ = TIOCGWINSZ;
   unsigned IOCTL_TIOCMBIC = TIOCMBIC;
   unsigned IOCTL_TIOCMBIS = TIOCMBIS;
   unsigned IOCTL_TIOCMGET = TIOCMGET;
   unsigned IOCTL_TIOCMSET = TIOCMSET;
-  unsigned IOCTL_TIOCNOTTY = TIOCNOTTY;
   unsigned IOCTL_TIOCNXCL = TIOCNXCL;
   unsigned IOCTL_TIOCOUTQ = TIOCOUTQ;
-  unsigned IOCTL_TIOCPKT = TIOCPKT;
   unsigned IOCTL_TIOCSCTTY = TIOCSCTTY;
-  unsigned IOCTL_TIOCSETD = TIOCSETD;
   unsigned IOCTL_TIOCSPGRP = TIOCSPGRP;
-  unsigned IOCTL_TIOCSTI = TIOCSTI;
   unsigned IOCTL_TIOCSWINSZ = TIOCSWINSZ;
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
   unsigned IOCTL_SIOCGETSGCNT = SIOCGETSGCNT;
 @@ -1100,7 +1115,7 @@ COMPILER_CHECK(sizeof(__sanitizer_dirent) <= sizeof(dirent));
 CHECK_SIZE_AND_OFFSET(dirent, d_ino);
 #if SANITIZER_APPLE
 CHECK_SIZE_AND_OFFSET(dirent, d_seekoff);
-#elif SANITIZER_FREEBSD
+#elif SANITIZER_FREEBSD || SANITIZER_HAIKU
 // There is no 'd_off' field on FreeBSD.
 #else
 CHECK_SIZE_AND_OFFSET(dirent, d_off);
 @@ -1116,7 +1131,9 @@ CHECK_SIZE_AND_OFFSET(dirent64, d_reclen);
 CHECK_TYPE_SIZE(ifconf);
 CHECK_SIZE_AND_OFFSET(ifconf, ifc_len);
+#if !SANITIZER_HAIKU
 CHECK_SIZE_AND_OFFSET(ifconf, ifc_ifcu);
+#endif
 CHECK_TYPE_SIZE(pollfd);
 CHECK_SIZE_AND_OFFSET(pollfd, fd);
 @@ -1171,7 +1188,7 @@ CHECK_TYPE_SIZE(__kernel_loff_t);
 CHECK_TYPE_SIZE(__kernel_fd_set);
 #endif
-#if !SANITIZER_ANDROID
+#if !SANITIZER_ANDROID && !SANITIZER_HAIKU
 CHECK_TYPE_SIZE(wordexp_t);
 CHECK_SIZE_AND_OFFSET(wordexp_t, we_wordc);
 CHECK_SIZE_AND_OFFSET(wordexp_t, we_wordv);
 @@ -1201,7 +1218,9 @@ CHECK_SIZE_AND_OFFSET(mntent, mnt_freq);
 CHECK_SIZE_AND_OFFSET(mntent, mnt_passno);
 #endif
+#if !SANITIZER_HAIKU
 CHECK_TYPE_SIZE(ether_addr);
+#endif
 #if SANITIZER_GLIBC || SANITIZER_FREEBSD
 CHECK_TYPE_SIZE(ipc_perm);
 @@ -1239,7 +1258,7 @@ CHECK_TYPE_SIZE(clock_t);
 CHECK_TYPE_SIZE(clockid_t);
 #endif
-#if !SANITIZER_ANDROID
+#if !SANITIZER_ANDROID && !SANITIZER_HAIKU
 CHECK_TYPE_SIZE(ifaddrs);
 CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_next);
 CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_name);

lib/libtsan/sanitizer_common/sanitizer_platform_limits_posix.h+320-288

 @@ -14,39 +14,39 @@
 #ifndef SANITIZER_PLATFORM_LIMITS_POSIX_H
 #define SANITIZER_PLATFORM_LIMITS_POSIX_H
-#if SANITIZER_LINUX || SANITIZER_APPLE
+#if SANITIZER_LINUX || SANITIZER_APPLE || SANITIZER_HAIKU
-#include "sanitizer_internal_defs.h"
+#  include "sanitizer_internal_defs.h"
-#include "sanitizer_platform.h"
+#  include "sanitizer_mallinfo.h"
-#include "sanitizer_mallinfo.h"
+#  include "sanitizer_platform.h"
-#if SANITIZER_APPLE
+#  if SANITIZER_APPLE
-#include <sys/cdefs.h>
+#    include <sys/cdefs.h>
-#if !__DARWIN_ONLY_64_BIT_INO_T
+#    if !__DARWIN_ONLY_64_BIT_INO_T
-#define SANITIZER_HAS_STAT64 1
+#      define SANITIZER_HAS_STAT64 1
-#define SANITIZER_HAS_STATFS64 1
+#      define SANITIZER_HAS_STATFS64 1
-#else
+#    else
-#define SANITIZER_HAS_STAT64 0
+#      define SANITIZER_HAS_STAT64 0
-#define SANITIZER_HAS_STATFS64 0
+#      define SANITIZER_HAS_STATFS64 0
-#endif
+#    endif
-#elif SANITIZER_GLIBC || SANITIZER_ANDROID
+#  elif SANITIZER_GLIBC || SANITIZER_ANDROID
-#define SANITIZER_HAS_STAT64 1
+#    define SANITIZER_HAS_STAT64 1
-#define SANITIZER_HAS_STATFS64 1
+#    define SANITIZER_HAS_STATFS64 1
-#endif
+#  endif
-#if defined(__sparc__)
+#  if defined(__sparc__)
 // FIXME: This can't be included from tsan which does not support sparc yet.
-#include "sanitizer_glibc_version.h"
+#    include "sanitizer_glibc_version.h"
-#endif
+#  endif
-# define GET_LINK_MAP_BY_DLOPEN_HANDLE(handle) ((link_map*)(handle))
+#  define GET_LINK_MAP_BY_DLOPEN_HANDLE(handle) ((link_map *)(handle))
 namespace __sanitizer {
 extern unsigned struct_utsname_sz;
 extern unsigned struct_stat_sz;
-#if SANITIZER_HAS_STAT64
+#  if SANITIZER_HAS_STAT64
 extern unsigned struct_stat64_sz;
-#endif
+#  endif
 extern unsigned struct_rusage_sz;
 extern unsigned siginfo_t_sz;
 extern unsigned struct_itimerval_sz;
 @@ -64,13 +64,13 @@ extern unsigned struct_itimerspec_sz;
 extern unsigned struct_sigevent_sz;
 extern unsigned struct_stack_t_sz;
 extern unsigned struct_sched_param_sz;
-#if SANITIZER_HAS_STATFS64
+#  if SANITIZER_HAS_STATFS64
 extern unsigned struct_statfs64_sz;
-#endif
+#  endif
 extern unsigned struct_regex_sz;
 extern unsigned struct_regmatch_sz;
-#if !SANITIZER_ANDROID
+#  if !SANITIZER_ANDROID
 extern unsigned struct_fstab_sz;
 extern unsigned struct_statfs_sz;
 extern unsigned struct_sockaddr_sz;
 @@ -82,22 +82,22 @@ unsigned ucontext_t_sz(void *uctx);
 #    if defined(__x86_64__)
 const unsigned struct_kernel_stat_sz = 144;
 const unsigned struct_kernel_stat64_sz = 0;
-#elif defined(__i386__)
+#    elif defined(__i386__)
 const unsigned struct_kernel_stat_sz = 64;
 const unsigned struct_kernel_stat64_sz = 96;
-#elif defined(__arm__)
+#    elif defined(__arm__)
 const unsigned struct_kernel_stat_sz = 64;
 const unsigned struct_kernel_stat64_sz = 104;
-#elif defined(__aarch64__)
+#    elif defined(__aarch64__)
 const unsigned struct_kernel_stat_sz = 128;
 const unsigned struct_kernel_stat64_sz = 104;
-#elif defined(__powerpc__) && !defined(__powerpc64__)
+#    elif defined(__powerpc__) && !defined(__powerpc64__)
 const unsigned struct_kernel_stat_sz = 72;
 const unsigned struct_kernel_stat64_sz = 104;
-#elif defined(__powerpc64__)
+#    elif defined(__powerpc64__)
 const unsigned struct_kernel_stat_sz = 144;
 const unsigned struct_kernel_stat64_sz = 104;
-#elif defined(__mips__)
+#    elif defined(__mips__)
 const unsigned struct_kernel_stat_sz = SANITIZER_ANDROID
                                            ? FIRST_32_SECOND_64(104, 128)
 #      if defined(_ABIN32) && _MIPS_SIM == _ABIN32
 @@ -106,21 +106,21 @@ const unsigned struct_kernel_stat_sz = SANITIZER_ANDROID
                                            : FIRST_32_SECOND_64(160, 216);
 #      endif
 const unsigned struct_kernel_stat64_sz = 104;
-#elif defined(__s390__) && !defined(__s390x__)
+#    elif defined(__s390__) && !defined(__s390x__)
 const unsigned struct_kernel_stat_sz = 64;
 const unsigned struct_kernel_stat64_sz = 104;
-#elif defined(__s390x__)
+#    elif defined(__s390x__)
 const unsigned struct_kernel_stat_sz = 144;
 const unsigned struct_kernel_stat64_sz = 0;
-#elif defined(__sparc__) && defined(__arch64__)
+#    elif defined(__sparc__) && defined(__arch64__)
 const unsigned struct___old_kernel_stat_sz = 0;
 const unsigned struct_kernel_stat_sz = 104;
 const unsigned struct_kernel_stat64_sz = 144;
-#elif defined(__sparc__) && !defined(__arch64__)
+#    elif defined(__sparc__) && !defined(__arch64__)
 const unsigned struct___old_kernel_stat_sz = 0;
 const unsigned struct_kernel_stat_sz = 64;
 const unsigned struct_kernel_stat64_sz = 104;
-#elif SANITIZER_RISCV64
+#    elif SANITIZER_RISCV64
 const unsigned struct_kernel_stat_sz = 128;
 const unsigned struct_kernel_stat64_sz = 0;  // RISCV64 does not use stat64
 #    elif defined(__hexagon__)
 @@ -145,15 +145,15 @@ extern unsigned struct_old_utsname_sz;
 extern unsigned struct_oldold_utsname_sz;
 const unsigned struct_kexec_segment_sz = 4 * sizeof(unsigned long);
-#endif  // SANITIZER_LINUX
+#  endif  // SANITIZER_LINUX
-#if SANITIZER_LINUX
+#  if SANITIZER_LINUX
-#if defined(__powerpc64__) || defined(__s390__) || defined(__loongarch__)
+#    if defined(__powerpc64__) || defined(__s390__) || defined(__loongarch__)
 const unsigned struct___old_kernel_stat_sz = 0;
-#elif !defined(__sparc__)
+#    elif !defined(__sparc__)
 const unsigned struct___old_kernel_stat_sz = 32;
-#endif
+#    endif
 extern unsigned struct_rlimit_sz;
 extern unsigned struct_utimbuf_sz;
 @@ -198,17 +198,17 @@ struct __sanitizer___sysctl_args {
 const unsigned old_sigset_t_sz = sizeof(unsigned long);
 struct __sanitizer_sem_t {
-#if SANITIZER_ANDROID && defined(_LP64)
+#    if SANITIZER_ANDROID && defined(_LP64)
   int data[4];
-#elif SANITIZER_ANDROID && !defined(_LP64)
+#    elif SANITIZER_ANDROID && !defined(_LP64)
   int data;
-#elif SANITIZER_LINUX
+#    elif SANITIZER_LINUX
   uptr data[4];
-#endif
+#    endif
 };
-#endif // SANITIZER_LINUX
+#  endif  // SANITIZER_LINUX
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
+#  if SANITIZER_LINUX && !SANITIZER_ANDROID
 extern unsigned struct_ustat_sz;
 extern unsigned struct_rlimit64_sz;
 extern unsigned struct_statvfs64_sz;
 @@ -219,45 +219,45 @@ struct __sanitizer_ipc_perm {
   int gid;
   int cuid;
   int cgid;
-#ifdef __powerpc__
+#    ifdef __powerpc__
   unsigned mode;
   unsigned __seq;
   u64 __unused1;
   u64 __unused2;
-#elif defined(__sparc__)
+#    elif defined(__sparc__)
   unsigned mode;
   unsigned short __pad2;
   unsigned short __seq;
   unsigned long long __unused1;
   unsigned long long __unused2;
-#else
+#    else
   unsigned int mode;
   unsigned short __seq;
   unsigned short __pad2;
-#if defined(__x86_64__) && !defined(_LP64)
+#      if defined(__x86_64__) && !defined(_LP64)
   u64 __unused1;
   u64 __unused2;
-#else
+#      else
   unsigned long __unused1;
   unsigned long __unused2;
-#endif
+#      endif
-#endif
+#    endif
 };
 struct __sanitizer_shmid_ds {
   __sanitizer_ipc_perm shm_perm;
-#if defined(__sparc__)
+#    if defined(__sparc__)
-#if !defined(__arch64__)
+#      if !defined(__arch64__)
   u32 __pad1;
-#endif
+#      endif
   long shm_atime;
-#if !defined(__arch64__)
+#      if !defined(__arch64__)
   u32 __pad2;
-#endif
+#      endif
   long shm_dtime;
-#if !defined(__arch64__)
+#      if !defined(__arch64__)
   u32 __pad3;
-#endif
+#      endif
   long shm_ctime;
   uptr shm_segsz;
   int shm_cpid;
 @@ -265,61 +265,61 @@ struct __sanitizer_shmid_ds {
   unsigned long shm_nattch;
   unsigned long __glibc_reserved1;
   unsigned long __glibc_reserved2;
-#else
+#    else
-#ifndef __powerpc__
+#      ifndef __powerpc__
   uptr shm_segsz;
-#elif !defined(__powerpc64__)
+#      elif !defined(__powerpc64__)
   uptr __unused0;
-#endif
+#      endif
-#if defined(__x86_64__) && !defined(_LP64)
+#      if defined(__x86_64__) && !defined(_LP64)
   u64 shm_atime;
   u64 shm_dtime;
   u64 shm_ctime;
-#else
+#      else
   uptr shm_atime;
-#if !defined(_LP64) && !defined(__mips__)
+#        if !defined(_LP64) && !defined(__mips__)
   uptr __unused1;
-#endif
+#        endif
   uptr shm_dtime;
-#if !defined(_LP64) && !defined(__mips__)
+#        if !defined(_LP64) && !defined(__mips__)
   uptr __unused2;
-#endif
+#        endif
   uptr shm_ctime;
-#if !defined(_LP64) && !defined(__mips__)
+#        if !defined(_LP64) && !defined(__mips__)
   uptr __unused3;
-#endif
+#        endif
-#endif
+#      endif
-#ifdef __powerpc__
+#      ifdef __powerpc__
   uptr shm_segsz;
-#endif
+#      endif
   int shm_cpid;
   int shm_lpid;
-#if defined(__x86_64__) && !defined(_LP64)
+#      if defined(__x86_64__) && !defined(_LP64)
   u64 shm_nattch;
   u64 __unused4;
   u64 __unused5;
-#else
+#      else
   uptr shm_nattch;
   uptr __unused4;
   uptr __unused5;
-#endif
+#      endif
-#endif
+#    endif
 };
-#endif
+#  endif
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
+#  if SANITIZER_LINUX && !SANITIZER_ANDROID
 extern unsigned struct_msqid_ds_sz;
 extern unsigned struct_mq_attr_sz;
 extern unsigned struct_timex_sz;
 extern unsigned struct_statvfs_sz;
-#endif  // SANITIZER_LINUX && !SANITIZER_ANDROID
+#  endif  // SANITIZER_LINUX && !SANITIZER_ANDROID
 struct __sanitizer_iovec {
   void *iov_base;
   usize iov_len;
 };
-#if !SANITIZER_ANDROID
+#  if !SANITIZER_ANDROID
 struct __sanitizer_ifaddrs {
   struct __sanitizer_ifaddrs *ifa_next;
   char *ifa_name;
 @@ -327,21 +327,21 @@ struct __sanitizer_ifaddrs {
   void *ifa_addr;     // (struct sockaddr *)
   void *ifa_netmask;  // (struct sockaddr *)
   // This is a union on Linux.
-# ifdef ifa_dstaddr
+#    ifdef ifa_dstaddr
-# undef ifa_dstaddr
+#      undef ifa_dstaddr
-# endif
+#    endif
   void *ifa_dstaddr;  // (struct sockaddr *)
   void *ifa_data;
 };
-#endif  // !SANITIZER_ANDROID
+#  endif  // !SANITIZER_ANDROID
-#if SANITIZER_APPLE
+#  if SANITIZER_APPLE
 typedef unsigned long __sanitizer_pthread_key_t;
-#else
+#  else
 typedef unsigned __sanitizer_pthread_key_t;
-#endif
+#  endif
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
+#  if SANITIZER_LINUX && !SANITIZER_ANDROID
 struct __sanitizer_XDR {
   int x_op;
 @@ -355,25 +355,28 @@ struct __sanitizer_XDR {
 const int __sanitizer_XDR_ENCODE = 0;
 const int __sanitizer_XDR_DECODE = 1;
 const int __sanitizer_XDR_FREE = 2;
-#endif
+#  endif
 struct __sanitizer_passwd {
   char *pw_name;
   char *pw_passwd;
   int pw_uid;
   int pw_gid;
-#if SANITIZER_APPLE
+#  if SANITIZER_APPLE
   long pw_change;
   char *pw_class;
-#endif
+#  endif
-#if !(SANITIZER_ANDROID && (SANITIZER_WORDSIZE == 32))
+#  if !(SANITIZER_ANDROID && (SANITIZER_WORDSIZE == 32)) && !SANITIZER_HAIKU
   char *pw_gecos;
-#endif
+#  endif
   char *pw_dir;
   char *pw_shell;
-#if SANITIZER_APPLE
+#  if SANITIZER_APPLE
   long pw_expire;
-#endif
+#  endif
+#  if SANITIZER_HAIKU
+  char *pw_gecos;
+#  endif
 };
 struct __sanitizer_group {
 @@ -386,9 +389,9 @@ struct __sanitizer_group {
 #  if (SANITIZER_LINUX && !SANITIZER_GLIBC && !SANITIZER_ANDROID) || \
       (defined(__x86_64__) && !defined(_LP64)) || defined(__hexagon__)
 typedef long long __sanitizer_time_t;
-#else
+#  else
 typedef long __sanitizer_time_t;
-#endif
+#  endif
 typedef long __sanitizer_suseconds_t;
 @@ -433,11 +436,15 @@ struct __sanitizer_tm {
   int tm_wday;
   int tm_yday;
   int tm_isdst;
+#  if SANITIZER_HAIKU
+  int tm_gmtoff;
+#  else
   long int tm_gmtoff;
+#  endif
   const char *tm_zone;
 };
-#if SANITIZER_LINUX
+#  if SANITIZER_LINUX
 struct __sanitizer_mntent {
   char *mnt_fsname;
   char *mnt_dir;
 @@ -452,9 +459,9 @@ struct __sanitizer_file_handle {
   int handle_type;
   unsigned char f_handle[1];  // variable sized
 };
-#endif
+#  endif
-#if SANITIZER_APPLE
+#  if SANITIZER_APPLE || SANITIZER_HAIKU
 struct __sanitizer_msghdr {
   void *msg_name;
   unsigned msg_namelen;
 @@ -469,7 +476,7 @@ struct __sanitizer_cmsghdr {
   int cmsg_level;
   int cmsg_type;
 };
-#else
+#  else
 // In POSIX, int msg_iovlen; socklen_t msg_controllen; socklen_t cmsg_len; but
 // many implementations don't conform to the standard.
 struct __sanitizer_msghdr {
 @@ -486,22 +493,31 @@ struct __sanitizer_cmsghdr {
   int cmsg_level;
   int cmsg_type;
 };
-#endif
+#  endif
-#if SANITIZER_LINUX
+#  if SANITIZER_LINUX
 struct __sanitizer_mmsghdr {
   __sanitizer_msghdr msg_hdr;
   unsigned int msg_len;
 };
-#endif
+#  endif
-#if SANITIZER_APPLE
+#  if SANITIZER_APPLE
 struct __sanitizer_dirent {
   unsigned long long d_ino;
   unsigned long long d_seekoff;
   unsigned short d_reclen;
   // more fields that we don't care about
 };
+#  elif SANITIZER_HAIKU
+struct __sanitizer_dirent {
+  int d_dev;
+  int d_pdev;
+  unsigned long long d_ino;
+  unsigned long long d_pino;
+  unsigned short d_reclen;
+  // more fields that we don't care about
+};
 #  elif (SANITIZER_LINUX && !SANITIZER_GLIBC) || defined(__x86_64__) || \
       defined(__hexagon__)
 struct __sanitizer_dirent {
 @@ -527,47 +543,49 @@ struct __sanitizer_dirent64 {
   // more fields that we don't care about
 };
 extern unsigned struct_sock_fprog_sz;
-#endif
+#  endif
-#if defined(__x86_64__) && !defined(_LP64)
+#  if SANITIZER_HAIKU
+typedef int __sanitizer_clock_t;
+#  elif defined(__x86_64__) && !defined(_LP64)
 typedef long long __sanitizer_clock_t;
-#else
+#  else
 typedef long __sanitizer_clock_t;
-#endif
+#  endif
-#if SANITIZER_LINUX
+#  if SANITIZER_LINUX || SANITIZER_HAIKU
 typedef int __sanitizer_clockid_t;
 typedef unsigned long long __sanitizer_eventfd_t;
-#endif
+#  endif
-#if SANITIZER_LINUX
+#  if SANITIZER_LINUX
 #    if defined(_LP64) || defined(__x86_64__) || defined(__powerpc__) || \
         defined(__mips__) || defined(__hexagon__)
 typedef unsigned __sanitizer___kernel_uid_t;
 typedef unsigned __sanitizer___kernel_gid_t;
-#else
+#    else
 typedef unsigned short __sanitizer___kernel_uid_t;
 typedef unsigned short __sanitizer___kernel_gid_t;
-#endif
+#    endif
-#if defined(__x86_64__) && !defined(_LP64)
+#    if defined(__x86_64__) && !defined(_LP64)
 typedef long long __sanitizer___kernel_off_t;
-#else
+#    else
 typedef long __sanitizer___kernel_off_t;
-#endif
+#    endif
-#if defined(__powerpc__) || defined(__mips__)
+#    if defined(__powerpc__) || defined(__mips__)
 typedef unsigned int __sanitizer___kernel_old_uid_t;
 typedef unsigned int __sanitizer___kernel_old_gid_t;
-#else
+#    else
 typedef unsigned short __sanitizer___kernel_old_uid_t;
 typedef unsigned short __sanitizer___kernel_old_gid_t;
-#endif
+#    endif
 typedef long long __sanitizer___kernel_loff_t;
 typedef struct {
   unsigned long fds_bits[1024 / (8 * sizeof(long))];
 } __sanitizer___kernel_fd_set;
-#endif
+#  endif
 // This thing depends on the platform. We are only interested in the upper
 // limit. Verified with a compiler assert in .cpp.
 @@ -576,50 +594,52 @@ union __sanitizer_pthread_attr_t {
   void *align;
 };
-#if SANITIZER_ANDROID
+#  if SANITIZER_ANDROID
-# if SANITIZER_MIPS
+#    if SANITIZER_MIPS
 typedef unsigned long __sanitizer_sigset_t[16 / sizeof(unsigned long)];
-# else
+#    else
 typedef unsigned long __sanitizer_sigset_t;
-# endif
+#    endif
-#elif SANITIZER_APPLE
+#  elif SANITIZER_APPLE
 typedef unsigned __sanitizer_sigset_t;
-#elif SANITIZER_LINUX
+#  elif SANITIZER_HAIKU
+typedef unsigned long __sanitizer_sigset_t;
+#  elif SANITIZER_LINUX
 struct __sanitizer_sigset_t {
   // The size is determined by looking at sizeof of real sigset_t on linux.
   uptr val[128 / sizeof(uptr)];
 };
-#endif
+#  endif
 struct __sanitizer_siginfo_pad {
-#if SANITIZER_X32
+#  if SANITIZER_X32
   // x32 siginfo_t is aligned to 8 bytes.
   u64 pad[128 / sizeof(u64)];
-#else
+#  else
   // Require uptr, because siginfo_t is always pointer-size aligned on Linux.
   uptr pad[128 / sizeof(uptr)];
-#endif
+#  endif
 };
-#if SANITIZER_LINUX
+#  if SANITIZER_LINUX
-# define SANITIZER_HAS_SIGINFO 1
+#    define SANITIZER_HAS_SIGINFO 1
 union __sanitizer_siginfo {
   __extension__ struct {
     int si_signo;
-# if SANITIZER_MIPS
+#    if SANITIZER_MIPS
     int si_code;
     int si_errno;
-# else
+#    else
     int si_errno;
     int si_code;
-# endif
+#    endif
   };
   __sanitizer_siginfo_pad pad;
 };
-#else
+#  else
-# define SANITIZER_HAS_SIGINFO 0
+#    define SANITIZER_HAS_SIGINFO 0
 typedef __sanitizer_siginfo_pad __sanitizer_siginfo;
-#endif
+#  endif
 using __sanitizer_sighandler_ptr = void (*)(int sig);
 using __sanitizer_sigactionhandler_ptr = void (*)(int sig,
 @@ -627,7 +647,7 @@ using __sanitizer_sigactionhandler_ptr = void (*)(int sig,
                                                   void *uctx);
 // Linux system headers define the 'sa_handler' and 'sa_sigaction' macros.
-#if SANITIZER_ANDROID && (SANITIZER_WORDSIZE == 64)
+#  if SANITIZER_ANDROID && (SANITIZER_WORDSIZE == 64)
 struct __sanitizer_sigaction {
   unsigned sa_flags;
   union {
 @@ -637,7 +657,8 @@ struct __sanitizer_sigaction {
   __sanitizer_sigset_t sa_mask;
   void (*sa_restorer)();
 };
-#elif SANITIZER_ANDROID && SANITIZER_MIPS32  // check this before WORDSIZE == 32
+#  elif SANITIZER_ANDROID && \
+      SANITIZER_MIPS32  // check this before WORDSIZE == 32
 struct __sanitizer_sigaction {
   unsigned sa_flags;
   union {
 @@ -646,7 +667,7 @@ struct __sanitizer_sigaction {
   };
   __sanitizer_sigset_t sa_mask;
 };
-#elif SANITIZER_ANDROID && (SANITIZER_WORDSIZE == 32)
+#  elif SANITIZER_ANDROID && (SANITIZER_WORDSIZE == 32)
 struct __sanitizer_sigaction {
   union {
     __sanitizer_sigactionhandler_ptr sigaction;
 @@ -656,66 +677,66 @@ struct __sanitizer_sigaction {
   uptr sa_flags;
   void (*sa_restorer)();
 };
-#else // !SANITIZER_ANDROID
+#  else  // !SANITIZER_ANDROID
 struct __sanitizer_sigaction {
-#if defined(__mips__) && !SANITIZER_FREEBSD
+#    if defined(__mips__) && !SANITIZER_FREEBSD && !SANITIZER_MUSL
   unsigned int sa_flags;
-#endif
+#    endif
   union {
     __sanitizer_sigactionhandler_ptr sigaction;
     __sanitizer_sighandler_ptr handler;
   };
-#if SANITIZER_FREEBSD
+#    if SANITIZER_FREEBSD
   int sa_flags;
   __sanitizer_sigset_t sa_mask;
-#else
+#    else
-#if defined(__s390x__)
+#      if defined(__s390x__)
   int sa_resv;
-#else
+#      else
   __sanitizer_sigset_t sa_mask;
-#endif
+#      endif
-#ifndef __mips__
+#      if !defined(__mips__) || SANITIZER_MUSL
-#if defined(__sparc__)
+#        if defined(__sparc__)
-#if __GLIBC_PREREQ (2, 20)
+#          if __GLIBC_PREREQ(2, 20)
   // On sparc glibc 2.19 and earlier sa_flags was unsigned long.
-#if defined(__arch64__)
+#            if defined(__arch64__)
   // To maintain ABI compatibility on sparc64 when switching to an int,
   // __glibc_reserved0 was added.
   int __glibc_reserved0;
-#endif
+#            endif
   int sa_flags;
-#else
+#          else
   unsigned long sa_flags;
-#endif
+#          endif
-#else
+#        else
   int sa_flags;
-#endif
+#        endif
-#endif
+#      endif
-#endif
+#    endif
-#if SANITIZER_LINUX
+#    if SANITIZER_LINUX || SANITIZER_HAIKU
   void (*sa_restorer)();
-#endif
+#    endif
-#if defined(__mips__) && (SANITIZER_WORDSIZE == 32)
+#    if defined(__mips__) && (SANITIZER_WORDSIZE == 32) && !SANITIZER_MUSL
   int sa_resv[1];
-#endif
+#    endif
-#if defined(__s390x__)
+#    if defined(__s390x__)
   __sanitizer_sigset_t sa_mask;
-#endif
+#    endif
 };
-#endif // !SANITIZER_ANDROID
+#  endif  // !SANITIZER_ANDROID
-#if defined(__mips__)
+#  if defined(__mips__)
-#define __SANITIZER_KERNEL_NSIG 128
+#    define __SANITIZER_KERNEL_NSIG 128
-#else
+#  else
-#define __SANITIZER_KERNEL_NSIG 64
+#    define __SANITIZER_KERNEL_NSIG 64
-#endif
+#  endif
 struct __sanitizer_kernel_sigset_t {
   uptr sig[__SANITIZER_KERNEL_NSIG / (sizeof(uptr) * 8)];
 };
 // Linux system headers define the 'sa_handler' and 'sa_sigaction' macros.
-#if SANITIZER_MIPS
+#  if SANITIZER_MIPS
 struct __sanitizer_kernel_sigaction_t {
   unsigned int sa_flags;
   union {
 @@ -725,7 +746,7 @@ struct __sanitizer_kernel_sigaction_t {
   __sanitizer_kernel_sigset_t sa_mask;
   void (*sa_restorer)(void);
 };
-#else
+#  else
 struct __sanitizer_kernel_sigaction_t {
   union {
     void (*handler)(int signo);
 @@ -735,22 +756,22 @@ struct __sanitizer_kernel_sigaction_t {
   void (*sa_restorer)(void);
   __sanitizer_kernel_sigset_t sa_mask;
 };
-#endif
+#  endif
 extern const uptr sig_ign;
 extern const uptr sig_dfl;
 extern const uptr sig_err;
 extern const uptr sa_siginfo;
-#if SANITIZER_LINUX
+#  if SANITIZER_LINUX
 extern int e_tabsz;
-#endif
+#  endif
 extern int af_inet;
 extern int af_inet6;
 uptr __sanitizer_in_addr_sz(int af);
-#if SANITIZER_LINUX
+#  if SANITIZER_LINUX
 struct __sanitizer_dl_phdr_info {
   uptr dlpi_addr;
   const char *dlpi_name;
 @@ -759,7 +780,7 @@ struct __sanitizer_dl_phdr_info {
 };
 extern unsigned struct_ElfW_Phdr_sz;
-#endif
+#  endif
 struct __sanitizer_protoent {
   char *p_name;
 @@ -779,15 +800,15 @@ struct __sanitizer_addrinfo {
   int ai_family;
   int ai_socktype;
   int ai_protocol;
-#if SANITIZER_ANDROID || SANITIZER_APPLE
+#  if SANITIZER_ANDROID || SANITIZER_APPLE || SANITIZER_HAIKU
   unsigned ai_addrlen;
   char *ai_canonname;
   void *ai_addr;
-#else // LINUX
+#  else  // LINUX
   unsigned ai_addrlen;
   void *ai_addr;
   char *ai_canonname;
-#endif
+#  endif
   struct __sanitizer_addrinfo *ai_next;
 };
 @@ -805,14 +826,14 @@ struct __sanitizer_pollfd {
   short revents;
 };
-#if SANITIZER_ANDROID || SANITIZER_APPLE
+#  if SANITIZER_ANDROID || SANITIZER_APPLE
 typedef unsigned __sanitizer_nfds_t;
-#else
+#  else
 typedef unsigned long __sanitizer_nfds_t;
-#endif
+#  endif
-#if !SANITIZER_ANDROID
+#  if !SANITIZER_ANDROID
-# if SANITIZER_LINUX
+#    if SANITIZER_LINUX
 struct __sanitizer_glob_t {
   uptr gl_pathc;
   char **gl_pathv;
 @@ -825,13 +846,13 @@ struct __sanitizer_glob_t {
   int (*gl_lstat)(const char *, void *);
   int (*gl_stat)(const char *, void *);
 };
-# endif  // SANITIZER_LINUX
+#    endif  // SANITIZER_LINUX
-# if SANITIZER_LINUX
+#    if SANITIZER_LINUX
 extern int glob_nomatch;
 extern int glob_altdirfunc;
-# endif
+#    endif
-#endif  // !SANITIZER_ANDROID
+#  endif  // !SANITIZER_ANDROID
 extern unsigned path_max;
 @@ -845,7 +866,7 @@ struct __sanitizer_wordexp_t {
   uptr we_offs;
 };
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
+#  if SANITIZER_LINUX && !SANITIZER_ANDROID
 struct __sanitizer_FILE {
   int _flags;
   char *_IO_read_ptr;
 @@ -863,11 +884,11 @@ struct __sanitizer_FILE {
   __sanitizer_FILE *_chain;
   int _fileno;
 };
-# define SANITIZER_HAS_STRUCT_FILE 1
+#    define SANITIZER_HAS_STRUCT_FILE 1
-#else
+#  else
 typedef void __sanitizer_FILE;
-# define SANITIZER_HAS_STRUCT_FILE 0
+#    define SANITIZER_HAS_STRUCT_FILE 0
-#endif
+#  endif
 #  if SANITIZER_LINUX && !SANITIZER_ANDROID &&                               \
       (defined(__i386) || defined(__x86_64) || defined(__mips64) ||          \
 @@ -919,14 +940,14 @@ extern int shmctl_ipc_stat;
 extern int shmctl_ipc_info;
 extern int shmctl_shm_info;
 extern int shmctl_shm_stat;
-#endif
+#  endif
-#if !SANITIZER_APPLE && !SANITIZER_FREEBSD
+#  if !SANITIZER_APPLE && !SANITIZER_FREEBSD
 extern unsigned struct_utmp_sz;
-#endif
+#  endif
-#if !SANITIZER_ANDROID
+#  if !SANITIZER_ANDROID
 extern unsigned struct_utmpx_sz;
-#endif
+#  endif
 extern int map_fixed;
 @@ -936,13 +957,13 @@ struct __sanitizer_ifconf {
   union {
     void *ifcu_req;
   } ifc_ifcu;
-#if SANITIZER_APPLE
+#  if SANITIZER_APPLE
 } __attribute__((packed));
-#else
+#  else
 };
-#endif
+#  endif
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
+#  if SANITIZER_LINUX && !SANITIZER_ANDROID
 struct __sanitizer__obstack_chunk {
   char *limit;
   struct __sanitizer__obstack_chunk *prev;
 @@ -969,57 +990,57 @@ struct __sanitizer_cookie_io_functions_t {
   __sanitizer_cookie_io_seek seek;
   __sanitizer_cookie_io_close close;
 };
-#endif
+#  endif
-#define IOC_NRBITS 8
+#  define IOC_NRBITS 8
-#define IOC_TYPEBITS 8
+#  define IOC_TYPEBITS 8
-#if defined(__powerpc__) || defined(__powerpc64__) || defined(__mips__) || \
+#  if defined(__powerpc__) || defined(__powerpc64__) || defined(__mips__) || \
-    defined(__sparc__)
+      defined(__sparc__)
-#define IOC_SIZEBITS 13
+#    define IOC_SIZEBITS 13
-#define IOC_DIRBITS 3
+#    define IOC_DIRBITS 3
-#define IOC_NONE 1U
+#    define IOC_NONE 1U
-#define IOC_WRITE 4U
+#    define IOC_WRITE 4U
-#define IOC_READ 2U
+#    define IOC_READ 2U
-#else
+#  else
-#define IOC_SIZEBITS 14
+#    define IOC_SIZEBITS 14
-#define IOC_DIRBITS 2
+#    define IOC_DIRBITS 2
-#define IOC_NONE 0U
+#    define IOC_NONE 0U
-#define IOC_WRITE 1U
+#    define IOC_WRITE 1U
-#define IOC_READ 2U
+#    define IOC_READ 2U
-#endif
+#  endif
-#define IOC_NRMASK ((1 << IOC_NRBITS) - 1)
+#  define IOC_NRMASK ((1 << IOC_NRBITS) - 1)
-#define IOC_TYPEMASK ((1 << IOC_TYPEBITS) - 1)
+#  define IOC_TYPEMASK ((1 << IOC_TYPEBITS) - 1)
-#define IOC_SIZEMASK ((1 << IOC_SIZEBITS) - 1)
+#  define IOC_SIZEMASK ((1 << IOC_SIZEBITS) - 1)
-#if defined(IOC_DIRMASK)
+#  if defined(IOC_DIRMASK)
-#undef IOC_DIRMASK
+#    undef IOC_DIRMASK
-#endif
+#  endif
-#define IOC_DIRMASK ((1 << IOC_DIRBITS) - 1)
+#  define IOC_DIRMASK ((1 << IOC_DIRBITS) - 1)
-#define IOC_NRSHIFT 0
+#  define IOC_NRSHIFT 0
-#define IOC_TYPESHIFT (IOC_NRSHIFT + IOC_NRBITS)
+#  define IOC_TYPESHIFT (IOC_NRSHIFT + IOC_NRBITS)
-#define IOC_SIZESHIFT (IOC_TYPESHIFT + IOC_TYPEBITS)
+#  define IOC_SIZESHIFT (IOC_TYPESHIFT + IOC_TYPEBITS)
-#define IOC_DIRSHIFT (IOC_SIZESHIFT + IOC_SIZEBITS)
+#  define IOC_DIRSHIFT (IOC_SIZESHIFT + IOC_SIZEBITS)
-#define EVIOC_EV_MAX 0x1f
+#  define EVIOC_EV_MAX 0x1f
-#define EVIOC_ABS_MAX 0x3f
+#  define EVIOC_ABS_MAX 0x3f
-#define IOC_DIR(nr) (((nr) >> IOC_DIRSHIFT) & IOC_DIRMASK)
+#  define IOC_DIR(nr) (((nr) >> IOC_DIRSHIFT) & IOC_DIRMASK)
-#define IOC_TYPE(nr) (((nr) >> IOC_TYPESHIFT) & IOC_TYPEMASK)
+#  define IOC_TYPE(nr) (((nr) >> IOC_TYPESHIFT) & IOC_TYPEMASK)
-#define IOC_NR(nr) (((nr) >> IOC_NRSHIFT) & IOC_NRMASK)
+#  define IOC_NR(nr) (((nr) >> IOC_NRSHIFT) & IOC_NRMASK)
-#if defined(__sparc__)
+#  if defined(__sparc__)
 // In sparc the 14 bits SIZE field overlaps with the
 // least significant bit of DIR, so either IOC_READ or
 // IOC_WRITE shall be 1 in order to get a non-zero SIZE.
-#define IOC_SIZE(nr) \
+#    define IOC_SIZE(nr) \
-  ((((((nr) >> 29) & 0x7) & (4U | 2U)) == 0) ? 0 : (((nr) >> 16) & 0x3fff))
+      ((((((nr) >> 29) & 0x7) & (4U | 2U)) == 0) ? 0 : (((nr) >> 16) & 0x3fff))
-#else
+#  else
-#define IOC_SIZE(nr) (((nr) >> IOC_SIZESHIFT) & IOC_SIZEMASK)
+#    define IOC_SIZE(nr) (((nr) >> IOC_SIZESHIFT) & IOC_SIZEMASK)
-#endif
+#  endif
 extern unsigned struct_ifreq_sz;
 extern unsigned struct_termios_sz;
 extern unsigned struct_winsize_sz;
-#if SANITIZER_LINUX
+#  if SANITIZER_LINUX
 extern unsigned struct_arpreq_sz;
 extern unsigned struct_cdrom_msf_sz;
 extern unsigned struct_cdrom_multisession_sz;
 @@ -1046,9 +1067,9 @@ extern unsigned struct_mtpos_sz;
 extern unsigned struct_vt_consize_sz;
 extern unsigned struct_vt_sizes_sz;
 extern unsigned struct_vt_stat_sz;
-#endif  // SANITIZER_LINUX
+#  endif  // SANITIZER_LINUX
-#if SANITIZER_LINUX
+#  if SANITIZER_LINUX
 extern unsigned struct_copr_buffer_sz;
 extern unsigned struct_copr_debug_buf_sz;
 extern unsigned struct_copr_msg_sz;
 @@ -1060,9 +1081,9 @@ extern unsigned struct_sbi_instrument_sz;
 extern unsigned struct_seq_event_rec_sz;
 extern unsigned struct_synth_info_sz;
 extern unsigned struct_vt_mode_sz;
-#endif // SANITIZER_LINUX
+#  endif  // SANITIZER_LINUX
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
+#  if SANITIZER_LINUX && !SANITIZER_ANDROID
 extern unsigned struct_ax25_parms_struct_sz;
 extern unsigned struct_input_keymap_entry_sz;
 extern unsigned struct_ipx_config_data_sz;
 @@ -1083,15 +1104,15 @@ extern unsigned struct_unimapinit_sz;
 extern const unsigned long __sanitizer_bufsiz;
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
+#  if SANITIZER_LINUX && !SANITIZER_ANDROID
 extern unsigned struct_audio_buf_info_sz;
 extern unsigned struct_ppp_stats_sz;
-#endif  // (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+#  endif  // (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
-#if !SANITIZER_ANDROID && !SANITIZER_APPLE
+#  if !SANITIZER_ANDROID && !SANITIZER_APPLE
 extern unsigned struct_sioc_sg_req_sz;
 extern unsigned struct_sioc_vif_req_sz;
-#endif
+#  endif
 extern unsigned fpos_t_sz;
 @@ -1127,29 +1148,31 @@ extern unsigned IOCTL_SIOCSIFMETRIC;
 extern unsigned IOCTL_SIOCSIFMTU;
 extern unsigned IOCTL_SIOCSIFNETMASK;
 extern unsigned IOCTL_SIOCSPGRP;
+#  if !SANITIZER_HAIKU
 extern unsigned IOCTL_TIOCCONS;
-extern unsigned IOCTL_TIOCEXCL;
 extern unsigned IOCTL_TIOCGETD;
+extern unsigned IOCTL_TIOCNOTTY;
+extern unsigned IOCTL_TIOCPKT;
+extern unsigned IOCTL_TIOCSETD;
+extern unsigned IOCTL_TIOCSTI;
+#  endif
+extern unsigned IOCTL_TIOCEXCL;
 extern unsigned IOCTL_TIOCGPGRP;
 extern unsigned IOCTL_TIOCGWINSZ;
 extern unsigned IOCTL_TIOCMBIC;
 extern unsigned IOCTL_TIOCMBIS;
 extern unsigned IOCTL_TIOCMGET;
 extern unsigned IOCTL_TIOCMSET;
-extern unsigned IOCTL_TIOCNOTTY;
 extern unsigned IOCTL_TIOCNXCL;
 extern unsigned IOCTL_TIOCOUTQ;
-extern unsigned IOCTL_TIOCPKT;
 extern unsigned IOCTL_TIOCSCTTY;
-extern unsigned IOCTL_TIOCSETD;
 extern unsigned IOCTL_TIOCSPGRP;
-extern unsigned IOCTL_TIOCSTI;
 extern unsigned IOCTL_TIOCSWINSZ;
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
+#  if SANITIZER_LINUX && !SANITIZER_ANDROID
 extern unsigned IOCTL_SIOCGETSGCNT;
 extern unsigned IOCTL_SIOCGETVIFCNT;
-#endif
+#  endif
-#if SANITIZER_LINUX
+#  if SANITIZER_LINUX
 extern unsigned IOCTL_EVIOCGABS;
 extern unsigned IOCTL_EVIOCGBIT;
 extern unsigned IOCTL_EVIOCGEFFECTS;
 @@ -1415,9 +1438,9 @@ extern unsigned IOCTL_VT_OPENQRY;
 extern unsigned IOCTL_VT_RELDISP;
 extern unsigned IOCTL_VT_SETMODE;
 extern unsigned IOCTL_VT_WAITACTIVE;
-#endif  // SANITIZER_LINUX
+#  endif  // SANITIZER_LINUX
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
+#  if SANITIZER_LINUX && !SANITIZER_ANDROID
 extern unsigned IOCTL_EQL_EMANCIPATE;
 extern unsigned IOCTL_EQL_ENSLAVE;
 extern unsigned IOCTL_EQL_GETMASTRCFG;
 @@ -1506,35 +1529,44 @@ extern unsigned IOCTL_KDSETMODE;
 extern unsigned IOCTL_KDSKBMODE;
 extern unsigned IOCTL_KIOCSOUND;
 extern unsigned IOCTL_PIO_SCRNMAP;
-#endif
+#  endif
+#  if SANITIZER_GLIBC
+struct __sanitizer_servent {
+  char *s_name;
+  char **s_aliases;
+  int s_port;
+  char *s_proto;
+};
+#  endif
 extern const int si_SEGV_MAPERR;
 extern const int si_SEGV_ACCERR;
 }  // namespace __sanitizer
-#define CHECK_TYPE_SIZE(TYPE) \
+#  define CHECK_TYPE_SIZE(TYPE) \
-  COMPILER_CHECK(sizeof(__sanitizer_##TYPE) == sizeof(TYPE))
+    COMPILER_CHECK(sizeof(__sanitizer_##TYPE) == sizeof(TYPE))
-#define CHECK_SIZE_AND_OFFSET(CLASS, MEMBER)                      \
+#  define CHECK_SIZE_AND_OFFSET(CLASS, MEMBER)                      \
-  COMPILER_CHECK(sizeof(((__sanitizer_##CLASS *)NULL)->MEMBER) == \
+    COMPILER_CHECK(sizeof(((__sanitizer_##CLASS *)NULL)->MEMBER) == \
-                 sizeof(((CLASS *)NULL)->MEMBER));                \
+                   sizeof(((CLASS *)NULL)->MEMBER));                \
-  COMPILER_CHECK(offsetof(__sanitizer_##CLASS, MEMBER) ==         \
+    COMPILER_CHECK(offsetof(__sanitizer_##CLASS, MEMBER) ==         \
-                 offsetof(CLASS, MEMBER))
+                   offsetof(CLASS, MEMBER))
 // For sigaction, which is a function and struct at the same time,
 // and thus requires explicit "struct" in sizeof() expression.
-#define CHECK_STRUCT_SIZE_AND_OFFSET(CLASS, MEMBER)                      \
+#  define CHECK_STRUCT_SIZE_AND_OFFSET(CLASS, MEMBER)                      \
-  COMPILER_CHECK(sizeof(((struct __sanitizer_##CLASS *)NULL)->MEMBER) == \
+    COMPILER_CHECK(sizeof(((struct __sanitizer_##CLASS *)NULL)->MEMBER) == \
-                 sizeof(((struct CLASS *)NULL)->MEMBER));                \
+                   sizeof(((struct CLASS *)NULL)->MEMBER));                \
-  COMPILER_CHECK(offsetof(struct __sanitizer_##CLASS, MEMBER) ==         \
+    COMPILER_CHECK(offsetof(struct __sanitizer_##CLASS, MEMBER) ==         \
-                 offsetof(struct CLASS, MEMBER))
+                   offsetof(struct CLASS, MEMBER))
-#define SIGACTION_SYMNAME sigaction
+#  define SIGACTION_SYMNAME sigaction
 #  if SANITIZER_LINUX
 typedef void *__sanitizer_timer_t;
 #  endif
-#endif  // SANITIZER_LINUX || SANITIZER_APPLE
+#endif  // SANITIZER_LINUX || SANITIZER_APPLE || SANITIZER_HAIKU
 #endif

lib/libtsan/sanitizer_common/sanitizer_procmaps.h+1-1

...	@@ -16,7 +16,7 @@	...	@@ -16,7 +16,7 @@
16	#include "sanitizer_platform.h"	16	#include "sanitizer_platform.h"
17		17
18	#if SANITIZER_LINUX \|\| SANITIZER_FREEBSD \|\| SANITIZER_NETBSD \|\| \	18	#if SANITIZER_LINUX \|\| SANITIZER_FREEBSD \|\| SANITIZER_NETBSD \|\| \
19	SANITIZER_APPLE \|\| SANITIZER_SOLARIS \|\| \	19	SANITIZER_APPLE \|\| SANITIZER_SOLARIS \|\| SANITIZER_HAIKU \|\| \
20	SANITIZER_FUCHSIA	20	SANITIZER_FUCHSIA
21		21
22	#include "sanitizer_common.h"	22	#include "sanitizer_common.h"

lib/libtsan/sanitizer_common/sanitizer_procmaps_haiku.cpp created+94

...	@@ -0,0 +1,94 @@
1	//===-- sanitizer_procmaps_haiku.cpp --------------------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8	//
9	// Information about the process mappings
10	// (Haiku-specific parts).
11	//===----------------------------------------------------------------------===//
12
13	#include "sanitizer_platform.h"
14	#if SANITIZER_HAIKU
15	# include "sanitizer_common.h"
16	# include "sanitizer_procmaps.h"
17
18	# include <kernel/OS.h>
19
20	namespace __sanitizer {
21
22	void MemoryMappedSegment::AddAddressRanges(LoadedModule *module) {
23	// data_ should be unused on this platform
24	CHECK(!data_);
25	module->addAddressRange(start, end, IsExecutable(), IsWritable());
26	}
27
28	MemoryMappingLayout::MemoryMappingLayout(bool) { Reset(); }
29
30	void MemoryMappingLayout::Reset() { data_.cookie = 0; }
31
32	MemoryMappingLayout::~MemoryMappingLayout() {}
33
34	// static
35	void MemoryMappingLayout::CacheMemoryMappings() {}
36
37	bool MemoryMappingLayout::Next(MemoryMappedSegment *segment) {
38	area_info info;
39	if (get_next_area_info(B_CURRENT_TEAM, &data_.cookie, &info) != B_OK)
40	return false;
41
42	segment->start = (uptr)info.address;
43	segment->end = (uptr)info.address + info.size;
44	segment->offset = 0;
45	segment->protection = 0;
46	if (info.protection & B_READ_AREA)
47	segment->protection \|= kProtectionRead;
48	if (info.protection & B_WRITE_AREA)
49	segment->protection \|= kProtectionWrite;
50	if (info.protection & B_EXECUTE_AREA)
51	segment->protection \|= kProtectionExecute;
52	if (segment->filename) {
53	uptr len = Min((uptr)B_OS_NAME_LENGTH, segment->filename_size - 1);
54	internal_strncpy(segment->filename, info.name, len);
55	segment->filename[len] = 0;
56	}
57	return true;
58	}
59
60	bool MemoryMappingLayout::Error() const { return false; }
61
62	void MemoryMappingLayout::DumpListOfModules(
63	InternalMmapVectorNoCtor<LoadedModule> *modules) {
64	Reset();
65	InternalMmapVector<char> module_name(kMaxPathLength);
66	MemoryMappedSegment segment(module_name.data(), module_name.size());
67	for (uptr i = 0; Next(&segment); i++) {
68	const char *cur_name = segment.filename;
69	if (cur_name[0] == '\0')
70	continue;
71	// Don't subtract 'cur_beg' from the first entry:
72	// * If a binary is compiled w/o -pie, then the first entry in
73	// process maps is likely the binary itself (all dynamic libs
74	// are mapped higher in address space). For such a binary,
75	// instruction offset in binary coincides with the actual
76	// instruction address in virtual memory (as code section
77	// is mapped to a fixed memory range).
78	// * If a binary is compiled with -pie, all the modules are
79	// mapped high at address space (in particular, higher than
80	// shadow memory of the tool), so the module can't be the
81	// first entry.
82	uptr base_address = (i ? segment.start : 0) - segment.offset;
83	LoadedModule cur_module;
84	cur_module.set(cur_name, base_address);
85	segment.AddAddressRanges(&cur_module);
86	modules->push_back(cur_module);
87	}
88	}
89
90	void GetMemoryProfile(fill_profile_f cb, uptr *stats) {}
91
92	} // namespace __sanitizer
93
94	#endif

lib/libtsan/sanitizer_common/sanitizer_procmaps_mac.cpp+28-8

 @@ -334,9 +334,22 @@ static const load_command *NextCommand(const load_command *lc) {
   return (const load_command *)((const char *)lc + lc->cmdsize);
 }
-static void FindUUID(const load_command *first_lc, u8 *uuid_output) {
+#  ifdef MH_MAGIC_64
-  for (const load_command *lc = first_lc; lc->cmd != 0; lc = NextCommand(lc)) {
+static constexpr size_t header_size = sizeof(mach_header_64);
-    if (lc->cmd != LC_UUID) continue;
+#  else
+static constexpr size_t header_size = sizeof(mach_header);
+#  endif
+static void FindUUID(const load_command *first_lc, const mach_header *hdr,
+                     u8 *uuid_output) {
+  uint32_t curcmd = 0;
+  for (const load_command *lc = first_lc; curcmd < hdr->ncmds;
+       curcmd++, lc = NextCommand(lc)) {
+    CHECK_LT((const char *)lc,
+             (const char *)hdr + header_size + hdr->sizeofcmds);
+    if (lc->cmd != LC_UUID)
+      continue;
     const uuid_command *uuid_lc = (const uuid_command *)lc;
     const uint8_t *uuid = &uuid_lc->uuid[0];
 @@ -345,9 +358,16 @@ static void FindUUID(const load_command *first_lc, u8 *uuid_output) {
   }
 }
-static bool IsModuleInstrumented(const load_command *first_lc) {
+static bool IsModuleInstrumented(const load_command *first_lc,
-  for (const load_command *lc = first_lc; lc->cmd != 0; lc = NextCommand(lc)) {
+                                 const mach_header *hdr) {
-    if (lc->cmd != LC_LOAD_DYLIB) continue;
+  uint32_t curcmd = 0;
+  for (const load_command *lc = first_lc; curcmd < hdr->ncmds;
+       curcmd++, lc = NextCommand(lc)) {
+    CHECK_LT((const char *)lc,
+             (const char *)hdr + header_size + hdr->sizeofcmds);
+    if (lc->cmd != LC_LOAD_DYLIB)
+      continue;
     const dylib_command *dylib_lc = (const dylib_command *)lc;
     uint32_t dylib_name_offset = dylib_lc->dylib.name.offset;
 @@ -393,10 +413,10 @@ bool MemoryMappingLayout::Next(MemoryMappedSegment *segment) {
           continue;
         }
       }
-      FindUUID((const load_command *)data_.current_load_cmd_addr,
+      FindUUID((const load_command *)data_.current_load_cmd_addr, hdr,
                data_.current_uuid);
       data_.current_instrumented = IsModuleInstrumented(
-          (const load_command *)data_.current_load_cmd_addr);
+          (const load_command *)data_.current_load_cmd_addr, hdr);
     }
     while (data_.current_load_cmd_count > 0) {

lib/libtsan/sanitizer_common/sanitizer_procmaps_solaris.cpp-3

 @@ -9,9 +9,6 @@
 // Information about the process mappings (Solaris-specific parts).
 //===----------------------------------------------------------------------===//
-// Before Solaris 11.4, <procfs.h> doesn't work in a largefile environment.
-#undef _FILE_OFFSET_BITS
 // Avoid conflict between `_TIME_BITS` defined vs. `_FILE_OFFSET_BITS`
 // undefined in some Linux configurations.
 #undef _TIME_BITS

lib/libtsan/sanitizer_common/sanitizer_redefine_builtins.h+1-1

...	@@ -15,7 +15,7 @@	...	@@ -15,7 +15,7 @@
15	# define SANITIZER_REDEFINE_BUILTINS_H	15	# define SANITIZER_REDEFINE_BUILTINS_H
16		16
17	// The asm hack only works with GCC and Clang.	17	// The asm hack only works with GCC and Clang.
18	# if !defined(_WIN32)	18	# if !defined(_WIN32) && !defined(_AIX)
19		19
20	asm(R"(	20	asm(R"(
21	.set memcpy, __sanitizer_internal_memcpy	21	.set memcpy, __sanitizer_internal_memcpy

lib/libtsan/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cpp+23-24

...	@@ -38,25 +38,28 @@	...	@@ -38,25 +38,28 @@
38	# include <asm/ptrace.h>	38	# include <asm/ptrace.h>
39	#endif	39	#endif
40	#include <sys/user.h> // for user_regs_struct	40	#include <sys/user.h> // for user_regs_struct
41	#if SANITIZER_ANDROID && SANITIZER_MIPS	41	# if SANITIZER_MIPS
42	# include <asm/reg.h> // for mips SP register in sys/user.h	42	// clang-format off
43	#endif	43	# include <asm/sgidefs.h> // <asm/sgidefs.h> must be included before <asm/reg.h>
44	#include <sys/wait.h> // for signal-related stuff	44	# include <asm/reg.h> // for mips SP register
45		45	// clang-format on
46	#ifdef sa_handler	46	# endif
47	# undef sa_handler	47	# include <sys/wait.h> // for signal-related stuff
48	#endif	48
49		49	# ifdef sa_handler
50	#ifdef sa_sigaction	50	# undef sa_handler
51	# undef sa_sigaction	51	# endif
52	#endif	52
53		53	# ifdef sa_sigaction
54	#include "sanitizer_common.h"	54	# undef sa_sigaction
55	#include "sanitizer_flags.h"	55	# endif
56	#include "sanitizer_libc.h"	56
57	#include "sanitizer_linux.h"	57	# include "sanitizer_common.h"
58	#include "sanitizer_mutex.h"	58	# include "sanitizer_flags.h"
59	#include "sanitizer_placement_new.h"	59	# include "sanitizer_libc.h"
		60	# include "sanitizer_linux.h"
		61	# include "sanitizer_mutex.h"
		62	# include "sanitizer_placement_new.h"
60		63
61	// Sufficiently old kernel headers don't provide this value, but we can still	64	// Sufficiently old kernel headers don't provide this value, but we can still
62	// call prctl with it. If the runtime kernel is new enough, the prctl call will	65	// call prctl with it. If the runtime kernel is new enough, the prctl call will
...	@@ -511,11 +514,7 @@ typedef pt_regs regs_struct;	...	@@ -511,11 +514,7 @@ typedef pt_regs regs_struct;
511		514
512	#elif defined(__mips__)	515	#elif defined(__mips__)
513	typedef struct user regs_struct;	516	typedef struct user regs_struct;
514	# if SANITIZER_ANDROID	517	# define REG_SP regs[EF_R29]
515	# define REG_SP regs[EF_R29]
516	# else
517	# define REG_SP regs[EF_REG29]
518	# endif
519		518
520	#elif defined(__aarch64__)	519	#elif defined(__aarch64__)
521	typedef struct user_pt_regs regs_struct;	520	typedef struct user_pt_regs regs_struct;

lib/libtsan/sanitizer_common/sanitizer_stoptheworld_win.cpp+2

...	@@ -49,6 +49,8 @@ struct SuspendedThreadsListWindows final : public SuspendedThreadsList {	...	@@ -49,6 +49,8 @@ struct SuspendedThreadsListWindows final : public SuspendedThreadsList {
49	# define SP_REG Esp	49	# define SP_REG Esp
50	# elif SANITIZER_ARM \| SANITIZER_ARM64	50	# elif SANITIZER_ARM \| SANITIZER_ARM64
51	# define SP_REG Sp	51	# define SP_REG Sp
		52	# elif SANITIZER_MIPS32
		53	# define SP_REG IntSp
52	# else	54	# else
53	# error Architecture not supported!	55	# error Architecture not supported!
54	# endif	56	# endif

lib/libtsan/sanitizer_common/sanitizer_symbolizer_libcdep.cpp+45-41

 @@ -31,11 +31,12 @@ Symbolizer *Symbolizer::GetOrInit() {
 const char *ExtractToken(const char *str, const char *delims, char **result) {
   uptr prefix_len = internal_strcspn(str, delims);
-  *result = (char*)InternalAlloc(prefix_len + 1);
+  *result = (char *)InternalAlloc(prefix_len + 1);
   internal_memcpy(*result, str, prefix_len);
   (*result)[prefix_len] = '\0';
   const char *prefix_end = str + prefix_len;
-  if (*prefix_end != '\0') prefix_end++;
+  if (*prefix_end != '\0')
+    prefix_end++;
   return prefix_end;
 }
 @@ -78,7 +79,8 @@ const char *ExtractTokenUpToDelimiter(const char *str, const char *delimiter,
   internal_memcpy(*result, str, prefix_len);
   (*result)[prefix_len] = '\0';
   const char *prefix_end = str + prefix_len;
-  if (*prefix_end != '\0') prefix_end += internal_strlen(delimiter);
+  if (*prefix_end != '\0')
+    prefix_end += internal_strlen(delimiter);
   return prefix_end;
 }
 @@ -215,18 +217,20 @@ const LoadedModule *Symbolizer::FindModuleForAddress(uptr address) {
     modules_were_reloaded = true;
   }
   const LoadedModule *module = SearchForModule(modules_, address);
-  if (module) return module;
+  if (module)
+    return module;
   // dlopen/dlclose interceptors invalidate the module list, but when
   // interception is disabled, we need to retry if the lookup fails in
   // case the module list changed.
-#if !SANITIZER_INTERCEPT_DLOPEN_DLCLOSE
+#  if !SANITIZER_INTERCEPT_DLOPEN_DLCLOSE
   if (!modules_were_reloaded) {
     RefreshModules();
     module = SearchForModule(modules_, address);
-    if (module) return module;
+    if (module)
+      return module;
   }
-#endif
+#  endif
   if (fallback_modules_.size()) {
     module = SearchForModule(fallback_modules_, address);
 @@ -260,31 +264,31 @@ class LLVMSymbolizerProcess final : public SymbolizerProcess {
   // script/asan_symbolize.py and sanitizer_common.h.
   void GetArgV(const char *path_to_binary,
                const char *(&argv)[kArgVMax]) const override {
-#if defined(__x86_64h__)
+#  if defined(__x86_64h__)
-    const char* const kSymbolizerArch = "--default-arch=x86_64h";
+    const char *const kSymbolizerArch = "--default-arch=x86_64h";
-#elif defined(__x86_64__)
+#  elif defined(__x86_64__)
-    const char* const kSymbolizerArch = "--default-arch=x86_64";
+    const char *const kSymbolizerArch = "--default-arch=x86_64";
-#elif defined(__i386__)
+#  elif defined(__i386__)
-    const char* const kSymbolizerArch = "--default-arch=i386";
+    const char *const kSymbolizerArch = "--default-arch=i386";
-#elif SANITIZER_LOONGARCH64
+#  elif SANITIZER_LOONGARCH64
     const char *const kSymbolizerArch = "--default-arch=loongarch64";
-#elif SANITIZER_RISCV64
+#  elif SANITIZER_RISCV64
     const char *const kSymbolizerArch = "--default-arch=riscv64";
-#elif defined(__aarch64__)
+#  elif defined(__aarch64__)
-    const char* const kSymbolizerArch = "--default-arch=arm64";
+    const char *const kSymbolizerArch = "--default-arch=arm64";
-#elif defined(__arm__)
+#  elif defined(__arm__)
-    const char* const kSymbolizerArch = "--default-arch=arm";
+    const char *const kSymbolizerArch = "--default-arch=arm";
-#elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#  elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-    const char* const kSymbolizerArch = "--default-arch=powerpc64";
+    const char *const kSymbolizerArch = "--default-arch=powerpc64";
-#elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#  elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-    const char* const kSymbolizerArch = "--default-arch=powerpc64le";
+    const char *const kSymbolizerArch = "--default-arch=powerpc64le";
-#elif defined(__s390x__)
+#  elif defined(__s390x__)
-    const char* const kSymbolizerArch = "--default-arch=s390x";
+    const char *const kSymbolizerArch = "--default-arch=s390x";
-#elif defined(__s390__)
+#  elif defined(__s390__)
-    const char* const kSymbolizerArch = "--default-arch=s390";
+    const char *const kSymbolizerArch = "--default-arch=s390";
-#else
+#  else
-    const char* const kSymbolizerArch = "--default-arch=unknown";
+    const char *const kSymbolizerArch = "--default-arch=unknown";
-#endif
+#  endif
     const char *const demangle_flag =
         common_flags()->demangle ? "--demangle" : "--no-demangle";
 @@ -315,7 +319,8 @@ static const char *ParseFileLineInfo(AddressInfo *info, const char *str) {
     char *back = file_line_info + size - 1;
     for (int i = 0; i < 2; ++i) {
       while (back > file_line_info && IsDigit(*back)) --back;
-      if (*back != ':' || !IsDigit(back[1])) break;
+      if (*back != ':' || !IsDigit(back[1]))
+        break;
       info->column = info->line;
       info->line = internal_atoll(back + 1);
       // Truncate the string at the colon to keep only filename.
 @@ -436,7 +441,7 @@ bool LLVMSymbolizer::SymbolizeData(uptr addr, DataInfo *info) {
   if (!buf)
     return false;
   ParseSymbolizeDataOutput(buf, info);
-  info->start += (addr - info->module_offset); // Add the base address.
+  info->start += (addr - info->module_offset);  // Add the base address.
   return true;
 }
 @@ -459,10 +464,9 @@ const char *LLVMSymbolizer::FormatAndSendCommand(const char *command_prefix,
     size_needed = internal_snprintf(buffer_, kBufferSize, "%s \"%s\" 0x%zx\n",
                                     command_prefix, module_name, module_offset);
   else
-    size_needed = internal_snprintf(buffer_, kBufferSize,
+    size_needed = internal_snprintf(
-                                    "%s \"%s:%s\" 0x%zx\n", command_prefix,
+        buffer_, kBufferSize, "%s \"%s:%s\" 0x%zx\n", command_prefix,
-                                    module_name, ModuleArchToString(arch),
+        module_name, ModuleArchToString(arch), module_offset);
-                                    module_offset);
   if (size_needed >= static_cast<int>(kBufferSize)) {
     Report("WARNING: Command buffer too small");
 @@ -484,9 +488,9 @@ SymbolizerProcess::SymbolizerProcess(const char *path, bool use_posix_spawn)
   CHECK_NE(path_[0], '\0');
 }
-static bool IsSameModule(const char* path) {
+static bool IsSameModule(const char *path) {
-  if (const char* ProcessName = GetProcessName()) {
+  if (const char *ProcessName = GetProcessName()) {
-    if (const char* SymbolizerName = StripModuleName(path)) {
+    if (const char *SymbolizerName = StripModuleName(path)) {
       return !internal_strcmp(ProcessName, SymbolizerName);
     }
   }
 @@ -516,9 +520,9 @@ const char *SymbolizerProcess::SendCommand(const char *command) {
 const char *SymbolizerProcess::SendCommandImpl(const char *command) {
   if (input_fd_ == kInvalidFd || output_fd_ == kInvalidFd)
-      return nullptr;
+    return nullptr;
   if (!WriteToSymbolizer(command, internal_strlen(command)))
-      return nullptr;
+    return nullptr;
   if (!ReadFromSymbolizer())
     return nullptr;
   return buffer_.data();

lib/libtsan/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp+56-44

 @@ -38,9 +38,10 @@
 // because we do not require a C++ ABI library to be linked to a program
 // using sanitizers; if it's not present, we'll just use the mangled name.
 namespace __cxxabiv1 {
-  extern "C" SANITIZER_WEAK_ATTRIBUTE
+extern "C" SANITIZER_WEAK_ATTRIBUTE char *__cxa_demangle(const char *mangled,
-  char *__cxa_demangle(const char *mangled, char *buffer,
+                                                         char *buffer,
-                                  size_t *length, int *status);
+                                                         size_t *length,
+                                                         int *status);
 }
 namespace __sanitizer {
 @@ -53,8 +54,7 @@ const char *DemangleCXXABI(const char *name) {
   // it does not allocate). For now, we just call it anyway, and we leak
   // the returned value.
   if (&__cxxabiv1::__cxa_demangle)
-    if (const char *demangled_name =
+    if (const char *demangled_name = __cxxabiv1::__cxa_demangle(name, 0, 0, 0))
-          __cxxabiv1::__cxa_demangle(name, 0, 0, 0))
       return demangled_name;
   return nullptr;
 @@ -85,7 +85,8 @@ const char *DemangleSwift(const char *name) {
 }
 const char *DemangleSwiftAndCXX(const char *name) {
-  if (!name) return nullptr;
+  if (!name)
+    return nullptr;
   if (const char *swift_demangled_name = DemangleSwift(name))
     return swift_demangled_name;
   return DemangleCXXABI(name);
 @@ -114,7 +115,8 @@ static bool CreateTwoHighNumberedPipes(int *infd_, int *outfd_) {
       } else {
         outfd = sock_pair[i];
         for (int j = 0; j < i; j++) {
-          if (sock_pair[j] == infd) continue;
+          if (sock_pair[j] == infd)
+            continue;
           internal_close(sock_pair[j][0]);
           internal_close(sock_pair[j][1]);
         }
 @@ -155,7 +157,7 @@ bool SymbolizerProcess::StartSymbolizerSubprocess() {
   }
   if (use_posix_spawn_) {
-#if SANITIZER_APPLE
+#  if SANITIZER_APPLE
     fd_t fd = internal_spawn(argv, const_cast<const char **>(GetEnvP()), &pid);
     if (fd == kInvalidFd) {
       Report("WARNING: failed to spawn external symbolizer (errno: %d)\n",
 @@ -165,14 +167,16 @@ bool SymbolizerProcess::StartSymbolizerSubprocess() {
     input_fd_ = fd;
     output_fd_ = fd;
-#else  // SANITIZER_APPLE
+#  else   // SANITIZER_APPLE
     UNIMPLEMENTED();
-#endif  // SANITIZER_APPLE
+#  endif  // SANITIZER_APPLE
   } else {
     fd_t infd[2] = {}, outfd[2] = {};
     if (!CreateTwoHighNumberedPipes(infd, outfd)) {
-      Report("WARNING: Can't create a socket pair to start "
+      Report(
-             "external symbolizer (errno: %d)\n", errno);
+          "WARNING: Can't create a socket pair to start "
+          "external symbolizer (errno: %d)\n",
+          errno);
       return false;
     }
 @@ -260,10 +264,11 @@ bool Addr2LineProcess::ReachedEndOfOutput(const char *buffer,
   // 1. First one, corresponding to given offset to be symbolized
   // (may be equal to output_terminator_, if offset is not valid).
   // 2. Second one for output_terminator_, itself to mark the end of output.
-  if (length <= kTerminatorLen) return false;
+  if (length <= kTerminatorLen)
+    return false;
   // Addr2Line output should end up with output_terminator_.
-  return !internal_memcmp(buffer + length - kTerminatorLen,
+  return !internal_memcmp(buffer + length - kTerminatorLen, output_terminator_,
-                          output_terminator_, kTerminatorLen);
+                          kTerminatorLen);
 }
 class Addr2LinePool final : public SymbolizerTool {
 @@ -283,9 +288,7 @@ class Addr2LinePool final : public SymbolizerTool {
     return false;
   }
-  bool SymbolizeData(uptr addr, DataInfo *info) override {
+  bool SymbolizeData(uptr addr, DataInfo *info) override { return false; }
-    return false;
-  }
  private:
   const char *SendCommand(const char *module_name, uptr module_offset) {
 @@ -299,22 +302,21 @@ class Addr2LinePool final : public SymbolizerTool {
     }
     if (!addr2line) {
       addr2line =
-          new(*allocator_) Addr2LineProcess(addr2line_path_, module_name);
+          new (*allocator_) Addr2LineProcess(addr2line_path_, module_name);
       addr2line_pool_.push_back(addr2line);
     }
     CHECK_EQ(0, internal_strcmp(module_name, addr2line->module_name()));
     char buffer[kBufferSize];
-    internal_snprintf(buffer, kBufferSize, "0x%zx\n0x%zx\n",
+    internal_snprintf(buffer, kBufferSize, "0x%zx\n0x%zx\n", module_offset,
-                      module_offset, dummy_address_);
+                      dummy_address_);
     return addr2line->SendCommand(buffer);
   }
   static const uptr kBufferSize = 64;
   const char *addr2line_path_;
   LowLevelAllocator *allocator_;
-  InternalMmapVector<Addr2LineProcess*> addr2line_pool_;
+  InternalMmapVector<Addr2LineProcess *> addr2line_pool_;
-  static const uptr dummy_address_ =
+  static const uptr dummy_address_ = FIRST_32_SECOND_64(UINT32_MAX, UINT64_MAX);
-      FIRST_32_SECOND_64(UINT32_MAX, UINT64_MAX);
 };
 #  if SANITIZER_SUPPORTS_WEAK_HOOKS
 @@ -352,8 +354,9 @@ class InternalSymbolizer final : public SymbolizerTool {
   }
   bool SymbolizePC(uptr addr, SymbolizedStack *stack) override {
-    bool result = __sanitizer_symbolize_code(
+    bool result = __sanitizer_symbolize_code(stack->info.module,
-        stack->info.module, stack->info.module_offset, buffer_, sizeof(buffer_));
+                                             stack->info.module_offset, buffer_,
+                                             sizeof(buffer_));
     if (result)
       ParseSymbolizePCOutput(buffer_, stack);
     return result;
 @@ -423,44 +426,53 @@ static SymbolizerTool *ChooseExternalSymbolizer(LowLevelAllocator *allocator) {
   } else if (!internal_strncmp(binary_name, kLLVMSymbolizerPrefix,
                                internal_strlen(kLLVMSymbolizerPrefix))) {
     VReport(2, "Using llvm-symbolizer at user-specified path: %s\n", path);
-    return new(*allocator) LLVMSymbolizer(path, allocator);
+    return new (*allocator) LLVMSymbolizer(path, allocator);
   } else if (!internal_strcmp(binary_name, "atos")) {
-#if SANITIZER_APPLE
+#  if SANITIZER_APPLE
     VReport(2, "Using atos at user-specified path: %s\n", path);
-    return new(*allocator) AtosSymbolizer(path, allocator);
+    return new (*allocator) AtosSymbolizer(path, allocator);
-#else  // SANITIZER_APPLE
+#  else   // SANITIZER_APPLE
     Report("ERROR: Using `atos` is only supported on Darwin.\n");
     Die();
-#endif  // SANITIZER_APPLE
+#  endif  // SANITIZER_APPLE
   } else if (!internal_strcmp(binary_name, "addr2line")) {
     VReport(2, "Using addr2line at user-specified path: %s\n", path);
-    return new(*allocator) Addr2LinePool(path, allocator);
+    return new (*allocator) Addr2LinePool(path, allocator);
   } else if (path) {
-    Report("ERROR: External symbolizer path is set to '%s' which isn't "
+    Report(
-           "a known symbolizer. Please set the path to the llvm-symbolizer "
+        "ERROR: External symbolizer path is set to '%s' which isn't "
-           "binary or other known tool.\n", path);
+        "a known symbolizer. Please set the path to the llvm-symbolizer "
+        "binary or other known tool.\n",
+        path);
     Die();
   }
   // Otherwise symbolizer program is unknown, let's search $PATH
+#  ifdef SANITIZER_DISABLE_SYMBOLIZER_PATH_SEARCH
+  VReport(2,
+          "Symbolizer path search is disabled in the runtime "
+          "build configuration.\n");
+  return nullptr;
+#  else
   CHECK(path == nullptr);
-#if SANITIZER_APPLE
+#    if SANITIZER_APPLE
   if (const char *found_path = FindPathToBinary("atos")) {
     VReport(2, "Using atos found at: %s\n", found_path);
-    return new(*allocator) AtosSymbolizer(found_path, allocator);
+    return new (*allocator) AtosSymbolizer(found_path, allocator);
   }
-#endif  // SANITIZER_APPLE
+#    endif  // SANITIZER_APPLE
   if (const char *found_path = FindPathToBinary("llvm-symbolizer")) {
     VReport(2, "Using llvm-symbolizer found at: %s\n", found_path);
-    return new(*allocator) LLVMSymbolizer(found_path, allocator);
+    return new (*allocator) LLVMSymbolizer(found_path, allocator);
   }
   if (common_flags()->allow_addr2line) {
     if (const char *found_path = FindPathToBinary("addr2line")) {
       VReport(2, "Using addr2line found at: %s\n", found_path);
-      return new(*allocator) Addr2LinePool(found_path, allocator);
+      return new (*allocator) Addr2LinePool(found_path, allocator);
     }
   }
   return nullptr;
+#  endif    // SANITIZER_DISABLE_SYMBOLIZER_PATH_SEARCH
 }
 static void ChooseSymbolizerTools(IntrusiveList<SymbolizerTool> *list,
 @@ -492,17 +504,17 @@ static void ChooseSymbolizerTools(IntrusiveList<SymbolizerTool> *list,
     list->push_back(tool);
   }
-#if SANITIZER_APPLE
+#  if SANITIZER_APPLE
   VReport(2, "Using dladdr symbolizer.\n");
-  list->push_back(new(*allocator) DlAddrSymbolizer());
+  list->push_back(new (*allocator) DlAddrSymbolizer());
-#endif  // SANITIZER_APPLE
+#  endif  // SANITIZER_APPLE
 }
 Symbolizer *Symbolizer::PlatformInit() {
   IntrusiveList<SymbolizerTool> list;
   list.clear();
   ChooseSymbolizerTools(&list, &symbolizer_allocator_);
-  return new(symbolizer_allocator_) Symbolizer(list);
+  return new (symbolizer_allocator_) Symbolizer(list);
 }
 void Symbolizer::LateInitialize() {

lib/libtsan/sanitizer_common/sanitizer_unwind_linux_libcdep.cpp+2-34

...	@@ -12,7 +12,7 @@	...	@@ -12,7 +12,7 @@
12		12
13	#include "sanitizer_platform.h"	13	#include "sanitizer_platform.h"
14	#if SANITIZER_FREEBSD \|\| SANITIZER_LINUX \|\| SANITIZER_NETBSD \|\| \	14	#if SANITIZER_FREEBSD \|\| SANITIZER_LINUX \|\| SANITIZER_NETBSD \|\| \
15	SANITIZER_SOLARIS	15	SANITIZER_SOLARIS \|\| SANITIZER_HAIKU
16	#include "sanitizer_common.h"	16	#include "sanitizer_common.h"
17	#include "sanitizer_stacktrace.h"	17	#include "sanitizer_stacktrace.h"
18		18
...	@@ -91,38 +91,6 @@ _Unwind_Reason_Code Unwind_Trace(struct _Unwind_Context ctx, void param) {	...	@@ -91,38 +91,6 @@ _Unwind_Reason_Code Unwind_Trace(struct _Unwind_Context ctx, void param) {
91		91
92	} // namespace	92	} // namespace
93		93
94	#if SANITIZER_ANDROID
95	void SanitizerInitializeUnwinder() {
96	if (AndroidGetApiLevel() >= ANDROID_LOLLIPOP_MR1) return;
97
98	// Pre-lollipop Android can not unwind through signal handler frames with
99	// libgcc unwinder, but it has a libcorkscrew.so library with the necessary
100	// workarounds.
101	void *p = dlopen("libcorkscrew.so", RTLD_LAZY);
102	if (!p) {
103	VReport(1,
104	"Failed to open libcorkscrew.so. You may see broken stack traces "
105	"in SEGV reports.");
106	return;
107	}
108	acquire_my_map_info_list =
109	(acquire_my_map_info_list_func)(uptr)dlsym(p, "acquire_my_map_info_list");
110	release_my_map_info_list =
111	(release_my_map_info_list_func)(uptr)dlsym(p, "release_my_map_info_list");
112	unwind_backtrace_signal_arch = (unwind_backtrace_signal_arch_func)(uptr)dlsym(
113	p, "unwind_backtrace_signal_arch");
114	if (!acquire_my_map_info_list \|\| !release_my_map_info_list \|\|
115	!unwind_backtrace_signal_arch) {
116	VReport(1,
117	"Failed to find one of the required symbols in libcorkscrew.so. "
118	"You may see broken stack traces in SEGV reports.");
119	acquire_my_map_info_list = 0;
120	unwind_backtrace_signal_arch = 0;
121	release_my_map_info_list = 0;
122	}
123	}
124	#endif
125
126	void BufferedStackTrace::UnwindSlow(uptr pc, u32 max_depth) {	94	void BufferedStackTrace::UnwindSlow(uptr pc, u32 max_depth) {
127	CHECK_GE(max_depth, 2);	95	CHECK_GE(max_depth, 2);
128	size = 0;	96	size = 0;
...	@@ -171,4 +139,4 @@ void BufferedStackTrace::UnwindSlow(uptr pc, void *context, u32 max_depth) {	...	@@ -171,4 +139,4 @@ void BufferedStackTrace::UnwindSlow(uptr pc, void *context, u32 max_depth) {
171	} // namespace __sanitizer	139	} // namespace __sanitizer
172		140
173	#endif // SANITIZER_FREEBSD \|\| SANITIZER_LINUX \|\| SANITIZER_NETBSD \|\|	141	#endif // SANITIZER_FREEBSD \|\| SANITIZER_LINUX \|\| SANITIZER_NETBSD \|\|
174	// SANITIZER_SOLARIS	142	// SANITIZER_SOLARIS \|\| SANITIZER_HAIKU

lib/libtsan/sanitizer_common/sanitizer_unwind_win.cpp+5

 @@ -75,6 +75,11 @@ void BufferedStackTrace::UnwindSlow(uptr pc, void *context, u32 max_depth) {
   stack_frame.AddrPC.Offset = ctx.Pc;
   stack_frame.AddrFrame.Offset = ctx.R11;
   stack_frame.AddrStack.Offset = ctx.Sp;
+#      elif SANITIZER_MIPS32
+  int machine_type = IMAGE_FILE_MACHINE_R4000;
+  stack_frame.AddrPC.Offset = ctx.Fir;
+  stack_frame.AddrFrame.Offset = ctx.IntS8;
+  stack_frame.AddrStack.Offset = ctx.IntSp;
 #      else
   int machine_type = IMAGE_FILE_MACHINE_I386;
   stack_frame.AddrPC.Offset = ctx.Eip;

lib/libtsan/sanitizer_common/sanitizer_win.cpp+3

 @@ -1011,6 +1011,9 @@ void SignalContext::InitPcSpBp() {
 #    if SANITIZER_ARM
   bp = (uptr)context_record->R11;
   sp = (uptr)context_record->Sp;
+#    elif SANITIZER_MIPS32
+  bp = (uptr)context_record->IntS8;
+  sp = (uptr)context_record->IntSp;
 #    else
   bp = (uptr)context_record->Ebp;
   sp = (uptr)context_record->Esp;

lib/libtsan/tsan_interceptors_posix.cpp+72-15

 @@ -12,6 +12,9 @@
 // sanitizer_common/sanitizer_common_interceptors.inc
 //===----------------------------------------------------------------------===//
+#include <stdarg.h>
+#include "interception/interception.h"
 #include "sanitizer_common/sanitizer_allocator_dlsym.h"
 #include "sanitizer_common/sanitizer_atomic.h"
 #include "sanitizer_common/sanitizer_errno.h"
 @@ -19,21 +22,20 @@
 #include "sanitizer_common/sanitizer_internal_defs.h"
 #include "sanitizer_common/sanitizer_libc.h"
 #include "sanitizer_common/sanitizer_linux.h"
+#include "sanitizer_common/sanitizer_platform_interceptors.h"
 #include "sanitizer_common/sanitizer_platform_limits_netbsd.h"
 #include "sanitizer_common/sanitizer_platform_limits_posix.h"
 #include "sanitizer_common/sanitizer_posix.h"
 #include "sanitizer_common/sanitizer_stacktrace.h"
 #include "sanitizer_common/sanitizer_tls_get_addr.h"
-#include "interception/interception.h"
+#include "sanitizer_common/sanitizer_vector.h"
+#include "tsan_fd.h"
 #include "tsan_interceptors.h"
 #include "tsan_interface.h"
+#include "tsan_mman.h"
 #include "tsan_platform.h"
-#include "tsan_suppressions.h"
 #include "tsan_rtl.h"
-#include "tsan_mman.h"
+#include "tsan_suppressions.h"
-#include "tsan_fd.h"
-#include <stdarg.h>
 using namespace __tsan;
 @@ -177,7 +179,7 @@ struct ThreadSignalContext {
   SignalDesc pending_signals[kSigCount];
   // emptyset and oldset are too big for stack.
   __sanitizer_sigset_t emptyset;
-  __sanitizer_sigset_t oldset;
+  __sanitizer::Vector<__sanitizer_sigset_t> oldset;
 };
 void EnterBlockingFunc(ThreadState *thr) {
 @@ -558,6 +560,7 @@ static void SetJmp(ThreadState *thr, uptr sp) {
   buf->shadow_stack_pos = thr->shadow_stack_pos;
   ThreadSignalContext *sctx = SigCtx(thr);
   buf->int_signal_send = sctx ? sctx->int_signal_send : 0;
+  buf->oldset_stack_size = sctx ? sctx->oldset.Size() : 0;
   buf->in_blocking_func = atomic_load(&thr->in_blocking_func, memory_order_relaxed);
   buf->in_signal_handler = atomic_load(&thr->in_signal_handler,
       memory_order_relaxed);
 @@ -574,8 +577,11 @@ static void LongJmp(ThreadState *thr, uptr *env) {
       while (thr->shadow_stack_pos > buf->shadow_stack_pos)
         FuncExit(thr);
       ThreadSignalContext *sctx = SigCtx(thr);
-      if (sctx)
+      if (sctx) {
         sctx->int_signal_send = buf->int_signal_send;
+        while (sctx->oldset.Size() > buf->oldset_stack_size)
+          sctx->oldset.PopBack();
+      }
       atomic_store(&thr->in_blocking_func, buf->in_blocking_func,
           memory_order_relaxed);
       atomic_store(&thr->in_signal_handler, buf->in_signal_handler,
 @@ -742,6 +748,41 @@ TSAN_INTERCEPTOR(void, free, void *p) {
   user_free(thr, pc, p);
 }
+#  if SANITIZER_INTERCEPT_FREE_SIZED
+TSAN_INTERCEPTOR(void, free_sized, void *p, uptr size) {
+  if (UNLIKELY(!p))
+    return;
+  if (in_symbolizer())
+    return InternalFree(p);
+  if (DlsymAlloc::PointerIsMine(p))
+    return DlsymAlloc::Free(p);
+  invoke_free_hook(p);
+  SCOPED_INTERCEPTOR_RAW(free_sized, p, size);
+  user_free(thr, pc, p);
+}
+#    define TSAN_MAYBE_INTERCEPT_FREE_SIZED INTERCEPT_FUNCTION(free_sized)
+#  else
+#    define TSAN_MAYBE_INTERCEPT_FREE_SIZED
+#  endif
+#  if SANITIZER_INTERCEPT_FREE_ALIGNED_SIZED
+TSAN_INTERCEPTOR(void, free_aligned_sized, void *p, uptr alignment, uptr size) {
+  if (UNLIKELY(!p))
+    return;
+  if (in_symbolizer())
+    return InternalFree(p);
+  if (DlsymAlloc::PointerIsMine(p))
+    return DlsymAlloc::Free(p);
+  invoke_free_hook(p);
+  SCOPED_INTERCEPTOR_RAW(free_aligned_sized, p, alignment, size);
+  user_free(thr, pc, p);
+}
+#    define TSAN_MAYBE_INTERCEPT_FREE_ALIGNED_SIZED \
+      INTERCEPT_FUNCTION(free_aligned_sized)
+#  else
+#    define TSAN_MAYBE_INTERCEPT_FREE_ALIGNED_SIZED
+#  endif
 TSAN_INTERCEPTOR(void, cfree, void *p) {
   if (UNLIKELY(!p))
     return;
 @@ -758,6 +799,9 @@ TSAN_INTERCEPTOR(uptr, malloc_usable_size, void *p) {
   SCOPED_INTERCEPTOR_RAW(malloc_usable_size, p);
   return user_alloc_usable_size(p);
 }
+#else
+#  define TSAN_MAYBE_INTERCEPT_FREE_SIZED
+#  define TSAN_MAYBE_INTERCEPT_FREE_ALIGNED_SIZED
 #endif
 TSAN_INTERCEPTOR(char *, strcpy, char *dst, const char *src) {
 @@ -892,10 +936,9 @@ constexpr u32 kGuardWaiter = 1 << 17;
 static int guard_acquire(ThreadState *thr, uptr pc, atomic_uint32_t *g,
                          bool blocking_hooks = true) {
-  if (blocking_hooks)
+  bool in_potentially_blocking_region = false;
-    OnPotentiallyBlockingRegionBegin();
+  auto on_exit = at_scope_exit([&] {
-  auto on_exit = at_scope_exit([blocking_hooks] {
+    if (in_potentially_blocking_region)
-    if (blocking_hooks)
       OnPotentiallyBlockingRegionEnd();
   });
 @@ -912,8 +955,13 @@ static int guard_acquire(ThreadState *thr, uptr pc, atomic_uint32_t *g,
     } else {
       if ((cmp & kGuardWaiter) ||
           atomic_compare_exchange_strong(g, &cmp, cmp | kGuardWaiter,
-                                         memory_order_relaxed))
+                                         memory_order_relaxed)) {
+        if (blocking_hooks && !in_potentially_blocking_region) {
+          in_potentially_blocking_region = true;
+          OnPotentiallyBlockingRegionBegin();
+        }
         FutexWait(g, cmp | kGuardWaiter);
+      }
     }
   }
 }
 @@ -976,6 +1024,7 @@ void PlatformCleanUpThreadState(ThreadState *thr) {
       &thr->signal_ctx, memory_order_relaxed);
   if (sctx) {
     atomic_store(&thr->signal_ctx, 0, memory_order_relaxed);
+    sctx->oldset.Reset();
     UnmapOrDie(sctx, sizeof(*sctx));
   }
 }
 @@ -2172,7 +2221,8 @@ void ProcessPendingSignalsImpl(ThreadState *thr) {
     return;
   atomic_fetch_add(&thr->in_signal_handler, 1, memory_order_relaxed);
   internal_sigfillset(&sctx->emptyset);
-  int res = REAL(pthread_sigmask)(SIG_SETMASK, &sctx->emptyset, &sctx->oldset);
+  __sanitizer_sigset_t *oldset = sctx->oldset.PushBack();
+  int res = REAL(pthread_sigmask)(SIG_SETMASK, &sctx->emptyset, oldset);
   CHECK_EQ(res, 0);
   for (int sig = 0; sig < kSigCount; sig++) {
     SignalDesc *signal = &sctx->pending_signals[sig];
 @@ -2182,8 +2232,9 @@ void ProcessPendingSignalsImpl(ThreadState *thr) {
                             &signal->ctx);
     }
   }
-  res = REAL(pthread_sigmask)(SIG_SETMASK, &sctx->oldset, 0);
+  res = REAL(pthread_sigmask)(SIG_SETMASK, oldset, 0);
   CHECK_EQ(res, 0);
+  sctx->oldset.PopBack();
   atomic_fetch_add(&thr->in_signal_handler, -1, memory_order_relaxed);
 }
 @@ -2951,6 +3002,8 @@ void InitializeInterceptors() {
   TSAN_INTERCEPT(realloc);
   TSAN_INTERCEPT(reallocarray);
   TSAN_INTERCEPT(free);
+  TSAN_MAYBE_INTERCEPT_FREE_SIZED;
+  TSAN_MAYBE_INTERCEPT_FREE_ALIGNED_SIZED;
   TSAN_INTERCEPT(cfree);
   TSAN_INTERCEPT(munmap);
   TSAN_MAYBE_INTERCEPT_MEMALIGN;
 @@ -3073,6 +3126,10 @@ void InitializeInterceptors() {
 #if !SANITIZER_ANDROID
   TSAN_INTERCEPT(dl_iterate_phdr);
 #endif
+  // Symbolization indirectly calls dl_iterate_phdr
+  ready_to_symbolize = true;
   TSAN_MAYBE_INTERCEPT_ON_EXIT;
   TSAN_INTERCEPT(__cxa_atexit);
   TSAN_INTERCEPT(_exit);

lib/libtsan/tsan_interface_java.cpp-1

...	@@ -122,7 +122,6 @@ void __tsan_java_move(jptr src, jptr dst, jptr size) {	...	@@ -122,7 +122,6 @@ void __tsan_java_move(jptr src, jptr dst, jptr size) {
122	DCHECK_GE(dst, jctx->heap_begin);	122	DCHECK_GE(dst, jctx->heap_begin);
123	DCHECK_LE(dst + size, jctx->heap_begin + jctx->heap_size);	123	DCHECK_LE(dst + size, jctx->heap_begin + jctx->heap_size);
124	DCHECK_NE(dst, src);	124	DCHECK_NE(dst, src);
125	DCHECK_NE(size, 0);
126		125
127	// Assuming it's not running concurrently with threads that do	126	// Assuming it's not running concurrently with threads that do
128	// memory accesses and mutex operations (stop-the-world phase).	127	// memory accesses and mutex operations (stop-the-world phase).

lib/libtsan/tsan_malloc_mac.cpp+13-9

...	@@ -73,15 +73,19 @@ using namespace __tsan;	...	@@ -73,15 +73,19 @@ using namespace __tsan;
73	invoke_free_hook(ptr); \	73	invoke_free_hook(ptr); \
74	SCOPED_INTERCEPTOR_RAW(free, ptr); \	74	SCOPED_INTERCEPTOR_RAW(free, ptr); \
75	user_free(thr, pc, ptr)	75	user_free(thr, pc, ptr)
76	#define COMMON_MALLOC_SIZE(ptr) uptr size = user_alloc_usable_size(ptr);	76	# define COMMON_MALLOC_FREE_SIZED(ptr, size) COMMON_MALLOC_FREE(ptr)
77	#define COMMON_MALLOC_FILL_STATS(zone, stats)	77	# define COMMON_MALLOC_FREE_ALIGNED_SIZED(ptr, alignment, size) \
78	#define COMMON_MALLOC_REPORT_UNKNOWN_REALLOC(ptr, zone_ptr, zone_name) \	78	COMMON_MALLOC_FREE(ptr)
79	(void)zone_name; \	79	# define COMMON_MALLOC_SIZE(ptr) uptr size = user_alloc_usable_size(ptr);
80	Report("mz_realloc(%p) -- attempting to realloc unallocated memory.\n", ptr);	80	# define COMMON_MALLOC_FILL_STATS(zone, stats)
81	#define COMMON_MALLOC_NAMESPACE __tsan	81	# define COMMON_MALLOC_REPORT_UNKNOWN_REALLOC(ptr, zone_ptr, zone_name) \
82	#define COMMON_MALLOC_HAS_ZONE_ENUMERATOR 0	82	(void)zone_name; \
83	#define COMMON_MALLOC_HAS_EXTRA_INTROSPECTION_INIT 0	83	Report("mz_realloc(%p) -- attempting to realloc unallocated memory.\n", \
		84	ptr);
		85	# define COMMON_MALLOC_NAMESPACE __tsan
		86	# define COMMON_MALLOC_HAS_ZONE_ENUMERATOR 0
		87	# define COMMON_MALLOC_HAS_EXTRA_INTROSPECTION_INIT 0
84		88
85	#include "sanitizer_common/sanitizer_malloc_mac.inc"	89	# include "sanitizer_common/sanitizer_malloc_mac.inc"
86		90
87	#endif	91	#endif

lib/libtsan/tsan_platform.h+32-2

...	@@ -681,6 +681,33 @@ struct MappingGoMips64_47 {	...	@@ -681,6 +681,33 @@ struct MappingGoMips64_47 {
681	static const uptr kShadowAdd = 0x200000000000ull;	681	static const uptr kShadowAdd = 0x200000000000ull;
682	};	682	};
683		683
		684	/* Go on linux/riscv64 (48-bit VMA)
		685	0000 0001 0000 - 00e0 0000 0000: executable and heap (896 GiB)
		686	00e0 0000 0000 - 2000 0000 0000: -
		687	2000 0000 0000 - 2400 0000 0000: shadow - 4 TiB ( ~ 4 * app)
		688	2400 0000 0000 - 3000 0000 0000: -
		689	3000 0000 0000 - 3100 0000 0000: metainfo - 1 TiB ( ~ 1 * app)
		690	3100 0000 0000 - 8000 0000 0000: -
		691	*/
		692	struct MappingGoRiscv64 {
		693	static const uptr kMetaShadowBeg = 0x300000000000ull;
		694	static const uptr kMetaShadowEnd = 0x310000000000ull;
		695	static const uptr kShadowBeg = 0x200000000000ull;
		696	static const uptr kShadowEnd = 0x240000000000ull;
		697	static const uptr kLoAppMemBeg = 0x000000010000ull;
		698	static const uptr kLoAppMemEnd = 0x000e00000000ull;
		699	static const uptr kMidAppMemBeg = 0;
		700	static const uptr kMidAppMemEnd = 0;
		701	static const uptr kHiAppMemBeg = 0;
		702	static const uptr kHiAppMemEnd = 0;
		703	static const uptr kHeapMemBeg = 0;
		704	static const uptr kHeapMemEnd = 0;
		705	static const uptr kVdsoBeg = 0;
		706	static const uptr kShadowMsk = 0;
		707	static const uptr kShadowXor = 0;
		708	static const uptr kShadowAdd = 0x200000000000ull;
		709	};
		710
684	/*	711	/*
685	Go on linux/s390x	712	Go on linux/s390x
686	0000 0000 1000 - 1000 0000 0000: executable and heap - 16 TiB	713	0000 0000 1000 - 1000 0000 0000: executable and heap - 16 TiB
...	@@ -728,6 +755,8 @@ ALWAYS_INLINE auto SelectMapping(Arg arg) {	...	@@ -728,6 +755,8 @@ ALWAYS_INLINE auto SelectMapping(Arg arg) {
728	return Func::template Apply<MappingGoAarch64>(arg);	755	return Func::template Apply<MappingGoAarch64>(arg);
729	# elif defined(__loongarch_lp64)	756	# elif defined(__loongarch_lp64)
730	return Func::template Apply<MappingGoLoongArch64_47>(arg);	757	return Func::template Apply<MappingGoLoongArch64_47>(arg);
		758	# elif SANITIZER_RISCV64
		759	return Func::template Apply<MappingGoRiscv64>(arg);
731	# elif SANITIZER_WINDOWS	760	# elif SANITIZER_WINDOWS
732	return Func::template Apply<MappingGoWindows>(arg);	761	return Func::template Apply<MappingGoWindows>(arg);
733	# else	762	# else
...	@@ -798,6 +827,7 @@ void ForEachMapping() {	...	@@ -798,6 +827,7 @@ void ForEachMapping() {
798	Func::template Apply<MappingGoAarch64>();	827	Func::template Apply<MappingGoAarch64>();
799	Func::template Apply<MappingGoLoongArch64_47>();	828	Func::template Apply<MappingGoLoongArch64_47>();
800	Func::template Apply<MappingGoMips64_47>();	829	Func::template Apply<MappingGoMips64_47>();
		830	Func::template Apply<MappingGoRiscv64>();
801	Func::template Apply<MappingGoS390x>();	831	Func::template Apply<MappingGoS390x>();
802	}	832	}
803		833
...	@@ -901,7 +931,7 @@ bool IsAppMem(uptr mem) { return SelectMapping<IsAppMemImpl>(mem); }	...	@@ -901,7 +931,7 @@ bool IsAppMem(uptr mem) { return SelectMapping<IsAppMemImpl>(mem); }
901	struct IsShadowMemImpl {	931	struct IsShadowMemImpl {
902	template <typename Mapping>	932	template <typename Mapping>
903	static bool Apply(uptr mem) {	933	static bool Apply(uptr mem) {
904	return mem >= Mapping::kShadowBeg && mem <= Mapping::kShadowEnd;	934	return mem >= Mapping::kShadowBeg && mem < Mapping::kShadowEnd;
905	}	935	}
906	};	936	};
907		937
...	@@ -913,7 +943,7 @@ bool IsShadowMem(RawShadow *p) {	...	@@ -913,7 +943,7 @@ bool IsShadowMem(RawShadow *p) {
913	struct IsMetaMemImpl {	943	struct IsMetaMemImpl {
914	template <typename Mapping>	944	template <typename Mapping>
915	static bool Apply(uptr mem) {	945	static bool Apply(uptr mem) {
916	return mem >= Mapping::kMetaShadowBeg && mem <= Mapping::kMetaShadowEnd;	946	return mem >= Mapping::kMetaShadowBeg && mem < Mapping::kMetaShadowEnd;
917	}	947	}
918	};	948	};
919		949

lib/libtsan/tsan_platform_linux.cpp+27-2

...	@@ -259,7 +259,15 @@ static void ReExecIfNeeded(bool ignore_heap) {	...	@@ -259,7 +259,15 @@ static void ReExecIfNeeded(bool ignore_heap) {
259	"WARNING: Program is run with randomized virtual address "	259	"WARNING: Program is run with randomized virtual address "
260	"space, which wouldn't work with ThreadSanitizer on Android.\n"	260	"space, which wouldn't work with ThreadSanitizer on Android.\n"
261	"Re-execing with fixed virtual address space.\n");	261	"Re-execing with fixed virtual address space.\n");
262	CHECK_NE(personality(old_personality \| ADDR_NO_RANDOMIZE), -1);	262
		263	if (personality(old_personality \| ADDR_NO_RANDOMIZE) == -1) {
		264	Printf(
		265	"FATAL: ThreadSanitizer: unable to disable ASLR (perhaps "
		266	"sandboxing is enabled?).\n");
		267	Printf("FATAL: Please rerun without sandboxing and/or ASLR.\n");
		268	Die();
		269	}
		270
263	reexec = true;	271	reexec = true;
264	}	272	}
265	# endif	273	# endif
...	@@ -287,7 +295,18 @@ static void ReExecIfNeeded(bool ignore_heap) {	...	@@ -287,7 +295,18 @@ static void ReExecIfNeeded(bool ignore_heap) {
287	"possibly due to high-entropy ASLR.\n"	295	"possibly due to high-entropy ASLR.\n"
288	"Re-execing with fixed virtual address space.\n"	296	"Re-execing with fixed virtual address space.\n"
289	"N.B. reducing ASLR entropy is preferable.\n");	297	"N.B. reducing ASLR entropy is preferable.\n");
290	CHECK_NE(personality(old_personality \| ADDR_NO_RANDOMIZE), -1);	298
		299	if (personality(old_personality \| ADDR_NO_RANDOMIZE) == -1) {
		300	Printf(
		301	"FATAL: ThreadSanitizer: encountered an incompatible memory "
		302	"layout but was unable to disable ASLR (perhaps sandboxing is "
		303	"enabled?).\n");
		304	Printf(
		305	"FATAL: Please rerun with lower ASLR entropy, ASLR disabled, "
		306	"and/or sandboxing disabled.\n");
		307	Die();
		308	}
		309
291	reexec = true;	310	reexec = true;
292	} else {	311	} else {
293	Printf(	312	Printf(
...	@@ -373,6 +392,12 @@ void InitializePlatformEarly() {	...	@@ -373,6 +392,12 @@ void InitializePlatformEarly() {
373	Printf("FATAL: Found %zd - Supported 39 and 48\n", vmaSize);	392	Printf("FATAL: Found %zd - Supported 39 and 48\n", vmaSize);
374	Die();	393	Die();
375	}	394	}
		395	# else
		396	if (vmaSize != 48) {
		397	Printf("FATAL: ThreadSanitizer: unsupported VMA range\n");
		398	Printf("FATAL: Found %zd - Supported 48\n", vmaSize);
		399	Die();
		400	}
376	# endif	401	# endif
377	# endif	402	# endif
378		403

lib/libtsan/tsan_rtl.cpp+25-6

 @@ -566,17 +566,32 @@ static bool IsValidMmapRange(uptr addr, uptr size) {
   return false;
 }
-void UnmapShadow(ThreadState *thr, uptr addr, uptr size) {
+void UnmapShadow(ThreadState* thr, uptr addr, uptr size) {
   if (size == 0 || !IsValidMmapRange(addr, size))
     return;
-  DontNeedShadowFor(addr, size);
+  // unmap shadow is related to semantic of mmap/munmap, so we
+  // should clear the whole shadow range, including the tail shadow
+  // while addr + size % kShadowCell != 0.
+  uptr rounded_size_shadow = RoundUp(addr + size, kShadowCell) - addr;
+  DontNeedShadowFor(addr, rounded_size_shadow);
   ScopedGlobalProcessor sgp;
   SlotLocker locker(thr, true);
-  ctx->metamap.ResetRange(thr->proc(), addr, size, true);
+  uptr rounded_size_meta = RoundUp(addr + size, kMetaShadowCell) - addr;
+  ctx->metamap.ResetRange(thr->proc(), addr, rounded_size_meta, true);
 }
 #endif
 void MapShadow(uptr addr, uptr size) {
+  // Although named MapShadow, this function's semantic is unrelated to
+  // UnmapShadow. This function currently only used for Go's lazy allocation
+  // of shadow, whose targets are program section (e.g., bss, data, etc.).
+  // Therefore, we can guarantee that the addr and size align to kShadowCell
+  // and kMetaShadowCell by the following assertions.
+  DCHECK_EQ(addr % kShadowCell, 0);
+  DCHECK_EQ(size % kShadowCell, 0);
+  DCHECK_EQ(addr % kMetaShadowCell, 0);
+  DCHECK_EQ(size % kMetaShadowCell, 0);
   // Ensure thead registry lock held, so as to synchronize
   // with DoReset, which also access the mapped_shadow_* ctxt fields.
   ThreadRegistryLock lock0(&ctx->thread_registry);
 @@ -624,6 +639,7 @@ void MapShadow(uptr addr, uptr size) {
   static uptr mapped_meta_end = 0;
   uptr meta_begin = (uptr)MemToMeta(addr);
   uptr meta_end = (uptr)MemToMeta(addr + size);
+  // Windows wants 64K alignment.
   meta_begin = RoundDownTo(meta_begin, 64 << 10);
   meta_end = RoundUpTo(meta_end, 64 << 10);
   if (!data_mapped) {
 @@ -634,9 +650,6 @@ void MapShadow(uptr addr, uptr size) {
       Die();
   } else {
     // Mapping continuous heap.
-    // Windows wants 64K alignment.
-    meta_begin = RoundDownTo(meta_begin, 64 << 10);
-    meta_end = RoundUpTo(meta_end, 64 << 10);
     CHECK_GT(meta_end, mapped_meta_end);
     if (meta_begin < mapped_meta_end)
       meta_begin = mapped_meta_end;
 @@ -679,6 +692,12 @@ void CheckUnwind() {
 bool is_initialized;
+// Symbolization indirectly calls dl_iterate_phdr. If a CHECK() fails early on
+// (prior to the dl_iterate_phdr interceptor setup), resulting in an attempted
+// symbolization, it will segfault.
+// dl_iterate_phdr is not intercepted for Android.
+bool ready_to_symbolize = SANITIZER_ANDROID;
 void Initialize(ThreadState *thr) {
   // Thread safe because done before all threads exist.
   if (is_initialized)

lib/libtsan/tsan_rtl.h+4-1

 @@ -54,13 +54,15 @@
 namespace __tsan {
+extern bool ready_to_symbolize;
 #if !SANITIZER_GO
 struct MapUnmapCallback;
 #  if defined(__mips64) || defined(__aarch64__) || defined(__loongarch__) || \
       defined(__powerpc__) || SANITIZER_RISCV64
 struct AP32 {
-  static const uptr kSpaceBeg = 0;
+  static const uptr kSpaceBeg = SANITIZER_MMAP_BEGIN;
   static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
   static const uptr kMetadataSize = 0;
   typedef __sanitizer::CompactSizeClassMap SizeClassMap;
 @@ -98,6 +100,7 @@ struct JmpBuf {
   uptr sp;
   int int_signal_send;
   bool in_blocking_func;
+  uptr oldset_stack_size;
   uptr in_signal_handler;
   uptr *shadow_stack_pos;
 };

lib/libtsan/tsan_rtl_access.cpp+18-12

...	@@ -523,9 +523,9 @@ SECOND:	...	@@ -523,9 +523,9 @@ SECOND:
523	}	523	}
524		524
525	void ShadowSet(RawShadow* p, RawShadow* end, RawShadow v) {	525	void ShadowSet(RawShadow* p, RawShadow* end, RawShadow v) {
526	DCHECK_LE(p, end);	526	DCHECK_LT(p, end);
527	DCHECK(IsShadowMem(p));	527	DCHECK(IsShadowMem(p));
528	DCHECK(IsShadowMem(end));	528	DCHECK(IsShadowMem(end - 1));
529	UNUSED const uptr kAlign = kShadowCnt * kShadowSize;	529	UNUSED const uptr kAlign = kShadowCnt * kShadowSize;
530	DCHECK_EQ(reinterpret_cast<uptr>(p) % kAlign, 0);	530	DCHECK_EQ(reinterpret_cast<uptr>(p) % kAlign, 0);
531	DCHECK_EQ(reinterpret_cast<uptr>(end) % kAlign, 0);	531	DCHECK_EQ(reinterpret_cast<uptr>(end) % kAlign, 0);
...	@@ -569,6 +569,7 @@ static void MemoryRangeSet(uptr addr, uptr size, RawShadow val) {	...	@@ -569,6 +569,7 @@ static void MemoryRangeSet(uptr addr, uptr size, RawShadow val) {
569	RawShadow* mid1 =	569	RawShadow* mid1 =
570	Min(end, reinterpret_cast<RawShadow*>(RoundUp(	570	Min(end, reinterpret_cast<RawShadow*>(RoundUp(
571	reinterpret_cast<uptr>(begin) + kPageSize / 2, kPageSize)));	571	reinterpret_cast<uptr>(begin) + kPageSize / 2, kPageSize)));
		572	// begin must < mid1
572	ShadowSet(begin, mid1, val);	573	ShadowSet(begin, mid1, val);
573	// Reset middle part.	574	// Reset middle part.
574	RawShadow* mid2 = RoundDown(end, kPageSize);	575	RawShadow* mid2 = RoundDown(end, kPageSize);
...	@@ -577,7 +578,10 @@ static void MemoryRangeSet(uptr addr, uptr size, RawShadow val) {	...	@@ -577,7 +578,10 @@ static void MemoryRangeSet(uptr addr, uptr size, RawShadow val) {
577	Die();	578	Die();
578	}	579	}
579	// Set the ending.	580	// Set the ending.
580	ShadowSet(mid2, end, val);	581	if (mid2 < end)
		582	ShadowSet(mid2, end, val);
		583	else
		584	DCHECK_EQ(mid2, end);
581	}	585	}
582		586
583	void MemoryResetRange(ThreadState* thr, uptr pc, uptr addr, uptr size) {	587	void MemoryResetRange(ThreadState* thr, uptr pc, uptr addr, uptr size) {
...	@@ -669,7 +673,7 @@ void MemoryAccessRangeT(ThreadState* thr, uptr pc, uptr addr, uptr size) {	...	@@ -669,7 +673,7 @@ void MemoryAccessRangeT(ThreadState* thr, uptr pc, uptr addr, uptr size) {
669	RawShadow* shadow_mem = MemToShadow(addr);	673	RawShadow* shadow_mem = MemToShadow(addr);
670	DPrintf2("#%d: MemoryAccessRange: @%p %p size=%d is_read=%d\n", thr->tid,	674	DPrintf2("#%d: MemoryAccessRange: @%p %p size=%d is_read=%d\n", thr->tid,
671	(void)pc, (void)addr, (int)size, is_read);	675	(void)pc, (void)addr, (int)size, is_read);
672		676	DCHECK_NE(size, 0);
673	#if SANITIZER_DEBUG	677	#if SANITIZER_DEBUG
674	if (!IsAppMem(addr)) {	678	if (!IsAppMem(addr)) {
675	Printf("Access to non app mem start: %p\n", (void*)addr);	679	Printf("Access to non app mem start: %p\n", (void*)addr);
...	@@ -684,16 +688,18 @@ void MemoryAccessRangeT(ThreadState* thr, uptr pc, uptr addr, uptr size) {	...	@@ -684,16 +688,18 @@ void MemoryAccessRangeT(ThreadState* thr, uptr pc, uptr addr, uptr size) {
684	DCHECK(IsShadowMem(shadow_mem));	688	DCHECK(IsShadowMem(shadow_mem));
685	}	689	}
686		690
687	RawShadow* shadow_mem_end = reinterpret_cast<RawShadow*>(	691	uptr rounded_size =
688	reinterpret_cast<uptr>(shadow_mem) + size * kShadowMultiplier - 1);	692	(RoundUpTo(addr + size, kShadowCell) - RoundDownTo(addr, kShadowCell));
689	if (!IsShadowMem(shadow_mem_end)) {	693	RawShadow* shadow_mem_end =
690	Printf("Bad shadow end addr: %p (%p)\n", shadow_mem_end,	694	shadow_mem + rounded_size / kShadowCell * kShadowCnt;
		695	if (!IsShadowMem(shadow_mem_end - 1)) {
		696	Printf("Bad shadow end addr: %p (%p)\n", shadow_mem_end - 1,
691	(void*)(addr + size - 1));	697	(void*)(addr + size - 1));
692	Printf(	698	Printf(
693	"Shadow start addr (ok): %p (%p); size: 0x%zx; kShadowMultiplier: "	699	"Shadow start addr (ok): %p (%p); size: 0x%zx; rounded_size: 0x%zx; "
694	"%zx\n",	700	"kShadowMultiplier: %zx\n",
695	shadow_mem, (void*)addr, size, kShadowMultiplier);	701	shadow_mem, (void*)addr, size, rounded_size, kShadowMultiplier);
696	DCHECK(IsShadowMem(shadow_mem_end));	702	DCHECK(IsShadowMem(shadow_mem_end - 1));
697	}	703	}
698	#endif	704	#endif
699		705

lib/libtsan/tsan_rtl_report.cpp+10-1

...	@@ -846,7 +846,16 @@ ALWAYS_INLINE USED void PrintCurrentStack(uptr pc, bool fast) {	...	@@ -846,7 +846,16 @@ ALWAYS_INLINE USED void PrintCurrentStack(uptr pc, bool fast) {
846	ptrace->trace_buffer[i] = ptrace->trace_buffer[ptrace->size - i - 1];	846	ptrace->trace_buffer[i] = ptrace->trace_buffer[ptrace->size - i - 1];
847	ptrace->trace_buffer[ptrace->size - i - 1] = tmp;	847	ptrace->trace_buffer[ptrace->size - i - 1] = tmp;
848	}	848	}
849	PrintStack(SymbolizeStack(*ptrace));	849
		850	if (ready_to_symbolize) {
		851	PrintStack(SymbolizeStack(*ptrace));
		852	} else {
		853	Printf(
		854	"WARNING: PrintCurrentStack() has been called too early, before "
		855	"symbolization is possible. Printing unsymbolized stack trace:\n");
		856	for (unsigned int i = 0; i < ptrace->size; i++)
		857	Printf(" #%u: 0x%zx\n", i, ptrace->trace[i]);
		858	}
850	#endif	859	#endif
851	}	860	}
852		861

lib/libtsan/tsan_sync.cpp+22-5

...	@@ -246,12 +246,29 @@ void MetaMap::MoveMemory(uptr src, uptr dst, uptr sz) {	...	@@ -246,12 +246,29 @@ void MetaMap::MoveMemory(uptr src, uptr dst, uptr sz) {
246	// there are no concurrent accesses to the regions (e.g. stop-the-world).	246	// there are no concurrent accesses to the regions (e.g. stop-the-world).
247	CHECK_NE(src, dst);	247	CHECK_NE(src, dst);
248	CHECK_NE(sz, 0);	248	CHECK_NE(sz, 0);
		249
		250	// The current MoveMemory implementation behaves incorrectly when src, dst,
		251	// and sz are not aligned to kMetaShadowCell.
		252	// For example, with kMetaShadowCell == 8:
		253	// - src = 4: unexpectedly clears the metadata for the range [0, 4).
		254	// - src = 16, dst = 4, size = 8: A sync variable for addr = 20, which should
		255	// be moved to the metadata for address 8, is incorrectly moved to the
		256	// metadata for address 0 instead.
		257	// - src = 0, sz = 4: fails to move the tail metadata.
		258	// Therefore, the following assertions is needed.
		259	DCHECK_EQ(src % kMetaShadowCell, 0);
		260	DCHECK_EQ(dst % kMetaShadowCell, 0);
		261	DCHECK_EQ(sz % kMetaShadowCell, 0);
		262
249	uptr diff = dst - src;	263	uptr diff = dst - src;
250	u32 *src_meta = MemToMeta(src);	264	u32 src_meta, dst_meta, *src_meta_end;
251	u32 *dst_meta = MemToMeta(dst);	265	uptr inc;
252	u32 *src_meta_end = MemToMeta(src + sz);	266	if (dst < src) {
253	uptr inc = 1;	267	src_meta = MemToMeta(src);
254	if (dst > src) {	268	dst_meta = MemToMeta(dst);
		269	src_meta_end = MemToMeta(src + sz);
		270	inc = 1;
		271	} else {
255	src_meta = MemToMeta(src + sz) - 1;	272	src_meta = MemToMeta(src + sz) - 1;
256	dst_meta = MemToMeta(dst + sz) - 1;	273	dst_meta = MemToMeta(dst + sz) - 1;
257	src_meta_end = MemToMeta(src) - 1;	274	src_meta_end = MemToMeta(src) - 1;

lib/libtsan/ubsan/ubsan_platform.h+1-1

...	@@ -16,7 +16,7 @@	...	@@ -16,7 +16,7 @@
16	#if defined(__linux__) \|\| defined(__FreeBSD__) \|\| defined(__APPLE__) \|\| \	16	#if defined(__linux__) \|\| defined(__FreeBSD__) \|\| defined(__APPLE__) \|\| \
17	defined(__NetBSD__) \|\| defined(__DragonFly__) \|\| \	17	defined(__NetBSD__) \|\| defined(__DragonFly__) \|\| \
18	(defined(__sun__) && defined(__svr4__)) \|\| defined(_WIN32) \|\| \	18	(defined(__sun__) && defined(__svr4__)) \|\| defined(_WIN32) \|\| \
19	defined(__Fuchsia__)	19	defined(__Fuchsia__) \|\| defined(__HAIKU__)
20	#define CAN_SANITIZE_UB 1	20	#define CAN_SANITIZE_UB 1
21	#else	21	#else
22	# define CAN_SANITIZE_UB 0	22	# define CAN_SANITIZE_UB 0

src/libs/libtsan.zig+3

...	@@ -403,6 +403,7 @@ const sanitizer_common_sources = [_][]const u8{	...	@@ -403,6 +403,7 @@ const sanitizer_common_sources = [_][]const u8{
403	"sanitizer_flag_parser.cpp",	403	"sanitizer_flag_parser.cpp",
404	"sanitizer_flags.cpp",	404	"sanitizer_flags.cpp",
405	"sanitizer_fuchsia.cpp",	405	"sanitizer_fuchsia.cpp",
		406	"sanitizer_haiku.cpp",
406	"sanitizer_libc.cpp",	407	"sanitizer_libc.cpp",
407	"sanitizer_libignore.cpp",	408	"sanitizer_libignore.cpp",
408	"sanitizer_linux.cpp",	409	"sanitizer_linux.cpp",
...	@@ -420,6 +421,7 @@ const sanitizer_common_sources = [_][]const u8{	...	@@ -420,6 +421,7 @@ const sanitizer_common_sources = [_][]const u8{
420	"sanitizer_procmaps_bsd.cpp",	421	"sanitizer_procmaps_bsd.cpp",
421	"sanitizer_procmaps_common.cpp",	422	"sanitizer_procmaps_common.cpp",
422	"sanitizer_procmaps_fuchsia.cpp",	423	"sanitizer_procmaps_fuchsia.cpp",
		424	"sanitizer_procmaps_haiku.cpp",
423	"sanitizer_procmaps_linux.cpp",	425	"sanitizer_procmaps_linux.cpp",
424	"sanitizer_procmaps_mac.cpp",	426	"sanitizer_procmaps_mac.cpp",
425	"sanitizer_procmaps_solaris.cpp",	427	"sanitizer_procmaps_solaris.cpp",
...	@@ -478,6 +480,7 @@ const sanitizer_symbolizer_sources = [_][]const u8{	...	@@ -478,6 +480,7 @@ const sanitizer_symbolizer_sources = [_][]const u8{
478	};	480	};
479		481
480	const interception_sources = [_][]const u8{	482	const interception_sources = [_][]const u8{
		483	"interception_aix.cpp",
481	"interception_linux.cpp",	484	"interception_linux.cpp",
482	"interception_mac.cpp",	485	"interception_mac.cpp",
483	"interception_win.cpp",	486	"interception_win.cpp",

author	Alex Rønne Petersen <alex@alexrp.com> 2025-07-16 11:22:46+02:00
committer	Alex Rønne Petersen <alex@alexrp.com> 2025-08-30 06:36:41+02:00
log	ac2050609055d76a58b058b064f0b0c4d54e2faa
tree	54855b2bde3e1eed89d870251b044e93972f6c5c
parent	85438e75e04b356ca319051c33e0987a9958ad4a
signature	Signed by SSH key SHA256:7B/LJ7bpR1eX8aCXSr4mtd5M45VMPKcx9zY8e95b5QM

libtsan: update to LLVM 21