1 //===-- sanitizer_symbolizer_posix_libcdep.cpp ----------------------------===//
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
7 //===----------------------------------------------------------------------===//
9 // This file is shared between AddressSanitizer and ThreadSanitizer
10 // run-time libraries.
11 // POSIX-specific implementation of symbolizer parts.
12 //===----------------------------------------------------------------------===//
14 #include "sanitizer_platform.h"
16 #include "sanitizer_allocator_internal.h"
17 #include "sanitizer_common.h"
18 #include "sanitizer_file.h"
19 #include "sanitizer_flags.h"
20 #include "sanitizer_internal_defs.h"
21 #include "sanitizer_linux.h"
22 #include "sanitizer_placement_new.h"
23 #include "sanitizer_posix.h"
24 #include "sanitizer_procmaps.h"
25 #include "sanitizer_symbolizer_internal.h"
26 #include "sanitizer_symbolizer_libbacktrace.h"
27 #include "sanitizer_symbolizer_mac.h"
29 #include <dlfcn.h> // for dlsym()
36 // C++ demangling function, as required by Itanium C++ ABI. This is weak,
37 // because we do not require a C++ ABI library to be linked to a program
38 // using sanitizers; if it's not present, we'll just use the mangled name.
39 namespace __cxxabiv1
{
40 extern "C" SANITIZER_WEAK_ATTRIBUTE
41 char *__cxa_demangle(const char *mangled
, char *buffer
,
42 size_t *length
, int *status
);
45 namespace __sanitizer
{
47 // Attempts to demangle the name via __cxa_demangle from __cxxabiv1.
48 const char *DemangleCXXABI(const char *name
) {
49 // FIXME: __cxa_demangle aggressively insists on allocating memory.
50 // There's not much we can do about that, short of providing our
51 // own demangler (libc++abi's implementation could be adapted so that
52 // it does not allocate). For now, we just call it anyway, and we leak
53 // the returned value.
54 if (&__cxxabiv1::__cxa_demangle
)
55 if (const char *demangled_name
=
56 __cxxabiv1::__cxa_demangle(name
, 0, 0, 0))
57 return demangled_name
;
62 // As of now, there are no headers for the Swift runtime. Once they are
63 // present, we will weakly link since we do not require Swift runtime to be
65 typedef char *(*swift_demangle_ft
)(const char *mangledName
,
66 size_t mangledNameLength
, char *outputBuffer
,
67 size_t *outputBufferSize
, uint32_t flags
);
68 static swift_demangle_ft swift_demangle_f
;
70 // This must not happen lazily at symbolication time, because dlsym uses
71 // malloc and thread-local storage, which is not a good thing to do during
73 static void InitializeSwiftDemangler() {
74 swift_demangle_f
= (swift_demangle_ft
)dlsym(RTLD_DEFAULT
, "swift_demangle");
75 (void)dlerror(); // Cleanup error message in case of failure
78 // Attempts to demangle a Swift name. The demangler will return nullptr if a
79 // non-Swift name is passed in.
80 const char *DemangleSwift(const char *name
) {
81 if (!name
) return nullptr;
83 // Check if we are dealing with a Swift mangled name first.
84 if (name
[0] != '_' || name
[1] != 'T') {
89 return swift_demangle_f(name
, internal_strlen(name
), 0, 0, 0);
94 const char *DemangleSwiftAndCXX(const char *name
) {
95 if (!name
) return nullptr;
96 if (const char *swift_demangled_name
= DemangleSwift(name
))
97 return swift_demangled_name
;
98 return DemangleCXXABI(name
);
101 static bool CreateTwoHighNumberedPipes(int *infd_
, int *outfd_
) {
104 // The client program may close its stdin and/or stdout and/or stderr
105 // thus allowing socketpair to reuse file descriptors 0, 1 or 2.
106 // In this case the communication between the forked processes may be
107 // broken if either the parent or the child tries to close or duplicate
108 // these descriptors. The loop below produces two pairs of file
109 // descriptors, each greater than 2 (stderr).
111 for (int i
= 0; i
< 5; i
++) {
112 if (pipe(sock_pair
[i
]) == -1) {
113 for (int j
= 0; j
< i
; j
++) {
114 internal_close(sock_pair
[j
][0]);
115 internal_close(sock_pair
[j
][1]);
118 } else if (sock_pair
[i
][0] > 2 && sock_pair
[i
][1] > 2) {
122 outfd
= sock_pair
[i
];
123 for (int j
= 0; j
< i
; j
++) {
124 if (sock_pair
[j
] == infd
) continue;
125 internal_close(sock_pair
[j
][0]);
126 internal_close(sock_pair
[j
][1]);
136 outfd_
[0] = outfd
[0];
137 outfd_
[1] = outfd
[1];
141 bool SymbolizerProcess::StartSymbolizerSubprocess() {
142 if (!FileExists(path_
)) {
143 if (!reported_invalid_path_
) {
144 Report("WARNING: invalid path to external symbolizer!\n");
145 reported_invalid_path_
= true;
150 const char *argv
[kArgVMax
];
151 GetArgV(path_
, argv
);
154 // Report how symbolizer is being launched for debugging purposes.
155 if (Verbosity() >= 3) {
156 // Only use `Report` for first line so subsequent prints don't get prefixed
158 Report("Launching Symbolizer process: ");
159 for (unsigned index
= 0; index
< kArgVMax
&& argv
[index
]; ++index
)
160 Printf("%s ", argv
[index
]);
164 if (use_posix_spawn_
) {
166 fd_t fd
= internal_spawn(argv
, const_cast<const char **>(GetEnvP()), &pid
);
167 if (fd
== kInvalidFd
) {
168 Report("WARNING: failed to spawn external symbolizer (errno: %d)\n",
175 #else // SANITIZER_MAC
177 #endif // SANITIZER_MAC
179 fd_t infd
[2] = {}, outfd
[2] = {};
180 if (!CreateTwoHighNumberedPipes(infd
, outfd
)) {
181 Report("WARNING: Can't create a socket pair to start "
182 "external symbolizer (errno: %d)\n", errno
);
186 pid
= StartSubprocess(path_
, argv
, GetEnvP(), /* stdin */ outfd
[0],
187 /* stdout */ infd
[1]);
189 internal_close(infd
[0]);
190 internal_close(outfd
[1]);
195 output_fd_
= outfd
[1];
200 // Check that symbolizer subprocess started successfully.
201 SleepForMillis(kSymbolizerStartupTimeMillis
);
202 if (!IsProcessRunning(pid
)) {
203 // Either waitpid failed, or child has already exited.
204 Report("WARNING: external symbolizer didn't start up correctly!\n");
211 class Addr2LineProcess
: public SymbolizerProcess
{
213 Addr2LineProcess(const char *path
, const char *module_name
)
214 : SymbolizerProcess(path
), module_name_(internal_strdup(module_name
)) {}
216 const char *module_name() const { return module_name_
; }
219 void GetArgV(const char *path_to_binary
,
220 const char *(&argv
)[kArgVMax
]) const override
{
222 argv
[i
++] = path_to_binary
;
224 argv
[i
++] = module_name_
;
228 bool ReachedEndOfOutput(const char *buffer
, uptr length
) const override
;
230 bool ReadFromSymbolizer(char *buffer
, uptr max_length
) override
{
231 if (!SymbolizerProcess::ReadFromSymbolizer(buffer
, max_length
))
233 // The returned buffer is empty when output is valid, but exceeds
237 // We should cut out output_terminator_ at the end of given buffer,
238 // appended by addr2line to mark the end of its meaningful output.
239 // We cannot scan buffer from it's beginning, because it is legal for it
240 // to start with output_terminator_ in case given offset is invalid. So,
241 // scanning from second character.
242 char *garbage
= internal_strstr(buffer
+ 1, output_terminator_
);
243 // This should never be NULL since buffer must end up with
244 // output_terminator_.
251 const char *module_name_
; // Owned, leaked.
252 static const char output_terminator_
[];
255 const char Addr2LineProcess::output_terminator_
[] = "??\n??:0\n";
257 bool Addr2LineProcess::ReachedEndOfOutput(const char *buffer
,
259 const size_t kTerminatorLen
= sizeof(output_terminator_
) - 1;
260 // Skip, if we read just kTerminatorLen bytes, because Addr2Line output
261 // should consist at least of two pairs of lines:
262 // 1. First one, corresponding to given offset to be symbolized
263 // (may be equal to output_terminator_, if offset is not valid).
264 // 2. Second one for output_terminator_, itself to mark the end of output.
265 if (length
<= kTerminatorLen
) return false;
266 // Addr2Line output should end up with output_terminator_.
267 return !internal_memcmp(buffer
+ length
- kTerminatorLen
,
268 output_terminator_
, kTerminatorLen
);
271 class Addr2LinePool
: public SymbolizerTool
{
273 explicit Addr2LinePool(const char *addr2line_path
,
274 LowLevelAllocator
*allocator
)
275 : addr2line_path_(addr2line_path
), allocator_(allocator
) {
276 addr2line_pool_
.reserve(16);
279 bool SymbolizePC(uptr addr
, SymbolizedStack
*stack
) override
{
280 if (const char *buf
=
281 SendCommand(stack
->info
.module
, stack
->info
.module_offset
)) {
282 ParseSymbolizePCOutput(buf
, stack
);
288 bool SymbolizeData(uptr addr
, DataInfo
*info
) override
{
293 const char *SendCommand(const char *module_name
, uptr module_offset
) {
294 Addr2LineProcess
*addr2line
= 0;
295 for (uptr i
= 0; i
< addr2line_pool_
.size(); ++i
) {
297 internal_strcmp(module_name
, addr2line_pool_
[i
]->module_name())) {
298 addr2line
= addr2line_pool_
[i
];
304 new(*allocator_
) Addr2LineProcess(addr2line_path_
, module_name
);
305 addr2line_pool_
.push_back(addr2line
);
307 CHECK_EQ(0, internal_strcmp(module_name
, addr2line
->module_name()));
308 char buffer
[kBufferSize
];
309 internal_snprintf(buffer
, kBufferSize
, "0x%zx\n0x%zx\n",
310 module_offset
, dummy_address_
);
311 return addr2line
->SendCommand(buffer
);
314 static const uptr kBufferSize
= 64;
315 const char *addr2line_path_
;
316 LowLevelAllocator
*allocator_
;
317 InternalMmapVector
<Addr2LineProcess
*> addr2line_pool_
;
318 static const uptr dummy_address_
=
319 FIRST_32_SECOND_64(UINT32_MAX
, UINT64_MAX
);
322 #if SANITIZER_SUPPORTS_WEAK_HOOKS
324 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
325 bool __sanitizer_symbolize_code(const char *ModuleName
, u64 ModuleOffset
,
326 char *Buffer
, int MaxLength
);
327 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
328 bool __sanitizer_symbolize_data(const char *ModuleName
, u64 ModuleOffset
,
329 char *Buffer
, int MaxLength
);
330 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
331 void __sanitizer_symbolize_flush();
332 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
333 int __sanitizer_symbolize_demangle(const char *Name
, char *Buffer
,
337 class InternalSymbolizer
: public SymbolizerTool
{
339 static InternalSymbolizer
*get(LowLevelAllocator
*alloc
) {
340 if (__sanitizer_symbolize_code
!= 0 &&
341 __sanitizer_symbolize_data
!= 0) {
342 return new(*alloc
) InternalSymbolizer();
347 bool SymbolizePC(uptr addr
, SymbolizedStack
*stack
) override
{
348 bool result
= __sanitizer_symbolize_code(
349 stack
->info
.module
, stack
->info
.module_offset
, buffer_
, kBufferSize
);
350 if (result
) ParseSymbolizePCOutput(buffer_
, stack
);
354 bool SymbolizeData(uptr addr
, DataInfo
*info
) override
{
355 bool result
= __sanitizer_symbolize_data(info
->module
, info
->module_offset
,
356 buffer_
, kBufferSize
);
358 ParseSymbolizeDataOutput(buffer_
, info
);
359 info
->start
+= (addr
- info
->module_offset
); // Add the base address.
364 void Flush() override
{
365 if (__sanitizer_symbolize_flush
)
366 __sanitizer_symbolize_flush();
369 const char *Demangle(const char *name
) override
{
370 if (__sanitizer_symbolize_demangle
) {
371 for (uptr res_length
= 1024;
372 res_length
<= InternalSizeClassMap::kMaxSize
;) {
373 char *res_buff
= static_cast<char*>(InternalAlloc(res_length
));
375 __sanitizer_symbolize_demangle(name
, res_buff
, res_length
);
376 if (req_length
> res_length
) {
377 res_length
= req_length
+ 1;
378 InternalFree(res_buff
);
388 InternalSymbolizer() { }
390 static const int kBufferSize
= 16 * 1024;
391 char buffer_
[kBufferSize
];
393 #else // SANITIZER_SUPPORTS_WEAK_HOOKS
395 class InternalSymbolizer
: public SymbolizerTool
{
397 static InternalSymbolizer
*get(LowLevelAllocator
*alloc
) { return 0; }
400 #endif // SANITIZER_SUPPORTS_WEAK_HOOKS
402 const char *Symbolizer::PlatformDemangle(const char *name
) {
403 return DemangleSwiftAndCXX(name
);
406 static SymbolizerTool
*ChooseExternalSymbolizer(LowLevelAllocator
*allocator
) {
407 const char *path
= common_flags()->external_symbolizer_path
;
408 const char *binary_name
= path
? StripModuleName(path
) : "";
409 if (path
&& path
[0] == '\0') {
410 VReport(2, "External symbolizer is explicitly disabled.\n");
412 } else if (!internal_strcmp(binary_name
, "llvm-symbolizer")) {
413 VReport(2, "Using llvm-symbolizer at user-specified path: %s\n", path
);
414 return new(*allocator
) LLVMSymbolizer(path
, allocator
);
415 } else if (!internal_strcmp(binary_name
, "atos")) {
417 VReport(2, "Using atos at user-specified path: %s\n", path
);
418 return new(*allocator
) AtosSymbolizer(path
, allocator
);
419 #else // SANITIZER_MAC
420 Report("ERROR: Using `atos` is only supported on Darwin.\n");
422 #endif // SANITIZER_MAC
423 } else if (!internal_strcmp(binary_name
, "addr2line")) {
424 VReport(2, "Using addr2line at user-specified path: %s\n", path
);
425 return new(*allocator
) Addr2LinePool(path
, allocator
);
427 Report("ERROR: External symbolizer path is set to '%s' which isn't "
428 "a known symbolizer. Please set the path to the llvm-symbolizer "
429 "binary or other known tool.\n", path
);
433 // Otherwise symbolizer program is unknown, let's search $PATH
434 CHECK(path
== nullptr);
436 if (const char *found_path
= FindPathToBinary("atos")) {
437 VReport(2, "Using atos found at: %s\n", found_path
);
438 return new(*allocator
) AtosSymbolizer(found_path
, allocator
);
440 #endif // SANITIZER_MAC
441 if (const char *found_path
= FindPathToBinary("llvm-symbolizer")) {
442 VReport(2, "Using llvm-symbolizer found at: %s\n", found_path
);
443 return new(*allocator
) LLVMSymbolizer(found_path
, allocator
);
445 if (common_flags()->allow_addr2line
) {
446 if (const char *found_path
= FindPathToBinary("addr2line")) {
447 VReport(2, "Using addr2line found at: %s\n", found_path
);
448 return new(*allocator
) Addr2LinePool(found_path
, allocator
);
454 static void ChooseSymbolizerTools(IntrusiveList
<SymbolizerTool
> *list
,
455 LowLevelAllocator
*allocator
) {
456 if (!common_flags()->symbolize
) {
457 VReport(2, "Symbolizer is disabled.\n");
460 if (IsAllocatorOutOfMemory()) {
461 VReport(2, "Cannot use internal symbolizer: out of memory\n");
462 } else if (SymbolizerTool
*tool
= InternalSymbolizer::get(allocator
)) {
463 VReport(2, "Using internal symbolizer.\n");
464 list
->push_back(tool
);
467 if (SymbolizerTool
*tool
= LibbacktraceSymbolizer::get(allocator
)) {
468 VReport(2, "Using libbacktrace symbolizer.\n");
469 list
->push_back(tool
);
473 if (SymbolizerTool
*tool
= ChooseExternalSymbolizer(allocator
)) {
474 list
->push_back(tool
);
478 VReport(2, "Using dladdr symbolizer.\n");
479 list
->push_back(new(*allocator
) DlAddrSymbolizer());
480 #endif // SANITIZER_MAC
483 Symbolizer
*Symbolizer::PlatformInit() {
484 IntrusiveList
<SymbolizerTool
> list
;
486 ChooseSymbolizerTools(&list
, &symbolizer_allocator_
);
487 return new(symbolizer_allocator_
) Symbolizer(list
);
490 void Symbolizer::LateInitialize() {
491 Symbolizer::GetOrInit()->LateInitializeTools();
492 InitializeSwiftDemangler();
495 } // namespace __sanitizer
497 #endif // SANITIZER_POSIX