Commit dbaea8d67e680121f4e917458a99bc538b473d9d | zig

lib/libtsan/LICENSE.TXT created+311

...	@@ -0,0 +1,311 @@
1	==============================================================================
2	The LLVM Project is under the Apache License v2.0 with LLVM Exceptions:
3	==============================================================================
4
5	Apache License
6	Version 2.0, January 2004
7	http://www.apache.org/licenses/
8
9	TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
10
11	1. Definitions.
12
13	"License" shall mean the terms and conditions for use, reproduction,
14	and distribution as defined by Sections 1 through 9 of this document.
15
16	"Licensor" shall mean the copyright owner or entity authorized by
17	the copyright owner that is granting the License.
18
19	"Legal Entity" shall mean the union of the acting entity and all
20	other entities that control, are controlled by, or are under common
21	control with that entity. For the purposes of this definition,
22	"control" means (i) the power, direct or indirect, to cause the
23	direction or management of such entity, whether by contract or
24	otherwise, or (ii) ownership of fifty percent (50%) or more of the
25	outstanding shares, or (iii) beneficial ownership of such entity.
26
27	"You" (or "Your") shall mean an individual or Legal Entity
28	exercising permissions granted by this License.
29
30	"Source" form shall mean the preferred form for making modifications,
31	including but not limited to software source code, documentation
32	source, and configuration files.
33
34	"Object" form shall mean any form resulting from mechanical
35	transformation or translation of a Source form, including but
36	not limited to compiled object code, generated documentation,
37	and conversions to other media types.
38
39	"Work" shall mean the work of authorship, whether in Source or
40	Object form, made available under the License, as indicated by a
41	copyright notice that is included in or attached to the work
42	(an example is provided in the Appendix below).
43
44	"Derivative Works" shall mean any work, whether in Source or Object
45	form, that is based on (or derived from) the Work and for which the
46	editorial revisions, annotations, elaborations, or other modifications
47	represent, as a whole, an original work of authorship. For the purposes
48	of this License, Derivative Works shall not include works that remain
49	separable from, or merely link (or bind by name) to the interfaces of,
50	the Work and Derivative Works thereof.
51
52	"Contribution" shall mean any work of authorship, including
53	the original version of the Work and any modifications or additions
54	to that Work or Derivative Works thereof, that is intentionally
55	submitted to Licensor for inclusion in the Work by the copyright owner
56	or by an individual or Legal Entity authorized to submit on behalf of
57	the copyright owner. For the purposes of this definition, "submitted"
58	means any form of electronic, verbal, or written communication sent
59	to the Licensor or its representatives, including but not limited to
60	communication on electronic mailing lists, source code control systems,
61	and issue tracking systems that are managed by, or on behalf of, the
62	Licensor for the purpose of discussing and improving the Work, but
63	excluding communication that is conspicuously marked or otherwise
64	designated in writing by the copyright owner as "Not a Contribution."
65
66	"Contributor" shall mean Licensor and any individual or Legal Entity
67	on behalf of whom a Contribution has been received by Licensor and
68	subsequently incorporated within the Work.
69
70	2. Grant of Copyright License. Subject to the terms and conditions of
71	this License, each Contributor hereby grants to You a perpetual,
72	worldwide, non-exclusive, no-charge, royalty-free, irrevocable
73	copyright license to reproduce, prepare Derivative Works of,
74	publicly display, publicly perform, sublicense, and distribute the
75	Work and such Derivative Works in Source or Object form.
76
77	3. Grant of Patent License. Subject to the terms and conditions of
78	this License, each Contributor hereby grants to You a perpetual,
79	worldwide, non-exclusive, no-charge, royalty-free, irrevocable
80	(except as stated in this section) patent license to make, have made,
81	use, offer to sell, sell, import, and otherwise transfer the Work,
82	where such license applies only to those patent claims licensable
83	by such Contributor that are necessarily infringed by their
84	Contribution(s) alone or by combination of their Contribution(s)
85	with the Work to which such Contribution(s) was submitted. If You
86	institute patent litigation against any entity (including a
87	cross-claim or counterclaim in a lawsuit) alleging that the Work
88	or a Contribution incorporated within the Work constitutes direct
89	or contributory patent infringement, then any patent licenses
90	granted to You under this License for that Work shall terminate
91	as of the date such litigation is filed.
92
93	4. Redistribution. You may reproduce and distribute copies of the
94	Work or Derivative Works thereof in any medium, with or without
95	modifications, and in Source or Object form, provided that You
96	meet the following conditions:
97
98	(a) You must give any other recipients of the Work or
99	Derivative Works a copy of this License; and
100
101	(b) You must cause any modified files to carry prominent notices
102	stating that You changed the files; and
103
104	(c) You must retain, in the Source form of any Derivative Works
105	that You distribute, all copyright, patent, trademark, and
106	attribution notices from the Source form of the Work,
107	excluding those notices that do not pertain to any part of
108	the Derivative Works; and
109
110	(d) If the Work includes a "NOTICE" text file as part of its
111	distribution, then any Derivative Works that You distribute must
112	include a readable copy of the attribution notices contained
113	within such NOTICE file, excluding those notices that do not
114	pertain to any part of the Derivative Works, in at least one
115	of the following places: within a NOTICE text file distributed
116	as part of the Derivative Works; within the Source form or
117	documentation, if provided along with the Derivative Works; or,
118	within a display generated by the Derivative Works, if and
119	wherever such third-party notices normally appear. The contents
120	of the NOTICE file are for informational purposes only and
121	do not modify the License. You may add Your own attribution
122	notices within Derivative Works that You distribute, alongside
123	or as an addendum to the NOTICE text from the Work, provided
124	that such additional attribution notices cannot be construed
125	as modifying the License.
126
127	You may add Your own copyright statement to Your modifications and
128	may provide additional or different license terms and conditions
129	for use, reproduction, or distribution of Your modifications, or
130	for any such Derivative Works as a whole, provided Your use,
131	reproduction, and distribution of the Work otherwise complies with
132	the conditions stated in this License.
133
134	5. Submission of Contributions. Unless You explicitly state otherwise,
135	any Contribution intentionally submitted for inclusion in the Work
136	by You to the Licensor shall be under the terms and conditions of
137	this License, without any additional terms or conditions.
138	Notwithstanding the above, nothing herein shall supersede or modify
139	the terms of any separate license agreement you may have executed
140	with Licensor regarding such Contributions.
141
142	6. Trademarks. This License does not grant permission to use the trade
143	names, trademarks, service marks, or product names of the Licensor,
144	except as required for reasonable and customary use in describing the
145	origin of the Work and reproducing the content of the NOTICE file.
146
147	7. Disclaimer of Warranty. Unless required by applicable law or
148	agreed to in writing, Licensor provides the Work (and each
149	Contributor provides its Contributions) on an "AS IS" BASIS,
150	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
151	implied, including, without limitation, any warranties or conditions
152	of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
153	PARTICULAR PURPOSE. You are solely responsible for determining the
154	appropriateness of using or redistributing the Work and assume any
155	risks associated with Your exercise of permissions under this License.
156
157	8. Limitation of Liability. In no event and under no legal theory,
158	whether in tort (including negligence), contract, or otherwise,
159	unless required by applicable law (such as deliberate and grossly
160	negligent acts) or agreed to in writing, shall any Contributor be
161	liable to You for damages, including any direct, indirect, special,
162	incidental, or consequential damages of any character arising as a
163	result of this License or out of the use or inability to use the
164	Work (including but not limited to damages for loss of goodwill,
165	work stoppage, computer failure or malfunction, or any and all
166	other commercial damages or losses), even if such Contributor
167	has been advised of the possibility of such damages.
168
169	9. Accepting Warranty or Additional Liability. While redistributing
170	the Work or Derivative Works thereof, You may choose to offer,
171	and charge a fee for, acceptance of support, warranty, indemnity,
172	or other liability obligations and/or rights consistent with this
173	License. However, in accepting such obligations, You may act only
174	on Your own behalf and on Your sole responsibility, not on behalf
175	of any other Contributor, and only if You agree to indemnify,
176	defend, and hold each Contributor harmless for any liability
177	incurred by, or claims asserted against, such Contributor by reason
178	of your accepting any such warranty or additional liability.
179
180	END OF TERMS AND CONDITIONS
181
182	APPENDIX: How to apply the Apache License to your work.
183
184	To apply the Apache License to your work, attach the following
185	boilerplate notice, with the fields enclosed by brackets "[]"
186	replaced with your own identifying information. (Don't include
187	the brackets!) The text should be enclosed in the appropriate
188	comment syntax for the file format. We also recommend that a
189	file or class name and description of purpose be included on the
190	same "printed page" as the copyright notice for easier
191	identification within third-party archives.
192
193	Copyright [yyyy] [name of copyright owner]
194
195	Licensed under the Apache License, Version 2.0 (the "License");
196	you may not use this file except in compliance with the License.
197	You may obtain a copy of the License at
198
199	http://www.apache.org/licenses/LICENSE-2.0
200
201	Unless required by applicable law or agreed to in writing, software
202	distributed under the License is distributed on an "AS IS" BASIS,
203	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
204	See the License for the specific language governing permissions and
205	limitations under the License.
206
207
208	---- LLVM Exceptions to the Apache 2.0 License ----
209
210	As an exception, if, as a result of your compiling your source code, portions
211	of this Software are embedded into an Object form of such source code, you
212	may redistribute such embedded portions in such Object form without complying
213	with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
214
215	In addition, if you combine or link compiled forms of this Software with
216	software that is licensed under the GPLv2 ("Combined Software") and if a
217	court of competent jurisdiction determines that the patent provision (Section
218	3), the indemnity provision (Section 9) or other Section of the License
219	conflicts with the conditions of the GPLv2, you may retroactively and
220	prospectively choose to deem waived or otherwise exclude such Section(s) of
221	the License, but only in their entirety and only with respect to the Combined
222	Software.
223
224	==============================================================================
225	Software from third parties included in the LLVM Project:
226	==============================================================================
227	The LLVM Project contains third party software which is under different license
228	terms. All such code will be identified clearly using at least one of two
229	mechanisms:
230	1) It will be in a separate directory tree with its own `LICENSE.txt` or
231	`LICENSE` file at the top containing the specific license and restrictions
232	which apply to that software, or
233	2) It will contain specific license and restriction terms at the top of every
234	file.
235
236	==============================================================================
237	Legacy LLVM License (https://llvm.org/docs/DeveloperPolicy.html#legacy):
238	==============================================================================
239
240	The compiler_rt library is dual licensed under both the University of Illinois
241	"BSD-Like" license and the MIT license. As a user of this code you may choose
242	to use it under either license. As a contributor, you agree to allow your code
243	to be used under both.
244
245	Full text of the relevant licenses is included below.
246
247	==============================================================================
248
249	University of Illinois/NCSA
250	Open Source License
251
252	Copyright (c) 2009-2019 by the contributors listed in CREDITS.TXT
253
254	All rights reserved.
255
256	Developed by:
257
258	LLVM Team
259
260	University of Illinois at Urbana-Champaign
261
262	http://llvm.org
263
264	Permission is hereby granted, free of charge, to any person obtaining a copy of
265	this software and associated documentation files (the "Software"), to deal with
266	the Software without restriction, including without limitation the rights to
267	use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
268	of the Software, and to permit persons to whom the Software is furnished to do
269	so, subject to the following conditions:
270
271	* Redistributions of source code must retain the above copyright notice,
272	this list of conditions and the following disclaimers.
273
274	* Redistributions in binary form must reproduce the above copyright notice,
275	this list of conditions and the following disclaimers in the
276	documentation and/or other materials provided with the distribution.
277
278	* Neither the names of the LLVM Team, University of Illinois at
279	Urbana-Champaign, nor the names of its contributors may be used to
280	endorse or promote products derived from this Software without specific
281	prior written permission.
282
283	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
284	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
285	FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
286	CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
287	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
288	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
289	SOFTWARE.
290
291	==============================================================================
292
293	Copyright (c) 2009-2015 by the contributors listed in CREDITS.TXT
294
295	Permission is hereby granted, free of charge, to any person obtaining a copy
296	of this software and associated documentation files (the "Software"), to deal
297	in the Software without restriction, including without limitation the rights
298	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
299	copies of the Software, and to permit persons to whom the Software is
300	furnished to do so, subject to the following conditions:
301
302	The above copyright notice and this permission notice shall be included in
303	all copies or substantial portions of the Software.
304
305	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
306	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
307	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
308	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
309	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
310	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
311	THE SOFTWARE.

lib/libtsan/builtins/assembly.h+41-8

 @@ -14,7 +14,7 @@
 #ifndef COMPILERRT_ASSEMBLY_H
 #define COMPILERRT_ASSEMBLY_H
-#if defined(__linux__) && defined(__CET__)
+#ifdef __CET__
 #if __has_include(<cet.h>)
 #include <cet.h>
 #endif
 @@ -71,19 +71,35 @@
 #endif
+#if defined(__aarch64__) && defined(__ELF__) &&                                \
+    defined(COMPILER_RT_EXECUTE_ONLY_CODE)
+// The assembler always creates an implicit '.text' section with default flags
+// (SHF_ALLOC | SHF_EXECINSTR), which is incompatible with the execute-only
+// '.text' section we want to create here because of the missing
+// SHF_AARCH64_PURECODE section flag. To solve this, we use 'unique,0' to
+// differentiate the two sections. The output will therefore have two separate
+// sections named '.text', where code will be placed into the execute-only
+// '.text' section, and the implicitly-created one will be empty.
+#define TEXT_SECTION                                                           \
+  .section .text,"axy",@progbits,unique,0
+#else
+#define TEXT_SECTION                                                           \
+  .text
+#endif
 #if defined(__arm__) || defined(__aarch64__) || defined(__arm64ec__)
 #define FUNC_ALIGN                                                             \
-  .text SEPARATOR                                                              \
   .balign 16 SEPARATOR
 #else
 #define FUNC_ALIGN
 #endif
-// BTI and PAC gnu property note
+// BTI, PAC, and GCS gnu property note
 #define NT_GNU_PROPERTY_TYPE_0 5
 #define GNU_PROPERTY_AARCH64_FEATURE_1_AND 0xc0000000
 #define GNU_PROPERTY_AARCH64_FEATURE_1_BTI 1
 #define GNU_PROPERTY_AARCH64_FEATURE_1_PAC 2
+#define GNU_PROPERTY_AARCH64_FEATURE_1_GCS 4
 #if defined(__ARM_FEATURE_BTI_DEFAULT)
 #define BTI_FLAG GNU_PROPERTY_AARCH64_FEATURE_1_BTI
 @@ -97,6 +113,12 @@
 #define PAC_FLAG 0
 #endif
+#if defined(__ARM_FEATURE_GCS_DEFAULT)
+#define GCS_FLAG GNU_PROPERTY_AARCH64_FEATURE_1_GCS
+#else
+#define GCS_FLAG 0
+#endif
 #define GNU_PROPERTY(type, value)                                              \
   .pushsection .note.gnu.property, "a" SEPARATOR                               \
   .p2align 3 SEPARATOR                                                         \
 @@ -118,11 +140,12 @@
 #define BTI_J
 #endif
-#if (BTI_FLAG | PAC_FLAG) != 0
+#if (BTI_FLAG | PAC_FLAG | GCS_FLAG) != 0
-#define GNU_PROPERTY_BTI_PAC                                                   \
+#define GNU_PROPERTY_BTI_PAC_GCS                                               \
-  GNU_PROPERTY(GNU_PROPERTY_AARCH64_FEATURE_1_AND, BTI_FLAG | PAC_FLAG)
+  GNU_PROPERTY(GNU_PROPERTY_AARCH64_FEATURE_1_AND,                             \
+               BTI_FLAG | PAC_FLAG | GCS_FLAG)
 #else
-#define GNU_PROPERTY_BTI_PAC
+#define GNU_PROPERTY_BTI_PAC_GCS
 #endif
 #if defined(__clang__) || defined(__GCC_HAVE_DWARF2_CFI_ASM)
 @@ -247,6 +270,7 @@
 #endif
 #define DEFINE_COMPILERRT_FUNCTION(name)                                       \
+  TEXT_SECTION SEPARATOR                                                       \
   DEFINE_CODE_STATE                                                            \
   FILE_LEVEL_DIRECTIVE SEPARATOR                                               \
   .globl FUNC_SYMBOL(SYMBOL_NAME(name)) SEPARATOR                              \
 @@ -256,6 +280,7 @@
   FUNC_SYMBOL(SYMBOL_NAME(name)):
 #define DEFINE_COMPILERRT_THUMB_FUNCTION(name)                                 \
+  TEXT_SECTION SEPARATOR                                                       \
   DEFINE_CODE_STATE                                                            \
   FILE_LEVEL_DIRECTIVE SEPARATOR                                               \
   .globl FUNC_SYMBOL(SYMBOL_NAME(name)) SEPARATOR                              \
 @@ -265,6 +290,7 @@
   FUNC_SYMBOL(SYMBOL_NAME(name)):
 #define DEFINE_COMPILERRT_PRIVATE_FUNCTION(name)                               \
+  TEXT_SECTION SEPARATOR                                                       \
   DEFINE_CODE_STATE                                                            \
   FILE_LEVEL_DIRECTIVE SEPARATOR                                               \
   .globl FUNC_SYMBOL(SYMBOL_NAME(name)) SEPARATOR                              \
 @@ -274,6 +300,7 @@
   FUNC_SYMBOL(SYMBOL_NAME(name)):
 #define DEFINE_COMPILERRT_PRIVATE_FUNCTION_UNMANGLED(name)                     \
+  TEXT_SECTION SEPARATOR                                                       \
   DEFINE_CODE_STATE                                                            \
   .globl FUNC_SYMBOL(name) SEPARATOR                                           \
   SYMBOL_IS_FUNC(name) SEPARATOR                                               \
 @@ -282,6 +309,7 @@
   FUNC_SYMBOL(name):
 #define DEFINE_COMPILERRT_OUTLINE_FUNCTION_UNMANGLED(name)                     \
+  TEXT_SECTION SEPARATOR                                                       \
   DEFINE_CODE_STATE                                                            \
   FUNC_ALIGN                                                                   \
   .globl FUNC_SYMBOL(name) SEPARATOR                                           \
 @@ -296,7 +324,7 @@
   .globl FUNC_SYMBOL(SYMBOL_NAME(name)) SEPARATOR                              \
   SYMBOL_IS_FUNC(SYMBOL_NAME(name)) SEPARATOR                                  \
   DECLARE_SYMBOL_VISIBILITY(name) SEPARATOR                                    \
-  .set FUNC_SYMBOL(SYMBOL_NAME(name)), FUNC_SYMBOL(target) SEPARATOR
+  .set FUNC_SYMBOL(SYMBOL_NAME(name)), FUNC_SYMBOL(SYMBOL_NAME(target)) SEPARATOR
 #if defined(__ARM_EABI__)
 #define DEFINE_AEABI_FUNCTION_ALIAS(aeabi_name, name)                          \
 @@ -329,4 +357,9 @@
 #endif
 #endif
+#if defined(__ASSEMBLER__) && (defined(__i386__) || defined(__amd64__)) &&     \
+    !defined(__arm64ec__)
+.att_syntax
+#endif
 #endif // COMPILERRT_ASSEMBLY_H

lib/libtsan/interception/interception_win.cpp+4

lib/libtsan/sanitizer_common/sanitizer_allocator_primary32.h+1

...	@@ -288,6 +288,7 @@ class SizeClassAllocator32 {	...	@@ -288,6 +288,7 @@ class SizeClassAllocator32 {
288	uptr ComputeRegionId(uptr mem) const {	288	uptr ComputeRegionId(uptr mem) const {
289	if (SANITIZER_SIGN_EXTENDED_ADDRESSES)	289	if (SANITIZER_SIGN_EXTENDED_ADDRESSES)
290	mem &= (kSpaceSize - 1);	290	mem &= (kSpaceSize - 1);
		291	mem -= kSpaceBeg;
291	const uptr res = mem >> kRegionSizeLog;	292	const uptr res = mem >> kRegionSizeLog;
292	CHECK_LT(res, kNumPossibleRegions);	293	CHECK_LT(res, kNumPossibleRegions);
293	return res;	294	return res;

lib/libtsan/sanitizer_common/sanitizer_allocator_primary64.h+18

...	@@ -113,6 +113,24 @@ class SizeClassAllocator64 {	...	@@ -113,6 +113,24 @@ class SizeClassAllocator64 {
113	// ~(uptr)0.	113	// ~(uptr)0.
114	void Init(s32 release_to_os_interval_ms, uptr heap_start = 0) {	114	void Init(s32 release_to_os_interval_ms, uptr heap_start = 0) {
115	uptr TotalSpaceSize = kSpaceSize + AdditionalSize();	115	uptr TotalSpaceSize = kSpaceSize + AdditionalSize();
		116
		117	uptr MaxAddr = GetMaxUserVirtualAddress();
		118	// VReport does not call the sanitizer allocator.
		119	VReport(3, "Max user virtual address: 0x%zx\n", MaxAddr);
		120	VReport(3, "Total space size for primary allocator: 0x%zx\n",
		121	TotalSpaceSize);
		122	// TODO: revise the check if we ever configure sanitizers to deliberately
		123	// map beyond the 2**48 barrier (note that Linux pretends the VMA is
		124	// limited to 48-bit for backwards compatibility, but allows apps to
		125	// explicitly specify an address beyond that).
		126	if (heap_start + TotalSpaceSize >= MaxAddr) {
		127	// We can't easily adjust the requested heap size, because kSpaceSize is
		128	// const (for optimization) and used throughout the code.
		129	VReport(0, "Error: heap size %zx exceeds max user virtual address %zx\n",
		130	TotalSpaceSize, MaxAddr);
		131	VReport(
		132	0, "Try using a kernel that allows a larger virtual address space\n");
		133	}
116	PremappedHeap = heap_start != 0;	134	PremappedHeap = heap_start != 0;
117	if (PremappedHeap) {	135	if (PremappedHeap) {
118	CHECK(!kUsingConstantSpaceBeg);	136	CHECK(!kUsingConstantSpaceBeg);

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

 @@ -78,8 +78,8 @@ uptr GetMmapGranularity();
 uptr GetMaxVirtualAddress();
 uptr GetMaxUserVirtualAddress();
 // Threads
-tid_t GetTid();
+ThreadID GetTid();
-int TgKill(pid_t pid, tid_t tid, int sig);
+int TgKill(pid_t pid, ThreadID tid, int sig);
 uptr GetThreadSelf();
 void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top,
                                 uptr *stack_bottom);
 @@ -390,6 +390,9 @@ void ReportDeadlySignal(const SignalContext &sig, u32 tid,
 void SetAlternateSignalStack();
 void UnsetAlternateSignalStack();
+bool IsSignalHandlerFromSanitizer(int signum);
+bool SetSignalHandlerFromSanitizer(int signum, bool new_state);
 // Construct a one-line string:
 //   SUMMARY: SanitizerToolName: error_message
 // and pass it to __sanitizer_report_error_summary.
 @@ -484,6 +487,13 @@ inline uptr Log2(uptr x) {
   return LeastSignificantSetBitIndex(x);
 }
+inline bool IntervalsAreSeparate(uptr start1, uptr end1, uptr start2,
+                                 uptr end2) {
+  CHECK_LE(start1, end1);
+  CHECK_LE(start2, end2);
+  return (end1 < start2) || (end2 < start1);
+}
 // Don't use std::min, std::max or std::swap, to minimize dependency
 // on libstdc++.
 template <class T>
 @@ -734,6 +744,7 @@ enum ModuleArch {
   kModuleArchARMV7S,
   kModuleArchARMV7K,
   kModuleArchARM64,
+  kModuleArchARM64E,
   kModuleArchLoongArch64,
   kModuleArchRISCV64,
   kModuleArchHexagon
 @@ -807,6 +818,8 @@ inline const char *ModuleArchToString(ModuleArch arch) {
       return "armv7k";
     case kModuleArchARM64:
       return "arm64";
+    case kModuleArchARM64E:
+      return "arm64e";
     case kModuleArchLoongArch64:
       return "loongarch64";
     case kModuleArchRISCV64:

lib/libtsan/sanitizer_common/sanitizer_common_interceptors.inc+30-4

...	@@ -1285,8 +1285,34 @@ INTERCEPTOR(int, puts, char *s) {	...	@@ -1285,8 +1285,34 @@ INTERCEPTOR(int, puts, char *s) {
1285	#endif	1285	#endif
1286		1286
1287	#if SANITIZER_INTERCEPT_PRCTL	1287	#if SANITIZER_INTERCEPT_PRCTL
1288	INTERCEPTOR(int, prctl, int option, unsigned long arg2, unsigned long arg3,	1288
1289	unsigned long arg4, unsigned long arg5) {	1289	# if defined(__aarch64__)
		1290	// https://llvm.org/docs/PointerAuth.html
		1291	// AArch64 is currently the only architecture with full PAC support.
		1292	// Avoid adding PAC instructions to prevent crashes caused by
		1293	// prctl(PR_PAC_RESET_KEYS, ...). Since PR_PAC_RESET_KEYS resets the
		1294	// authentication key, using the old key afterward will lead to a crash.
		1295
		1296	# if defined(__ARM_FEATURE_BTI_DEFAULT)
		1297	# define BRANCH_PROTECTION_ATTRIBUTE \
		1298	__attribute__((target("branch-protection=bti")))
		1299	# else
		1300	# define BRANCH_PROTECTION_ATTRIBUTE \
		1301	__attribute__((target("branch-protection=none")))
		1302	# endif
		1303
		1304	# define PRCTL_INTERCEPTOR(ret_type, func, ...) \
		1305	DEFINE_REAL(ret_type, func, __VA_ARGS__) \
		1306	DECLARE_WRAPPER(ret_type, func, __VA_ARGS__) \
		1307	extern "C" INTERCEPTOR_ATTRIBUTE BRANCH_PROTECTION_ATTRIBUTE ret_type \
		1308	WRAP(func)(__VA_ARGS__)
		1309
		1310	# else
		1311	# define PRCTL_INTERCEPTOR INTERCEPTOR
		1312	# endif
		1313
		1314	PRCTL_INTERCEPTOR(int, prctl, int option, unsigned long arg2,
		1315	unsigned long arg3, unsigned long arg4, unsigned long arg5) {
1290	void *ctx;	1316	void *ctx;
1291	COMMON_INTERCEPTOR_ENTER(ctx, prctl, option, arg2, arg3, arg4, arg5);	1317	COMMON_INTERCEPTOR_ENTER(ctx, prctl, option, arg2, arg3, arg4, arg5);
1292	static const int PR_SET_NAME = 15;	1318	static const int PR_SET_NAME = 15;
...	@@ -1300,7 +1326,7 @@ INTERCEPTOR(int, prctl, int option, unsigned long arg2, unsigned long arg3,	...	@@ -1300,7 +1326,7 @@ INTERCEPTOR(int, prctl, int option, unsigned long arg2, unsigned long arg3,
1300	static const int PR_SET_SECCOMP = 22;	1326	static const int PR_SET_SECCOMP = 22;
1301	static const int SECCOMP_MODE_FILTER = 2;	1327	static const int SECCOMP_MODE_FILTER = 2;
1302	# endif	1328	# endif
1303	if (option == PR_SET_VMA && arg2 == 0UL) {	1329	if (option == PR_SET_VMA && arg2 == 0UL && arg5 != 0UL) {
1304	char name = (char )arg5;	1330	char name = (char )arg5;
1305	COMMON_INTERCEPTOR_READ_RANGE(ctx, name, internal_strlen(name) + 1);	1331	COMMON_INTERCEPTOR_READ_RANGE(ctx, name, internal_strlen(name) + 1);
1306	}	1332	}
...	@@ -1326,7 +1352,7 @@ INTERCEPTOR(int, prctl, int option, unsigned long arg2, unsigned long arg3,	...	@@ -1326,7 +1352,7 @@ INTERCEPTOR(int, prctl, int option, unsigned long arg2, unsigned long arg3,
1326	}	1352	}
1327	return res;	1353	return res;
1328	}	1354	}
1329	#define INIT_PRCTL COMMON_INTERCEPT_FUNCTION(prctl)	1355	# define INIT_PRCTL COMMON_INTERCEPT_FUNCTION(prctl)
1330	#else	1356	#else
1331	#define INIT_PRCTL	1357	#define INIT_PRCTL
1332	#endif // SANITIZER_INTERCEPT_PRCTL	1358	#endif // SANITIZER_INTERCEPT_PRCTL

lib/libtsan/sanitizer_common/sanitizer_common_interceptors_ioctl.inc+4

 @@ -344,12 +344,16 @@ static void ioctl_table_fill() {
   _(SOUND_PCM_WRITE_CHANNELS, WRITE, sizeof(int));
   _(SOUND_PCM_WRITE_FILTER, WRITE, sizeof(int));
   _(TCFLSH, NONE, 0);
+#    if SANITIZER_TERMIOS_IOCTL_CONSTANTS
   _(TCGETS, WRITE, struct_termios_sz);
+#    endif
   _(TCSBRK, NONE, 0);
   _(TCSBRKP, NONE, 0);
+#    if SANITIZER_TERMIOS_IOCTL_CONSTANTS
   _(TCSETS, READ, struct_termios_sz);
   _(TCSETSF, READ, struct_termios_sz);
   _(TCSETSW, READ, struct_termios_sz);
+#    endif
   _(TCXONC, NONE, 0);
   _(TIOCGLCKTRMIOS, WRITE, struct_termios_sz);
   _(TIOCGSOFTCAR, WRITE, sizeof(int));

lib/libtsan/sanitizer_common/sanitizer_common_interceptors_vfork_aarch64.inc.S+2-1

...	@@ -5,6 +5,7 @@	...	@@ -5,6 +5,7 @@
5		5
6	ASM_HIDDEN(COMMON_INTERCEPTOR_SPILL_AREA)	6	ASM_HIDDEN(COMMON_INTERCEPTOR_SPILL_AREA)
7		7
		8	TEXT_SECTION
8	.comm _ZN14__interception10real_vforkE,8,8	9	.comm _ZN14__interception10real_vforkE,8,8
9	.globl ASM_WRAPPER_NAME(vfork)	10	.globl ASM_WRAPPER_NAME(vfork)
10	ASM_TYPE_FUNCTION(ASM_WRAPPER_NAME(vfork))	11	ASM_TYPE_FUNCTION(ASM_WRAPPER_NAME(vfork))
...	@@ -43,6 +44,6 @@ ASM_SIZE(vfork)	...	@@ -43,6 +44,6 @@ ASM_SIZE(vfork)
43	ASM_INTERCEPTOR_TRAMPOLINE(vfork)	44	ASM_INTERCEPTOR_TRAMPOLINE(vfork)
44	ASM_TRAMPOLINE_ALIAS(vfork, vfork)	45	ASM_TRAMPOLINE_ALIAS(vfork, vfork)
45		46
46	GNU_PROPERTY_BTI_PAC	47	GNU_PROPERTY_BTI_PAC_GCS
47		48
48	#endif	49	#endif

lib/libtsan/sanitizer_common/sanitizer_common_interceptors_vfork_i386.inc.S+2

...	@@ -2,6 +2,8 @@	...	@@ -2,6 +2,8 @@
2		2
3	#include "sanitizer_common/sanitizer_asm.h"	3	#include "sanitizer_common/sanitizer_asm.h"
4		4
		5	.att_syntax
		6
5	.comm _ZN14__interception10real_vforkE,4,4	7	.comm _ZN14__interception10real_vforkE,4,4
6	.globl ASM_WRAPPER_NAME(vfork)	8	.globl ASM_WRAPPER_NAME(vfork)
7	ASM_TYPE_FUNCTION(ASM_WRAPPER_NAME(vfork))	9	ASM_TYPE_FUNCTION(ASM_WRAPPER_NAME(vfork))

lib/libtsan/sanitizer_common/sanitizer_common_interceptors_vfork_x86_64.inc.S+2

...	@@ -2,6 +2,8 @@	...	@@ -2,6 +2,8 @@
2		2
3	#include "sanitizer_common/sanitizer_asm.h"	3	#include "sanitizer_common/sanitizer_asm.h"
4		4
		5	.att_syntax
		6
5	.comm _ZN14__interception10real_vforkE,8,8	7	.comm _ZN14__interception10real_vforkE,8,8
6	.globl ASM_WRAPPER_NAME(vfork)	8	.globl ASM_WRAPPER_NAME(vfork)
7	ASM_TYPE_FUNCTION(ASM_WRAPPER_NAME(vfork))	9	ASM_TYPE_FUNCTION(ASM_WRAPPER_NAME(vfork))

lib/libtsan/sanitizer_common/sanitizer_common_syscalls.inc+18

...	@@ -143,6 +143,12 @@ struct sanitizer_kernel_sockaddr {	...	@@ -143,6 +143,12 @@ struct sanitizer_kernel_sockaddr {
143	char sa_data[14];	143	char sa_data[14];
144	};	144	};
145		145
		146	struct sanitizer_kernel_open_how {
		147	u64 flags;
		148	u64 mode;
		149	u64 resolve;
		150	};
		151
146	// Real sigset size is always passed as a syscall argument.	152	// Real sigset size is always passed as a syscall argument.
147	// Declare it "void" to catch sizeof(kernel_sigset_t).	153	// Declare it "void" to catch sizeof(kernel_sigset_t).
148	typedef void kernel_sigset_t;	154	typedef void kernel_sigset_t;
...	@@ -2843,6 +2849,18 @@ PRE_SYSCALL(openat)(long dfd, const void *filename, long flags, long mode) {	...	@@ -2843,6 +2849,18 @@ PRE_SYSCALL(openat)(long dfd, const void *filename, long flags, long mode) {
2843	POST_SYSCALL(openat)	2849	POST_SYSCALL(openat)
2844	(long res, long dfd, const void *filename, long flags, long mode) {}	2850	(long res, long dfd, const void *filename, long flags, long mode) {}
2845		2851
		2852	PRE_SYSCALL(openat2)(long dfd, const void* filename,
		2853	const sanitizer_kernel_open_how* how, uptr howlen) {
		2854	if (filename)
		2855	PRE_READ(filename, __sanitizer::internal_strlen((const char*)filename) + 1);
		2856
		2857	if (how)
		2858	PRE_READ(how, howlen);
		2859	}
		2860
		2861	POST_SYSCALL(openat2)(long res, long dfd, const void* filename,
		2862	const sanitizer_kernel_open_how* how, uptr howlen) {}
		2863
2846	PRE_SYSCALL(newfstatat)	2864	PRE_SYSCALL(newfstatat)
2847	(long dfd, const void filename, void statbuf, long flag) {	2865	(long dfd, const void filename, void statbuf, long flag) {
2848	if (filename)	2866	if (filename)

lib/libtsan/sanitizer_common/sanitizer_coverage_interface.inc deleted-43

...	@@ -1,43 +0,0 @@
1	//===-- sanitizer_coverage_interface.inc ----------------------------------===//
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	// Sanitizer Coverage interface list.
9	//===----------------------------------------------------------------------===//
10	INTERFACE_FUNCTION(__sanitizer_cov_dump)
11	INTERFACE_FUNCTION(__sanitizer_cov_reset)
12	INTERFACE_FUNCTION(__sanitizer_dump_coverage)
13	INTERFACE_FUNCTION(__sanitizer_dump_trace_pc_guard_coverage)
14	INTERFACE_WEAK_FUNCTION(__sancov_default_options)
15	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_trace_cmp)
16	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_trace_cmp1)
17	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_trace_cmp2)
18	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_trace_cmp4)
19	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_trace_cmp8)
20	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_trace_const_cmp1)
21	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_trace_const_cmp2)
22	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_trace_const_cmp4)
23	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_trace_const_cmp8)
24	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_trace_div4)
25	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_trace_div8)
26	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_trace_gep)
27	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_trace_pc_guard)
28	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_trace_pc_guard_init)
29	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_trace_pc_indir)
30	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_load1)
31	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_load2)
32	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_load4)
33	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_load8)
34	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_load16)
35	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_store1)
36	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_store2)
37	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_store4)
38	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_store8)
39	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_store16)
40	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_trace_switch)
41	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_8bit_counters_init)
42	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_bool_flag_init)
43	INTERFACE_WEAK_FUNCTION(__sanitizer_cov_pcs_init)

lib/libtsan/sanitizer_common/sanitizer_file.cpp+40-12

 @@ -36,9 +36,17 @@ void RawWrite(const char *buffer) {
 void ReportFile::ReopenIfNecessary() {
   mu->CheckLocked();
-  if (fd == kStdoutFd || fd == kStderrFd) return;
   uptr pid = internal_getpid();
+  if (fallbackToStderrActive && fd_pid != pid) {
+    // If fallbackToStderrActive is set then we fellback to stderr. If this is a
+    // new process, mark fd as invalid so we attempt to open again.
+    CHECK_EQ(fd, kStderrFd);
+    fd = kInvalidFd;
+    fallbackToStderrActive = false;
+  }
+  if (fd == kStdoutFd || fd == kStderrFd)
+    return;
   // If in tracer, use the parent's file.
   if (pid == stoptheworld_tracer_pid)
     pid = stoptheworld_tracer_ppid;
 @@ -48,8 +56,7 @@ void ReportFile::ReopenIfNecessary() {
     // process, close it now.
     if (fd_pid == pid)
       return;
-    else
+    CloseFile(fd);
-      CloseFile(fd);
   }
   const char *exe_name = GetProcessName();
 @@ -65,18 +72,24 @@ void ReportFile::ReopenIfNecessary() {
   error_t err;
   fd = OpenFile(full_path, WrOnly, &err);
   if (fd == kInvalidFd) {
-    const char *ErrorMsgPrefix = "ERROR: Can't open file: ";
+    bool fallback = common_flags()->log_fallback_to_stderr;
+    const char *ErrorMsgPrefix =
+        fallback ? "WARNING: Can't open file, falling back to stderr: "
+                 : "ERROR: Can't open file: ";
     WriteToFile(kStderrFd, ErrorMsgPrefix, internal_strlen(ErrorMsgPrefix));
     WriteToFile(kStderrFd, full_path, internal_strlen(full_path));
     char errmsg[100];
     internal_snprintf(errmsg, sizeof(errmsg), " (reason: %d)\n", err);
     WriteToFile(kStderrFd, errmsg, internal_strlen(errmsg));
-    Die();
+    if (!fallback)
+      Die();
+    fallbackToStderrActive = true;
+    fd = kStderrFd;
   }
   fd_pid = pid;
 }
-static void RecursiveCreateParentDirs(char *path) {
+static void RecursiveCreateParentDirs(char *path, fd_t &fd) {
   if (path[0] == '\0')
     return;
   for (int i = 1; path[i] != '\0'; ++i) {
 @@ -85,12 +98,19 @@ static void RecursiveCreateParentDirs(char *path) {
       continue;
     path[i] = '\0';
     if (!DirExists(path) && !CreateDir(path)) {
-      const char *ErrorMsgPrefix = "ERROR: Can't create directory: ";
+      bool fallback = common_flags()->log_fallback_to_stderr;
+      const char *ErrorMsgPrefix =
+          fallback ? "WARNING: Can't create directory, falling back to stderr: "
+                   : "ERROR: Can't create directory: ";
       WriteToFile(kStderrFd, ErrorMsgPrefix, internal_strlen(ErrorMsgPrefix));
       WriteToFile(kStderrFd, path, internal_strlen(path));
       const char *ErrorMsgSuffix = "\n";
       WriteToFile(kStderrFd, ErrorMsgSuffix, internal_strlen(ErrorMsgSuffix));
-      Die();
+      if (!fallback)
+        Die();
+      path[i] = save;
+      fd = kStderrFd;
+      return;
     }
     path[i] = save;
   }
 @@ -108,6 +128,9 @@ static void ParseAndSetPath(const char *pattern, char *dest,
   CHECK(dest);
   CHECK_GE(dest_size, 1);
   dest[0] = '\0';
+  // Return empty string if empty string was passed
+  if (internal_strlen(pattern) == 0)
+    return;
   uptr next_substr_start_idx = 0;
   for (uptr i = 0; i < internal_strlen(pattern) - 1; i++) {
     if (pattern[i] != '%')
 @@ -161,12 +184,17 @@ void ReportFile::SetReportPath(const char *path) {
   if (path) {
     uptr len = internal_strlen(path);
     if (len > sizeof(path_prefix) - 100) {
-      const char *message = "ERROR: Path is too long: ";
+      bool fallback = common_flags()->log_fallback_to_stderr;
+      const char *message =
+          fallback ? "WARNING: Path is too long, falling back to stderr: "
+                   : "ERROR: Path is too long: ";
       WriteToFile(kStderrFd, message, internal_strlen(message));
       WriteToFile(kStderrFd, path, 8);
       message = "...\n";
       WriteToFile(kStderrFd, message, internal_strlen(message));
-      Die();
+      if (!fallback)
+        Die();
+      path = "stderr";
     }
   }
 @@ -180,7 +208,7 @@ void ReportFile::SetReportPath(const char *path) {
     fd = kStdoutFd;
   } else {
     ParseAndSetPath(path, path_prefix, kMaxPathLength);
-    RecursiveCreateParentDirs(path_prefix);
+    RecursiveCreateParentDirs(path_prefix, fd);
   }
 }

lib/libtsan/sanitizer_common/sanitizer_file.h+3

 @@ -43,6 +43,9 @@ struct ReportFile {
   // PID of the process that opened fd. If a fork() occurs,
   // the PID of child will be different from fd_pid.
   uptr fd_pid;
+  // Set to true if the last attempt to open the logfile failed, perhaps due to
+  // permission errors
+  bool fallbackToStderrActive = false;
  private:
   void ReopenIfNecessary();

lib/libtsan/sanitizer_common/sanitizer_flags.inc+7

 @@ -65,6 +65,8 @@ COMMON_FLAG(
     bool, log_to_syslog, (bool)SANITIZER_ANDROID || (bool)SANITIZER_APPLE,
     "Write all sanitizer output to syslog in addition to other means of "
     "logging.")
+COMMON_FLAG(bool, log_fallback_to_stderr, false,
+            "When set, fallback to stderr if we are unable to open log path.")
 COMMON_FLAG(
     int, verbosity, 0,
     "Verbosity level (0 - silent, 1 - a bit of output, 2+ - more output).")
 @@ -111,6 +113,11 @@ COMMON_FLAG(HandleSignalMode, handle_sigfpe, kHandleSignalYes,
 COMMON_FLAG(bool, allow_user_segv_handler, true,
             "Deprecated. True has no effect, use handle_sigbus=1. If false, "
             "handle_*=1 will be upgraded to handle_*=2.")
+COMMON_FLAG(bool, cloak_sanitizer_signal_handlers, false,
+            "If set, signal/sigaction will pretend that sanitizers did not "
+            "preinstall any signal handlers. If the user subsequently installs "
+            "a signal handler, this will disable cloaking for the respective "
+            "signal.")
 COMMON_FLAG(bool, use_sigaltstack, true,
             "If set, uses alternate stack for signal handling.")
 COMMON_FLAG(bool, detect_deadlocks, true,

lib/libtsan/sanitizer_common/sanitizer_fuchsia.cpp+30-3

...	@@ -14,6 +14,7 @@	...	@@ -14,6 +14,7 @@
14	#include "sanitizer_fuchsia.h"	14	#include "sanitizer_fuchsia.h"
15	#if SANITIZER_FUCHSIA	15	#if SANITIZER_FUCHSIA
16		16
		17	# include <limits.h>
17	# include <pthread.h>	18	# include <pthread.h>
18	# include <stdlib.h>	19	# include <stdlib.h>
19	# include <unistd.h>	20	# include <unistd.h>
...	@@ -68,7 +69,7 @@ int internal_dlinfo(void handle, int request, void p) { UNIMPLEMENTED(); }	...	@@ -68,7 +69,7 @@ int internal_dlinfo(void handle, int request, void p) { UNIMPLEMENTED(); }
68		69
69	uptr GetThreadSelf() { return reinterpret_cast<uptr>(thrd_current()); }	70	uptr GetThreadSelf() { return reinterpret_cast<uptr>(thrd_current()); }
70		71
71	tid_t GetTid() { return GetThreadSelf(); }	72	ThreadID GetTid() { return GetThreadSelf(); }
72		73
73	void Abort() { abort(); }	74	void Abort() { abort(); }
74		75
...	@@ -117,11 +118,37 @@ uptr GetMmapGranularity() { return _zx_system_get_page_size(); }	...	@@ -117,11 +118,37 @@ uptr GetMmapGranularity() { return _zx_system_get_page_size(); }
117		118
118	sanitizer_shadow_bounds_t ShadowBounds;	119	sanitizer_shadow_bounds_t ShadowBounds;
119		120
		121	// Any sanitizer that utilizes shadow should explicitly call whenever it's
		122	// appropriate for that sanitizer to reference shadow bounds. For ASan, this is
		123	// done in `InitializeShadowMemory` and for HWASan, this is done in
		124	// `InitShadow`.
120	void InitShadowBounds() { ShadowBounds = __sanitizer_shadow_bounds(); }	125	void InitShadowBounds() { ShadowBounds = __sanitizer_shadow_bounds(); }
121		126
		127	// TODO(leonardchan): It's not immediately clear from a user perspective if
		128	// `GetMaxUserVirtualAddress` should be called exatly once on runtime startup
		129	// or can be called multiple times. Currently it looks like most instances of
		130	// `GetMaxUserVirtualAddress` are meant to be called once, but if someone
		131	// decides to call this multiple times in the future, we should have a separate
		132	// function that's ok to call multiple times. Ideally we would just invoke this
		133	// syscall once. Also for Fuchsia, this syscall technically gets invoked twice
		134	// since `__sanitizer_shadow_bounds` also invokes this syscall under the hood.
122	uptr GetMaxUserVirtualAddress() {	135	uptr GetMaxUserVirtualAddress() {
123	InitShadowBounds();	136	zx_info_vmar_t info;
124	return ShadowBounds.memory_limit - 1;	137	zx_status_t status = _zx_object_get_info(_zx_vmar_root_self(), ZX_INFO_VMAR,
		138	&info, sizeof(info), NULL, NULL);
		139	CHECK_EQ(status, ZX_OK);
		140
		141	// Find the top of the accessible address space.
		142	uintptr_t top = info.base + info.len;
		143
		144	// Round it up to a power-of-two size. There may be some pages at
		145	// the top that can't actually be mapped, but for purposes of the
		146	// the shadow, we'll pretend they could be.
		147	int bit = (sizeof(uintptr_t) * CHAR_BIT) - __builtin_clzl(top);
		148	if (top != (uintptr_t)1 << bit)
		149	top = (uintptr_t)1 << (bit + 1);
		150
		151	return top - 1;
125	}	152	}
126		153
127	uptr GetMaxVirtualAddress() { return GetMaxUserVirtualAddress(); }	154	uptr GetMaxVirtualAddress() { return GetMaxUserVirtualAddress(); }

lib/libtsan/sanitizer_common/sanitizer_haiku.cpp+2-2

...	@@ -231,12 +231,12 @@ uptr internal_execve(const char filename, char const argv[],	...	@@ -231,12 +231,12 @@ uptr internal_execve(const char filename, char const argv[],
231	}	231	}
232		232
233	# if 0	233	# if 0
234	tid_t GetTid() {	234	ThreadID GetTid() {
235	DEFINE__REAL(int, _lwp_self);	235	DEFINE__REAL(int, _lwp_self);
236	return _REAL(_lwp_self);	236	return _REAL(_lwp_self);
237	}	237	}
238		238
239	int TgKill(pid_t pid, tid_t tid, int sig) {	239	int TgKill(pid_t pid, ThreadID tid, int sig) {
240	DEFINE__REAL(int, _lwp_kill, int a, int b);	240	DEFINE__REAL(int, _lwp_kill, int a, int b);
241	(void)pid;	241	(void)pid;
242	return _REAL(_lwp_kill, tid, sig);	242	return _REAL(_lwp_kill, tid, sig);

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

...	@@ -209,7 +209,7 @@ typedef long ssize;	...	@@ -209,7 +209,7 @@ typedef long ssize;
209	typedef sptr ssize;	209	typedef sptr ssize;
210	#endif	210	#endif
211		211
212	typedef u64 tid_t;	212	typedef u64 ThreadID;
213		213
214	// ----------- ATTENTION -------------	214	// ----------- ATTENTION -------------
215	// This header should NOT include any other headers to avoid portability issues.	215	// This header should NOT include any other headers to avoid portability issues.

lib/libtsan/sanitizer_common/sanitizer_libc.cpp+8

...	@@ -190,6 +190,14 @@ uptr internal_strlcat(char dst, const char src, uptr maxlen) {	...	@@ -190,6 +190,14 @@ uptr internal_strlcat(char dst, const char src, uptr maxlen) {
190	return dstlen + srclen;	190	return dstlen + srclen;
191	}	191	}
192		192
		193	char* internal_strcat(char* dst, const char* src) {
		194	uptr len = internal_strlen(dst);
		195	uptr i;
		196	for (i = 0; src[i]; i++) dst[len + i] = src[i];
		197	dst[len + i] = 0;
		198	return dst;
		199	}
		200
193	char internal_strncat(char dst, const char *src, uptr n) {	201	char internal_strncat(char dst, const char *src, uptr n) {
194	uptr len = internal_strlen(dst);	202	uptr len = internal_strlen(dst);
195	uptr i;	203	uptr i;

lib/libtsan/sanitizer_common/sanitizer_libc.h+1

...	@@ -59,6 +59,7 @@ char internal_strdup(const char s);	...	@@ -59,6 +59,7 @@ char internal_strdup(const char s);
59	uptr internal_strlen(const char *s);	59	uptr internal_strlen(const char *s);
60	uptr internal_strlcat(char dst, const char src, uptr maxlen);	60	uptr internal_strlcat(char dst, const char src, uptr maxlen);
61	char internal_strncat(char dst, const char *src, uptr n);	61	char internal_strncat(char dst, const char *src, uptr n);
		62	char* internal_strcat(char* dst, const char* src);
62	int internal_strncmp(const char s1, const char s2, uptr n);	63	int internal_strncmp(const char s1, const char s2, uptr n);
63	uptr internal_strlcpy(char dst, const char src, uptr maxlen);	64	uptr internal_strlcpy(char dst, const char src, uptr maxlen);
64	char internal_strncpy(char dst, const char *src, uptr n);	65	char internal_strncpy(char dst, const char *src, uptr n);

lib/libtsan/sanitizer_common/sanitizer_linux.cpp+15-7

...	@@ -635,7 +635,7 @@ bool DirExists(const char *path) {	...	@@ -635,7 +635,7 @@ bool DirExists(const char *path) {
635	}	635	}
636		636
637	# if !SANITIZER_NETBSD	637	# if !SANITIZER_NETBSD
638	tid_t GetTid() {	638	ThreadID GetTid() {
639	# if SANITIZER_FREEBSD	639	# if SANITIZER_FREEBSD
640	long Tid;	640	long Tid;
641	thr_self(&Tid);	641	thr_self(&Tid);
...	@@ -649,7 +649,7 @@ tid_t GetTid() {	...	@@ -649,7 +649,7 @@ tid_t GetTid() {
649	# endif	649	# endif
650	}	650	}
651		651
652	int TgKill(pid_t pid, tid_t tid, int sig) {	652	int TgKill(pid_t pid, ThreadID tid, int sig) {
653	# if SANITIZER_LINUX	653	# if SANITIZER_LINUX
654	return internal_syscall(SYSCALL(tgkill), pid, tid, sig);	654	return internal_syscall(SYSCALL(tgkill), pid, tid, sig);
655	# elif SANITIZER_FREEBSD	655	# elif SANITIZER_FREEBSD
...	@@ -1091,7 +1091,7 @@ ThreadLister::ThreadLister(pid_t pid) : buffer_(4096) {	...	@@ -1091,7 +1091,7 @@ ThreadLister::ThreadLister(pid_t pid) : buffer_(4096) {
1091	}	1091	}
1092		1092
1093	ThreadLister::Result ThreadLister::ListThreads(	1093	ThreadLister::Result ThreadLister::ListThreads(
1094	InternalMmapVector<tid_t> *threads) {	1094	InternalMmapVector<ThreadID> *threads) {
1095	int descriptor = internal_open(task_path_.data(), O_RDONLY \| O_DIRECTORY);	1095	int descriptor = internal_open(task_path_.data(), O_RDONLY \| O_DIRECTORY);
1096	if (internal_iserror(descriptor)) {	1096	if (internal_iserror(descriptor)) {
1097	Report("Can't open %s for reading.\n", task_path_.data());	1097	Report("Can't open %s for reading.\n", task_path_.data());
...	@@ -1146,7 +1146,7 @@ ThreadLister::Result ThreadLister::ListThreads(	...	@@ -1146,7 +1146,7 @@ ThreadLister::Result ThreadLister::ListThreads(
1146	}	1146	}
1147	}	1147	}
1148		1148
1149	const char *ThreadLister::LoadStatus(tid_t tid) {	1149	const char *ThreadLister::LoadStatus(ThreadID tid) {
1150	status_path_.clear();	1150	status_path_.clear();
1151	status_path_.AppendF("%s/%llu/status", task_path_.data(), tid);	1151	status_path_.AppendF("%s/%llu/status", task_path_.data(), tid);
1152	auto cleanup = at_scope_exit([&] {	1152	auto cleanup = at_scope_exit([&] {
...	@@ -1159,7 +1159,7 @@ const char *ThreadLister::LoadStatus(tid_t tid) {	...	@@ -1159,7 +1159,7 @@ const char *ThreadLister::LoadStatus(tid_t tid) {
1159	return buffer_.data();	1159	return buffer_.data();
1160	}	1160	}
1161		1161
1162	bool ThreadLister::IsAlive(tid_t tid) {	1162	bool ThreadLister::IsAlive(ThreadID tid) {
1163	// /proc/%d/task/%d/status uses same call to detect alive threads as	1163	// /proc/%d/task/%d/status uses same call to detect alive threads as
1164	// proc_task_readdir. See task_state implementation in Linux.	1164	// proc_task_readdir. See task_state implementation in Linux.
1165	static const char kPrefix[] = "\nPPid:";	1165	static const char kPrefix[] = "\nPPid:";
...	@@ -1289,7 +1289,7 @@ uptr GetPageSize() {	...	@@ -1289,7 +1289,7 @@ uptr GetPageSize() {
1289		1289
1290	uptr ReadBinaryName(/out/ char *buf, uptr buf_len) {	1290	uptr ReadBinaryName(/out/ char *buf, uptr buf_len) {
1291	# if SANITIZER_HAIKU	1291	# if SANITIZER_HAIKU
1292	int cookie = 0;	1292	int32 cookie = 0;
1293	image_info info;	1293	image_info info;
1294	const char *argv0 = "<UNKNOWN>";	1294	const char *argv0 = "<UNKNOWN>";
1295	while (get_next_image_info(B_CURRENT_TEAM, &cookie, &info) == B_OK) {	1295	while (get_next_image_info(B_CURRENT_TEAM, &cookie, &info) == B_OK) {
...	@@ -1989,7 +1989,10 @@ SignalContext::WriteFlag SignalContext::GetWriteFlag() const {	...	@@ -1989,7 +1989,10 @@ SignalContext::WriteFlag SignalContext::GetWriteFlag() const {
1989	# elif SANITIZER_NETBSD	1989	# elif SANITIZER_NETBSD
1990	uptr err = ucontext->uc_mcontext.__gregs[_REG_ERR];	1990	uptr err = ucontext->uc_mcontext.__gregs[_REG_ERR];
1991	# elif SANITIZER_HAIKU	1991	# elif SANITIZER_HAIKU
1992	uptr err = ucontext->uc_mcontext.r13;	1992	uptr err = 0; // FIXME: ucontext->uc_mcontext.r13;
		1993	// The err register was added on the main branch and not
		1994	// available with the current release. To be reverted later.
		1995	// https://github.com/haiku/haiku/commit/11adda21aa4e6b24f71a496868a44d7607bc3764
1993	# elif SANITIZER_SOLARIS && defined(__i386__)	1996	# elif SANITIZER_SOLARIS && defined(__i386__)
1994	const int Err = 13;	1997	const int Err = 13;
1995	uptr err = ucontext->uc_mcontext.gregs[Err];	1998	uptr err = ucontext->uc_mcontext.gregs[Err];
...	@@ -2619,6 +2622,11 @@ static void GetPcSpBp(void context, uptr pc, uptr sp, uptr bp) {	...	@@ -2619,6 +2622,11 @@ static void GetPcSpBp(void context, uptr pc, uptr sp, uptr bp) {
2619	*pc = ucontext->uc_mcontext.mc_eip;	2622	*pc = ucontext->uc_mcontext.mc_eip;
2620	*bp = ucontext->uc_mcontext.mc_ebp;	2623	*bp = ucontext->uc_mcontext.mc_ebp;
2621	*sp = ucontext->uc_mcontext.mc_esp;	2624	*sp = ucontext->uc_mcontext.mc_esp;
		2625	# elif SANITIZER_HAIKU
		2626	ucontext_t ucontext = (ucontext_t )context;
		2627	*pc = ucontext->uc_mcontext.eip;
		2628	*bp = ucontext->uc_mcontext.ebp;
		2629	*sp = ucontext->uc_mcontext.esp;
2622	# else	2630	# else
2623	ucontext_t ucontext = (ucontext_t )context;	2631	ucontext_t ucontext = (ucontext_t )context;
2624	# if SANITIZER_SOLARIS	2632	# if SANITIZER_SOLARIS

lib/libtsan/sanitizer_common/sanitizer_linux.h+3-3

...	@@ -108,11 +108,11 @@ class ThreadLister {	...	@@ -108,11 +108,11 @@ class ThreadLister {
108	Incomplete,	108	Incomplete,
109	Ok,	109	Ok,
110	};	110	};
111	Result ListThreads(InternalMmapVector<tid_t> *threads);	111	Result ListThreads(InternalMmapVector<ThreadID> *threads);
112	const char *LoadStatus(tid_t tid);	112	const char *LoadStatus(ThreadID tid);
113		113
114	private:	114	private:
115	bool IsAlive(tid_t tid);	115	bool IsAlive(ThreadID tid);
116		116
117	InternalScopedString task_path_;	117	InternalScopedString task_path_;
118	InternalScopedString status_path_;	118	InternalScopedString status_path_;

lib/libtsan/sanitizer_common/sanitizer_linux_libcdep.cpp+1

...	@@ -29,6 +29,7 @@	...	@@ -29,6 +29,7 @@
29	# include "sanitizer_solaris.h"	29	# include "sanitizer_solaris.h"
30		30
31	# if SANITIZER_HAIKU	31	# if SANITIZER_HAIKU
		32	# define _GNU_SOURCE
32	# define _DEFAULT_SOURCE	33	# define _DEFAULT_SOURCE
33	# endif	34	# endif
34		35

lib/libtsan/sanitizer_common/sanitizer_mac.cpp+255-104

...	@@ -22,6 +22,11 @@	...	@@ -22,6 +22,11 @@
22	# endif	22	# endif
23	# include <stdio.h>	23	# include <stdio.h>
24		24
		25	// Start searching for available memory region past PAGEZERO, which is
		26	// 4KB on 32-bit and 4GB on 64-bit.
		27	# define GAP_SEARCH_START_ADDRESS \
		28	((SANITIZER_WORDSIZE == 32) ? 0x000000001000 : 0x000100000000)
		29
25	# include "sanitizer_common.h"	30	# include "sanitizer_common.h"
26	# include "sanitizer_file.h"	31	# include "sanitizer_file.h"
27	# include "sanitizer_flags.h"	32	# include "sanitizer_flags.h"
...	@@ -58,9 +63,11 @@ extern char ***_NSGetArgv(void);	...	@@ -58,9 +63,11 @@ extern char ***_NSGetArgv(void);
58	# include <dlfcn.h> // for dladdr()	63	# include <dlfcn.h> // for dladdr()
59	# include <errno.h>	64	# include <errno.h>
60	# include <fcntl.h>	65	# include <fcntl.h>
		66	# include <inttypes.h>
61	# include <libkern/OSAtomic.h>	67	# include <libkern/OSAtomic.h>
62	# include <mach-o/dyld.h>	68	# include <mach-o/dyld.h>
63	# include <mach/mach.h>	69	# include <mach/mach.h>
		70	# include <mach/mach_error.h>
64	# include <mach/mach_time.h>	71	# include <mach/mach_time.h>
65	# include <mach/vm_statistics.h>	72	# include <mach/vm_statistics.h>
66	# include <malloc/malloc.h>	73	# include <malloc/malloc.h>
...	@@ -96,8 +103,16 @@ extern "C" {	...	@@ -96,8 +103,16 @@ extern "C" {
96	natural_t *nesting_depth,	103	natural_t *nesting_depth,
97	vm_region_recurse_info_t info,	104	vm_region_recurse_info_t info,
98	mach_msg_type_number_t *infoCnt);	105	mach_msg_type_number_t *infoCnt);
		106
		107	extern const void* _dyld_get_shared_cache_range(size_t* length);
99	}	108	}
100		109
		110	# if !SANITIZER_GO
		111	// Weak symbol no-op when TSan is not linked
		112	SANITIZER_WEAK_ATTRIBUTE extern void __tsan_set_in_internal_write_call(
		113	bool value) {}
		114	# endif
		115
101	namespace __sanitizer {	116	namespace __sanitizer {
102		117
103	#include "sanitizer_syscall_generic.inc"	118	#include "sanitizer_syscall_generic.inc"
...	@@ -168,7 +183,15 @@ uptr internal_read(fd_t fd, void *buf, uptr count) {	...	@@ -168,7 +183,15 @@ uptr internal_read(fd_t fd, void *buf, uptr count) {
168	}	183	}
169		184
170	uptr internal_write(fd_t fd, const void *buf, uptr count) {	185	uptr internal_write(fd_t fd, const void *buf, uptr count) {
		186	# if SANITIZER_GO
171	return write(fd, buf, count);	187	return write(fd, buf, count);
		188	# else
		189	// We need to disable interceptors when writing in TSan
		190	__tsan_set_in_internal_write_call(true);
		191	uptr res = write(fd, buf, count);
		192	__tsan_set_in_internal_write_call(false);
		193	return res;
		194	# endif
172	}	195	}
173		196
174	uptr internal_stat(const char path, void buf) {	197	uptr internal_stat(const char path, void buf) {
...	@@ -258,53 +281,43 @@ int internal_sysctlbyname(const char sname, void oldp, uptr *oldlenp,	...	@@ -258,53 +281,43 @@ int internal_sysctlbyname(const char sname, void oldp, uptr *oldlenp,
258	(size_t)newlen);	281	(size_t)newlen);
259	}	282	}
260		283
261	static fd_t internal_spawn_impl(const char argv[], const char envp[],	284	bool internal_spawn(const char* argv[], const char* envp[], pid_t* pid,
262	pid_t *pid) {	285	fd_t fd_stdin, fd_t fd_stdout) {
263	fd_t primary_fd = kInvalidFd;	286	// NOTE: Caller ensures that fd_stdin and fd_stdout are not 0, 1, or 2, since
264	fd_t secondary_fd = kInvalidFd;	287	// this can break communication.
		288	//
		289	// NOTE: Caller is responsible for closing fd_stdin after the process has
		290	// died.
265		291
		292	int res;
266	auto fd_closer = at_scope_exit([&] {	293	auto fd_closer = at_scope_exit([&] {
267	internal_close(primary_fd);	294	// NOTE: We intentionally do not close fd_stdin since this can
268	internal_close(secondary_fd);	295	// cause us to receive a fatal SIGPIPE if the process dies.
		296	internal_close(fd_stdout);
269	});	297	});
270		298
271	// We need a new pseudoterminal to avoid buffering problems. The 'atos' tool
272	// in particular detects when it's talking to a pipe and forgets to flush the
273	// output stream after sending a response.
274	primary_fd = posix_openpt(O_RDWR);
275	if (primary_fd == kInvalidFd)
276	return kInvalidFd;
277
278	int res = grantpt(primary_fd) \|\| unlockpt(primary_fd);
279	if (res != 0) return kInvalidFd;
280
281	// Use TIOCPTYGNAME instead of ptsname() to avoid threading problems.
282	char secondary_pty_name[128];
283	res = ioctl(primary_fd, TIOCPTYGNAME, secondary_pty_name);
284	if (res == -1) return kInvalidFd;
285
286	secondary_fd = internal_open(secondary_pty_name, O_RDWR);
287	if (secondary_fd == kInvalidFd)
288	return kInvalidFd;
289
290	// File descriptor actions	299	// File descriptor actions
291	posix_spawn_file_actions_t acts;	300	posix_spawn_file_actions_t acts;
292	res = posix_spawn_file_actions_init(&acts);	301	res = posix_spawn_file_actions_init(&acts);
293	if (res != 0) return kInvalidFd;	302	if (res != 0)
		303	return false;
294		304
295	auto acts_cleanup = at_scope_exit([&] {	305	auto acts_cleanup = at_scope_exit([&] {
296	posix_spawn_file_actions_destroy(&acts);	306	posix_spawn_file_actions_destroy(&acts);
297	});	307	});
298		308
299	res = posix_spawn_file_actions_adddup2(&acts, secondary_fd, STDIN_FILENO) \|\|	309	res = posix_spawn_file_actions_adddup2(&acts, fd_stdin, STDIN_FILENO) \|\|
300	posix_spawn_file_actions_adddup2(&acts, secondary_fd, STDOUT_FILENO) \|\|	310	posix_spawn_file_actions_adddup2(&acts, fd_stdout, STDOUT_FILENO) \|\|
301	posix_spawn_file_actions_addclose(&acts, secondary_fd);	311	posix_spawn_file_actions_addclose(&acts, fd_stdin) \|\|
302	if (res != 0) return kInvalidFd;	312	posix_spawn_file_actions_addclose(&acts, fd_stdout);
		313	if (res != 0)
		314	return false;
303		315
304	// Spawn attributes	316	// Spawn attributes
305	posix_spawnattr_t attrs;	317	posix_spawnattr_t attrs;
306	res = posix_spawnattr_init(&attrs);	318	res = posix_spawnattr_init(&attrs);
307	if (res != 0) return kInvalidFd;	319	if (res != 0)
		320	return false;
308		321
309	auto attrs_cleanup = at_scope_exit([&] {	322	auto attrs_cleanup = at_scope_exit([&] {
310	posix_spawnattr_destroy(&attrs);	323	posix_spawnattr_destroy(&attrs);
...	@@ -313,50 +326,17 @@ static fd_t internal_spawn_impl(const char argv[], const char envp[],	...	@@ -313,50 +326,17 @@ static fd_t internal_spawn_impl(const char argv[], const char envp[],
313	// In the spawned process, close all file descriptors that are not explicitly	326	// In the spawned process, close all file descriptors that are not explicitly
314	// described by the file actions object. This is Darwin-specific extension.	327	// described by the file actions object. This is Darwin-specific extension.
315	res = posix_spawnattr_setflags(&attrs, POSIX_SPAWN_CLOEXEC_DEFAULT);	328	res = posix_spawnattr_setflags(&attrs, POSIX_SPAWN_CLOEXEC_DEFAULT);
316	if (res != 0) return kInvalidFd;	329	if (res != 0)
		330	return false;
317		331
318	// posix_spawn	332	// posix_spawn
319	char argv_casted = const_cast<char >(argv);	333	char argv_casted = const_cast<char >(argv);
320	char envp_casted = const_cast<char >(envp);	334	char envp_casted = const_cast<char >(envp);
321	res = posix_spawn(pid, argv[0], &acts, &attrs, argv_casted, envp_casted);	335	res = posix_spawn(pid, argv[0], &acts, &attrs, argv_casted, envp_casted);
322	if (res != 0) return kInvalidFd;	336	if (res != 0)
323		337	return false;
324	// Disable echo in the new terminal, disable CR.
325	struct termios termflags;
326	tcgetattr(primary_fd, &termflags);
327	termflags.c_oflag &= ~ONLCR;
328	termflags.c_lflag &= ~ECHO;
329	tcsetattr(primary_fd, TCSANOW, &termflags);
330
331	// On success, do not close primary_fd on scope exit.
332	fd_t fd = primary_fd;
333	primary_fd = kInvalidFd;
334
335	return fd;
336	}
337
338	fd_t internal_spawn(const char argv[], const char envp[], pid_t *pid) {
339	// The client program may close its stdin and/or stdout and/or stderr thus
340	// allowing open/posix_openpt to reuse file descriptors 0, 1 or 2. In this
341	// case the communication is broken if either the parent or the child tries to
342	// close or duplicate these descriptors. We temporarily reserve these
343	// descriptors here to prevent this.
344	fd_t low_fds[3];
345	size_t count = 0;
346
347	for (; count < 3; count++) {
348	low_fds[count] = posix_openpt(O_RDWR);
349	if (low_fds[count] >= STDERR_FILENO)
350	break;
351	}
352
353	fd_t fd = internal_spawn_impl(argv, envp, pid);
354
355	for (; count > 0; count--) {
356	internal_close(low_fds[count]);
357	}
358		338
359	return fd;	339	return true;
360	}	340	}
361		341
362	uptr internal_rename(const char oldpath, const char newpath) {	342	uptr internal_rename(const char oldpath, const char newpath) {
...	@@ -394,8 +374,8 @@ bool DirExists(const char *path) {	...	@@ -394,8 +374,8 @@ bool DirExists(const char *path) {
394	return S_ISDIR(st.st_mode);	374	return S_ISDIR(st.st_mode);
395	}	375	}
396		376
397	tid_t GetTid() {	377	ThreadID GetTid() {
398	tid_t tid;	378	ThreadID tid;
399	pthread_threadid_np(nullptr, &tid);	379	pthread_threadid_np(nullptr, &tid);
400	return tid;	380	return tid;
401	}	381	}
...	@@ -769,11 +749,17 @@ void internal_join_thread(void *th) { pthread_join((pthread_t)th, 0); }	...	@@ -769,11 +749,17 @@ void internal_join_thread(void *th) { pthread_join((pthread_t)th, 0); }
769	static Mutex syslog_lock;	749	static Mutex syslog_lock;
770	# endif	750	# endif
771		751
		752	# if SANITIZER_DRIVERKIT
		753	# define SANITIZER_OS_LOG os_log
		754	# else
		755	# define SANITIZER_OS_LOG os_log_error
		756	# endif
		757
772	void WriteOneLineToSyslog(const char *s) {	758	void WriteOneLineToSyslog(const char *s) {
773	#if !SANITIZER_GO	759	#if !SANITIZER_GO
774	syslog_lock.CheckLocked();	760	syslog_lock.CheckLocked();
775	if (GetMacosAlignedVersion() >= MacosVersion(10, 12)) {	761	if (GetMacosAlignedVersion() >= MacosVersion(10, 12)) {
776	os_log_error(OS_LOG_DEFAULT, "%{public}s", s);	762	SANITIZER_OS_LOG(OS_LOG_DEFAULT, "%{public}s", s);
777	} else {	763	} else {
778	#pragma clang diagnostic push	764	#pragma clang diagnostic push
779	// as_log is deprecated.	765	// as_log is deprecated.
...	@@ -837,22 +823,22 @@ void LogMessageOnPrintf(const char *str) {	...	@@ -837,22 +823,22 @@ void LogMessageOnPrintf(const char *str) {
837		823
838	void LogFullErrorReport(const char *buffer) {	824	void LogFullErrorReport(const char *buffer) {
839	# if !SANITIZER_GO	825	# if !SANITIZER_GO
840	// Log with os_log_error. This will make it into the crash log.	826	// When logging with os_log_error this will make it into the crash log.
841	if (internal_strncmp(SanitizerToolName, "AddressSanitizer",	827	if (internal_strncmp(SanitizerToolName, "AddressSanitizer",
842	sizeof("AddressSanitizer") - 1) == 0)	828	sizeof("AddressSanitizer") - 1) == 0)
843	os_log_error(OS_LOG_DEFAULT, "Address Sanitizer reported a failure.");	829	SANITIZER_OS_LOG(OS_LOG_DEFAULT, "Address Sanitizer reported a failure.");
844	else if (internal_strncmp(SanitizerToolName, "UndefinedBehaviorSanitizer",	830	else if (internal_strncmp(SanitizerToolName, "UndefinedBehaviorSanitizer",
845	sizeof("UndefinedBehaviorSanitizer") - 1) == 0)	831	sizeof("UndefinedBehaviorSanitizer") - 1) == 0)
846	os_log_error(OS_LOG_DEFAULT,	832	SANITIZER_OS_LOG(OS_LOG_DEFAULT,
847	"Undefined Behavior Sanitizer reported a failure.");	833	"Undefined Behavior Sanitizer reported a failure.");
848	else if (internal_strncmp(SanitizerToolName, "ThreadSanitizer",	834	else if (internal_strncmp(SanitizerToolName, "ThreadSanitizer",
849	sizeof("ThreadSanitizer") - 1) == 0)	835	sizeof("ThreadSanitizer") - 1) == 0)
850	os_log_error(OS_LOG_DEFAULT, "Thread Sanitizer reported a failure.");	836	SANITIZER_OS_LOG(OS_LOG_DEFAULT, "Thread Sanitizer reported a failure.");
851	else	837	else
852	os_log_error(OS_LOG_DEFAULT, "Sanitizer tool reported a failure.");	838	SANITIZER_OS_LOG(OS_LOG_DEFAULT, "Sanitizer tool reported a failure.");
853		839
854	if (common_flags()->log_to_syslog)	840	if (common_flags()->log_to_syslog)
855	os_log_error(OS_LOG_DEFAULT, "Consult syslog for more information.");	841	SANITIZER_OS_LOG(OS_LOG_DEFAULT, "Consult syslog for more information.");
856		842
857	// Log to syslog.	843	// Log to syslog.
858	// The logging on OS X may call pthread_create so we need the threading	844	// The logging on OS X may call pthread_create so we need the threading
...	@@ -933,7 +919,17 @@ static void DisableMmapExcGuardExceptions() {	...	@@ -933,7 +919,17 @@ static void DisableMmapExcGuardExceptions() {
933	RTLD_DEFAULT, "task_set_exc_guard_behavior");	919	RTLD_DEFAULT, "task_set_exc_guard_behavior");
934	if (set_behavior == nullptr) return;	920	if (set_behavior == nullptr) return;
935	const task_exc_guard_behavior_t task_exc_guard_none = 0;	921	const task_exc_guard_behavior_t task_exc_guard_none = 0;
936	set_behavior(mach_task_self(), task_exc_guard_none);	922	kern_return_t res = set_behavior(mach_task_self(), task_exc_guard_none);
		923	if (res != KERN_SUCCESS) {
		924	Report(
		925	"WARN: task_set_exc_guard_behavior returned %d (%s), "
		926	"mmap may fail unexpectedly.\n",
		927	res, mach_error_string(res));
		928	if (res == KERN_DENIED)
		929	Report(
		930	"HINT: Check that task_set_exc_guard_behavior is allowed by "
		931	"sandbox.\n");
		932	}
937	}	933	}
938		934
939	static void VerifyInterceptorsWorking();	935	static void VerifyInterceptorsWorking();
...	@@ -1100,6 +1096,67 @@ static void StripEnv() {	...	@@ -1100,6 +1096,67 @@ static void StripEnv() {
1100	}	1096	}
1101	#endif // SANITIZER_GO	1097	#endif // SANITIZER_GO
1102		1098
		1099	// Prints out a consolidated memory map: contiguous regions
		1100	// are merged together.
		1101	static void PrintVmmap() {
		1102	const mach_vm_address_t max_vm_address = GetMaxVirtualAddress() + 1;
		1103	mach_vm_address_t address = GAP_SEARCH_START_ADDRESS;
		1104	kern_return_t kr = KERN_SUCCESS;
		1105
		1106	Report("Memory map:\n");
		1107	mach_vm_address_t last = 0;
		1108	mach_vm_address_t lastsz = 0;
		1109
		1110	while (1) {
		1111	mach_vm_size_t vmsize = 0;
		1112	natural_t depth = 0;
		1113	vm_region_submap_short_info_data_64_t vminfo;
		1114	mach_msg_type_number_t count = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
		1115	kr = mach_vm_region_recurse(mach_task_self(), &address, &vmsize, &depth,
		1116	(vm_region_info_t)&vminfo, &count);
		1117
		1118	if (kr == KERN_DENIED) {
		1119	Report(
		1120	"ERROR: mach_vm_region_recurse got KERN_DENIED when printing memory "
		1121	"map.\n");
		1122	Report(
		1123	"HINT: Check whether mach_vm_region_recurse is allowed by "
		1124	"sandbox.\n");
		1125	}
		1126
		1127	if (kr == KERN_SUCCESS && address < max_vm_address) {
		1128	if (last + lastsz == address) {
		1129	// This region is contiguous with the last; merge together.
		1130	lastsz += vmsize;
		1131	} else {
		1132	if (lastsz)
		1133	Printf("\|\| `[%p, %p]` \|\| size=0x%016" PRIx64 " \|\|\n", (void*)last,
		1134	(void*)(last + lastsz), lastsz);
		1135
		1136	last = address;
		1137	lastsz = vmsize;
		1138	}
		1139	address += vmsize;
		1140	} else {
		1141	// We've reached the end of the memory map. Print the last remaining
		1142	// region, if there is one.
		1143	if (lastsz)
		1144	Printf("\|\| `[%p, %p]` \|\| size=0x%016" PRIx64 " \|\|\n", (void*)last,
		1145	(void*)(last + lastsz), lastsz);
		1146
		1147	break;
		1148	}
		1149	}
		1150	}
		1151
		1152	static void ReportShadowAllocFail(uptr shadow_size_bytes, uptr alignment) {
		1153	Report(
		1154	"FATAL: Failed to allocate shadow memory. Tried to allocate %p bytes "
		1155	"(alignment=%p).\n",
		1156	(void)shadow_size_bytes, (void)alignment);
		1157	PrintVmmap();
		1158	}
		1159
1103	char **GetArgv() {	1160	char **GetArgv() {
1104	return *_NSGetArgv();	1161	return *_NSGetArgv();
1105	}	1162	}
...	@@ -1207,10 +1264,11 @@ uptr MapDynamicShadow(uptr shadow_size_bytes, uptr shadow_scale,	...	@@ -1207,10 +1264,11 @@ uptr MapDynamicShadow(uptr shadow_size_bytes, uptr shadow_scale,
1207	if (new_max_vm < max_occupied_addr) {	1264	if (new_max_vm < max_occupied_addr) {
1208	Report("Unable to find a memory range for dynamic shadow.\n");	1265	Report("Unable to find a memory range for dynamic shadow.\n");
1209	Report(	1266	Report(
1210	"space_size = %p, largest_gap_found = %p, max_occupied_addr = %p, "	1267	"\tspace_size = %p\n\tlargest_gap_found = %p\n\tmax_occupied_addr "
1211	"new_max_vm = %p\n",	1268	"= %p\n\tnew_max_vm = %p\n",
1212	(void )space_size, (void )largest_gap_found,	1269	(void)space_size, (void)largest_gap_found, (void*)max_occupied_addr,
1213	(void )max_occupied_addr, (void )new_max_vm);	1270	(void*)new_max_vm);
		1271	ReportShadowAllocFail(shadow_size_bytes, alignment);
1214	CHECK(0 && "cannot place shadow");	1272	CHECK(0 && "cannot place shadow");
1215	}	1273	}
1216	RestrictMemoryToMaxAddress(new_max_vm);	1274	RestrictMemoryToMaxAddress(new_max_vm);
...	@@ -1221,6 +1279,7 @@ uptr MapDynamicShadow(uptr shadow_size_bytes, uptr shadow_scale,	...	@@ -1221,6 +1279,7 @@ uptr MapDynamicShadow(uptr shadow_size_bytes, uptr shadow_scale,
1221	nullptr, nullptr);	1279	nullptr, nullptr);
1222	if (shadow_start == 0) {	1280	if (shadow_start == 0) {
1223	Report("Unable to find a memory range after restricting VM.\n");	1281	Report("Unable to find a memory range after restricting VM.\n");
		1282	ReportShadowAllocFail(shadow_size_bytes, alignment);
1224	CHECK(0 && "cannot place shadow after restricting vm");	1283	CHECK(0 && "cannot place shadow after restricting vm");
1225	}	1284	}
1226	}	1285	}
...	@@ -1229,6 +1288,25 @@ uptr MapDynamicShadow(uptr shadow_size_bytes, uptr shadow_scale,	...	@@ -1229,6 +1288,25 @@ uptr MapDynamicShadow(uptr shadow_size_bytes, uptr shadow_scale,
1229	return shadow_start;	1288	return shadow_start;
1230	}	1289	}
1231		1290
		1291	// Returns a list of ranges which must be covered by shadow memory,
		1292	// and cannot overlap with any fixed mappings made by a sanitizer.
		1293	// This can ensure that the sanitizer runtime does not map over
		1294	// platform-reserved regions.
		1295	void GetAppReservedRanges(InternalMmapVector<ReservedRange>& ranges) {
		1296	ranges.clear();
		1297
		1298	# if SANITIZER_OSX
		1299	// On macOS, the first 512GB are platform-reserved (some of which
		1300	// may also be available to applications).
		1301	ranges.push_back({0x1000UL, 0x8000000000UL});
		1302	# endif
		1303
		1304	VReport(2, "App ranges:\n");
		1305	for (auto& [range_start, range_end] : ranges) {
		1306	VReport(2, " [%p, %p]\n", range_start, range_end);
		1307	}
		1308	}
		1309
1232	uptr MapDynamicShadowAndAliases(uptr shadow_size, uptr alias_size,	1310	uptr MapDynamicShadowAndAliases(uptr shadow_size, uptr alias_size,
1233	uptr num_aliases, uptr ring_buffer_size) {	1311	uptr num_aliases, uptr ring_buffer_size) {
1234	CHECK(false && "HWASan aliasing is unimplemented on Mac");	1312	CHECK(false && "HWASan aliasing is unimplemented on Mac");
...	@@ -1236,40 +1314,61 @@ uptr MapDynamicShadowAndAliases(uptr shadow_size, uptr alias_size,	...	@@ -1236,40 +1314,61 @@ uptr MapDynamicShadowAndAliases(uptr shadow_size, uptr alias_size,
1236	}	1314	}
1237		1315
1238	uptr FindAvailableMemoryRange(uptr size, uptr alignment, uptr left_padding,	1316	uptr FindAvailableMemoryRange(uptr size, uptr alignment, uptr left_padding,
1239	uptr *largest_gap_found,	1317	uptr* largest_gap_found,
1240	uptr *max_occupied_addr) {	1318	uptr* max_occupied_addr) {
1241	typedef vm_region_submap_short_info_data_64_t RegionInfo;
1242	enum { kRegionInfoSize = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64 };
1243	// Start searching for available memory region past PAGEZERO, which is
1244	// 4KB on 32-bit and 4GB on 64-bit.
1245	mach_vm_address_t start_address =
1246	(SANITIZER_WORDSIZE == 32) ? 0x000000001000 : 0x000100000000;
1247
1248	const mach_vm_address_t max_vm_address = GetMaxVirtualAddress() + 1;	1319	const mach_vm_address_t max_vm_address = GetMaxVirtualAddress() + 1;
1249	mach_vm_address_t address = start_address;	1320	mach_vm_address_t address = GAP_SEARCH_START_ADDRESS;
1250	mach_vm_address_t free_begin = start_address;	1321	mach_vm_address_t free_begin = GAP_SEARCH_START_ADDRESS;
		1322
		1323	// Restrict the search to be after any reserved ranges
		1324	InternalMmapVector<ReservedRange> app_ranges;
		1325	GetAppReservedRanges(app_ranges);
		1326
		1327	for (auto& [range_start, range_end] : app_ranges) {
		1328	address = Max(address, (mach_vm_address_t)range_end);
		1329	free_begin = Max(free_begin, (mach_vm_address_t)range_end);
		1330	}
		1331
1251	kern_return_t kr = KERN_SUCCESS;	1332	kern_return_t kr = KERN_SUCCESS;
1252	if (largest_gap_found) *largest_gap_found = 0;	1333	if (largest_gap_found) *largest_gap_found = 0;
1253	if (max_occupied_addr) *max_occupied_addr = 0;	1334	if (max_occupied_addr) *max_occupied_addr = 0;
1254	while (kr == KERN_SUCCESS) {	1335	while (kr == KERN_SUCCESS) {
1255	mach_vm_size_t vmsize = 0;	1336	mach_vm_size_t vmsize = 0;
1256	natural_t depth = 0;	1337	natural_t depth = 0;
1257	RegionInfo vminfo;	1338	vm_region_submap_short_info_data_64_t vminfo;
1258	mach_msg_type_number_t count = kRegionInfoSize;	1339	mach_msg_type_number_t count = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
1259	kr = mach_vm_region_recurse(mach_task_self(), &address, &vmsize, &depth,	1340	kr = mach_vm_region_recurse(mach_task_self(), &address, &vmsize, &depth,
1260	(vm_region_info_t)&vminfo, &count);	1341	(vm_region_info_t)&vminfo, &count);
1261		1342
1262	// There are cases where going beyond the processes' max vm does	1343	if (kr == KERN_SUCCESS) {
1263	// not return KERN_INVALID_ADDRESS so we check for going beyond that	1344	// There are cases where going beyond the processes' max vm does
1264	// max address as well.	1345	// not return KERN_INVALID_ADDRESS so we check for going beyond that
1265	if (kr == KERN_INVALID_ADDRESS \|\| address > max_vm_address) {	1346	// max address as well.
		1347	if (address > max_vm_address) {
		1348	address = max_vm_address;
		1349	kr = -1; // break after this iteration.
		1350	}
		1351
		1352	if (max_occupied_addr)
		1353	*max_occupied_addr = address + vmsize;
		1354	} else if (kr == KERN_INVALID_ADDRESS) {
1266	// No more regions beyond "address", consider the gap at the end of VM.	1355	// No more regions beyond "address", consider the gap at the end of VM.
1267	address = max_vm_address;	1356	address = max_vm_address;
1268	vmsize = 0;	1357
1269	kr = -1; // break after this iteration.	1358	// We will break after this iteration anyway since kr != KERN_SUCCESS
		1359	} else if (kr == KERN_DENIED) {
		1360	Report("ERROR: Unable to find a memory range for dynamic shadow.\n");
		1361	Report("HINT: Ensure mach_vm_region_recurse is allowed under sandbox.\n");
		1362	Die();
1270	} else {	1363	} else {
1271	if (max_occupied_addr) *max_occupied_addr = address + vmsize;	1364	Report(
		1365	"WARNING: mach_vm_region_recurse returned unexpected code %d (%s)\n",
		1366	kr, mach_error_string(kr));
		1367	DCHECK(false && "mach_vm_region_recurse returned unexpected code");
		1368	break; // address is not valid unless KERN_SUCCESS, therefore we must not
		1369	// use it.
1272	}	1370	}
		1371
1273	if (free_begin != address) {	1372	if (free_begin != address) {
1274	// We found a free region [free_begin..address-1].	1373	// We found a free region [free_begin..address-1].
1275	uptr gap_start = RoundUpTo((uptr)free_begin + left_padding, alignment);	1374	uptr gap_start = RoundUpTo((uptr)free_begin + left_padding, alignment);
...	@@ -1292,6 +1391,58 @@ uptr FindAvailableMemoryRange(uptr size, uptr alignment, uptr left_padding,	...	@@ -1292,6 +1391,58 @@ uptr FindAvailableMemoryRange(uptr size, uptr alignment, uptr left_padding,
1292	return 0;	1391	return 0;
1293	}	1392	}
1294		1393
		1394	// This function (when used during initialization when there is
		1395	// only a single thread), can be used to verify that a range
		1396	// of memory hasn't already been mapped, and won't be mapped
		1397	// later in the shared cache.
		1398	//
		1399	// If the syscall mach_vm_region_recurse fails (due to sandbox),
		1400	// we assume that the memory is not mapped so that execution can continue.
		1401	//
		1402	// NOTE: range_end is inclusive
		1403	//
		1404	// WARNING: This function must NOT allocate memory, since it is
		1405	// used in InitializeShadowMemory between where we search for
		1406	// space for shadow and where we actually allocate it.
		1407	bool MemoryRangeIsAvailable(uptr range_start, uptr range_end) {
		1408	mach_vm_size_t vmsize = 0;
		1409	natural_t depth = 0;
		1410	vm_region_submap_short_info_data_64_t vminfo;
		1411	mach_msg_type_number_t count = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
		1412	mach_vm_address_t address = range_start;
		1413
		1414	// First, check if the range is already mapped.
		1415	kern_return_t kr =
		1416	mach_vm_region_recurse(mach_task_self(), &address, &vmsize, &depth,
		1417	(vm_region_info_t)&vminfo, &count);
		1418
		1419	if (kr == KERN_DENIED) {
		1420	Report(
		1421	"WARN: mach_vm_region_recurse returned KERN_DENIED when checking "
		1422	"whether an address is mapped.\n");
		1423	Report("HINT: Is mach_vm_region_recurse allowed by sandbox?\n");
		1424	}
		1425
		1426	if (kr == KERN_SUCCESS && !IntervalsAreSeparate(address, address + vmsize - 1,
		1427	range_start, range_end)) {
		1428	// Overlaps with already-mapped memory
		1429	return false;
		1430	}
		1431
		1432	size_t cacheLength;
		1433	uptr cacheStart = (uptr)_dyld_get_shared_cache_range(&cacheLength);
		1434
		1435	if (cacheStart &&
		1436	!IntervalsAreSeparate(cacheStart, cacheStart + cacheLength - 1,
		1437	range_start, range_end)) {
		1438	// Overlaps with shared cache region
		1439	return false;
		1440	}
		1441
		1442	// We believe this address is available.
		1443	return true;
		1444	}
		1445
1295	// FIXME implement on this platform.	1446	// FIXME implement on this platform.
1296	void GetMemoryProfile(fill_profile_f cb, uptr *stats) {}	1447	void GetMemoryProfile(fill_profile_f cb, uptr *stats) {}
1297		1448

lib/libtsan/sanitizer_common/sanitizer_mac.h+5

 @@ -58,8 +58,13 @@ struct DarwinKernelVersion : VersionBase<DarwinKernelVersion> {
   DarwinKernelVersion(u16 major, u16 minor) : VersionBase(major, minor) {}
 };
+struct ReservedRange {
+  uptr beg, end;
+};
 MacosVersion GetMacosAlignedVersion();
 DarwinKernelVersion GetDarwinKernelVersion();
+void GetAppReservedRanges(InternalMmapVector<ReservedRange>& ranges);
 char **GetEnviron();

lib/libtsan/sanitizer_common/sanitizer_netbsd.cpp+2-2

...	@@ -229,12 +229,12 @@ uptr internal_execve(const char filename, char const argv[],	...	@@ -229,12 +229,12 @@ uptr internal_execve(const char filename, char const argv[],
229	return _sys_execve(filename, argv, envp);	229	return _sys_execve(filename, argv, envp);
230	}	230	}
231		231
232	tid_t GetTid() {	232	ThreadID GetTid() {
233	DEFINE__REAL(int, _lwp_self);	233	DEFINE__REAL(int, _lwp_self);
234	return _REAL(_lwp_self);	234	return _REAL(_lwp_self);
235	}	235	}
236		236
237	int TgKill(pid_t pid, tid_t tid, int sig) {	237	int TgKill(pid_t pid, ThreadID tid, int sig) {
238	DEFINE__REAL(int, _lwp_kill, int a, int b);	238	DEFINE__REAL(int, _lwp_kill, int a, int b);
239	(void)pid;	239	(void)pid;
240	return _REAL(_lwp_kill, tid, sig);	240	return _REAL(_lwp_kill, tid, sig);

lib/libtsan/sanitizer_common/sanitizer_platform.h+27-1

...	@@ -319,7 +319,11 @@	...	@@ -319,7 +319,11 @@
319	#endif	319	#endif
320		320
321	// The first address that can be returned by mmap.	321	// The first address that can be returned by mmap.
322	#define SANITIZER_MMAP_BEGIN 0	322	#if SANITIZER_AIX && SANITIZER_WORDSIZE == 64
		323	# define SANITIZER_MMAP_BEGIN 0x0a00'0000'0000'0000ULL
		324	#else
		325	# define SANITIZER_MMAP_BEGIN 0
		326	#endif
323		327
324	// The range of addresses which can be returned my mmap.	328	// The range of addresses which can be returned my mmap.
325	// FIXME: this value should be different on different platforms. Larger values	329	// FIXME: this value should be different on different platforms. Larger values
...	@@ -482,4 +486,26 @@	...	@@ -482,4 +486,26 @@
482	# define SANITIZER_START_BACKGROUND_THREAD_IN_ASAN_INTERNAL 0	486	# define SANITIZER_START_BACKGROUND_THREAD_IN_ASAN_INTERNAL 0
483	#endif	487	#endif
484		488
		489	#if SANITIZER_LINUX
		490	# if SANITIZER_GLIBC
		491	// Workaround for
		492	// glibc/commit/3d3572f59059e2b19b8541ea648a6172136ec42e
		493	// Linux: Keep termios ioctl constants strictly internal
		494	# if __GLIBC_PREREQ(2, 41)
		495	# define SANITIZER_TERMIOS_IOCTL_CONSTANTS 0
		496	# else
		497	# define SANITIZER_TERMIOS_IOCTL_CONSTANTS 1
		498	# endif
		499	# else
		500	# define SANITIZER_TERMIOS_IOCTL_CONSTANTS 1
		501	# endif
		502	#endif
		503
		504	#if SANITIZER_APPLE && SANITIZER_WORDSIZE == 64
		505	// MTE uses the lower half of the top byte.
		506	# define STRIP_MTE_TAG(addr) ((addr) & ~((uptr)0x0f << 56))
		507	#else
		508	# define STRIP_MTE_TAG(addr) (addr)
		509	#endif
		510
485	#endif // SANITIZER_PLATFORM_H	511	#endif // SANITIZER_PLATFORM_H

lib/libtsan/sanitizer_common/sanitizer_platform_interceptors.h+5-4

lib/libtsan/sanitizer_common/sanitizer_platform_limits_posix.cpp+4-4

 @@ -779,16 +779,16 @@ unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr);
   unsigned IOCTL_SOUND_PCM_WRITE_FILTER = SOUND_PCM_WRITE_FILTER;
 #endif // SOUND_VERSION
   unsigned IOCTL_TCFLSH = TCFLSH;
-  unsigned IOCTL_TCGETA = TCGETA;
+#    if SANITIZER_TERMIOS_IOCTL_CONSTANTS
   unsigned IOCTL_TCGETS = TCGETS;
+#    endif
   unsigned IOCTL_TCSBRK = TCSBRK;
   unsigned IOCTL_TCSBRKP = TCSBRKP;
-  unsigned IOCTL_TCSETA = TCSETA;
+#    if SANITIZER_TERMIOS_IOCTL_CONSTANTS
-  unsigned IOCTL_TCSETAF = TCSETAF;
-  unsigned IOCTL_TCSETAW = TCSETAW;
   unsigned IOCTL_TCSETS = TCSETS;
   unsigned IOCTL_TCSETSF = TCSETSF;
   unsigned IOCTL_TCSETSW = TCSETSW;
+#    endif
   unsigned IOCTL_TCXONC = TCXONC;
   unsigned IOCTL_TIOCGLCKTRMIOS = TIOCGLCKTRMIOS;
   unsigned IOCTL_TIOCGSOFTCAR = TIOCGSOFTCAR;

lib/libtsan/sanitizer_common/sanitizer_platform_limits_posix.h+32-6

 @@ -32,6 +32,8 @@
 #  elif SANITIZER_GLIBC || SANITIZER_ANDROID
 #    define SANITIZER_HAS_STAT64 1
 #    define SANITIZER_HAS_STATFS64 1
+#  elif SANITIZER_HAIKU
+#    include <stdint.h>
 #  endif
 #  if defined(__sparc__)
 @@ -102,6 +104,8 @@ const unsigned struct_kernel_stat_sz = SANITIZER_ANDROID
                                            ? FIRST_32_SECOND_64(104, 128)
 #      if defined(_ABIN32) && _MIPS_SIM == _ABIN32
                                            : FIRST_32_SECOND_64(176, 216);
+#      elif SANITIZER_MUSL
+                                           : FIRST_32_SECOND_64(160, 208);
 #      else
                                            : FIRST_32_SECOND_64(160, 216);
 #      endif
 @@ -476,6 +480,30 @@ struct __sanitizer_cmsghdr {
   int cmsg_level;
   int cmsg_type;
 };
+#  elif SANITIZER_MUSL
+struct __sanitizer_msghdr {
+  void *msg_name;
+  unsigned msg_namelen;
+  struct __sanitizer_iovec *msg_iov;
+  int msg_iovlen;
+#    if SANITIZER_WORDSIZE == 64
+  int __pad1;
+#    endif
+  void *msg_control;
+  unsigned msg_controllen;
+#    if SANITIZER_WORDSIZE == 64
+  int __pad2;
+#    endif
+  int msg_flags;
+};
+struct __sanitizer_cmsghdr {
+  unsigned cmsg_len;
+#    if SANITIZER_WORDSIZE == 64
+  int __pad1;
+#    endif
+  int cmsg_level;
+  int cmsg_type;
+};
 #  else
 // In POSIX, int msg_iovlen; socklen_t msg_controllen; socklen_t cmsg_len; but
 // many implementations don't conform to the standard.
 @@ -603,7 +631,7 @@ typedef unsigned long __sanitizer_sigset_t;
 #  elif SANITIZER_APPLE
 typedef unsigned __sanitizer_sigset_t;
 #  elif SANITIZER_HAIKU
-typedef unsigned long __sanitizer_sigset_t;
+typedef uint64_t __sanitizer_sigset_t;
 #  elif SANITIZER_LINUX
 struct __sanitizer_sigset_t {
   // The size is determined by looking at sizeof of real sigset_t on linux.
 @@ -1312,16 +1340,14 @@ extern unsigned IOCTL_SNDCTL_COPR_SENDMSG;
 extern unsigned IOCTL_SNDCTL_COPR_WCODE;
 extern unsigned IOCTL_SNDCTL_COPR_WDATA;
 extern unsigned IOCTL_TCFLSH;
-extern unsigned IOCTL_TCGETA;
-extern unsigned IOCTL_TCGETS;
 extern unsigned IOCTL_TCSBRK;
 extern unsigned IOCTL_TCSBRKP;
-extern unsigned IOCTL_TCSETA;
+#    if SANITIZER_TERMIOS_IOCTL_CONSTANTS
-extern unsigned IOCTL_TCSETAF;
+extern unsigned IOCTL_TCGETS;
-extern unsigned IOCTL_TCSETAW;
 extern unsigned IOCTL_TCSETS;
 extern unsigned IOCTL_TCSETSF;
 extern unsigned IOCTL_TCSETSW;
+#    endif
 extern unsigned IOCTL_TCXONC;
 extern unsigned IOCTL_TIOCGLCKTRMIOS;
 extern unsigned IOCTL_TIOCGSOFTCAR;

lib/libtsan/sanitizer_common/sanitizer_posix.cpp+3-12

 @@ -225,17 +225,9 @@ void *MapWritableFileToMemory(void *addr, uptr size, fd_t fd, OFF_T offset) {
   return (void *)p;
 }
-static inline bool IntervalsAreSeparate(uptr start1, uptr end1,
+#  if !SANITIZER_APPLE
-                                        uptr start2, uptr end2) {
-  CHECK(start1 <= end1);
-  CHECK(start2 <= end2);
-  return (end1 < start2) || (end2 < start1);
-}
 // FIXME: this is thread-unsafe, but should not cause problems most of the time.
-// When the shadow is mapped only a single thread usually exists (plus maybe
+// When the shadow is mapped only a single thread usually exists
-// several worker threads on Mac, which aren't expected to map big chunks of
-// memory).
 bool MemoryRangeIsAvailable(uptr range_start, uptr range_end) {
   MemoryMappingLayout proc_maps(/*cache_enabled*/true);
   if (proc_maps.Error())
 @@ -251,7 +243,6 @@ bool MemoryRangeIsAvailable(uptr range_start, uptr range_end) {
   return true;
 }
-#if !SANITIZER_APPLE
 void DumpProcessMap() {
   MemoryMappingLayout proc_maps(/*cache_enabled*/true);
   const sptr kBufSize = 4095;
 @@ -265,7 +256,7 @@ void DumpProcessMap() {
   Report("End of process memory map.\n");
   UnmapOrDie(filename, kBufSize);
 }
-#endif
+#  endif
 const char *GetPwd() {
   return GetEnv("PWD");

lib/libtsan/sanitizer_common/sanitizer_posix.h+2-1

...	@@ -67,7 +67,8 @@ uptr internal_ptrace(int request, int pid, void addr, void data);	...	@@ -67,7 +67,8 @@ uptr internal_ptrace(int request, int pid, void addr, void data);
67	uptr internal_waitpid(int pid, int *status, int options);	67	uptr internal_waitpid(int pid, int *status, int options);
68		68
69	int internal_fork();	69	int internal_fork();
70	fd_t internal_spawn(const char argv[], const char envp[], pid_t *pid);	70	bool internal_spawn(const char* argv[], const char* envp[], pid_t* pid,
		71	fd_t fd_stdin, fd_t fd_stdout);
71		72
72	int internal_sysctl(const int name, unsigned int namelen, void oldp,	73	int internal_sysctl(const int name, unsigned int namelen, void oldp,
73	uptr oldlenp, const void newp, uptr newlen);	74	uptr oldlenp, const void newp, uptr newlen);

lib/libtsan/sanitizer_common/sanitizer_posix_libcdep.cpp+19

...	@@ -47,6 +47,8 @@ typedef void (sa_sigaction_t)(int, siginfo_t , void *);	...	@@ -47,6 +47,8 @@ typedef void (sa_sigaction_t)(int, siginfo_t , void *);
47		47
48	namespace __sanitizer {	48	namespace __sanitizer {
49		49
		50	[[maybe_unused]] static atomic_uint8_t signal_handler_is_from_sanitizer[64];
		51
50	u32 GetUid() {	52	u32 GetUid() {
51	return getuid();	53	return getuid();
52	}	54	}
...	@@ -210,6 +212,20 @@ void UnsetAlternateSignalStack() {	...	@@ -210,6 +212,20 @@ void UnsetAlternateSignalStack() {
210	UnmapOrDie(oldstack.ss_sp, oldstack.ss_size);	212	UnmapOrDie(oldstack.ss_sp, oldstack.ss_size);
211	}	213	}
212		214
		215	bool IsSignalHandlerFromSanitizer(int signum) {
		216	return atomic_load(&signal_handler_is_from_sanitizer[signum],
		217	memory_order_relaxed);
		218	}
		219
		220	bool SetSignalHandlerFromSanitizer(int signum, bool new_state) {
		221	if (signum < 0 \|\| static_cast<unsigned>(signum) >=
		222	ARRAY_SIZE(signal_handler_is_from_sanitizer))
		223	return false;
		224
		225	return atomic_exchange(&signal_handler_is_from_sanitizer[signum], new_state,
		226	memory_order_relaxed);
		227	}
		228
213	static void MaybeInstallSigaction(int signum,	229	static void MaybeInstallSigaction(int signum,
214	SignalHandlerType handler) {	230	SignalHandlerType handler) {
215	if (GetHandleSignalMode(signum) == kHandleSignalNo) return;	231	if (GetHandleSignalMode(signum) == kHandleSignalNo) return;
...	@@ -223,6 +239,9 @@ static void MaybeInstallSigaction(int signum,	...	@@ -223,6 +239,9 @@ static void MaybeInstallSigaction(int signum,
223	if (common_flags()->use_sigaltstack) sigact.sa_flags \|= SA_ONSTACK;	239	if (common_flags()->use_sigaltstack) sigact.sa_flags \|= SA_ONSTACK;
224	CHECK_EQ(0, internal_sigaction(signum, &sigact, nullptr));	240	CHECK_EQ(0, internal_sigaction(signum, &sigact, nullptr));
225	VReport(1, "Installed the sigaction for signal %d\n", signum);	241	VReport(1, "Installed the sigaction for signal %d\n", signum);
		242
		243	if (common_flags()->cloak_sanitizer_signal_handlers)
		244	SetSignalHandlerFromSanitizer(signum, true);
226	}	245	}
227		246
228	void InstallDeadlySignalHandlers(SignalHandlerType handler) {	247	void InstallDeadlySignalHandlers(SignalHandlerType handler) {

lib/libtsan/sanitizer_common/sanitizer_procmaps_mac.cpp+102-37

...	@@ -20,18 +20,21 @@	...	@@ -20,18 +20,21 @@
20	#include <mach/mach.h>	20	#include <mach/mach.h>
21		21
22	// These are not available in older macOS SDKs.	22	// These are not available in older macOS SDKs.
23	#ifndef CPU_SUBTYPE_X86_64_H	23	# ifndef CPU_SUBTYPE_X86_64_H
24	#define CPU_SUBTYPE_X86_64_H ((cpu_subtype_t)8) /* Haswell */	24	# define CPU_SUBTYPE_X86_64_H ((cpu_subtype_t)8) /* Haswell */
25	#endif	25	# endif
26	#ifndef CPU_SUBTYPE_ARM_V7S	26	# ifndef CPU_SUBTYPE_ARM_V7S
27	#define CPU_SUBTYPE_ARM_V7S ((cpu_subtype_t)11) /* Swift */	27	# define CPU_SUBTYPE_ARM_V7S ((cpu_subtype_t)11) /* Swift */
28	#endif	28	# endif
29	#ifndef CPU_SUBTYPE_ARM_V7K	29	# ifndef CPU_SUBTYPE_ARM_V7K
30	#define CPU_SUBTYPE_ARM_V7K ((cpu_subtype_t)12)	30	# define CPU_SUBTYPE_ARM_V7K ((cpu_subtype_t)12)
31	#endif	31	# endif
32	#ifndef CPU_TYPE_ARM64	32	# ifndef CPU_TYPE_ARM64
33	#define CPU_TYPE_ARM64 (CPU_TYPE_ARM \| CPU_ARCH_ABI64)	33	# define CPU_TYPE_ARM64 (CPU_TYPE_ARM \| CPU_ARCH_ABI64)
34	#endif	34	# endif
		35	# ifndef CPU_SUBTYPE_ARM64E
		36	# define CPU_SUBTYPE_ARM64E ((cpu_subtype_t)2)
		37	# endif
35		38
36	namespace __sanitizer {	39	namespace __sanitizer {
37		40
...	@@ -42,7 +45,6 @@ struct MemoryMappedSegmentData {	...	@@ -42,7 +45,6 @@ struct MemoryMappedSegmentData {
42	const char *current_load_cmd_addr;	45	const char *current_load_cmd_addr;
43	u32 lc_type;	46	u32 lc_type;
44	uptr base_virt_addr;	47	uptr base_virt_addr;
45	uptr addr_mask;
46	};	48	};
47		49
48	template <typename Section>	50	template <typename Section>
...	@@ -51,12 +53,62 @@ static void NextSectionLoad(LoadedModule module, MemoryMappedSegmentData data,	...	@@ -51,12 +53,62 @@ static void NextSectionLoad(LoadedModule module, MemoryMappedSegmentData data,
51	const Section sc = (const Section )data->current_load_cmd_addr;	53	const Section sc = (const Section )data->current_load_cmd_addr;
52	data->current_load_cmd_addr += sizeof(Section);	54	data->current_load_cmd_addr += sizeof(Section);
53		55
54	uptr sec_start = (sc->addr & data->addr_mask) + data->base_virt_addr;	56	uptr sec_start = sc->addr + data->base_virt_addr;
55	uptr sec_end = sec_start + sc->size;	57	uptr sec_end = sec_start + sc->size;
56	module->addAddressRange(sec_start, sec_end, /executable=/false, isWritable,	58	module->addAddressRange(sec_start, sec_end, /executable=/false, isWritable,
57	sc->sectname);	59	sc->sectname);
58	}	60	}
59		61
		62	static bool VerifyMemoryMapping(MemoryMappingLayout* mapping) {
		63	InternalMmapVector<LoadedModule> modules;
		64	modules.reserve(128); // matches DumpProcessMap
		65	mapping->DumpListOfModules(&modules);
		66
		67	InternalMmapVector<LoadedModule::AddressRange> segments;
		68	for (uptr i = 0; i < modules.size(); ++i) {
		69	for (auto& range : modules[i].ranges()) {
		70	if (range.beg == range.end)
		71	continue;
		72	segments.push_back(range);
		73	}
		74	}
		75
		76	// Verify that none of the segments overlap:
		77	// 1. Sort the segments by the start address
		78	// 2. Check that every segment starts after the previous one ends.
		79	Sort(segments.data(), segments.size(),
		80	[](LoadedModule::AddressRange& a, LoadedModule::AddressRange& b) {
		81	return a.beg < b.beg;
		82	});
		83
		84	// To avoid spam, we only print the report message once-per-process.
		85	static bool invalid_module_map_reported = false;
		86	bool well_formed = true;
		87
		88	for (size_t i = 1; i < segments.size(); i++) {
		89	uptr cur_start = segments[i].beg;
		90	uptr prev_end = segments[i - 1].end;
		91	if (cur_start < prev_end) {
		92	well_formed = false;
		93	VReport(2, "Overlapping mappings: %s start = %p, %s end = %p\n",
		94	segments[i].name, (void*)cur_start, segments[i - 1].name,
		95	(void*)prev_end);
		96	if (!invalid_module_map_reported) {
		97	Report(
		98	"WARN: Invalid dyld module map detected. This is most likely a bug "
		99	"in the sanitizer.\n");
		100	Report("WARN: Backtraces may be unreliable.\n");
		101	invalid_module_map_reported = true;
		102	}
		103	}
		104	}
		105
		106	for (auto& m : modules) m.clear();
		107
		108	mapping->Reset();
		109	return well_formed;
		110	}
		111
60	void MemoryMappedSegment::AddAddressRanges(LoadedModule *module) {	112	void MemoryMappedSegment::AddAddressRanges(LoadedModule *module) {
61	// Don't iterate over sections when the caller hasn't set up the	113	// Don't iterate over sections when the caller hasn't set up the
62	// data pointer, when there are no sections, or when the segment	114	// data pointer, when there are no sections, or when the segment
...	@@ -82,6 +134,7 @@ void MemoryMappedSegment::AddAddressRanges(LoadedModule *module) {	...	@@ -82,6 +134,7 @@ void MemoryMappedSegment::AddAddressRanges(LoadedModule *module) {
82		134
83	MemoryMappingLayout::MemoryMappingLayout(bool cache_enabled) {	135	MemoryMappingLayout::MemoryMappingLayout(bool cache_enabled) {
84	Reset();	136	Reset();
		137	VerifyMemoryMapping(this);
85	}	138	}
86		139
87	MemoryMappingLayout::~MemoryMappingLayout() {	140	MemoryMappingLayout::~MemoryMappingLayout() {
...	@@ -123,7 +176,7 @@ void MemoryMappingLayout::Reset() {	...	@@ -123,7 +176,7 @@ void MemoryMappingLayout::Reset() {
123	// The dyld load address should be unchanged throughout process execution,	176	// The dyld load address should be unchanged throughout process execution,
124	// and it is expensive to compute once many libraries have been loaded,	177	// and it is expensive to compute once many libraries have been loaded,
125	// so cache it here and do not reset.	178	// so cache it here and do not reset.
126	static mach_header *dyld_hdr = 0;	179	static const mach_header* dyld_hdr = 0;
127	static const char kDyldPath[] = "/usr/lib/dyld";	180	static const char kDyldPath[] = "/usr/lib/dyld";
128	static const int kDyldImageIdx = -1;	181	static const int kDyldImageIdx = -1;
129		182
...	@@ -187,17 +240,22 @@ typedef struct dyld_shared_cache_dylib_text_info	...	@@ -187,17 +240,22 @@ typedef struct dyld_shared_cache_dylib_text_info
187		240
188	extern bool _dyld_get_shared_cache_uuid(uuid_t uuid);	241	extern bool _dyld_get_shared_cache_uuid(uuid_t uuid);
189	extern const void _dyld_get_shared_cache_range(size_t length);	242	extern const void _dyld_get_shared_cache_range(size_t length);
		243	extern intptr_t _dyld_get_image_slide(const struct mach_header* mh);
190	extern int dyld_shared_cache_iterate_text(	244	extern int dyld_shared_cache_iterate_text(
191	const uuid_t cacheUuid,	245	const uuid_t cacheUuid,
192	void (^callback)(const dyld_shared_cache_dylib_text_info *info));	246	void (^callback)(const dyld_shared_cache_dylib_text_info *info));
		247	SANITIZER_WEAK_IMPORT const struct mach_header* _dyld_get_dyld_header(void);
193	} // extern "C"	248	} // extern "C"
194		249
195	static mach_header *GetDyldImageHeaderViaSharedCache() {	250	static const mach_header* GetDyldImageHeaderViaSharedCache() {
196	uuid_t uuid;	251	uuid_t uuid;
197	bool hasCache = _dyld_get_shared_cache_uuid(uuid);	252	bool hasCache = _dyld_get_shared_cache_uuid(uuid);
198	if (!hasCache)	253	if (!hasCache)
199	return nullptr;	254	return nullptr;
200		255
		256	if (&_dyld_get_dyld_header != nullptr)
		257	return _dyld_get_dyld_header();
		258
201	size_t cacheLength;	259	size_t cacheLength;
202	__block uptr cacheStart = (uptr)_dyld_get_shared_cache_range(&cacheLength);	260	__block uptr cacheStart = (uptr)_dyld_get_shared_cache_range(&cacheLength);
203	CHECK(cacheStart && cacheLength);	261	CHECK(cacheStart && cacheLength);
...	@@ -255,23 +313,21 @@ static bool NextSegmentLoad(MemoryMappedSegment *segment,	...	@@ -255,23 +313,21 @@ static bool NextSegmentLoad(MemoryMappedSegment *segment,
255	layout_data->current_load_cmd_count--;	313	layout_data->current_load_cmd_count--;
256	if (((const load_command *)lc)->cmd == kLCSegment) {	314	if (((const load_command *)lc)->cmd == kLCSegment) {
257	const SegmentCommand* sc = (const SegmentCommand *)lc;	315	const SegmentCommand* sc = (const SegmentCommand *)lc;
258	uptr base_virt_addr, addr_mask;	316	if (internal_strcmp(sc->segname, "__LINKEDIT") == 0) {
259	if (layout_data->current_image == kDyldImageIdx) {	317	// The LINKEDIT sections are for internal linker use, and may alias
260	base_virt_addr = (uptr)get_dyld_hdr();	318	// with the LINKEDIT section for other modules. (If we included them,
261	// vmaddr is masked with 0xfffff because on macOS versions < 10.12,	319	// our memory map would contain overlappping sections.)
262	// it contains an absolute address rather than an offset for dyld.	320	return false;
263	// To make matters even more complicated, this absolute address	321	}
264	// isn't actually the absolute segment address, but the offset portion	322
265	// of the address is accurate when combined with the dyld base address,	323	uptr base_virt_addr;
266	// and the mask will give just this offset.	324	if (layout_data->current_image == kDyldImageIdx)
267	addr_mask = 0xfffff;	325	base_virt_addr = (uptr)_dyld_get_image_slide(get_dyld_hdr());
268	} else {	326	else
269	base_virt_addr =	327	base_virt_addr =
270	(uptr)_dyld_get_image_vmaddr_slide(layout_data->current_image);	328	(uptr)_dyld_get_image_vmaddr_slide(layout_data->current_image);
271	addr_mask = ~0;
272	}
273		329
274	segment->start = (sc->vmaddr & addr_mask) + base_virt_addr;	330	segment->start = sc->vmaddr + base_virt_addr;
275	segment->end = segment->start + sc->vmsize;	331	segment->end = segment->start + sc->vmsize;
276	// Most callers don't need section information, so only fill this struct	332	// Most callers don't need section information, so only fill this struct
277	// when required.	333	// when required.
...	@@ -281,9 +337,9 @@ static bool NextSegmentLoad(MemoryMappedSegment *segment,	...	@@ -281,9 +337,9 @@ static bool NextSegmentLoad(MemoryMappedSegment *segment,
281	(const char *)lc + sizeof(SegmentCommand);	337	(const char *)lc + sizeof(SegmentCommand);
282	seg_data->lc_type = kLCSegment;	338	seg_data->lc_type = kLCSegment;
283	seg_data->base_virt_addr = base_virt_addr;	339	seg_data->base_virt_addr = base_virt_addr;
284	seg_data->addr_mask = addr_mask;
285	internal_strncpy(seg_data->name, sc->segname,	340	internal_strncpy(seg_data->name, sc->segname,
286	ARRAY_SIZE(seg_data->name));	341	ARRAY_SIZE(seg_data->name));
		342	seg_data->name[ARRAY_SIZE(seg_data->name) - 1] = 0;
287	}	343	}
288		344
289	// Return the initial protection.	345	// Return the initial protection.
...	@@ -297,6 +353,7 @@ static bool NextSegmentLoad(MemoryMappedSegment *segment,	...	@@ -297,6 +353,7 @@ static bool NextSegmentLoad(MemoryMappedSegment *segment,
297	? kDyldPath	353	? kDyldPath
298	: _dyld_get_image_name(layout_data->current_image);	354	: _dyld_get_image_name(layout_data->current_image);
299	internal_strncpy(segment->filename, src, segment->filename_size);	355	internal_strncpy(segment->filename, src, segment->filename_size);
		356	segment->filename[segment->filename_size - 1] = 0;
300	}	357	}
301	segment->arch = layout_data->current_arch;	358	segment->arch = layout_data->current_arch;
302	internal_memcpy(segment->uuid, layout_data->current_uuid, kModuleUUIDSize);	359	internal_memcpy(segment->uuid, layout_data->current_uuid, kModuleUUIDSize);
...	@@ -311,18 +368,26 @@ ModuleArch ModuleArchFromCpuType(cpu_type_t cputype, cpu_subtype_t cpusubtype) {	...	@@ -311,18 +368,26 @@ ModuleArch ModuleArchFromCpuType(cpu_type_t cputype, cpu_subtype_t cpusubtype) {
311	case CPU_TYPE_I386:	368	case CPU_TYPE_I386:
312	return kModuleArchI386;	369	return kModuleArchI386;
313	case CPU_TYPE_X86_64:	370	case CPU_TYPE_X86_64:
314	if (cpusubtype == CPU_SUBTYPE_X86_64_ALL) return kModuleArchX86_64;	371	if (cpusubtype == CPU_SUBTYPE_X86_64_ALL)
315	if (cpusubtype == CPU_SUBTYPE_X86_64_H) return kModuleArchX86_64H;	372	return kModuleArchX86_64;
		373	if (cpusubtype == CPU_SUBTYPE_X86_64_H)
		374	return kModuleArchX86_64H;
316	CHECK(0 && "Invalid subtype of x86_64");	375	CHECK(0 && "Invalid subtype of x86_64");
317	return kModuleArchUnknown;	376	return kModuleArchUnknown;
318	case CPU_TYPE_ARM:	377	case CPU_TYPE_ARM:
319	if (cpusubtype == CPU_SUBTYPE_ARM_V6) return kModuleArchARMV6;	378	if (cpusubtype == CPU_SUBTYPE_ARM_V6)
320	if (cpusubtype == CPU_SUBTYPE_ARM_V7) return kModuleArchARMV7;	379	return kModuleArchARMV6;
321	if (cpusubtype == CPU_SUBTYPE_ARM_V7S) return kModuleArchARMV7S;	380	if (cpusubtype == CPU_SUBTYPE_ARM_V7)
322	if (cpusubtype == CPU_SUBTYPE_ARM_V7K) return kModuleArchARMV7K;	381	return kModuleArchARMV7;
		382	if (cpusubtype == CPU_SUBTYPE_ARM_V7S)
		383	return kModuleArchARMV7S;
		384	if (cpusubtype == CPU_SUBTYPE_ARM_V7K)
		385	return kModuleArchARMV7K;
323	CHECK(0 && "Invalid subtype of ARM");	386	CHECK(0 && "Invalid subtype of ARM");
324	return kModuleArchUnknown;	387	return kModuleArchUnknown;
325	case CPU_TYPE_ARM64:	388	case CPU_TYPE_ARM64:
		389	if (cpusubtype == CPU_SUBTYPE_ARM64E)
		390	return kModuleArchARM64E;
326	return kModuleArchARM64;	391	return kModuleArchARM64;
327	default:	392	default:
328	CHECK(0 && "Invalid CPU type");	393	CHECK(0 && "Invalid CPU type");

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) && !defined(_AIX)	18	# if !defined(_WIN32) && !defined(_AIX) && !defined(__APPLE__)
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_signal_interceptors.inc+40-2

...	@@ -45,6 +45,8 @@ using namespace __sanitizer;	...	@@ -45,6 +45,8 @@ using namespace __sanitizer;
45	INTERCEPTOR(uptr, bsd_signal, int signum, uptr handler) {	45	INTERCEPTOR(uptr, bsd_signal, int signum, uptr handler) {
46	SIGNAL_INTERCEPTOR_ENTER();	46	SIGNAL_INTERCEPTOR_ENTER();
47	if (GetHandleSignalMode(signum) == kHandleSignalExclusive) return 0;	47	if (GetHandleSignalMode(signum) == kHandleSignalExclusive) return 0;
		48
		49	// TODO: support cloak_sanitizer_signal_handlers
48	SIGNAL_INTERCEPTOR_SIGNAL_IMPL(bsd_signal, signum, handler);	50	SIGNAL_INTERCEPTOR_SIGNAL_IMPL(bsd_signal, signum, handler);
49	}	51	}
50	#define INIT_BSD_SIGNAL COMMON_INTERCEPT_FUNCTION(bsd_signal)	52	#define INIT_BSD_SIGNAL COMMON_INTERCEPT_FUNCTION(bsd_signal)
...	@@ -56,19 +58,55 @@ INTERCEPTOR(uptr, bsd_signal, int signum, uptr handler) {	...	@@ -56,19 +58,55 @@ INTERCEPTOR(uptr, bsd_signal, int signum, uptr handler) {
56	INTERCEPTOR(uptr, signal, int signum, uptr handler) {	58	INTERCEPTOR(uptr, signal, int signum, uptr handler) {
57	SIGNAL_INTERCEPTOR_ENTER();	59	SIGNAL_INTERCEPTOR_ENTER();
58	if (GetHandleSignalMode(signum) == kHandleSignalExclusive)	60	if (GetHandleSignalMode(signum) == kHandleSignalExclusive)
		61	// The user can neither view nor change the signal handler, regardless of
		62	// the cloak_sanitizer_signal_handlers setting. This differs from
		63	// sigaction().
59	return (uptr) nullptr;	64	return (uptr) nullptr;
60	SIGNAL_INTERCEPTOR_SIGNAL_IMPL(signal, signum, handler);	65
		66	uptr ret = +[](auto signal, int signum, uptr handler) {
		67	SIGNAL_INTERCEPTOR_SIGNAL_IMPL(signal, signum, handler);
		68	}(signal, signum, handler);
		69
		70	if (ret != sig_err && SetSignalHandlerFromSanitizer(signum, false))
		71	// If the user sets a signal handler, it becomes uncloaked, even if they
		72	// reuse a sanitizer's signal handler.
		73	ret = sig_dfl;
		74
		75	return ret;
61	}	76	}
62	#define INIT_SIGNAL COMMON_INTERCEPT_FUNCTION(signal)	77	#define INIT_SIGNAL COMMON_INTERCEPT_FUNCTION(signal)
63		78
64	INTERCEPTOR(int, sigaction_symname, int signum,	79	INTERCEPTOR(int, sigaction_symname, int signum,
65	const __sanitizer_sigaction act, __sanitizer_sigaction oldact) {	80	const __sanitizer_sigaction act, __sanitizer_sigaction oldact) {
66	SIGNAL_INTERCEPTOR_ENTER();	81	SIGNAL_INTERCEPTOR_ENTER();
		82
67	if (GetHandleSignalMode(signum) == kHandleSignalExclusive) {	83	if (GetHandleSignalMode(signum) == kHandleSignalExclusive) {
68	if (!oldact) return 0;	84	if (!oldact) return 0;
69	act = nullptr;	85	act = nullptr;
		86	// If cloak_sanitizer_signal_handlers=true, the user can neither view nor
		87	// change the signal handle.
		88	// If false, the user can view but not change the signal handler. This
		89	// differs from signal().
70	}	90	}
71	SIGNAL_INTERCEPTOR_SIGACTION_IMPL(signum, act, oldact);	91
		92	int ret = +[](int signum, const __sanitizer_sigaction* act,
		93	__sanitizer_sigaction* oldact) {
		94	SIGNAL_INTERCEPTOR_SIGACTION_IMPL(signum, act, oldact);
		95	}(signum, act, oldact);
		96
		97	if (act) {
		98	if (ret == 0 && SetSignalHandlerFromSanitizer(signum, false)) {
		99	// If the user sets a signal handler, it becomes uncloaked, even if they
		100	// reuse a sanitizer's signal handler.
		101
		102	if (oldact)
		103	oldact->handler = reinterpret_cast<__sanitizer_sighandler_ptr>(sig_dfl);
		104	}
		105	} else if (ret == 0 && oldact && IsSignalHandlerFromSanitizer(signum)) {
		106	oldact->handler = reinterpret_cast<__sanitizer_sighandler_ptr>(sig_dfl);
		107	}
		108
		109	return ret;
72	}	110	}
73	#define INIT_SIGACTION COMMON_INTERCEPT_FUNCTION(sigaction_symname)	111	#define INIT_SIGACTION COMMON_INTERCEPT_FUNCTION(sigaction_symname)
74		112

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

...	@@ -38,7 +38,7 @@ class SuspendedThreadsList {	...	@@ -38,7 +38,7 @@ class SuspendedThreadsList {
38	}	38	}
39		39
40	virtual uptr ThreadCount() const { UNIMPLEMENTED(); }	40	virtual uptr ThreadCount() const { UNIMPLEMENTED(); }
41	virtual tid_t GetThreadID(uptr index) const { UNIMPLEMENTED(); }	41	virtual ThreadID GetThreadID(uptr index) const { UNIMPLEMENTED(); }
42		42
43	protected:	43	protected:
44	~SuspendedThreadsList() {}	44	~SuspendedThreadsList() {}

lib/libtsan/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cpp+83-12

...	@@ -94,17 +94,17 @@ class SuspendedThreadsListLinux final : public SuspendedThreadsList {	...	@@ -94,17 +94,17 @@ class SuspendedThreadsListLinux final : public SuspendedThreadsList {
94	public:	94	public:
95	SuspendedThreadsListLinux() { thread_ids_.reserve(1024); }	95	SuspendedThreadsListLinux() { thread_ids_.reserve(1024); }
96		96
97	tid_t GetThreadID(uptr index) const override;	97	ThreadID GetThreadID(uptr index) const override;
98	uptr ThreadCount() const override;	98	uptr ThreadCount() const override;
99	bool ContainsTid(tid_t thread_id) const;	99	bool ContainsTid(ThreadID thread_id) const;
100	void Append(tid_t tid);	100	void Append(ThreadID tid);
101		101
102	PtraceRegistersStatus GetRegistersAndSP(uptr index,	102	PtraceRegistersStatus GetRegistersAndSP(uptr index,
103	InternalMmapVector<uptr> *buffer,	103	InternalMmapVector<uptr> *buffer,
104	uptr *sp) const override;	104	uptr *sp) const override;
105		105
106	private:	106	private:
107	InternalMmapVector<tid_t> thread_ids_;	107	InternalMmapVector<ThreadID> thread_ids_;
108	};	108	};
109		109
110	// Structure for passing arguments into the tracer thread.	110	// Structure for passing arguments into the tracer thread.
...	@@ -137,10 +137,10 @@ class ThreadSuspender {	...	@@ -137,10 +137,10 @@ class ThreadSuspender {
137	private:	137	private:
138	SuspendedThreadsListLinux suspended_threads_list_;	138	SuspendedThreadsListLinux suspended_threads_list_;
139	pid_t pid_;	139	pid_t pid_;
140	bool SuspendThread(tid_t thread_id);	140	bool SuspendThread(ThreadID thread_id);
141	};	141	};
142		142
143	bool ThreadSuspender::SuspendThread(tid_t tid) {	143	bool ThreadSuspender::SuspendThread(ThreadID tid) {
144	int pterrno;	144	int pterrno;
145	if (internal_iserror(internal_ptrace(PTRACE_ATTACH, tid, nullptr, nullptr),	145	if (internal_iserror(internal_ptrace(PTRACE_ATTACH, tid, nullptr, nullptr),
146	&pterrno)) {	146	&pterrno)) {
...	@@ -210,7 +210,7 @@ void ThreadSuspender::KillAllThreads() {	...	@@ -210,7 +210,7 @@ void ThreadSuspender::KillAllThreads() {
210	bool ThreadSuspender::SuspendAllThreads() {	210	bool ThreadSuspender::SuspendAllThreads() {
211	ThreadLister thread_lister(pid_);	211	ThreadLister thread_lister(pid_);
212	bool retry = true;	212	bool retry = true;
213	InternalMmapVector<tid_t> threads;	213	InternalMmapVector<ThreadID> threads;
214	threads.reserve(128);	214	threads.reserve(128);
215	for (int i = 0; i < 30 && retry; ++i) {	215	for (int i = 0; i < 30 && retry; ++i) {
216	retry = false;	216	retry = false;
...	@@ -226,7 +226,7 @@ bool ThreadSuspender::SuspendAllThreads() {	...	@@ -226,7 +226,7 @@ bool ThreadSuspender::SuspendAllThreads() {
226	case ThreadLister::Ok:	226	case ThreadLister::Ok:
227	break;	227	break;
228	}	228	}
229	for (tid_t tid : threads) {	229	for (ThreadID tid : threads) {
230	// Are we already attached to this thread?	230	// Are we already attached to this thread?
231	// Currently this check takes linear time, however the number of threads	231	// Currently this check takes linear time, however the number of threads
232	// is usually small.	232	// is usually small.
...	@@ -403,7 +403,77 @@ struct ScopedSetTracerPID {	...	@@ -403,7 +403,77 @@ struct ScopedSetTracerPID {
403	}	403	}
404	};	404	};
405		405
		406	// This detects whether ptrace is blocked (e.g., by seccomp), by forking and
		407	// then attempting ptrace.
		408	// This separate check is necessary because StopTheWorld() creates a thread
		409	// with a shared virtual address space and shared TLS, and therefore
		410	// cannot use waitpid() due to the shared errno.
		411	static void TestPTrace() {
		412	# if SANITIZER_SPARC
		413	// internal_fork() on SPARC actually calls __fork(). We can't safely fork,
		414	// because it's possible seccomp has been configured to disallow fork() but
		415	// allow clone().
		416	VReport(1, "WARNING: skipping TestPTrace() because this is SPARC\n");
		417	VReport(1,
		418	"If seccomp blocks ptrace, LeakSanitizer may hang without further "
		419	"notice\n");
		420	VReport(
		421	1,
		422	"If seccomp does not block ptrace, you can safely ignore this warning\n");
		423	# else
		424	// Heuristic: only check the first time this is called. This is not always
		425	// correct (e.g., user manually triggers leak detection, then updates
		426	// seccomp, then leak detection is triggered again).
		427	static bool checked = false;
		428	if (checked)
		429	return;
		430	checked = true;
		431
		432	// Hopefully internal_fork() is not too expensive, thanks to copy-on-write.
		433	// Besides, this is only called the first time.
		434	// Note that internal_fork() on non-SPARC Linux actually calls
		435	// SYSCALL(clone); thus, it is reasonable to use it because if seccomp kills
		436	// TestPTrace(), it would have killed StopTheWorld() anyway.
		437	int pid = internal_fork();
		438
		439	if (pid < 0) {
		440	int rverrno;
		441	if (internal_iserror(pid, &rverrno))
		442	VReport(0, "WARNING: TestPTrace() failed to fork (errno %d)\n", rverrno);
		443
		444	// We don't abort the sanitizer - it's still worth letting the sanitizer
		445	// try.
		446	return;
		447	}
		448
		449	if (pid == 0) {
		450	// Child subprocess
		451
		452	// TODO: consider checking return value of internal_ptrace, to handle
		453	// SCMP_ACT_ERRNO. However, be careful not to consume too many
		454	// resources performing a proper ptrace.
		455	internal_ptrace(PTRACE_ATTACH, 0, nullptr, nullptr);
		456	internal__exit(0);
		457	} else {
		458	int wstatus;
		459	internal_waitpid(pid, &wstatus, 0);
		460
		461	// Handle SCMP_ACT_KILL
		462	if (WIFSIGNALED(wstatus)) {
		463	VReport(0,
		464	"WARNING: ptrace appears to be blocked (is seccomp enabled?). "
		465	"LeakSanitizer may hang.\n");
		466	VReport(0, "Child exited with signal %d.\n", WTERMSIG(wstatus));
		467	// We don't abort the sanitizer - it's still worth letting the sanitizer
		468	// try.
		469	}
		470	}
		471	# endif
		472	}
		473
406	void StopTheWorld(StopTheWorldCallback callback, void *argument) {	474	void StopTheWorld(StopTheWorldCallback callback, void *argument) {
		475	TestPTrace();
		476
407	StopTheWorldScope in_stoptheworld;	477	StopTheWorldScope in_stoptheworld;
408	// Prepare the arguments for TracerThread.	478	// Prepare the arguments for TracerThread.
409	struct TracerThreadArgument tracer_thread_argument;	479	struct TracerThreadArgument tracer_thread_argument;
...	@@ -457,7 +527,8 @@ void StopTheWorld(StopTheWorldCallback callback, void *argument) {	...	@@ -457,7 +527,8 @@ void StopTheWorld(StopTheWorldCallback callback, void *argument) {
457	internal_prctl(PR_SET_PTRACER, tracer_pid, 0, 0, 0);	527	internal_prctl(PR_SET_PTRACER, tracer_pid, 0, 0, 0);
458	// Allow the tracer thread to start.	528	// Allow the tracer thread to start.
459	tracer_thread_argument.mutex.Unlock();	529	tracer_thread_argument.mutex.Unlock();
460	// NOTE: errno is shared between this thread and the tracer thread.	530	// NOTE: errno is shared between this thread and the tracer thread
		531	// (clone was called without CLONE_SETTLS / newtls).
461	// internal_waitpid() may call syscall() which can access/spoil errno,	532	// internal_waitpid() may call syscall() which can access/spoil errno,
462	// so we can't call it now. Instead we for the tracer thread to finish using	533	// so we can't call it now. Instead we for the tracer thread to finish using
463	// the spin loop below. Man page for sched_yield() says "In the Linux	534	// the spin loop below. Man page for sched_yield() says "In the Linux
...	@@ -546,7 +617,7 @@ static constexpr uptr kExtraRegs[] = {0};	...	@@ -546,7 +617,7 @@ static constexpr uptr kExtraRegs[] = {0};
546	#error "Unsupported architecture"	617	#error "Unsupported architecture"
547	#endif // SANITIZER_ANDROID && defined(__arm__)	618	#endif // SANITIZER_ANDROID && defined(__arm__)
548		619
549	tid_t SuspendedThreadsListLinux::GetThreadID(uptr index) const {	620	ThreadID SuspendedThreadsListLinux::GetThreadID(uptr index) const {
550	CHECK_LT(index, thread_ids_.size());	621	CHECK_LT(index, thread_ids_.size());
551	return thread_ids_[index];	622	return thread_ids_[index];
552	}	623	}
...	@@ -555,14 +626,14 @@ uptr SuspendedThreadsListLinux::ThreadCount() const {	...	@@ -555,14 +626,14 @@ uptr SuspendedThreadsListLinux::ThreadCount() const {
555	return thread_ids_.size();	626	return thread_ids_.size();
556	}	627	}
557		628
558	bool SuspendedThreadsListLinux::ContainsTid(tid_t thread_id) const {	629	bool SuspendedThreadsListLinux::ContainsTid(ThreadID thread_id) const {
559	for (uptr i = 0; i < thread_ids_.size(); i++) {	630	for (uptr i = 0; i < thread_ids_.size(); i++) {
560	if (thread_ids_[i] == thread_id) return true;	631	if (thread_ids_[i] == thread_id) return true;
561	}	632	}
562	return false;	633	return false;
563	}	634	}
564		635
565	void SuspendedThreadsListLinux::Append(tid_t tid) {	636	void SuspendedThreadsListLinux::Append(ThreadID tid) {
566	thread_ids_.push_back(tid);	637	thread_ids_.push_back(tid);
567	}	638	}
568		639

lib/libtsan/sanitizer_common/sanitizer_stoptheworld_mac.cpp+3-3

...	@@ -23,7 +23,7 @@	...	@@ -23,7 +23,7 @@
23		23
24	namespace __sanitizer {	24	namespace __sanitizer {
25	typedef struct {	25	typedef struct {
26	tid_t tid;	26	ThreadID tid;
27	thread_t thread;	27	thread_t thread;
28	} SuspendedThreadInfo;	28	} SuspendedThreadInfo;
29		29
...	@@ -31,7 +31,7 @@ class SuspendedThreadsListMac final : public SuspendedThreadsList {	...	@@ -31,7 +31,7 @@ class SuspendedThreadsListMac final : public SuspendedThreadsList {
31	public:	31	public:
32	SuspendedThreadsListMac() = default;	32	SuspendedThreadsListMac() = default;
33		33
34	tid_t GetThreadID(uptr index) const override;	34	ThreadID GetThreadID(uptr index) const override;
35	thread_t GetThread(uptr index) const;	35	thread_t GetThread(uptr index) const;
36	uptr ThreadCount() const override;	36	uptr ThreadCount() const override;
37	bool ContainsThread(thread_t thread) const;	37	bool ContainsThread(thread_t thread) const;
...	@@ -111,7 +111,7 @@ typedef x86_thread_state32_t regs_struct;	...	@@ -111,7 +111,7 @@ typedef x86_thread_state32_t regs_struct;
111	#error "Unsupported architecture"	111	#error "Unsupported architecture"
112	#endif	112	#endif
113		113
114	tid_t SuspendedThreadsListMac::GetThreadID(uptr index) const {	114	ThreadID SuspendedThreadsListMac::GetThreadID(uptr index) const {
115	CHECK_LT(index, threads_.size());	115	CHECK_LT(index, threads_.size());
116	return threads_[index].tid;	116	return threads_[index].tid;
117	}	117	}

lib/libtsan/sanitizer_common/sanitizer_stoptheworld_netbsd_libcdep.cpp+7-7

...	@@ -52,17 +52,17 @@ class SuspendedThreadsListNetBSD final : public SuspendedThreadsList {	...	@@ -52,17 +52,17 @@ class SuspendedThreadsListNetBSD final : public SuspendedThreadsList {
52	public:	52	public:
53	SuspendedThreadsListNetBSD() { thread_ids_.reserve(1024); }	53	SuspendedThreadsListNetBSD() { thread_ids_.reserve(1024); }
54		54
55	tid_t GetThreadID(uptr index) const;	55	ThreadID GetThreadID(uptr index) const;
56	uptr ThreadCount() const;	56	uptr ThreadCount() const;
57	bool ContainsTid(tid_t thread_id) const;	57	bool ContainsTid(ThreadID thread_id) const;
58	void Append(tid_t tid);	58	void Append(ThreadID tid);
59		59
60	PtraceRegistersStatus GetRegistersAndSP(uptr index,	60	PtraceRegistersStatus GetRegistersAndSP(uptr index,
61	InternalMmapVector<uptr> *buffer,	61	InternalMmapVector<uptr> *buffer,
62	uptr *sp) const;	62	uptr *sp) const;
63		63
64	private:	64	private:
65	InternalMmapVector<tid_t> thread_ids_;	65	InternalMmapVector<ThreadID> thread_ids_;
66	};	66	};
67		67
68	struct TracerThreadArgument {	68	struct TracerThreadArgument {
...	@@ -313,7 +313,7 @@ void StopTheWorld(StopTheWorldCallback callback, void *argument) {	...	@@ -313,7 +313,7 @@ void StopTheWorld(StopTheWorldCallback callback, void *argument) {
313	}	313	}
314	}	314	}
315		315
316	tid_t SuspendedThreadsListNetBSD::GetThreadID(uptr index) const {	316	ThreadID SuspendedThreadsListNetBSD::GetThreadID(uptr index) const {
317	CHECK_LT(index, thread_ids_.size());	317	CHECK_LT(index, thread_ids_.size());
318	return thread_ids_[index];	318	return thread_ids_[index];
319	}	319	}
...	@@ -322,7 +322,7 @@ uptr SuspendedThreadsListNetBSD::ThreadCount() const {	...	@@ -322,7 +322,7 @@ uptr SuspendedThreadsListNetBSD::ThreadCount() const {
322	return thread_ids_.size();	322	return thread_ids_.size();
323	}	323	}
324		324
325	bool SuspendedThreadsListNetBSD::ContainsTid(tid_t thread_id) const {	325	bool SuspendedThreadsListNetBSD::ContainsTid(ThreadID thread_id) const {
326	for (uptr i = 0; i < thread_ids_.size(); i++) {	326	for (uptr i = 0; i < thread_ids_.size(); i++) {
327	if (thread_ids_[i] == thread_id)	327	if (thread_ids_[i] == thread_id)
328	return true;	328	return true;
...	@@ -330,7 +330,7 @@ bool SuspendedThreadsListNetBSD::ContainsTid(tid_t thread_id) const {	...	@@ -330,7 +330,7 @@ bool SuspendedThreadsListNetBSD::ContainsTid(tid_t thread_id) const {
330	return false;	330	return false;
331	}	331	}
332		332
333	void SuspendedThreadsListNetBSD::Append(tid_t tid) {	333	void SuspendedThreadsListNetBSD::Append(ThreadID tid) {
334	thread_ids_.push_back(tid);	334	thread_ids_.push_back(tid);
335	}	335	}
336		336

lib/libtsan/sanitizer_common/sanitizer_stoptheworld_win.cpp+2-2

...	@@ -38,7 +38,7 @@ struct SuspendedThreadsListWindows final : public SuspendedThreadsList {	...	@@ -38,7 +38,7 @@ struct SuspendedThreadsListWindows final : public SuspendedThreadsList {
38	InternalMmapVector<uptr> *buffer,	38	InternalMmapVector<uptr> *buffer,
39	uptr *sp) const override;	39	uptr *sp) const override;
40		40
41	tid_t GetThreadID(uptr index) const override;	41	ThreadID GetThreadID(uptr index) const override;
42	uptr ThreadCount() const override;	42	uptr ThreadCount() const override;
43	};	43	};
44		44
...	@@ -68,7 +68,7 @@ PtraceRegistersStatus SuspendedThreadsListWindows::GetRegistersAndSP(	...	@@ -68,7 +68,7 @@ PtraceRegistersStatus SuspendedThreadsListWindows::GetRegistersAndSP(
68	return REGISTERS_AVAILABLE;	68	return REGISTERS_AVAILABLE;
69	}	69	}
70		70
71	tid_t SuspendedThreadsListWindows::GetThreadID(uptr index) const {	71	ThreadID SuspendedThreadsListWindows::GetThreadID(uptr index) const {
72	CHECK_LT(index, threadIds.size());	72	CHECK_LT(index, threadIds.size());
73	return threadIds[index];	73	return threadIds[index];
74	}	74	}

lib/libtsan/sanitizer_common/sanitizer_symbolizer_internal.h+5-1

...	@@ -83,7 +83,7 @@ class SymbolizerProcess {	...	@@ -83,7 +83,7 @@ class SymbolizerProcess {
83	const char SendCommand(const char command);	83	const char SendCommand(const char command);
84		84
85	protected:	85	protected:
86	~SymbolizerProcess() {}	86	~SymbolizerProcess();
87		87
88	/// The maximum number of arguments required to invoke a tool process.	88	/// The maximum number of arguments required to invoke a tool process.
89	static const unsigned kArgVMax = 16;	89	static const unsigned kArgVMax = 16;
...	@@ -114,6 +114,10 @@ class SymbolizerProcess {	...	@@ -114,6 +114,10 @@ class SymbolizerProcess {
114	fd_t input_fd_;	114	fd_t input_fd_;
115	fd_t output_fd_;	115	fd_t output_fd_;
116		116
		117	// We hold on to the child's stdin fd (the read end of the pipe)
		118	// so that when we write to it, we don't get a SIGPIPE
		119	fd_t child_stdin_fd_;
		120
117	InternalMmapVector<char> buffer_;	121	InternalMmapVector<char> buffer_;
118		122
119	static const uptr kMaxTimesRestarted = 5;	123	static const uptr kMaxTimesRestarted = 5;

lib/libtsan/sanitizer_common/sanitizer_symbolizer_libcdep.cpp+11-1

 @@ -476,10 +476,11 @@ const char *LLVMSymbolizer::FormatAndSendCommand(const char *command_prefix,
   return symbolizer_process_->SendCommand(buffer_);
 }
-SymbolizerProcess::SymbolizerProcess(const char *path, bool use_posix_spawn)
+SymbolizerProcess::SymbolizerProcess(const char* path, bool use_posix_spawn)
     : path_(path),
       input_fd_(kInvalidFd),
       output_fd_(kInvalidFd),
+      child_stdin_fd_(kInvalidFd),
       times_restarted_(0),
       failed_to_start_(false),
       reported_invalid_path_(false),
 @@ -488,6 +489,11 @@ SymbolizerProcess::SymbolizerProcess(const char *path, bool use_posix_spawn)
   CHECK_NE(path_[0], '\0');
 }
+SymbolizerProcess::~SymbolizerProcess() {
+  if (child_stdin_fd_ != kInvalidFd)
+    CloseFile(child_stdin_fd_);
+}
 static bool IsSameModule(const char *path) {
   if (const char *ProcessName = GetProcessName()) {
     if (const char *SymbolizerName = StripModuleName(path)) {
 @@ -533,6 +539,10 @@ bool SymbolizerProcess::Restart() {
     CloseFile(input_fd_);
   if (output_fd_ != kInvalidFd)
     CloseFile(output_fd_);
+  if (child_stdin_fd_ != kInvalidFd) {
+    CloseFile(child_stdin_fd_);
+    child_stdin_fd_ = kInvalidFd;  // Don't free in destructor
+  }
   return StartSymbolizerSubprocess();
 }

lib/libtsan/sanitizer_common/sanitizer_symbolizer_mac.cpp+86-29

...	@@ -78,13 +78,25 @@ class AtosSymbolizerProcess final : public SymbolizerProcess {	...	@@ -78,13 +78,25 @@ class AtosSymbolizerProcess final : public SymbolizerProcess {
78	}	78	}
79		79
80	bool ReachedEndOfOutput(const char *buffer, uptr length) const override {	80	bool ReachedEndOfOutput(const char *buffer, uptr length) const override {
81	return (length >= 1 && buffer[length - 1] == '\n');	81	if (common_flags()->symbolize_inline_frames) {
		82	// When running with -i, atos sends two newlines at the end of each
		83	// address it symbolizes. This indicates the end of the set of frames
		84	// for a particular address.
		85	return length >= 2 && buffer[length - 1] == '\n' &&
		86	buffer[length - 2] == '\n';
		87	} else {
		88	// When running without -i, atos only sends a single newline at
		89	// the end of each address it symbolizes.
		90	return length >= 1 && buffer[length - 1] == '\n';
		91	}
82	}	92	}
83		93
84	void GetArgV(const char *path_to_binary,	94	void GetArgV(const char *path_to_binary,
85	const char *(&argv)[kArgVMax]) const override {	95	const char *(&argv)[kArgVMax]) const override {
86	int i = 0;	96	int i = 0;
87	argv[i++] = path_to_binary;	97	argv[i++] = path_to_binary;
		98	if (common_flags()->symbolize_inline_frames)
		99	argv[i++] = "-i";
88	argv[i++] = "-p";	100	argv[i++] = "-p";
89	argv[i++] = &pid_str_[0];	101	argv[i++] = &pid_str_[0];
90	if (GetMacosAlignedVersion() == MacosVersion(10, 9)) {	102	if (GetMacosAlignedVersion() == MacosVersion(10, 9)) {
...	@@ -102,12 +114,16 @@ class AtosSymbolizerProcess final : public SymbolizerProcess {	...	@@ -102,12 +114,16 @@ class AtosSymbolizerProcess final : public SymbolizerProcess {
102		114
103	#undef K_ATOS_ENV_VAR	115	#undef K_ATOS_ENV_VAR
104		116
105	static bool ParseCommandOutput(const char str, uptr addr, char *out_name,	117	// Parses a single frame (one line) from str, and returns the pointer to the
106	char out_module, char out_file, uptr *line,	118	// next character to parse (i.e. after the newline) if successful. If
107	uptr *start_address) {	119	// it fails, returns NULL.
		120	static const char* ParseCommandOutput(const char* str, uptr addr,
		121	char out_name, char out_module,
		122	char** out_file, uptr* line,
		123	uptr* start_address) {
108	// Trim ending newlines.	124	// Trim ending newlines.
109	char *trim;	125	char *trim;
110	ExtractTokenUpToDelimiter(str, "\n", &trim);	126	str = ExtractTokenUpToDelimiter(str, "\n", &trim);
111		127
112	// The line from `atos` is in one of these formats:	128	// The line from `atos` is in one of these formats:
113	// myfunction (in library.dylib) (sourcefile.c:17)	129	// myfunction (in library.dylib) (sourcefile.c:17)
...	@@ -124,7 +140,7 @@ static bool ParseCommandOutput(const char str, uptr addr, char *out_name,	...	@@ -124,7 +140,7 @@ static bool ParseCommandOutput(const char str, uptr addr, char *out_name,
124	if (rest[0] == '\0') {	140	if (rest[0] == '\0') {
125	InternalFree(symbol_name);	141	InternalFree(symbol_name);
126	InternalFree(trim);	142	InternalFree(trim);
127	return false;	143	return NULL;
128	}	144	}
129		145
130	if (internal_strncmp(symbol_name, "0x", 2) != 0)	146	if (internal_strncmp(symbol_name, "0x", 2) != 0)
...	@@ -149,7 +165,7 @@ static bool ParseCommandOutput(const char str, uptr addr, char *out_name,	...	@@ -149,7 +165,7 @@ static bool ParseCommandOutput(const char str, uptr addr, char *out_name,
149	}	165	}
150		166
151	InternalFree(trim);	167	InternalFree(trim);
152	return true;	168	return str;
153	}	169	}
154		170
155	AtosSymbolizer::AtosSymbolizer(const char path, LowLevelAllocator allocator)	171	AtosSymbolizer::AtosSymbolizer(const char path, LowLevelAllocator allocator)
...	@@ -161,31 +177,72 @@ bool AtosSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {	...	@@ -161,31 +177,72 @@ bool AtosSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
161	char command[32];	177	char command[32];
162	internal_snprintf(command, sizeof(command), "0x%zx\n", addr);	178	internal_snprintf(command, sizeof(command), "0x%zx\n", addr);
163	const char *buf = process_->SendCommand(command);	179	const char *buf = process_->SendCommand(command);
164	if (!buf) return false;	180	if (!buf)
165	uptr line;
166	uptr start_address = AddressInfo::kUnknown;
167	if (!ParseCommandOutput(buf, addr, &stack->info.function, &stack->info.module,
168	&stack->info.file, &line, &start_address)) {
169	Report("WARNING: atos failed to symbolize address \"0x%zx\"\n", addr);
170	return false;	181	return false;
171	}
172	stack->info.line = (int)line;
173
174	if (start_address == AddressInfo::kUnknown) {
175	// Fallback to dladdr() to get function start address if atos doesn't report
176	// it.
177	Dl_info info;
178	int result = dladdr((const void *)addr, &info);
179	if (result)
180	start_address = reinterpret_cast<uptr>(info.dli_saddr);
181	}
182		182
183	// Only assign to `function_offset` if we were able to get the function's	183	SymbolizedStack* last = stack;
184	// start address and we got a sensible `start_address` (dladdr doesn't always	184	bool top_frame = true;
185	// ensure that `addr >= sym_addr`).	185
186	if (start_address != AddressInfo::kUnknown && addr >= start_address) {	186	// Parse one line of input (i.e. one frame).
187	stack->info.function_offset = addr - start_address;	187	//
		188	// When symbolize_inline_frames=true, an empty line
		189	// (i.e. \n at the beginning of a line) indicates that the last
		190	// frame has been sent.
		191	//
		192	// When symbolize_inline_frames=false, the symbolizer will send only
		193	// one frame (without a empty line), so loop runs exactly once
		194	// and hits an early `break`.
		195	while (*buf != '\n') {
		196	uptr line;
		197	uptr start_address = AddressInfo::kUnknown;
		198
		199	SymbolizedStack* cur;
		200	if (top_frame) {
		201	cur = stack;
		202	} else {
		203	cur = SymbolizedStack::New(stack->info.address);
		204	cur->info.FillModuleInfo(stack->info.module, stack->info.module_offset,
		205	stack->info.module_arch);
		206	last->next = cur;
		207	last = cur;
		208	}
		209
		210	// Parse one line of input (i.e. one frame)
		211	// If this succeeds, buf will be updated to point to the first character
		212	// after the newline.
		213	buf = ParseCommandOutput(buf, addr, &cur->info.function, &cur->info.module,
		214	&cur->info.file, &line, &start_address);
		215
		216	// Upon failure, ParseCommandOutput returns NULL.
		217	if (!buf) {
		218	Report("WARNING: atos failed to symbolize address \"0x%zx\"\n", addr);
		219	return false;
		220	}
		221	cur->info.line = (int)line;
		222
		223	if (top_frame && start_address == AddressInfo::kUnknown) {
		224	// Fallback to dladdr() to get function start address if atos doesn't
		225	// report it.
		226	Dl_info info;
		227	int result = dladdr((const void*)addr, &info);
		228	if (result)
		229	start_address = reinterpret_cast<uptr>(info.dli_saddr);
		230	}
		231
		232	// Only assign to `function_offset` if we were able to get the function's
		233	// start address and we got a sensible `start_address` (dladdr doesn't
		234	// always ensure that `addr >= sym_addr`).
		235	if (start_address != AddressInfo::kUnknown && addr >= start_address) {
		236	cur->info.function_offset = addr - start_address;
		237	}
		238
		239	// atos only sends one line when inline frames are off
		240	if (!common_flags()->symbolize_inline_frames)
		241	break;
		242
		243	top_frame = false;
188	}	244	}
		245
189	return true;	246	return true;
190	}	247	}
191		248

lib/libtsan/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp+27-16

 @@ -156,30 +156,34 @@ bool SymbolizerProcess::StartSymbolizerSubprocess() {
     Printf("\n");
   }
+  fd_t infd[2] = {}, outfd[2] = {};
+  if (!CreateTwoHighNumberedPipes(infd, outfd)) {
+    Report(
+        "WARNING: Can't create a socket pair to start "
+        "external symbolizer (errno: %d)\n",
+        errno);
+    return false;
+  }
   if (use_posix_spawn_) {
 #  if SANITIZER_APPLE
-    fd_t fd = internal_spawn(argv, const_cast<const char **>(GetEnvP()), &pid);
+    bool success = internal_spawn(argv, const_cast<const char**>(GetEnvP()),
-    if (fd == kInvalidFd) {
+                                  &pid, outfd[0], infd[1]);
+    if (!success) {
       Report("WARNING: failed to spawn external symbolizer (errno: %d)\n",
              errno);
+      internal_close(infd[0]);
+      internal_close(outfd[1]);
       return false;
     }
-    input_fd_ = fd;
+    // We intentionally hold on to the read-end so that we don't get a SIGPIPE
-    output_fd_ = fd;
+    child_stdin_fd_ = outfd[0];
 #  else   // SANITIZER_APPLE
     UNIMPLEMENTED();
 #  endif  // SANITIZER_APPLE
   } else {
-    fd_t infd[2] = {}, outfd[2] = {};
-    if (!CreateTwoHighNumberedPipes(infd, outfd)) {
-      Report(
-          "WARNING: Can't create a socket pair to start "
-          "external symbolizer (errno: %d)\n",
-          errno);
-      return false;
-    }
     pid = StartSubprocess(path_, argv, GetEnvP(), /* stdin */ outfd[0],
                           /* stdout */ infd[1]);
     if (pid < 0) {
 @@ -187,11 +191,11 @@ bool SymbolizerProcess::StartSymbolizerSubprocess() {
       internal_close(outfd[1]);
       return false;
     }
-    input_fd_ = infd[0];
-    output_fd_ = outfd[1];
   }
+  input_fd_ = infd[0];
+  output_fd_ = outfd[1];
   CHECK_GT(pid, 0);
   // Check that symbolizer subprocess started successfully.
 @@ -505,6 +509,13 @@ static void ChooseSymbolizerTools(IntrusiveList<SymbolizerTool> *list,
   }
 #  if SANITIZER_APPLE
+  if (list->empty()) {
+    Report(
+        "WARN: No external symbolizers found. Symbols may be missing or "
+        "unreliable.\n");
+    Report(
+        "HINT: Is PATH set? Does sandbox allow file-read of /usr/bin/atos?\n");
+  }
   VReport(2, "Using dladdr symbolizer.\n");
   list->push_back(new (*allocator) DlAddrSymbolizer());
 #  endif  // SANITIZER_APPLE

lib/libtsan/sanitizer_common/sanitizer_thread_registry.cpp+5-4

...	@@ -80,7 +80,7 @@ void ThreadContextBase::SetFinished() {	...	@@ -80,7 +80,7 @@ void ThreadContextBase::SetFinished() {
80	OnFinished();	80	OnFinished();
81	}	81	}
82		82
83	void ThreadContextBase::SetStarted(tid_t _os_id, ThreadType _thread_type,	83	void ThreadContextBase::SetStarted(ThreadID _os_id, ThreadType _thread_type,
84	void *arg) {	84	void *arg) {
85	status = ThreadStatusRunning;	85	status = ThreadStatusRunning;
86	os_id = _os_id;	86	os_id = _os_id;
...	@@ -228,7 +228,8 @@ static bool FindThreadContextByOsIdCallback(ThreadContextBase *tctx,	...	@@ -228,7 +228,8 @@ static bool FindThreadContextByOsIdCallback(ThreadContextBase *tctx,
228	tctx->status != ThreadStatusDead);	228	tctx->status != ThreadStatusDead);
229	}	229	}
230		230
231	ThreadContextBase *ThreadRegistry::FindThreadContextByOsIDLocked(tid_t os_id) {	231	ThreadContextBase *ThreadRegistry::FindThreadContextByOsIDLocked(
		232	ThreadID os_id) {
232	return FindThreadContextLocked(FindThreadContextByOsIdCallback,	233	return FindThreadContextLocked(FindThreadContextByOsIdCallback,
233	(void *)os_id);	234	(void *)os_id);
234	}	235	}
...	@@ -322,8 +323,8 @@ ThreadStatus ThreadRegistry::FinishThread(u32 tid) {	...	@@ -322,8 +323,8 @@ ThreadStatus ThreadRegistry::FinishThread(u32 tid) {
322	return prev_status;	323	return prev_status;
323	}	324	}
324		325
325	void ThreadRegistry::StartThread(u32 tid, tid_t os_id, ThreadType thread_type,	326	void ThreadRegistry::StartThread(u32 tid, ThreadID os_id,
326	void *arg) {	327	ThreadType thread_type, void *arg) {
327	ThreadRegistryLock l(this);	328	ThreadRegistryLock l(this);
328	running_threads_++;	329	running_threads_++;
329	ThreadContextBase *tctx = threads_[tid];	330	ThreadContextBase *tctx = threads_[tid];

lib/libtsan/sanitizer_common/sanitizer_thread_registry.h+4-4

lib/libtsan/sanitizer_common/sanitizer_win.cpp+1-3

 @@ -108,9 +108,7 @@ int internal_dlinfo(void *handle, int request, void *p) {
 // In contrast to POSIX, on Windows GetCurrentThreadId()
 // returns a system-unique identifier.
-tid_t GetTid() {
+ThreadID GetTid() { return GetCurrentThreadId(); }
-  return GetCurrentThreadId();
-}
 uptr GetThreadSelf() {
   return GetTid();

lib/libtsan/tsan_debugging.cpp+2-2

...	@@ -165,7 +165,7 @@ int __tsan_get_report_mutex(void report, uptr idx, uptr mutex_id, void **addr,	...	@@ -165,7 +165,7 @@ int __tsan_get_report_mutex(void report, uptr idx, uptr mutex_id, void **addr,
165	}	165	}
166		166
167	SANITIZER_INTERFACE_ATTRIBUTE	167	SANITIZER_INTERFACE_ATTRIBUTE
168	int __tsan_get_report_thread(void report, uptr idx, int tid, tid_t *os_id,	168	int __tsan_get_report_thread(void report, uptr idx, int tid, ThreadID *os_id,
169	int running, const char name, int parent_tid,	169	int running, const char name, int parent_tid,
170	void **trace, uptr trace_size) {	170	void **trace, uptr trace_size) {
171	const ReportDesc rep = (ReportDesc )report;	171	const ReportDesc rep = (ReportDesc )report;
...	@@ -242,7 +242,7 @@ const char __tsan_locate_address(uptr addr, char name, uptr name_size,	...	@@ -242,7 +242,7 @@ const char __tsan_locate_address(uptr addr, char name, uptr name_size,
242		242
243	SANITIZER_INTERFACE_ATTRIBUTE	243	SANITIZER_INTERFACE_ATTRIBUTE
244	int __tsan_get_alloc_stack(uptr addr, uptr trace, uptr size, int thread_id,	244	int __tsan_get_alloc_stack(uptr addr, uptr trace, uptr size, int thread_id,
245	tid_t *os_id) {	245	ThreadID *os_id) {
246	MBlock *b = 0;	246	MBlock *b = 0;
247	Allocator *a = allocator();	247	Allocator *a = allocator();
248	if (a->PointerIsMine((void *)addr)) {	248	if (a->PointerIsMine((void *)addr)) {

lib/libtsan/tsan_flags.cpp+37

...	@@ -20,6 +20,43 @@	...	@@ -20,6 +20,43 @@
20	#include "tsan_rtl.h"	20	#include "tsan_rtl.h"
21	#include "ubsan/ubsan_flags.h"	21	#include "ubsan/ubsan_flags.h"
22		22
		23	#if SANITIZER_APPLE && !SANITIZER_GO
		24	namespace __sanitizer {
		25
		26	template <>
		27	inline bool FlagHandler<LockDuringWriteSetting>::Parse(const char *value) {
		28	if (internal_strcmp(value, "on") == 0) {
		29	*t_ = kLockDuringAllWrites;
		30	return true;
		31	}
		32	if (internal_strcmp(value, "disable_for_current_process") == 0) {
		33	*t_ = kNoLockDuringWritesCurrentProcess;
		34	return true;
		35	}
		36	if (internal_strcmp(value, "disable_for_all_processes") == 0) {
		37	*t_ = kNoLockDuringWritesAllProcesses;
		38	return true;
		39	}
		40	Printf("ERROR: Invalid value for signal handler option: '%s'\n", value);
		41	return false;
		42	}
		43
		44	template <>
		45	inline bool FlagHandler<LockDuringWriteSetting>::Format(char *buffer,
		46	uptr size) {
		47	switch (*t_) {
		48	case kLockDuringAllWrites:
		49	return FormatString(buffer, size, "on");
		50	case kNoLockDuringWritesCurrentProcess:
		51	return FormatString(buffer, size, "disable_for_current_process");
		52	case kNoLockDuringWritesAllProcesses:
		53	return FormatString(buffer, size, "disable_for_all_processes");
		54	}
		55	}
		56
		57	} // namespace __sanitizer
		58	#endif // SANITIZER_APPLE && !SANITIZER_GO
		59
23	namespace __tsan {	60	namespace __tsan {
24		61
25	// Can be overriden in frontend.	62	// Can be overriden in frontend.

lib/libtsan/tsan_flags.h+8

...	@@ -16,6 +16,14 @@	...	@@ -16,6 +16,14 @@
16	#include "sanitizer_common/sanitizer_flags.h"	16	#include "sanitizer_common/sanitizer_flags.h"
17	#include "sanitizer_common/sanitizer_deadlock_detector_interface.h"	17	#include "sanitizer_common/sanitizer_deadlock_detector_interface.h"
18		18
		19	#if SANITIZER_APPLE && !SANITIZER_GO
		20	enum LockDuringWriteSetting {
		21	kLockDuringAllWrites,
		22	kNoLockDuringWritesCurrentProcess,
		23	kNoLockDuringWritesAllProcesses,
		24	};
		25	#endif
		26
19	namespace __tsan {	27	namespace __tsan {
20		28
21	struct Flags : DDFlags {	29	struct Flags : DDFlags {

lib/libtsan/tsan_flags.inc+12

...	@@ -80,3 +80,15 @@ TSAN_FLAG(bool, shared_ptr_interceptor, true,	...	@@ -80,3 +80,15 @@ TSAN_FLAG(bool, shared_ptr_interceptor, true,
80	TSAN_FLAG(bool, print_full_thread_history, false,	80	TSAN_FLAG(bool, print_full_thread_history, false,
81	"If set, prints thread creation stacks for the threads involved in "	81	"If set, prints thread creation stacks for the threads involved in "
82	"the report and their ancestors up to the main thread.")	82	"the report and their ancestors up to the main thread.")
		83
		84	#if SANITIZER_APPLE && !SANITIZER_GO
		85	TSAN_FLAG(LockDuringWriteSetting, lock_during_write, kLockDuringAllWrites,
		86	"Determines whether to obtain a lock while writing logs or error "
		87	"reports. "
		88	"\"on\" - [default] lock during all writes. "
		89	"\"disable_for_current_process\" - don't lock during all writes in "
		90	"the current process, but do lock for all writes in child "
		91	"processes."
		92	"\"disable_for_all_processes\" - don't lock during all writes in "
		93	"the current process and it's children processes.")
		94	#endif

lib/libtsan/tsan_interceptors.h+9-1

 @@ -1,6 +1,9 @@
 #ifndef TSAN_INTERCEPTORS_H
 #define TSAN_INTERCEPTORS_H
+#if SANITIZER_APPLE && !SANITIZER_GO
+#  include "sanitizer_common/sanitizer_mac.h"
+#endif
 #include "sanitizer_common/sanitizer_stacktrace.h"
 #include "tsan_rtl.h"
 @@ -43,7 +46,12 @@ inline bool in_symbolizer() {
 #endif
 inline bool MustIgnoreInterceptor(ThreadState *thr) {
-  return !thr->is_inited || thr->ignore_interceptors || thr->in_ignored_lib;
+  return !thr->is_inited || thr->ignore_interceptors || thr->in_ignored_lib
+#if SANITIZER_APPLE && !SANITIZER_GO
+         || (flags()->lock_during_write != kLockDuringAllWrites &&
+             thr->in_internal_write_call)
+#endif
+      ;
 }
 }  // namespace __tsan

lib/libtsan/tsan_interceptors_mac.cpp+19

...	@@ -281,6 +281,25 @@ TSAN_INTERCEPTOR(void, os_unfair_lock_lock, os_unfair_lock_t lock) {	...	@@ -281,6 +281,25 @@ TSAN_INTERCEPTOR(void, os_unfair_lock_lock, os_unfair_lock_t lock) {
281	Acquire(thr, pc, (uptr)lock);	281	Acquire(thr, pc, (uptr)lock);
282	}	282	}
283		283
		284	// os_unfair_lock_lock_with_flags was introduced in macOS 15
		285	# if defined(__MAC_15_0) \|\| defined(__IPHONE_18_0) \|\| defined(__TVOS_18_0) \|\| \
		286	defined(__VISIONOS_2_0) \|\| defined(__WATCHOS_11_0)
		287	# pragma clang diagnostic push
		288	# pragma clang diagnostic ignored "-Wunguarded-availability-new"
		289	// We're just intercepting this - if it doesn't exist on the platform, then the
		290	// process shouldn't have called it in the first place.
		291	TSAN_INTERCEPTOR(void, os_unfair_lock_lock_with_flags, os_unfair_lock_t lock,
		292	os_unfair_lock_flags_t flags) {
		293	if (!cur_thread()->is_inited \|\| cur_thread()->is_dead) {
		294	return REAL(os_unfair_lock_lock_with_flags)(lock, flags);
		295	}
		296	SCOPED_TSAN_INTERCEPTOR(os_unfair_lock_lock_with_flags, lock, flags);
		297	REAL(os_unfair_lock_lock_with_flags)(lock, flags);
		298	Acquire(thr, pc, (uptr)lock);
		299	}
		300	# pragma clang diagnostic pop
		301	# endif
		302
284	TSAN_INTERCEPTOR(void, os_unfair_lock_lock_with_options, os_unfair_lock_t lock,	303	TSAN_INTERCEPTOR(void, os_unfair_lock_lock_with_options, os_unfair_lock_t lock,
285	u32 options) {	304	u32 options) {
286	if (!cur_thread()->is_inited \|\| cur_thread()->is_dead) {	305	if (!cur_thread()->is_inited \|\| cur_thread()->is_dead) {

lib/libtsan/tsan_interceptors_posix.cpp+78-32

 @@ -22,6 +22,7 @@
 #include "sanitizer_common/sanitizer_internal_defs.h"
 #include "sanitizer_common/sanitizer_libc.h"
 #include "sanitizer_common/sanitizer_linux.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
 #include "sanitizer_common/sanitizer_platform_interceptors.h"
 #include "sanitizer_common/sanitizer_platform_limits_netbsd.h"
 #include "sanitizer_common/sanitizer_platform_limits_posix.h"
 @@ -30,6 +31,9 @@
 #include "sanitizer_common/sanitizer_tls_get_addr.h"
 #include "sanitizer_common/sanitizer_vector.h"
 #include "tsan_fd.h"
+#if SANITIZER_APPLE && !SANITIZER_GO
+#  include "tsan_flags.h"
+#endif
 #include "tsan_interceptors.h"
 #include "tsan_interface.h"
 #include "tsan_mman.h"
 @@ -78,17 +82,6 @@ struct ucontext_t {
 };
 #endif
-#if defined(__x86_64__) || defined(__mips__) || SANITIZER_PPC64V1 || \
-    defined(__s390x__)
-#define PTHREAD_ABI_BASE  "GLIBC_2.3.2"
-#elif defined(__aarch64__) || SANITIZER_PPC64V2
-#define PTHREAD_ABI_BASE  "GLIBC_2.17"
-#elif SANITIZER_LOONGARCH64
-#define PTHREAD_ABI_BASE  "GLIBC_2.36"
-#elif SANITIZER_RISCV64
-#  define PTHREAD_ABI_BASE "GLIBC_2.27"
-#endif
 extern "C" int pthread_attr_init(void *attr);
 extern "C" int pthread_attr_destroy(void *attr);
 DECLARE_REAL(int, pthread_attr_getdetachstate, void *, void *)
 @@ -340,11 +333,6 @@ void ScopedInterceptor::DisableIgnoresImpl() {
 }
 #define TSAN_INTERCEPT(func) INTERCEPT_FUNCTION(func)
-#if SANITIZER_FREEBSD || SANITIZER_NETBSD
-#  define TSAN_INTERCEPT_VER(func, ver) INTERCEPT_FUNCTION(func)
-#else
-#  define TSAN_INTERCEPT_VER(func, ver) INTERCEPT_FUNCTION_VER(func, ver)
-#endif
 #if SANITIZER_FREEBSD
 #  define TSAN_MAYBE_INTERCEPT_FREEBSD_ALIAS(func) \
     INTERCEPT_FUNCTION(_pthread_##func)
 @@ -1145,6 +1133,22 @@ TSAN_INTERCEPTOR(int, pthread_create,
 TSAN_INTERCEPTOR(int, pthread_join, void *th, void **ret) {
   SCOPED_INTERCEPTOR_RAW(pthread_join, th, ret);
+#if SANITIZER_ANDROID
+  {
+    // In Bionic, if the target thread has already exited when pthread_detach is
+    // called, pthread_detach will call pthread_join internally to clean it up.
+    // In that case, the thread has already been consumed by the pthread_detach
+    // interceptor.
+    Tid tid = ctx->thread_registry.FindThread(
+        [](ThreadContextBase* tctx, void* arg) {
+          return tctx->user_id == (uptr)arg;
+        },
+        th);
+    if (tid == kInvalidTid) {
+      return REAL(pthread_join)(th, ret);
+    }
+  }
+#endif
   Tid tid = ThreadConsumeTid(thr, pc, (uptr)th);
   ThreadIgnoreBegin(thr, pc);
   int res = BLOCK_REAL(pthread_join)(th, ret);
 @@ -1664,6 +1668,14 @@ TSAN_INTERCEPTOR(int, pthread_barrier_wait, void *b) {
 TSAN_INTERCEPTOR(int, pthread_once, void *o, void (*f)()) {
   SCOPED_INTERCEPTOR_RAW(pthread_once, o, f);
+#if SANITIZER_APPLE && !SANITIZER_GO
+  if (flags()->lock_during_write != kLockDuringAllWrites &&
+      cur_thread_init()->in_internal_write_call) {
+    // This is needed to make it through process launch without hanging
+    f();
+    return 0;
+  }
+#endif
   if (o == 0 || f == 0)
     return errno_EINVAL;
   atomic_uint32_t *a;
 @@ -2141,13 +2153,29 @@ static void ReportErrnoSpoiling(ThreadState *thr, uptr pc, int sig) {
   // StackTrace::GetNestInstructionPc(pc) is used because return address is
   // expected, OutputReport() will undo this.
   ObtainCurrentStack(thr, StackTrace::GetNextInstructionPc(pc), &stack);
-  ThreadRegistryLock l(&ctx->thread_registry);
+  // Use alloca, because malloc during signal handling deadlocks
-  ScopedReport rep(ReportTypeErrnoInSignal);
+  ScopedReport *rep = (ScopedReport *)__builtin_alloca(sizeof(ScopedReport));
-  rep.SetSigNum(sig);
+  bool suppressed;
-  if (!IsFiredSuppression(ctx, ReportTypeErrnoInSignal, stack)) {
+  // Take a new scope as Apple platforms require the below locks released
-    rep.AddStack(stack, true);
+  // before symbolizing in order to avoid a deadlock
-    OutputReport(thr, rep);
+  {
+    ThreadRegistryLock l(&ctx->thread_registry);
+    new (rep) ScopedReport(ReportTypeErrnoInSignal);
+    rep->SetSigNum(sig);
+    suppressed = IsFiredSuppression(ctx, ReportTypeErrnoInSignal, stack);
+    if (!suppressed)
+      rep->AddStack(stack, true);
+#if SANITIZER_APPLE
+  }  // Close this scope to release the locks before writing report
+#endif
+    if (!suppressed)
+      OutputReport(thr, *rep);
+    // Need to manually destroy this because we used placement new to allocate
+    rep->~ScopedReport();
+#if !SANITIZER_APPLE
   }
+#endif
 }
 static void CallUserSignalHandler(ThreadState *thr, bool sync, bool acquire,
 @@ -2411,7 +2439,11 @@ TSAN_INTERCEPTOR(int, vfork, int fake) {
 }
 #endif
-#if SANITIZER_LINUX
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
+// Bionic's pthread_create internally calls clone. When the CLONE_THREAD flag is
+// set, clone does not create a new process but a new thread. This is a
+// workaround for Android. Disabling the interception of clone solves the
+// problem in most scenarios.
 TSAN_INTERCEPTOR(int, clone, int (*fn)(void *), void *stack, int flags,
                  void *arg, int *parent_tid, void *tls, pid_t *child_tid) {
   SCOPED_INTERCEPTOR_RAW(clone, fn, stack, flags, arg, parent_tid, tls,
 @@ -2888,12 +2920,12 @@ TSAN_INTERCEPTOR(void, _lwp_exit) {
 #endif
 #if SANITIZER_FREEBSD
-TSAN_INTERCEPTOR(void, thr_exit, tid_t *state) {
+TSAN_INTERCEPTOR(void, thr_exit, ThreadID *state) {
   SCOPED_TSAN_INTERCEPTOR(thr_exit, state);
   DestroyThreadState();
   REAL(thr_exit(state));
 }
-#define TSAN_MAYBE_INTERCEPT_THR_EXIT TSAN_INTERCEPT(thr_exit)
+#  define TSAN_MAYBE_INTERCEPT_THR_EXIT TSAN_INTERCEPT(thr_exit)
 #else
 #define TSAN_MAYBE_INTERCEPT_THR_EXIT
 #endif
 @@ -3024,12 +3056,26 @@ void InitializeInterceptors() {
   TSAN_INTERCEPT(pthread_timedjoin_np);
   #endif
-  TSAN_INTERCEPT_VER(pthread_cond_init, PTHREAD_ABI_BASE);
+  // In glibc versions older than 2.36, dlsym(RTLD_NEXT, "pthread_cond_init")
-  TSAN_INTERCEPT_VER(pthread_cond_signal, PTHREAD_ABI_BASE);
+  // may return an outdated symbol (max(2.2,base_version)) if the port was
-  TSAN_INTERCEPT_VER(pthread_cond_broadcast, PTHREAD_ABI_BASE);
+  // introduced before 2.3.2 (when the new pthread_cond_t was introduced).
-  TSAN_INTERCEPT_VER(pthread_cond_wait, PTHREAD_ABI_BASE);
+#if SANITIZER_GLIBC && !__GLIBC_PREREQ(2, 36) &&                      \
-  TSAN_INTERCEPT_VER(pthread_cond_timedwait, PTHREAD_ABI_BASE);
+    (defined(__x86_64__) || defined(__mips__) || SANITIZER_PPC64V1 || \
-  TSAN_INTERCEPT_VER(pthread_cond_destroy, PTHREAD_ABI_BASE);
+     defined(__s390x__))
+  INTERCEPT_FUNCTION_VER(pthread_cond_init, "GLIBC_2.3.2");
+  INTERCEPT_FUNCTION_VER(pthread_cond_signal, "GLIBC_2.3.2");
+  INTERCEPT_FUNCTION_VER(pthread_cond_broadcast, "GLIBC_2.3.2");
+  INTERCEPT_FUNCTION_VER(pthread_cond_wait, "GLIBC_2.3.2");
+  INTERCEPT_FUNCTION_VER(pthread_cond_timedwait, "GLIBC_2.3.2");
+  INTERCEPT_FUNCTION_VER(pthread_cond_destroy, "GLIBC_2.3.2");
+#else
+  INTERCEPT_FUNCTION(pthread_cond_init);
+  INTERCEPT_FUNCTION(pthread_cond_signal);
+  INTERCEPT_FUNCTION(pthread_cond_broadcast);
+  INTERCEPT_FUNCTION(pthread_cond_wait);
+  INTERCEPT_FUNCTION(pthread_cond_timedwait);
+  INTERCEPT_FUNCTION(pthread_cond_destroy);
+#endif
   TSAN_MAYBE_PTHREAD_COND_CLOCKWAIT;
 @@ -3120,7 +3166,7 @@ void InitializeInterceptors() {
   TSAN_INTERCEPT(fork);
   TSAN_INTERCEPT(vfork);
-#if SANITIZER_LINUX
+#if SANITIZER_LINUX && !SANITIZER_ANDROID
   TSAN_INTERCEPT(clone);
 #endif
 #if !SANITIZER_ANDROID

lib/libtsan/tsan_interface.h+3-3

...	@@ -16,7 +16,7 @@	...	@@ -16,7 +16,7 @@
16	#define TSAN_INTERFACE_H	16	#define TSAN_INTERFACE_H
17		17
18	#include <sanitizer_common/sanitizer_internal_defs.h>	18	#include <sanitizer_common/sanitizer_internal_defs.h>
19	using __sanitizer::tid_t;	19	using __sanitizer::ThreadID;
20	using __sanitizer::uptr;	20	using __sanitizer::uptr;
21		21
22	// This header should NOT include any other headers.	22	// This header should NOT include any other headers.
...	@@ -175,7 +175,7 @@ int __tsan_get_report_mutex(void report, uptr idx, uptr mutex_id, void **addr,	...	@@ -175,7 +175,7 @@ int __tsan_get_report_mutex(void report, uptr idx, uptr mutex_id, void **addr,
175		175
176	// Returns information about threads included in the report.	176	// Returns information about threads included in the report.
177	SANITIZER_INTERFACE_ATTRIBUTE	177	SANITIZER_INTERFACE_ATTRIBUTE
178	int __tsan_get_report_thread(void report, uptr idx, int tid, tid_t *os_id,	178	int __tsan_get_report_thread(void report, uptr idx, int tid, ThreadID *os_id,
179	int running, const char name, int parent_tid,	179	int running, const char name, int parent_tid,
180	void **trace, uptr trace_size);	180	void **trace, uptr trace_size);
181		181
...	@@ -192,7 +192,7 @@ const char __tsan_locate_address(uptr addr, char name, uptr name_size,	...	@@ -192,7 +192,7 @@ const char __tsan_locate_address(uptr addr, char name, uptr name_size,
192	// Returns the allocation stack for a heap pointer.	192	// Returns the allocation stack for a heap pointer.
193	SANITIZER_INTERFACE_ATTRIBUTE	193	SANITIZER_INTERFACE_ATTRIBUTE
194	int __tsan_get_alloc_stack(uptr addr, uptr trace, uptr size, int thread_id,	194	int __tsan_get_alloc_stack(uptr addr, uptr trace, uptr size, int thread_id,
195	tid_t *os_id);	195	ThreadID *os_id);
196		196
197	#endif // SANITIZER_GO	197	#endif // SANITIZER_GO
198		198

lib/libtsan/tsan_interface_ann.cpp+23-9

...	@@ -437,16 +437,30 @@ void __tsan_mutex_post_divert(void *addr, unsigned flagz) {	...	@@ -437,16 +437,30 @@ void __tsan_mutex_post_divert(void *addr, unsigned flagz) {
437	}	437	}
438		438
439	static void ReportMutexHeldWrongContext(ThreadState *thr, uptr pc) {	439	static void ReportMutexHeldWrongContext(ThreadState *thr, uptr pc) {
440	ThreadRegistryLock l(&ctx->thread_registry);	440	// Use alloca, because malloc during signal handling deadlocks
441	ScopedReport rep(ReportTypeMutexHeldWrongContext);	441	ScopedReport rep = (ScopedReport )__builtin_alloca(sizeof(ScopedReport));
442	for (uptr i = 0; i < thr->mset.Size(); ++i) {	442	// Take a new scope as Apple platforms require the below locks released
443	MutexSet::Desc desc = thr->mset.Get(i);	443	// before symbolizing in order to avoid a deadlock
444	rep.AddMutex(desc.addr, desc.stack_id);	444	{
		445	ThreadRegistryLock l(&ctx->thread_registry);
		446	new (rep) ScopedReport(ReportTypeMutexHeldWrongContext);
		447	for (uptr i = 0; i < thr->mset.Size(); ++i) {
		448	MutexSet::Desc desc = thr->mset.Get(i);
		449	rep->AddMutex(desc.addr, desc.stack_id);
		450	}
		451	VarSizeStackTrace trace;
		452	ObtainCurrentStack(thr, pc, &trace);
		453	rep->AddStack(trace, true);
		454	#if SANITIZER_APPLE
		455	} // Close this scope to release the locks
		456	#endif
		457	OutputReport(thr, *rep);
		458
		459	// Need to manually destroy this because we used placement new to allocate
		460	rep->~ScopedReport();
		461	#if !SANITIZER_APPLE
445	}	462	}
446	VarSizeStackTrace trace;	463	#endif
447	ObtainCurrentStack(thr, pc, &trace);
448	rep.AddStack(trace, true);
449	OutputReport(thr, rep);
450	}	464	}
451		465
452	INTERFACE_ATTRIBUTE	466	INTERFACE_ATTRIBUTE

lib/libtsan/tsan_mman.cpp+18-4

...	@@ -182,10 +182,24 @@ static void SignalUnsafeCall(ThreadState *thr, uptr pc) {	...	@@ -182,10 +182,24 @@ static void SignalUnsafeCall(ThreadState *thr, uptr pc) {
182	ObtainCurrentStack(thr, pc, &stack);	182	ObtainCurrentStack(thr, pc, &stack);
183	if (IsFiredSuppression(ctx, ReportTypeSignalUnsafe, stack))	183	if (IsFiredSuppression(ctx, ReportTypeSignalUnsafe, stack))
184	return;	184	return;
185	ThreadRegistryLock l(&ctx->thread_registry);	185	// Use alloca, because malloc during signal handling deadlocks
186	ScopedReport rep(ReportTypeSignalUnsafe);	186	ScopedReport rep = (ScopedReport )__builtin_alloca(sizeof(ScopedReport));
187	rep.AddStack(stack, true);	187	// Take a new scope as Apple platforms require the below locks released
188	OutputReport(thr, rep);	188	// before symbolizing in order to avoid a deadlock
		189	{
		190	ThreadRegistryLock l(&ctx->thread_registry);
		191	new (rep) ScopedReport(ReportTypeSignalUnsafe);
		192	rep->AddStack(stack, true);
		193	#if SANITIZER_APPLE
		194	} // Close this scope to release the locks
		195	#endif
		196	OutputReport(thr, *rep);
		197
		198	// Need to manually destroy this because we used placement new to allocate
		199	rep->~ScopedReport();
		200	#if !SANITIZER_APPLE
		201	}
		202	#endif
189	}	203	}
190		204
191		205

lib/libtsan/tsan_platform.h+44-7

 @@ -681,6 +681,32 @@ struct MappingGoMips64_47 {
   static const uptr kShadowAdd = 0x200000000000ull;
 };
+/* Go on linux/riscv64 (39-bit VMA)
+0000 0001 0000 - 000f 0000 0000: executable and heap (60 GiB)
+000f 0000 0000 - 0010 0000 0000: -
+0010 0000 0000 - 0030 0000 0000: shadow - 128 GiB ( ~ 2 * app)
+0030 0000 0000 - 0038 0000 0000: metainfo - 32 GiB ( ~ 0.5 * app)
+0038 0000 0000 - 0040 0000 0000: -
+*/
+struct MappingGoRiscv64_39 {
+  static const uptr kMetaShadowBeg = 0x003000000000ull;
+  static const uptr kMetaShadowEnd = 0x003800000000ull;
+  static const uptr kShadowBeg = 0x001000000000ull;
+  static const uptr kShadowEnd = 0x003000000000ull;
+  static const uptr kLoAppMemBeg = 0x000000010000ull;
+  static const uptr kLoAppMemEnd = 0x000f00000000ull;
+  static const uptr kMidAppMemBeg = 0;
+  static const uptr kMidAppMemEnd = 0;
+  static const uptr kHiAppMemBeg = 0;
+  static const uptr kHiAppMemEnd = 0;
+  static const uptr kHeapMemBeg = 0;
+  static const uptr kHeapMemEnd = 0;
+  static const uptr kVdsoBeg = 0;
+  static const uptr kShadowMsk = 0;
+  static const uptr kShadowXor = 0;
+  static const uptr kShadowAdd = 0x001000000000ull;
+};
 /* Go on linux/riscv64 (48-bit VMA)
 0000 0001 0000 - 00e0 0000 0000: executable and heap (896 GiB)
 00e0 0000 0000 - 2000 0000 0000: -
 @@ -689,13 +715,13 @@ struct MappingGoMips64_47 {
 3000 0000 0000 - 3100 0000 0000: metainfo - 1 TiB ( ~ 1 * app)
 3100 0000 0000 - 8000 0000 0000: -
 */
-struct MappingGoRiscv64 {
+struct MappingGoRiscv64_48 {
   static const uptr kMetaShadowBeg = 0x300000000000ull;
   static const uptr kMetaShadowEnd = 0x310000000000ull;
   static const uptr kShadowBeg = 0x200000000000ull;
   static const uptr kShadowEnd = 0x240000000000ull;
   static const uptr kLoAppMemBeg = 0x000000010000ull;
-  static const uptr kLoAppMemEnd = 0x000e00000000ull;
+  static const uptr kLoAppMemEnd = 0x00e000000000ull;
   static const uptr kMidAppMemBeg = 0;
   static const uptr kMidAppMemEnd = 0;
   static const uptr kHiAppMemBeg = 0;
 @@ -756,7 +782,12 @@ ALWAYS_INLINE auto SelectMapping(Arg arg) {
 #  elif defined(__loongarch_lp64)
   return Func::template Apply<MappingGoLoongArch64_47>(arg);
 #  elif SANITIZER_RISCV64
-  return Func::template Apply<MappingGoRiscv64>(arg);
+  switch (vmaSize) {
+    case 39:
+      return Func::template Apply<MappingGoRiscv64_39>(arg);
+    case 48:
+      return Func::template Apply<MappingGoRiscv64_48>(arg);
+  }
 #  elif SANITIZER_WINDOWS
   return Func::template Apply<MappingGoWindows>(arg);
 #  else
 @@ -827,7 +858,8 @@ void ForEachMapping() {
   Func::template Apply<MappingGoAarch64>();
   Func::template Apply<MappingGoLoongArch64_47>();
   Func::template Apply<MappingGoMips64_47>();
-  Func::template Apply<MappingGoRiscv64>();
+  Func::template Apply<MappingGoRiscv64_39>();
+  Func::template Apply<MappingGoRiscv64_48>();
   Func::template Apply<MappingGoS390x>();
 }
 @@ -926,7 +958,9 @@ struct IsAppMemImpl {
 };
 ALWAYS_INLINE
-bool IsAppMem(uptr mem) { return SelectMapping<IsAppMemImpl>(mem); }
+bool IsAppMem(uptr mem) {
+  return SelectMapping<IsAppMemImpl>(STRIP_MTE_TAG(mem));
+}
 struct IsShadowMemImpl {
   template <typename Mapping>
 @@ -965,7 +999,8 @@ struct MemToShadowImpl {
 ALWAYS_INLINE
 RawShadow *MemToShadow(uptr x) {
-  return reinterpret_cast<RawShadow *>(SelectMapping<MemToShadowImpl>(x));
+  return reinterpret_cast<RawShadow*>(
+      SelectMapping<MemToShadowImpl>(STRIP_MTE_TAG(x)));
 }
 struct MemToMetaImpl {
 @@ -979,7 +1014,9 @@ struct MemToMetaImpl {
 };
 ALWAYS_INLINE
-u32 *MemToMeta(uptr x) { return SelectMapping<MemToMetaImpl>(x); }
+u32* MemToMeta(uptr x) {
+  return SelectMapping<MemToMetaImpl>(STRIP_MTE_TAG(x));
+}
 struct ShadowToMemImpl {
   template <typename Mapping>

lib/libtsan/tsan_platform_linux.cpp+42-14

...	@@ -393,9 +393,9 @@ void InitializePlatformEarly() {	...	@@ -393,9 +393,9 @@ void InitializePlatformEarly() {
393	Die();	393	Die();
394	}	394	}
395	# else	395	# else
396	if (vmaSize != 48) {	396	if (vmaSize != 39 && vmaSize != 48) {
397	Printf("FATAL: ThreadSanitizer: unsupported VMA range\n");	397	Printf("FATAL: ThreadSanitizer: unsupported VMA range\n");
398	Printf("FATAL: Found %zd - Supported 48\n", vmaSize);	398	Printf("FATAL: Found %zd - Supported 39 and 48\n", vmaSize);
399	Die();	399	Die();
400	}	400	}
401	# endif	401	# endif
...	@@ -415,7 +415,7 @@ void InitializePlatform() {	...	@@ -415,7 +415,7 @@ void InitializePlatform() {
415	// is not compiled with -pie.	415	// is not compiled with -pie.
416	#if !SANITIZER_GO	416	#if !SANITIZER_GO
417	{	417	{
418	# if SANITIZER_LINUX && (defined(__aarch64__) \|\| defined(__loongarch_lp64))	418	# if INIT_LONGJMP_XOR_KEY
419	// Initialize the xor key used in {sig}{set,long}jump.	419	// Initialize the xor key used in {sig}{set,long}jump.
420	InitializeLongjmpXorKey();	420	InitializeLongjmpXorKey();
421	# endif	421	# endif
...	@@ -486,8 +486,20 @@ int ExtractRecvmsgFDs(void msgp, int fds, int nfd) {	...	@@ -486,8 +486,20 @@ int ExtractRecvmsgFDs(void msgp, int fds, int nfd) {
486		486
487	// Reverse operation of libc stack pointer mangling	487	// Reverse operation of libc stack pointer mangling
488	static uptr UnmangleLongJmpSp(uptr mangled_sp) {	488	static uptr UnmangleLongJmpSp(uptr mangled_sp) {
489	#if defined(__x86_64__)	489	# if SANITIZER_ANDROID && INIT_LONGJMP_XOR_KEY
490	# if SANITIZER_LINUX	490	if (longjmp_xor_key == 0) {
		491	// bionic libc initialization process: __libc_init_globals ->
		492	// __libc_init_vdso (calls strcmp) -> __libc_init_setjmp_cookie. strcmp is
		493	// intercepted by TSan, so during TSan initialization the setjmp_cookie
		494	// remains uninitialized. On Android, longjmp_xor_key must be set on first
		495	// use.
		496	InitializeLongjmpXorKey();
		497	CHECK_NE(longjmp_xor_key, 0);
		498	}
		499	# endif
		500
		501	# if defined(__x86_64__)
		502	# if SANITIZER_LINUX
491	// Reverse of:	503	// Reverse of:
492	// xor %fs:0x30, %rsi	504	// xor %fs:0x30, %rsi
493	// rol $0x11, %rsi	505	// rol $0x11, %rsi
...	@@ -542,13 +554,23 @@ static uptr UnmangleLongJmpSp(uptr mangled_sp) {	...	@@ -542,13 +554,23 @@ static uptr UnmangleLongJmpSp(uptr mangled_sp) {
542	# else	554	# else
543	# define LONG_JMP_SP_ENV_SLOT 2	555	# define LONG_JMP_SP_ENV_SLOT 2
544	# endif	556	# endif
545	#elif SANITIZER_LINUX	557	# elif SANITIZER_ANDROID
546	# ifdef __aarch64__	558	# ifdef __aarch64__
547	# define LONG_JMP_SP_ENV_SLOT 13	559	# define LONG_JMP_SP_ENV_SLOT 3
548	# elif defined(__loongarch__)	560	# elif SANITIZER_RISCV64
549	# define LONG_JMP_SP_ENV_SLOT 1	561	# define LONG_JMP_SP_ENV_SLOT 3
550	# elif defined(__mips64)	562	# elif defined(__x86_64__)
551	# define LONG_JMP_SP_ENV_SLOT 1	563	# define LONG_JMP_SP_ENV_SLOT 6
		564	# else
		565	# error unsupported
		566	# endif
		567	# elif SANITIZER_LINUX
		568	# ifdef __aarch64__
		569	# define LONG_JMP_SP_ENV_SLOT 13
		570	# elif defined(__loongarch__)
		571	# define LONG_JMP_SP_ENV_SLOT 1
		572	# elif defined(__mips64)
		573	# define LONG_JMP_SP_ENV_SLOT 1
552	# elif SANITIZER_RISCV64	574	# elif SANITIZER_RISCV64
553	# define LONG_JMP_SP_ENV_SLOT 13	575	# define LONG_JMP_SP_ENV_SLOT 13
554	# elif defined(__s390x__)	576	# elif defined(__s390x__)
...	@@ -556,7 +578,7 @@ static uptr UnmangleLongJmpSp(uptr mangled_sp) {	...	@@ -556,7 +578,7 @@ static uptr UnmangleLongJmpSp(uptr mangled_sp) {
556	# else	578	# else
557	# define LONG_JMP_SP_ENV_SLOT 6	579	# define LONG_JMP_SP_ENV_SLOT 6
558	# endif	580	# endif
559	#endif	581	# endif
560		582
561	uptr ExtractLongJmpSp(uptr *env) {	583	uptr ExtractLongJmpSp(uptr *env) {
562	uptr mangled_sp = env[LONG_JMP_SP_ENV_SLOT];	584	uptr mangled_sp = env[LONG_JMP_SP_ENV_SLOT];
...	@@ -653,7 +675,13 @@ ThreadState *cur_thread() {	...	@@ -653,7 +675,13 @@ ThreadState *cur_thread() {
653	}	675	}
654	CHECK_EQ(0, internal_sigprocmask(SIG_SETMASK, &oldset, nullptr));	676	CHECK_EQ(0, internal_sigprocmask(SIG_SETMASK, &oldset, nullptr));
655	}	677	}
656	return thr;	678
		679	// Skia calls mallopt(M_THREAD_DISABLE_MEM_INIT, 1), which sets the least
		680	// significant bit of TLS_SLOT_SANITIZER to 1. Scudo allocator uses this bit
		681	// as a flag to disable memory initialization. This is a workaround to get the
		682	// correct ThreadState pointer.
		683	uptr addr = reinterpret_cast<uptr>(thr);
		684	return reinterpret_cast<ThreadState*>(addr & ~1ULL);
657	}	685	}
658		686
659	void set_cur_thread(ThreadState *thr) {	687	void set_cur_thread(ThreadState *thr) {

lib/libtsan/tsan_platform_mac.cpp+16-3

 @@ -226,9 +226,20 @@ static void ThreadTerminateCallback(uptr thread) {
 void InitializePlatformEarly() {
 #  if !SANITIZER_GO && SANITIZER_IOS
   uptr max_vm = GetMaxUserVirtualAddress() + 1;
-  if (max_vm != HiAppMemEnd()) {
+  if (max_vm < HiAppMemEnd()) {
-    Printf("ThreadSanitizer: unsupported vm address limit %p, expected %p.\n",
+    Report(
-           (void *)max_vm, (void *)HiAppMemEnd());
+        "ThreadSanitizer: Unsupported virtual memory layout:\n\tVM address "
+        "limit = %p\n\tExpected %p.\n",
+        (void*)max_vm, (void*)HiAppMemEnd());
+    Die();
+  }
+  // In some configurations, the max_vm is expanded, but much of this space is
+  // already mapped. TSAN will not work in this configuration.
+  if (!MemoryRangeIsAvailable(HiAppMemEnd() - 1, HiAppMemEnd() - 1)) {
+    Report(
+        "ThreadSanitizer: Unsupported virtual memory layout: Address %p is "
+        "already mapped.\n",
+        (void*)(HiAppMemEnd() - 1));
     Die();
   }
 #endif
 @@ -248,7 +259,9 @@ void InitializePlatform() {
   ThreadEventCallbacks callbacks = {
       .create = ThreadCreateCallback,
+      .start = nullptr,
       .terminate = ThreadTerminateCallback,
+      .destroy = nullptr,
   };
   InstallPthreadIntrospectionHook(callbacks);
 #endif

lib/libtsan/tsan_report.h+14-1

 @@ -12,6 +12,8 @@
 #ifndef TSAN_REPORT_H
 #define TSAN_REPORT_H
+#include "sanitizer_common/sanitizer_internal_defs.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
 #include "sanitizer_common/sanitizer_symbolizer.h"
 #include "sanitizer_common/sanitizer_thread_registry.h"
 #include "sanitizer_common/sanitizer_vector.h"
 @@ -56,6 +58,7 @@ struct ReportMop {
   bool atomic;
   uptr external_tag;
   Vector<ReportMopMutex> mset;
+  StackTrace stack_trace;
   ReportStack *stack;
   ReportMop();
 @@ -79,25 +82,34 @@ struct ReportLocation {
   int fd = 0;
   bool fd_closed = false;
   bool suppressable = false;
+  StackID stack_id = 0;
   ReportStack *stack = nullptr;
 };
 struct ReportThread {
   Tid id;
-  tid_t os_id;
+  ThreadID os_id;
   bool running;
   ThreadType thread_type;
   char *name;
   Tid parent_tid;
+  StackID stack_id;
   ReportStack *stack;
+  bool suppressable;
 };
 struct ReportMutex {
   int id;
   uptr addr;
+  StackID stack_id;
   ReportStack *stack;
 };
+struct AddedLocationAddr {
+  uptr addr;
+  usize locs_idx;
+};
 class ReportDesc {
  public:
   ReportType typ;
 @@ -105,6 +117,7 @@ class ReportDesc {
   Vector<ReportStack*> stacks;
   Vector<ReportMop*> mops;
   Vector<ReportLocation*> locs;
+  Vector<AddedLocationAddr> added_location_addrs;
   Vector<ReportMutex*> mutexes;
   Vector<ReportThread*> threads;
   Vector<Tid> unique_tids;

lib/libtsan/tsan_rtl.cpp+14

...	@@ -40,6 +40,13 @@ SANITIZER_WEAK_DEFAULT_IMPL	...	@@ -40,6 +40,13 @@ SANITIZER_WEAK_DEFAULT_IMPL
40	void __tsan_test_only_on_fork() {}	40	void __tsan_test_only_on_fork() {}
41	#endif	41	#endif
42		42
		43	#if SANITIZER_APPLE && !SANITIZER_GO
		44	// Override weak symbol from sanitizer_common
		45	extern void __tsan_set_in_internal_write_call(bool value) {
		46	__tsan::cur_thread_init()->in_internal_write_call = value;
		47	}
		48	#endif
		49
43	namespace __tsan {	50	namespace __tsan {
44		51
45	#if !SANITIZER_GO	52	#if !SANITIZER_GO
...	@@ -893,6 +900,13 @@ void ForkChildAfter(ThreadState* thr, uptr pc, bool start_thread) {	...	@@ -893,6 +900,13 @@ void ForkChildAfter(ThreadState* thr, uptr pc, bool start_thread) {
893	ThreadIgnoreBegin(thr, pc);	900	ThreadIgnoreBegin(thr, pc);
894	ThreadIgnoreSyncBegin(thr, pc);	901	ThreadIgnoreSyncBegin(thr, pc);
895	}	902	}
		903
		904	# if SANITIZER_APPLE && !SANITIZER_GO
		905	// This flag can have inheritance disabled - we are the child so act
		906	// accordingly
		907	if (flags()->lock_during_write == kNoLockDuringWritesCurrentProcess)
		908	flags()->lock_during_write = kLockDuringAllWrites;
		909	# endif
896	}	910	}
897	#endif	911	#endif
898		912

lib/libtsan/tsan_rtl.h+7-2

lib/libtsan/tsan_rtl_aarch64.S+3-5

...	@@ -4,10 +4,8 @@	...	@@ -4,10 +4,8 @@
4	#include "sanitizer_common/sanitizer_asm.h"	4	#include "sanitizer_common/sanitizer_asm.h"
5	#include "builtins/assembly.h"	5	#include "builtins/assembly.h"
6		6
7	#if !defined(__APPLE__)	7	TEXT_SECTION
8	.section .text	8	#if defined(__APPLE__)
9	#else
10	.section __TEXT,__text
11	.align 3	9	.align 3
12	#endif	10	#endif
13		11
...	@@ -222,6 +220,6 @@ ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(__sigsetjmp))	...	@@ -222,6 +220,6 @@ ASM_SIZE(ASM_SYMBOL_INTERCEPTOR(__sigsetjmp))
222		220
223	NO_EXEC_STACK_DIRECTIVE	221	NO_EXEC_STACK_DIRECTIVE
224		222
225	GNU_PROPERTY_BTI_PAC	223	GNU_PROPERTY_BTI_PAC_GCS
226		224
227	#endif	225	#endif

lib/libtsan/tsan_rtl_access.cpp+8-3

 @@ -419,6 +419,11 @@ NOINLINE void TraceRestartMemoryAccess(ThreadState* thr, uptr pc, uptr addr,
 ALWAYS_INLINE USED void MemoryAccess(ThreadState* thr, uptr pc, uptr addr,
                                      uptr size, AccessType typ) {
+#if SANITIZER_APPLE && !SANITIZER_GO
+  // Swift symbolizer can be intercepted and deadlock without this
+  if (thr->in_symbolizer)
+    return;
+#endif
   RawShadow* shadow_mem = MemToShadow(addr);
   UNUSED char memBuf[4][64];
   DPrintf2("#%d: Access: %d@%d %p/%zd typ=0x%x {%s, %s, %s, %s}\n", thr->tid,
 @@ -684,7 +689,7 @@ void MemoryAccessRangeT(ThreadState* thr, uptr pc, uptr addr, uptr size) {
     DCHECK(IsAppMem(addr + size - 1));
   }
   if (!IsShadowMem(shadow_mem)) {
-    Printf("Bad shadow start addr: %p (%p)\n", shadow_mem, (void*)addr);
+    Printf("Bad shadow start addr: %p (%p)\n", (void*)shadow_mem, (void*)addr);
     DCHECK(IsShadowMem(shadow_mem));
   }
 @@ -693,12 +698,12 @@ void MemoryAccessRangeT(ThreadState* thr, uptr pc, uptr addr, uptr size) {
   RawShadow* shadow_mem_end =
       shadow_mem + rounded_size / kShadowCell * kShadowCnt;
   if (!IsShadowMem(shadow_mem_end - 1)) {
-    Printf("Bad shadow end addr: %p (%p)\n", shadow_mem_end - 1,
+    Printf("Bad shadow end addr: %p (%p)\n", (void*)(shadow_mem_end - 1),
            (void*)(addr + size - 1));
     Printf(
         "Shadow start addr (ok): %p (%p); size: 0x%zx; rounded_size: 0x%zx; "
         "kShadowMultiplier: %zx\n",
-        shadow_mem, (void*)addr, size, rounded_size, kShadowMultiplier);
+        (void*)shadow_mem, (void*)addr, size, rounded_size, kShadowMultiplier);
     DCHECK(IsShadowMem(shadow_mem_end - 1));
   }
 #endif

lib/libtsan/tsan_rtl_amd64.S+2

...	@@ -3,6 +3,8 @@	...	@@ -3,6 +3,8 @@
3		3
4	#include "sanitizer_common/sanitizer_asm.h"	4	#include "sanitizer_common/sanitizer_asm.h"
5		5
		6	.att_syntax
		7
6	#if !defined(__APPLE__)	8	#if !defined(__APPLE__)
7	.section .text	9	.section .text
8	#else	10	#else

lib/libtsan/tsan_rtl_mutex.cpp+94-49

...	@@ -11,14 +11,15 @@	...	@@ -11,14 +11,15 @@
11	//===----------------------------------------------------------------------===//	11	//===----------------------------------------------------------------------===//
12		12
13	#include <sanitizer_common/sanitizer_deadlock_detector_interface.h>	13	#include <sanitizer_common/sanitizer_deadlock_detector_interface.h>
		14	#include <sanitizer_common/sanitizer_placement_new.h>
14	#include <sanitizer_common/sanitizer_stackdepot.h>	15	#include <sanitizer_common/sanitizer_stackdepot.h>
15		16
16	#include "tsan_rtl.h"
17	#include "tsan_flags.h"	17	#include "tsan_flags.h"
18	#include "tsan_sync.h"	18	#include "tsan_platform.h"
19	#include "tsan_report.h"	19	#include "tsan_report.h"
		20	#include "tsan_rtl.h"
20	#include "tsan_symbolize.h"	21	#include "tsan_symbolize.h"
21	#include "tsan_platform.h"	22	#include "tsan_sync.h"
22		23
23	namespace __tsan {	24	namespace __tsan {
24		25
...	@@ -55,14 +56,28 @@ static void ReportMutexMisuse(ThreadState *thr, uptr pc, ReportType typ,	...	@@ -55,14 +56,28 @@ static void ReportMutexMisuse(ThreadState *thr, uptr pc, ReportType typ,
55	return;	56	return;
56	if (!ShouldReport(thr, typ))	57	if (!ShouldReport(thr, typ))
57	return;	58	return;
58	ThreadRegistryLock l(&ctx->thread_registry);	59	// Use alloca, because malloc during signal handling deadlocks
59	ScopedReport rep(typ);	60	ScopedReport rep = (ScopedReport )__builtin_alloca(sizeof(ScopedReport));
60	rep.AddMutex(addr, creation_stack_id);	61	// Take a new scope as Apple platforms require the below locks released
61	VarSizeStackTrace trace;	62	// before symbolizing in order to avoid a deadlock
62	ObtainCurrentStack(thr, pc, &trace);	63	{
63	rep.AddStack(trace, true);	64	ThreadRegistryLock l(&ctx->thread_registry);
64	rep.AddLocation(addr, 1);	65	new (rep) ScopedReport(typ);
65	OutputReport(thr, rep);	66	rep->AddMutex(addr, creation_stack_id);
		67	VarSizeStackTrace trace;
		68	ObtainCurrentStack(thr, pc, &trace);
		69	rep->AddStack(trace, true);
		70	rep->AddLocation(addr, 1);
		71	#if SANITIZER_APPLE
		72	} // Close this scope to release the locks
		73	#endif
		74	OutputReport(thr, *rep);
		75
		76	// Need to manually destroy this because we used placement new to allocate
		77	rep->~ScopedReport();
		78	#if !SANITIZER_APPLE
		79	}
		80	#endif
66	}	81	}
67		82
68	static void RecordMutexLock(ThreadState *thr, uptr pc, uptr addr,	83	static void RecordMutexLock(ThreadState *thr, uptr pc, uptr addr,
...	@@ -528,51 +543,81 @@ void AfterSleep(ThreadState *thr, uptr pc) {	...	@@ -528,51 +543,81 @@ void AfterSleep(ThreadState *thr, uptr pc) {
528	void ReportDeadlock(ThreadState thr, uptr pc, DDReport r) {	543	void ReportDeadlock(ThreadState thr, uptr pc, DDReport r) {
529	if (r == 0 \|\| !ShouldReport(thr, ReportTypeDeadlock))	544	if (r == 0 \|\| !ShouldReport(thr, ReportTypeDeadlock))
530	return;	545	return;
531	ThreadRegistryLock l(&ctx->thread_registry);	546	// Use alloca, because malloc during signal handling deadlocks
532	ScopedReport rep(ReportTypeDeadlock);	547	ScopedReport rep = (ScopedReport )__builtin_alloca(sizeof(ScopedReport));
533	for (int i = 0; i < r->n; i++) {	548	// Take a new scope as Apple platforms require the below locks released
534	rep.AddMutex(r->loop[i].mtx_ctx0, r->loop[i].stk[0]);	549	// before symbolizing in order to avoid a deadlock
535	rep.AddUniqueTid((int)r->loop[i].thr_ctx);	550	{
536	rep.AddThread((int)r->loop[i].thr_ctx);	551	ThreadRegistryLock l(&ctx->thread_registry);
537	}	552	new (rep) ScopedReport(ReportTypeDeadlock);
538	uptr dummy_pc = 0x42;	553	for (int i = 0; i < r->n; i++) {
539	for (int i = 0; i < r->n; i++) {	554	rep->AddMutex(r->loop[i].mtx_ctx0, r->loop[i].stk[0]);
540	for (int j = 0; j < (flags()->second_deadlock_stack ? 2 : 1); j++) {	555	rep->AddUniqueTid((int)r->loop[i].thr_ctx);
541	u32 stk = r->loop[i].stk[j];	556	rep->AddThread((int)r->loop[i].thr_ctx);
542	if (stk && stk != kInvalidStackID) {	557	}
543	rep.AddStack(StackDepotGet(stk), true);	558	uptr dummy_pc = 0x42;
544	} else {	559	for (int i = 0; i < r->n; i++) {
545	// Sometimes we fail to extract the stack trace (FIXME: investigate),	560	for (int j = 0; j < (flags()->second_deadlock_stack ? 2 : 1); j++) {
546	// but we should still produce some stack trace in the report.	561	u32 stk = r->loop[i].stk[j];
547	rep.AddStack(StackTrace(&dummy_pc, 1), true);	562	StackTrace stack;
		563	if (stk && stk != kInvalidStackID) {
		564	stack = StackDepotGet(stk);
		565	} else {
		566	// Sometimes we fail to extract the stack trace (FIXME: investigate),
		567	// but we should still produce some stack trace in the report.
		568	stack = StackTrace(&dummy_pc, 1);
		569	}
		570	rep->AddStack(stack, true);
548	}	571	}
549	}	572	}
		573	#if SANITIZER_APPLE
		574	} // Close this scope to release the locks
		575	#endif
		576	OutputReport(thr, *rep);
		577
		578	// Need to manually destroy this because we used placement new to allocate
		579	rep->~ScopedReport();
		580	#if !SANITIZER_APPLE
550	}	581	}
551	OutputReport(thr, rep);	582	#endif
552	}	583	}
553		584
554	void ReportDestroyLocked(ThreadState *thr, uptr pc, uptr addr,	585	void ReportDestroyLocked(ThreadState *thr, uptr pc, uptr addr,
555	FastState last_lock, StackID creation_stack_id) {	586	FastState last_lock, StackID creation_stack_id) {
556	// We need to lock the slot during RestoreStack because it protects	587	// Use alloca, because malloc during signal handling deadlocks
557	// the slot journal.	588	ScopedReport rep = (ScopedReport )__builtin_alloca(sizeof(ScopedReport));
558	Lock slot_lock(&ctx->slots[static_cast<uptr>(last_lock.sid())].mtx);	589	// Take a new scope as Apple platforms require the below locks released
559	ThreadRegistryLock l0(&ctx->thread_registry);	590	// before symbolizing in order to avoid a deadlock
560	Lock slots_lock(&ctx->slot_mtx);	591	{
561	ScopedReport rep(ReportTypeMutexDestroyLocked);	592	// We need to lock the slot during RestoreStack because it protects
562	rep.AddMutex(addr, creation_stack_id);	593	// the slot journal.
563	VarSizeStackTrace trace;	594	Lock slot_lock(&ctx->slots[static_cast<uptr>(last_lock.sid())].mtx);
564	ObtainCurrentStack(thr, pc, &trace);	595	ThreadRegistryLock l0(&ctx->thread_registry);
565	rep.AddStack(trace, true);	596	Lock slots_lock(&ctx->slot_mtx);
566		597	new (rep) ScopedReport(ReportTypeMutexDestroyLocked);
567	Tid tid;	598	rep->AddMutex(addr, creation_stack_id);
568	DynamicMutexSet mset;	599	VarSizeStackTrace trace;
569	uptr tag;	600	ObtainCurrentStack(thr, pc, &trace);
570	if (!RestoreStack(EventType::kLock, last_lock.sid(), last_lock.epoch(), addr,	601	rep->AddStack(trace, true);
571	0, kAccessWrite, &tid, &trace, mset, &tag))	602
572	return;	603	Tid tid;
573	rep.AddStack(trace, true);	604	DynamicMutexSet mset;
574	rep.AddLocation(addr, 1);	605	uptr tag;
575	OutputReport(thr, rep);	606	if (!RestoreStack(EventType::kLock, last_lock.sid(), last_lock.epoch(),
		607	addr, 0, kAccessWrite, &tid, &trace, mset, &tag))
		608	return;
		609	rep->AddStack(trace, true);
		610	rep->AddLocation(addr, 1);
		611	#if SANITIZER_APPLE
		612	} // Close this scope to release the locks
		613	#endif
		614	OutputReport(thr, *rep);
		615
		616	// Need to manually destroy this because we used placement new to allocate
		617	rep->~ScopedReport();
		618	#if !SANITIZER_APPLE
		619	}
		620	#endif
576	}	621	}
577		622
578	} // namespace __tsan	623	} // namespace __tsan

lib/libtsan/tsan_rtl_report.cpp+132-65

 @@ -11,10 +11,12 @@
 //===----------------------------------------------------------------------===//
 #include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_internal_defs.h"
 #include "sanitizer_common/sanitizer_libc.h"
 #include "sanitizer_common/sanitizer_placement_new.h"
 #include "sanitizer_common/sanitizer_stackdepot.h"
 #include "sanitizer_common/sanitizer_stacktrace.h"
+#include "tsan_defs.h"
 #include "tsan_fd.h"
 #include "tsan_flags.h"
 #include "tsan_mman.h"
 @@ -109,7 +111,13 @@ static ReportStack *SymbolizeStack(StackTrace trace) {
     // instruction.
     if ((pc & kExternalPCBit) == 0)
       pc1 = StackTrace::GetPreviousInstructionPc(pc);
-    SymbolizedStack *ent = SymbolizeCode(pc1);
+    SymbolizedStack* ent = SymbolizeCode(pc1, si == trace.size - 1);
+#if SANITIZER_GO
+    if (ent == nullptr) {
+      // Go might have 0 frames for this PC (wrapper frames aren't reported).
+      continue;
+    }
+#endif
     CHECK_NE(ent, 0);
     SymbolizedStack *last = ent;
     while (last->next) {
 @@ -187,10 +195,8 @@ void ScopedReportBase::AddMemoryAccess(uptr addr, uptr external_tag, Shadow s,
   mop->size = size;
   mop->write = !(typ & kAccessRead);
   mop->atomic = typ & kAccessAtomic;
-  mop->stack = SymbolizeStack(stack);
   mop->external_tag = external_tag;
-  if (mop->stack)
+  mop->stack_trace = stack;
-    mop->stack->suppressable = true;
   for (uptr i = 0; i < mset->Size(); i++) {
     MutexSet::Desc d = mset->Get(i);
     int id = this->AddMutex(d.addr, d.stack_id);
 @@ -199,6 +205,56 @@ void ScopedReportBase::AddMemoryAccess(uptr addr, uptr external_tag, Shadow s,
   }
 }
+void ScopedReportBase::SymbolizeStackElems() {
+  // symbolize memory ops
+  for (usize i = 0, size = rep_->mops.Size(); i < size; i++) {
+    ReportMop *mop = rep_->mops[i];
+    mop->stack = SymbolizeStack(mop->stack_trace);
+    if (mop->stack)
+      mop->stack->suppressable = true;
+  }
+  // symbolize locations
+  for (usize i = 0, size = rep_->locs.Size(); i < size; i++) {
+    // added locations have a NULL placeholder - don't dereference them
+    if (ReportLocation *loc = rep_->locs[i])
+      loc->stack = SymbolizeStackId(loc->stack_id);
+  }
+  // symbolize any added locations
+  for (usize i = 0, size = rep_->added_location_addrs.Size(); i < size; i++) {
+    AddedLocationAddr *added_loc = &rep_->added_location_addrs[i];
+    if (ReportLocation *loc = SymbolizeData(added_loc->addr)) {
+      loc->suppressable = true;
+      rep_->locs[added_loc->locs_idx] = loc;
+    }
+  }
+  // Filter out any added location placeholders that could not be symbolized
+  usize j = 0;
+  for (usize i = 0, size = rep_->locs.Size(); i < size; i++) {
+    if (rep_->locs[i] != nullptr) {
+      rep_->locs[j] = rep_->locs[i];
+      j++;
+    }
+  }
+  rep_->locs.Resize(j);
+  // symbolize threads
+  for (usize i = 0, size = rep_->threads.Size(); i < size; i++) {
+    ReportThread *rt = rep_->threads[i];
+    rt->stack = SymbolizeStackId(rt->stack_id);
+    if (rt->stack)
+      rt->stack->suppressable = rt->suppressable;
+  }
+  // symbolize mutexes
+  for (usize i = 0, size = rep_->mutexes.Size(); i < size; i++) {
+    ReportMutex *rm = rep_->mutexes[i];
+    rm->stack = SymbolizeStackId(rm->stack_id);
+  }
+}
 void ScopedReportBase::AddUniqueTid(Tid unique_tid) {
   rep_->unique_tids.PushBack(unique_tid);
 }
 @@ -216,10 +272,8 @@ void ScopedReportBase::AddThread(const ThreadContext *tctx, bool suppressable) {
   rt->name = internal_strdup(tctx->name);
   rt->parent_tid = tctx->parent_tid;
   rt->thread_type = tctx->thread_type;
-  rt->stack = 0;
+  rt->stack_id = tctx->creation_stack_id;
-  rt->stack = SymbolizeStackId(tctx->creation_stack_id);
+  rt->suppressable = suppressable;
-  if (rt->stack)
-    rt->stack->suppressable = suppressable;
 }
 #if !SANITIZER_GO
 @@ -270,7 +324,7 @@ int ScopedReportBase::AddMutex(uptr addr, StackID creation_stack_id) {
   rep_->mutexes.PushBack(rm);
   rm->id = rep_->mutexes.Size() - 1;
   rm->addr = addr;
-  rm->stack = SymbolizeStackId(creation_stack_id);
+  rm->stack_id = creation_stack_id;
   return rm->id;
 }
 @@ -288,7 +342,7 @@ void ScopedReportBase::AddLocation(uptr addr, uptr size) {
     loc->fd_closed = closed;
     loc->fd = fd;
     loc->tid = creat_tid;
-    loc->stack = SymbolizeStackId(creat_stack);
+    loc->stack_id = creat_stack;
     rep_->locs.PushBack(loc);
     AddThread(creat_tid);
     return;
 @@ -310,7 +364,7 @@ void ScopedReportBase::AddLocation(uptr addr, uptr size) {
     loc->heap_chunk_size = b->siz;
     loc->external_tag = b->tag;
     loc->tid = b->tid;
-    loc->stack = SymbolizeStackId(b->stk);
+    loc->stack_id = b->stk;
     rep_->locs.PushBack(loc);
     AddThread(b->tid);
     return;
 @@ -324,11 +378,8 @@ void ScopedReportBase::AddLocation(uptr addr, uptr size) {
     AddThread(tctx);
   }
 #endif
-  if (ReportLocation *loc = SymbolizeData(addr)) {
+  rep_->added_location_addrs.PushBack({addr, rep_->locs.Size()});
-    loc->suppressable = true;
+  rep_->locs.PushBack(nullptr);
-    rep_->locs.PushBack(loc);
-    return;
-  }
 }
 #if !SANITIZER_GO
 @@ -628,11 +679,12 @@ static bool HandleRacyStacks(ThreadState *thr, VarSizeStackTrace traces[2]) {
   return false;
 }
-bool OutputReport(ThreadState *thr, const ScopedReport &srep) {
+bool OutputReport(ThreadState *thr, ScopedReport &srep) {
   // These should have been checked in ShouldReport.
   // It's too late to check them here, we have already taken locks.
   CHECK(flags()->report_bugs);
   CHECK(!thr->suppress_reports);
+  srep.SymbolizeStackElems();
   atomic_store_relaxed(&ctx->last_symbolize_time_ns, NanoTime());
   const ReportDesc *rep = srep.GetReport();
   CHECK_EQ(thr->current_report, nullptr);
 @@ -761,65 +813,80 @@ void ReportRace(ThreadState *thr, RawShadow *shadow_mem, Shadow cur, Shadow old,
   DynamicMutexSet mset1;
   MutexSet *mset[kMop] = {&thr->mset, mset1};
-  // We need to lock the slot during RestoreStack because it protects
+  // Use alloca, because malloc during signal handling deadlocks
-  // the slot journal.
+  ScopedReport *rep = (ScopedReport *)__builtin_alloca(sizeof(ScopedReport));
-  Lock slot_lock(&ctx->slots[static_cast<uptr>(s[1].sid())].mtx);
+  // Take a new scope as Apple platforms require the below locks released
-  ThreadRegistryLock l0(&ctx->thread_registry);
+  // before symbolizing in order to avoid a deadlock
-  Lock slots_lock(&ctx->slot_mtx);
+  {
-  if (SpuriousRace(old))
+    // We need to lock the slot during RestoreStack because it protects
-    return;
+    // the slot journal.
-  if (!RestoreStack(EventType::kAccessExt, s[1].sid(), s[1].epoch(), addr1,
+    Lock slot_lock(&ctx->slots[static_cast<uptr>(s[1].sid())].mtx);
-                    size1, typ1, &tids[1], &traces[1], mset[1], &tags[1])) {
+    ThreadRegistryLock l0(&ctx->thread_registry);
-    StoreShadow(&ctx->last_spurious_race, old.raw());
+    Lock slots_lock(&ctx->slot_mtx);
-    return;
+    if (SpuriousRace(old))
-  }
+      return;
+    if (!RestoreStack(EventType::kAccessExt, s[1].sid(), s[1].epoch(), addr1,
+                      size1, typ1, &tids[1], &traces[1], mset[1], &tags[1])) {
+      StoreShadow(&ctx->last_spurious_race, old.raw());
+      return;
+    }
-  if (IsFiredSuppression(ctx, rep_typ, traces[1]))
+    if (IsFiredSuppression(ctx, rep_typ, traces[1]))
-    return;
+      return;
-  if (HandleRacyStacks(thr, traces))
+    if (HandleRacyStacks(thr, traces))
-    return;
+      return;
-  // If any of the accesses has a tag, treat this as an "external" race.
+    // If any of the accesses has a tag, treat this as an "external" race.
-  uptr tag = kExternalTagNone;
+    uptr tag = kExternalTagNone;
-  for (uptr i = 0; i < kMop; i++) {
+    for (uptr i = 0; i < kMop; i++) {
-    if (tags[i] != kExternalTagNone) {
+      if (tags[i] != kExternalTagNone) {
-      rep_typ = ReportTypeExternalRace;
+        rep_typ = ReportTypeExternalRace;
-      tag = tags[i];
+        tag = tags[i];
-      break;
+        break;
+      }
     }
-  }
-  ScopedReport rep(rep_typ, tag);
+    new (rep) ScopedReport(rep_typ, tag);
-  for (uptr i = 0; i < kMop; i++)
+    for (uptr i = 0; i < kMop; i++)
-    rep.AddMemoryAccess(addr, tags[i], s[i], tids[i], traces[i], mset[i]);
+      rep->AddMemoryAccess(addr, tags[i], s[i], tids[i], traces[i], mset[i]);
-  for (uptr i = 0; i < kMop; i++) {
+    for (uptr i = 0; i < kMop; i++) {
-    ThreadContext *tctx = static_cast<ThreadContext *>(
+      ThreadContext *tctx = static_cast<ThreadContext *>(
-        ctx->thread_registry.GetThreadLocked(tids[i]));
+          ctx->thread_registry.GetThreadLocked(tids[i]));
-    rep.AddThread(tctx);
+      rep->AddThread(tctx);
-  }
+    }
-  rep.AddLocation(addr_min, addr_max - addr_min);
+    rep->AddLocation(addr_min, addr_max - addr_min);
-  if (flags()->print_full_thread_history) {
+    if (flags()->print_full_thread_history) {
-    const ReportDesc *rep_desc = rep.GetReport();
+      const ReportDesc *rep_desc = rep->GetReport();
-    for (uptr i = 0; i < rep_desc->threads.Size(); i++) {
+      for (uptr i = 0; i < rep_desc->threads.Size(); i++) {
-      Tid parent_tid = rep_desc->threads[i]->parent_tid;
+        Tid parent_tid = rep_desc->threads[i]->parent_tid;
-      if (parent_tid == kMainTid || parent_tid == kInvalidTid)
+        if (parent_tid == kMainTid || parent_tid == kInvalidTid)
-        continue;
+          continue;
-      ThreadContext *parent_tctx = static_cast<ThreadContext *>(
+        ThreadContext *parent_tctx = static_cast<ThreadContext *>(
-          ctx->thread_registry.GetThreadLocked(parent_tid));
+            ctx->thread_registry.GetThreadLocked(parent_tid));
-      rep.AddThread(parent_tctx);
+        rep->AddThread(parent_tctx);
+      }
     }
-  }
 #if !SANITIZER_GO
-  if (!((typ0 | typ1) & kAccessFree) &&
+    if (!((typ0 | typ1) & kAccessFree) &&
-      s[1].epoch() <= thr->last_sleep_clock.Get(s[1].sid()))
+        s[1].epoch() <= thr->last_sleep_clock.Get(s[1].sid()))
-    rep.AddSleep(thr->last_sleep_stack_id);
+      rep->AddSleep(thr->last_sleep_stack_id);
+#endif
+#if SANITIZER_APPLE
+  }  // Close this scope to release the locks
+#endif
+    OutputReport(thr, *rep);
+    // Need to manually destroy this because we used placement new to allocate
+    rep->~ScopedReport();
+#if !SANITIZER_APPLE
+  }
 #endif
-  OutputReport(thr, rep);
 }
 void PrintCurrentStack(ThreadState *thr, uptr pc) {

lib/libtsan/tsan_rtl_thread.cpp+31-9

 @@ -88,15 +88,33 @@ void ThreadFinalize(ThreadState *thr) {
 #if !SANITIZER_GO
   if (!ShouldReport(thr, ReportTypeThreadLeak))
     return;
-  ThreadRegistryLock l(&ctx->thread_registry);
   Vector<ThreadLeak> leaks;
-  ctx->thread_registry.RunCallbackForEachThreadLocked(CollectThreadLeaks,
+  {
-                                                      &leaks);
+    ThreadRegistryLock l(&ctx->thread_registry);
+    ctx->thread_registry.RunCallbackForEachThreadLocked(CollectThreadLeaks,
+                                                        &leaks);
+  }
   for (uptr i = 0; i < leaks.Size(); i++) {
-    ScopedReport rep(ReportTypeThreadLeak);
+    // Use alloca, because malloc during signal handling deadlocks
-    rep.AddThread(leaks[i].tctx, true);
+    ScopedReport *rep = (ScopedReport *)__builtin_alloca(sizeof(ScopedReport));
-    rep.SetCount(leaks[i].count);
+    // Take a new scope as Apple platforms require the below locks released
-    OutputReport(thr, rep);
+    // before symbolizing in order to avoid a deadlock
+    {
+      ThreadRegistryLock l(&ctx->thread_registry);
+      new (rep) ScopedReport(ReportTypeThreadLeak);
+      rep->AddThread(leaks[i].tctx, true);
+      rep->SetCount(leaks[i].count);
+#  if SANITIZER_APPLE
+    }  // Close this scope to release the locks
+#  endif
+      OutputReport(thr, *rep);
+      // Need to manually destroy this because we used placement new to allocate
+      rep->~ScopedReport();
+#  if !SANITIZER_APPLE
+    }
+#  endif
   }
 #endif
 }
 @@ -149,7 +167,7 @@ struct OnStartedArgs {
   uptr tls_size;
 };
-void ThreadStart(ThreadState *thr, Tid tid, tid_t os_id,
+void ThreadStart(ThreadState *thr, Tid tid, ThreadID os_id,
                  ThreadType thread_type) {
   ctx->thread_registry.StartThread(tid, os_id, thread_type, thr);
   if (!thr->ignore_sync) {
 @@ -188,10 +206,14 @@ void ThreadStart(ThreadState *thr, Tid tid, tid_t os_id,
   }
 #endif
-#if !SANITIZER_GO
+#if !SANITIZER_GO && !SANITIZER_ANDROID
   // Don't imitate stack/TLS writes for the main thread,
   // because its initialization is synchronized with all
   // subsequent threads anyway.
+  // Because thr is created by MmapOrDie, the thr object
+  // is not in tls, the pointer to the thr object is in
+  // TLS_SLOT_SANITIZER slot. So skip this check on
+  // Android platform.
   if (tid != kMainTid) {
     if (stk_addr && stk_size) {
       const uptr pc = StackTrace::GetNextInstructionPc(

lib/libtsan/tsan_symbolize.cpp+1-1

...	@@ -79,7 +79,7 @@ static void AddFrame(void ctx, const char function_name, const char *file,	...	@@ -79,7 +79,7 @@ static void AddFrame(void ctx, const char function_name, const char *file,
79	info->column = column;	79	info->column = column;
80	}	80	}
81		81
82	SymbolizedStack *SymbolizeCode(uptr addr) {	82	SymbolizedStack* SymbolizeCode(uptr addr, bool leaf) {
83	// Check if PC comes from non-native land.	83	// Check if PC comes from non-native land.
84	if (addr & kExternalPCBit) {	84	if (addr & kExternalPCBit) {
85	SymbolizedStackBuilder ssb = {nullptr, nullptr, addr};	85	SymbolizedStackBuilder ssb = {nullptr, nullptr, addr};

lib/libtsan/tsan_symbolize.h+1-1

...	@@ -19,7 +19,7 @@ namespace __tsan {	...	@@ -19,7 +19,7 @@ namespace __tsan {
19		19
20	void EnterSymbolizer();	20	void EnterSymbolizer();
21	void ExitSymbolizer();	21	void ExitSymbolizer();
22	SymbolizedStack *SymbolizeCode(uptr addr);	22	SymbolizedStack* SymbolizeCode(uptr addr, bool leaf);
23	ReportLocation *SymbolizeData(uptr addr);	23	ReportLocation *SymbolizeData(uptr addr);
24	void SymbolizeFlush();	24	void SymbolizeFlush();
25		25

lib/libtsan/tsan_trace.h+1-1

...	@@ -190,7 +190,7 @@ struct Trace {	...	@@ -190,7 +190,7 @@ struct Trace {
190	Mutex mtx;	190	Mutex mtx;
191	IList<TraceHeader, &TraceHeader::trace_parts, TracePart> parts;	191	IList<TraceHeader, &TraceHeader::trace_parts, TracePart> parts;
192	// First node non-queued into ctx->trace_part_recycle.	192	// First node non-queued into ctx->trace_part_recycle.
193	TracePart* local_head;	193	TracePart* local_head = nullptr;
194	// Final position in the last part for finished threads.	194	// Final position in the last part for finished threads.
195	Event* final_pos = nullptr;	195	Event* final_pos = nullptr;
196	// Number of trace parts allocated on behalf of this trace specifically.	196	// Number of trace parts allocated on behalf of this trace specifically.

author	Alex Rønne Petersen <alex@alexrp.com> 2026-01-17 06:02:54+01:00
committer	Alex Rønne Petersen <alex@alexrp.com> 2026-04-25 21:49:39+02:00
log	dbaea8d67e680121f4e917458a99bc538b473d9d
tree	e3af41c263074ee293a1640b0011d92a4e8163c4
parent	e79b4e907a3ceed4984a252fb2bccab7f31ec383
signature	Signed by SSH key SHA256:7B/LJ7bpR1eX8aCXSr4mtd5M45VMPKcx9zY8e95b5QM

...	@@ -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 0xFF33: // 33 FF : xor edi, edi
649	case 0x9066: // 66 90 : xchg %ax,%ax (Two-byte NOP)	650	case 0x9066: // 66 90 : xchg %ax,%ax (Two-byte NOP)
650	case 0xDB84: // 84 DB : test bl,bl	651	case 0xDB84: // 84 DB : test bl,bl
651	case 0xC084: // 84 C0 : test al,al	652	case 0xC084: // 84 C0 : test al,al
...	@@ -764,6 +765,7 @@ static size_t GetInstructionSize(uptr address, size_t* rel_offset = nullptr) {	...	@@ -764,6 +765,7 @@ static size_t GetInstructionSize(uptr address, size_t* rel_offset = nullptr) {
764		765
765	switch (0x00FFFFFF & (u32 )address) {	766	switch (0x00FFFFFF & (u32 )address) {
766	case 0x10b70f: // 0f b7 10 : movzx edx, WORD PTR [rax]	767	case 0x10b70f: // 0f b7 10 : movzx edx, WORD PTR [rax]
		768	case 0x02b70f: // 0f b7 02 : movzx eax, WORD PTR [rdx]
767	case 0xc00b4d: // 4d 0b c0 : or r8, r8	769	case 0xc00b4d: // 4d 0b c0 : or r8, r8
768	case 0xc03345: // 45 33 c0 : xor r8d, r8d	770	case 0xc03345: // 45 33 c0 : xor r8d, r8d
769	case 0xc08548: // 48 85 c0 : test rax, rax	771	case 0xc08548: // 48 85 c0 : test rax, rax
...	@@ -799,6 +801,7 @@ static size_t GetInstructionSize(uptr address, size_t* rel_offset = nullptr) {	...	@@ -799,6 +801,7 @@ static size_t GetInstructionSize(uptr address, size_t* rel_offset = nullptr) {
799	case 0xc9854d: // 4d 85 c9 : test r9, r9	801	case 0xc9854d: // 4d 85 c9 : test r9, r9
800	case 0xc98b4c: // 4c 8b c9 : mov r9, rcx	802	case 0xc98b4c: // 4c 8b c9 : mov r9, rcx
801	case 0xd12948: // 48 29 d1 : sub rcx, rdx	803	case 0xd12948: // 48 29 d1 : sub rcx, rdx
		804	case 0xc22b4c: // 4c 2b c2 : sub r8, rdx
802	case 0xca2b48: // 48 2b ca : sub rcx, rdx	805	case 0xca2b48: // 48 2b ca : sub rcx, rdx
803	case 0xca3b48: // 48 3b ca : cmp rcx, rdx	806	case 0xca3b48: // 48 3b ca : cmp rcx, rdx
804	case 0xd12b48: // 48 2b d1 : sub rdx, rcx	807	case 0xd12b48: // 48 2b d1 : sub rdx, rcx
...	@@ -813,6 +816,7 @@ static size_t GetInstructionSize(uptr address, size_t* rel_offset = nullptr) {	...	@@ -813,6 +816,7 @@ static size_t GetInstructionSize(uptr address, size_t* rel_offset = nullptr) {
813	case 0xd9f748: // 48 f7 d9 : neg rcx	816	case 0xd9f748: // 48 f7 d9 : neg rcx
814	case 0xc03145: // 45 31 c0 : xor r8d,r8d	817	case 0xc03145: // 45 31 c0 : xor r8d,r8d
815	case 0xc93145: // 45 31 c9 : xor r9d,r9d	818	case 0xc93145: // 45 31 c9 : xor r9d,r9d
		819	case 0xd23345: // 45 33 d2 : xor r10d, r10d
816	case 0xdb3345: // 45 33 db : xor r11d, r11d	820	case 0xdb3345: // 45 33 db : xor r11d, r11d
817	case 0xc08445: // 45 84 c0 : test r8b,r8b	821	case 0xc08445: // 45 84 c0 : test r8b,r8b
818	case 0xd28445: // 45 84 d2 : test r10b,r10b	822	case 0xd28445: // 45 84 d2 : test r10b,r10b

...	@@ -167,7 +167,7 @@ SANITIZER_WEAK_IMPORT void *aligned_alloc(__sanitizer::usize __alignment,	...	@@ -167,7 +167,7 @@ SANITIZER_WEAK_IMPORT void *aligned_alloc(__sanitizer::usize __alignment,
167		167
168	#define SANITIZER_INTERCEPT_STRLEN SI_NOT_FUCHSIA	168	#define SANITIZER_INTERCEPT_STRLEN SI_NOT_FUCHSIA
169	#define SANITIZER_INTERCEPT_STRNLEN (SI_NOT_MAC && SI_NOT_FUCHSIA)	169	#define SANITIZER_INTERCEPT_STRNLEN (SI_NOT_MAC && SI_NOT_FUCHSIA)
170	#define SANITIZER_INTERCEPT_STRCMP (SI_NOT_FUCHSIA && SI_NOT_AIX)	170	#define SANITIZER_INTERCEPT_STRCMP SI_NOT_FUCHSIA
171	#define SANITIZER_INTERCEPT_STRSTR SI_NOT_FUCHSIA	171	#define SANITIZER_INTERCEPT_STRSTR SI_NOT_FUCHSIA
172	#define SANITIZER_INTERCEPT_STRCASESTR (SI_POSIX && SI_NOT_AIX)	172	#define SANITIZER_INTERCEPT_STRCASESTR (SI_POSIX && SI_NOT_AIX)
173	#define SANITIZER_INTERCEPT_STRTOK SI_NOT_FUCHSIA	173	#define SANITIZER_INTERCEPT_STRTOK SI_NOT_FUCHSIA
...	@@ -179,8 +179,8 @@ SANITIZER_WEAK_IMPORT void *aligned_alloc(__sanitizer::usize __alignment,	...	@@ -179,8 +179,8 @@ SANITIZER_WEAK_IMPORT void *aligned_alloc(__sanitizer::usize __alignment,
179	#define SANITIZER_INTERCEPT_TEXTDOMAIN SI_LINUX_NOT_ANDROID \|\| SI_SOLARIS	179	#define SANITIZER_INTERCEPT_TEXTDOMAIN SI_LINUX_NOT_ANDROID \|\| SI_SOLARIS
180	#define SANITIZER_INTERCEPT_STRCASECMP SI_POSIX	180	#define SANITIZER_INTERCEPT_STRCASECMP SI_POSIX
181	#define SANITIZER_INTERCEPT_MEMSET 1	181	#define SANITIZER_INTERCEPT_MEMSET 1
182	#define SANITIZER_INTERCEPT_MEMMOVE SI_NOT_AIX	182	#define SANITIZER_INTERCEPT_MEMMOVE 1
183	#define SANITIZER_INTERCEPT_MEMCPY SI_NOT_AIX	183	#define SANITIZER_INTERCEPT_MEMCPY 1
184	#define SANITIZER_INTERCEPT_MEMCMP SI_NOT_FUCHSIA	184	#define SANITIZER_INTERCEPT_MEMCMP SI_NOT_FUCHSIA
185	#define SANITIZER_INTERCEPT_BCMP \	185	#define SANITIZER_INTERCEPT_BCMP \
186	SANITIZER_INTERCEPT_MEMCMP && \	186	SANITIZER_INTERCEPT_MEMCMP && \
...	@@ -551,7 +551,8 @@ SANITIZER_WEAK_IMPORT void *aligned_alloc(__sanitizer::usize __alignment,	...	@@ -551,7 +551,8 @@ SANITIZER_WEAK_IMPORT void *aligned_alloc(__sanitizer::usize __alignment,
551	#define SANITIZER_INTERCEPT_MALLOC_USABLE_SIZE (!SI_MAC && !SI_NETBSD)	551	#define SANITIZER_INTERCEPT_MALLOC_USABLE_SIZE (!SI_MAC && !SI_NETBSD)
552	#define SANITIZER_INTERCEPT_MCHECK_MPROBE SI_LINUX_NOT_ANDROID	552	#define SANITIZER_INTERCEPT_MCHECK_MPROBE SI_LINUX_NOT_ANDROID
553	#define SANITIZER_INTERCEPT_WCSLEN 1	553	#define SANITIZER_INTERCEPT_WCSLEN 1
554	#define SANITIZER_INTERCEPT_WCSCAT SI_POSIX	554	#define SANITIZER_INTERCEPT_WCSNLEN 1
		555	#define SANITIZER_INTERCEPT_WCSCAT (SI_POSIX \|\| SI_WINDOWS)
555	#define SANITIZER_INTERCEPT_WCSDUP SI_POSIX	556	#define SANITIZER_INTERCEPT_WCSDUP SI_POSIX
556	#define SANITIZER_INTERCEPT_SIGNAL_AND_SIGACTION (!SI_WINDOWS && SI_NOT_FUCHSIA)	557	#define SANITIZER_INTERCEPT_SIGNAL_AND_SIGACTION (!SI_WINDOWS && SI_NOT_FUCHSIA)
557	#define SANITIZER_INTERCEPT_BSD_SIGNAL SI_ANDROID	558	#define SANITIZER_INTERCEPT_BSD_SIGNAL SI_ANDROID

...	@@ -43,7 +43,7 @@ class ThreadContextBase {	...	@@ -43,7 +43,7 @@ class ThreadContextBase {
43	const u32 tid; // Thread ID. Main thread should have tid = 0.	43	const u32 tid; // Thread ID. Main thread should have tid = 0.
44	u64 unique_id; // Unique thread ID.	44	u64 unique_id; // Unique thread ID.
45	u32 reuse_count; // Number of times this tid was reused.	45	u32 reuse_count; // Number of times this tid was reused.
46	tid_t os_id; // PID (used for reporting).	46	ThreadID os_id; // PID (used for reporting).
47	uptr user_id; // Some opaque user thread id (e.g. pthread_t).	47	uptr user_id; // Some opaque user thread id (e.g. pthread_t).
48	char name[64]; // As annotated by user.	48	char name[64]; // As annotated by user.
49		49
...	@@ -62,7 +62,7 @@ class ThreadContextBase {	...	@@ -62,7 +62,7 @@ class ThreadContextBase {
62	void SetDead();	62	void SetDead();
63	void SetJoined(void *arg);	63	void SetJoined(void *arg);
64	void SetFinished();	64	void SetFinished();
65	void SetStarted(tid_t _os_id, ThreadType _thread_type, void *arg);	65	void SetStarted(ThreadID _os_id, ThreadType _thread_type, void *arg);
66	void SetCreated(uptr _user_id, u64 _unique_id, bool _detached,	66	void SetCreated(uptr _user_id, u64 _unique_id, bool _detached,
67	u32 _parent_tid, u32 _stack_tid, void *arg);	67	u32 _parent_tid, u32 _stack_tid, void *arg);
68	void Reset();	68	void Reset();
...	@@ -126,7 +126,7 @@ class SANITIZER_MUTEX ThreadRegistry {	...	@@ -126,7 +126,7 @@ class SANITIZER_MUTEX ThreadRegistry {
126	// is found.	126	// is found.
127	ThreadContextBase *FindThreadContextLocked(FindThreadCallback cb,	127	ThreadContextBase *FindThreadContextLocked(FindThreadCallback cb,
128	void *arg);	128	void *arg);
129	ThreadContextBase *FindThreadContextByOsIDLocked(tid_t os_id);	129	ThreadContextBase *FindThreadContextByOsIDLocked(ThreadID os_id);
130		130
131	void SetThreadName(u32 tid, const char *name);	131	void SetThreadName(u32 tid, const char *name);
132	void SetThreadNameByUserId(uptr user_id, const char *name);	132	void SetThreadNameByUserId(uptr user_id, const char *name);
...	@@ -134,7 +134,7 @@ class SANITIZER_MUTEX ThreadRegistry {	...	@@ -134,7 +134,7 @@ class SANITIZER_MUTEX ThreadRegistry {
134	void JoinThread(u32 tid, void *arg);	134	void JoinThread(u32 tid, void *arg);
135	// Finishes thread and returns previous status.	135	// Finishes thread and returns previous status.
136	ThreadStatus FinishThread(u32 tid);	136	ThreadStatus FinishThread(u32 tid);
137	void StartThread(u32 tid, tid_t os_id, ThreadType thread_type, void *arg);	137	void StartThread(u32 tid, ThreadID os_id, ThreadType thread_type, void *arg);
138	u32 ConsumeThreadUserId(uptr user_id);	138	u32 ConsumeThreadUserId(uptr user_id);
139	void SetThreadUserId(u32 tid, uptr user_id);	139	void SetThreadUserId(u32 tid, uptr user_id);
140		140

...	@@ -236,6 +236,10 @@ struct alignas(SANITIZER_CACHE_LINE_SIZE) ThreadState {	...	@@ -236,6 +236,10 @@ struct alignas(SANITIZER_CACHE_LINE_SIZE) ThreadState {
236		236
237	const ReportDesc *current_report;	237	const ReportDesc *current_report;
238		238
		239	#if SANITIZER_APPLE && !SANITIZER_GO
		240	bool in_internal_write_call;
		241	#endif
		242
239	explicit ThreadState(Tid tid);	243	explicit ThreadState(Tid tid);
240	};	244	};
241		245
...	@@ -420,6 +424,7 @@ class ScopedReportBase {	...	@@ -420,6 +424,7 @@ class ScopedReportBase {
420	void AddSleep(StackID stack_id);	424	void AddSleep(StackID stack_id);
421	void SetCount(int count);	425	void SetCount(int count);
422	void SetSigNum(int sig);	426	void SetSigNum(int sig);
		427	void SymbolizeStackElems(void);
423		428
424	const ReportDesc *GetReport() const;	429	const ReportDesc *GetReport() const;
425		430
...	@@ -498,7 +503,7 @@ void ForkChildAfter(ThreadState *thr, uptr pc, bool start_thread);	...	@@ -498,7 +503,7 @@ void ForkChildAfter(ThreadState *thr, uptr pc, bool start_thread);
498		503
499	void ReportRace(ThreadState thr, RawShadow shadow_mem, Shadow cur, Shadow old,	504	void ReportRace(ThreadState thr, RawShadow shadow_mem, Shadow cur, Shadow old,
500	AccessType typ);	505	AccessType typ);
501	bool OutputReport(ThreadState *thr, const ScopedReport &srep);	506	bool OutputReport(ThreadState *thr, ScopedReport &srep);
502	bool IsFiredSuppression(Context *ctx, ReportType type, StackTrace trace);	507	bool IsFiredSuppression(Context *ctx, ReportType type, StackTrace trace);
503	bool IsExpectedReport(uptr addr, uptr size);	508	bool IsExpectedReport(uptr addr, uptr size);
504		509
...	@@ -559,7 +564,7 @@ void ThreadIgnoreSyncBegin(ThreadState *thr, uptr pc);	...	@@ -559,7 +564,7 @@ void ThreadIgnoreSyncBegin(ThreadState *thr, uptr pc);
559	void ThreadIgnoreSyncEnd(ThreadState *thr);	564	void ThreadIgnoreSyncEnd(ThreadState *thr);
560		565
561	Tid ThreadCreate(ThreadState *thr, uptr pc, uptr uid, bool detached);	566	Tid ThreadCreate(ThreadState *thr, uptr pc, uptr uid, bool detached);
562	void ThreadStart(ThreadState *thr, Tid tid, tid_t os_id,	567	void ThreadStart(ThreadState *thr, Tid tid, ThreadID os_id,
563	ThreadType thread_type);	568	ThreadType thread_type);
564	void ThreadFinish(ThreadState *thr);	569	void ThreadFinish(ThreadState *thr);
565	Tid ThreadConsumeTid(ThreadState *thr, uptr pc, uptr uid);	570	Tid ThreadConsumeTid(ThreadState *thr, uptr pc, uptr uid);

libtsan: update to LLVM 22