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 <dlfcn.h> // for dlsym()
20 # include <sys/wait.h>
23 # include "sanitizer_allocator_internal.h"
24 # include "sanitizer_common.h"
25 # include "sanitizer_file.h"
26 # include "sanitizer_flags.h"
27 # include "sanitizer_internal_defs.h"
28 # include "sanitizer_linux.h"
29 # include "sanitizer_placement_new.h"
30 # include "sanitizer_posix.h"
31 # include "sanitizer_procmaps.h"
32 # include "sanitizer_symbolizer_internal.h"
33 # include "sanitizer_symbolizer_libbacktrace.h"
34 # include "sanitizer_symbolizer_mac.h"
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");
77 // Attempts to demangle a Swift name. The demangler will return nullptr if a
78 // non-Swift name is passed in.
79 const char *DemangleSwift(const char *name
) {
81 return swift_demangle_f(name
, internal_strlen(name
), 0, 0, 0);
86 const char *DemangleSwiftAndCXX(const char *name
) {
87 if (!name
) return nullptr;
88 if (const char *swift_demangled_name
= DemangleSwift(name
))
89 return swift_demangled_name
;
90 return DemangleCXXABI(name
);
93 static bool CreateTwoHighNumberedPipes(int *infd_
, int *outfd_
) {
96 // The client program may close its stdin and/or stdout and/or stderr
97 // thus allowing socketpair to reuse file descriptors 0, 1 or 2.
98 // In this case the communication between the forked processes may be
99 // broken if either the parent or the child tries to close or duplicate
100 // these descriptors. The loop below produces two pairs of file
101 // descriptors, each greater than 2 (stderr).
103 for (int i
= 0; i
< 5; i
++) {
104 if (pipe(sock_pair
[i
]) == -1) {
105 for (int j
= 0; j
< i
; j
++) {
106 internal_close(sock_pair
[j
][0]);
107 internal_close(sock_pair
[j
][1]);
110 } else if (sock_pair
[i
][0] > 2 && sock_pair
[i
][1] > 2) {
114 outfd
= sock_pair
[i
];
115 for (int j
= 0; j
< i
; j
++) {
116 if (sock_pair
[j
] == infd
) continue;
117 internal_close(sock_pair
[j
][0]);
118 internal_close(sock_pair
[j
][1]);
128 outfd_
[0] = outfd
[0];
129 outfd_
[1] = outfd
[1];
133 bool SymbolizerProcess::StartSymbolizerSubprocess() {
134 if (!FileExists(path_
)) {
135 if (!reported_invalid_path_
) {
136 Report("WARNING: invalid path to external symbolizer!\n");
137 reported_invalid_path_
= true;
142 const char *argv
[kArgVMax
];
143 GetArgV(path_
, argv
);
146 // Report how symbolizer is being launched for debugging purposes.
147 if (Verbosity() >= 3) {
148 // Only use `Report` for first line so subsequent prints don't get prefixed
150 Report("Launching Symbolizer process: ");
151 for (unsigned index
= 0; index
< kArgVMax
&& argv
[index
]; ++index
)
152 Printf("%s ", argv
[index
]);
156 if (use_posix_spawn_
) {
158 fd_t fd
= internal_spawn(argv
, const_cast<const char **>(GetEnvP()), &pid
);
159 if (fd
== kInvalidFd
) {
160 Report("WARNING: failed to spawn external symbolizer (errno: %d)\n",
167 #else // SANITIZER_APPLE
169 #endif // SANITIZER_APPLE
171 fd_t infd
[2] = {}, outfd
[2] = {};
172 if (!CreateTwoHighNumberedPipes(infd
, outfd
)) {
173 Report("WARNING: Can't create a socket pair to start "
174 "external symbolizer (errno: %d)\n", errno
);
178 pid
= StartSubprocess(path_
, argv
, GetEnvP(), /* stdin */ outfd
[0],
179 /* stdout */ infd
[1]);
181 internal_close(infd
[0]);
182 internal_close(outfd
[1]);
187 output_fd_
= outfd
[1];
192 // Check that symbolizer subprocess started successfully.
193 SleepForMillis(kSymbolizerStartupTimeMillis
);
194 if (!IsProcessRunning(pid
)) {
195 // Either waitpid failed, or child has already exited.
196 Report("WARNING: external symbolizer didn't start up correctly!\n");
203 class Addr2LineProcess final
: public SymbolizerProcess
{
205 Addr2LineProcess(const char *path
, const char *module_name
)
206 : SymbolizerProcess(path
), module_name_(internal_strdup(module_name
)) {}
208 const char *module_name() const { return module_name_
; }
211 void GetArgV(const char *path_to_binary
,
212 const char *(&argv
)[kArgVMax
]) const override
{
214 argv
[i
++] = path_to_binary
;
215 if (common_flags()->demangle
)
217 if (common_flags()->symbolize_inline_frames
)
220 argv
[i
++] = module_name_
;
222 CHECK_LE(i
, kArgVMax
);
225 bool ReachedEndOfOutput(const char *buffer
, uptr length
) const override
;
227 bool ReadFromSymbolizer() override
{
228 if (!SymbolizerProcess::ReadFromSymbolizer())
230 auto &buff
= GetBuff();
231 // We should cut out output_terminator_ at the end of given buffer,
232 // appended by addr2line to mark the end of its meaningful output.
233 // We cannot scan buffer from it's beginning, because it is legal for it
234 // to start with output_terminator_ in case given offset is invalid. So,
235 // scanning from second character.
236 char *garbage
= internal_strstr(buff
.data() + 1, output_terminator_
);
237 // This should never be NULL since buffer must end up with
238 // output_terminator_.
242 uintptr_t new_size
= garbage
- buff
.data();
243 GetBuff().resize(new_size
);
244 GetBuff().push_back('\0');
248 const char *module_name_
; // Owned, leaked.
249 static const char output_terminator_
[];
252 const char Addr2LineProcess::output_terminator_
[] = "??\n??:0\n";
254 bool Addr2LineProcess::ReachedEndOfOutput(const char *buffer
,
256 const size_t kTerminatorLen
= sizeof(output_terminator_
) - 1;
257 // Skip, if we read just kTerminatorLen bytes, because Addr2Line output
258 // should consist at least of two pairs of lines:
259 // 1. First one, corresponding to given offset to be symbolized
260 // (may be equal to output_terminator_, if offset is not valid).
261 // 2. Second one for output_terminator_, itself to mark the end of output.
262 if (length
<= kTerminatorLen
) return false;
263 // Addr2Line output should end up with output_terminator_.
264 return !internal_memcmp(buffer
+ length
- kTerminatorLen
,
265 output_terminator_
, kTerminatorLen
);
268 class Addr2LinePool final
: public SymbolizerTool
{
270 explicit Addr2LinePool(const char *addr2line_path
,
271 LowLevelAllocator
*allocator
)
272 : addr2line_path_(addr2line_path
), allocator_(allocator
) {
273 addr2line_pool_
.reserve(16);
276 bool SymbolizePC(uptr addr
, SymbolizedStack
*stack
) override
{
277 if (const char *buf
=
278 SendCommand(stack
->info
.module
, stack
->info
.module_offset
)) {
279 ParseSymbolizePCOutput(buf
, stack
);
285 bool SymbolizeData(uptr addr
, DataInfo
*info
) override
{
290 const char *SendCommand(const char *module_name
, uptr module_offset
) {
291 Addr2LineProcess
*addr2line
= 0;
292 for (uptr i
= 0; i
< addr2line_pool_
.size(); ++i
) {
294 internal_strcmp(module_name
, addr2line_pool_
[i
]->module_name())) {
295 addr2line
= addr2line_pool_
[i
];
301 new(*allocator_
) Addr2LineProcess(addr2line_path_
, module_name
);
302 addr2line_pool_
.push_back(addr2line
);
304 CHECK_EQ(0, internal_strcmp(module_name
, addr2line
->module_name()));
305 char buffer
[kBufferSize
];
306 internal_snprintf(buffer
, kBufferSize
, "0x%zx\n0x%zx\n",
307 module_offset
, dummy_address_
);
308 return addr2line
->SendCommand(buffer
);
311 static const uptr kBufferSize
= 64;
312 const char *addr2line_path_
;
313 LowLevelAllocator
*allocator_
;
314 InternalMmapVector
<Addr2LineProcess
*> addr2line_pool_
;
315 static const uptr dummy_address_
=
316 FIRST_32_SECOND_64(UINT32_MAX
, UINT64_MAX
);
319 # if SANITIZER_SUPPORTS_WEAK_HOOKS
321 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
bool
322 __sanitizer_symbolize_code(const char *ModuleName
, u64 ModuleOffset
,
323 char *Buffer
, int MaxLength
);
324 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
bool
325 __sanitizer_symbolize_data(const char *ModuleName
, u64 ModuleOffset
,
326 char *Buffer
, int MaxLength
);
327 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
bool
328 __sanitizer_symbolize_frame(const char *ModuleName
, u64 ModuleOffset
,
329 char *Buffer
, int MaxLength
);
330 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
void
331 __sanitizer_symbolize_flush();
332 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
bool
333 __sanitizer_symbolize_demangle(const char *Name
, char *Buffer
, int MaxLength
);
334 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
bool
335 __sanitizer_symbolize_set_demangle(bool Demangle
);
336 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
bool
337 __sanitizer_symbolize_set_inline_frames(bool InlineFrames
);
340 class InternalSymbolizer final
: public SymbolizerTool
{
342 static InternalSymbolizer
*get(LowLevelAllocator
*alloc
) {
343 if (&__sanitizer_symbolize_set_demangle
)
344 CHECK(__sanitizer_symbolize_set_demangle(common_flags()->demangle
));
345 if (&__sanitizer_symbolize_set_inline_frames
)
346 CHECK(__sanitizer_symbolize_set_inline_frames(
347 common_flags()->symbolize_inline_frames
));
348 // These are essential, we don't have InternalSymbolizer without them.
349 if (&__sanitizer_symbolize_code
&& &__sanitizer_symbolize_data
)
350 return new (*alloc
) InternalSymbolizer();
354 bool SymbolizePC(uptr addr
, SymbolizedStack
*stack
) override
{
355 bool result
= __sanitizer_symbolize_code(
356 stack
->info
.module
, stack
->info
.module_offset
, buffer_
, sizeof(buffer_
));
358 ParseSymbolizePCOutput(buffer_
, stack
);
362 bool SymbolizeData(uptr addr
, DataInfo
*info
) override
{
363 bool result
= __sanitizer_symbolize_data(info
->module
, info
->module_offset
,
364 buffer_
, sizeof(buffer_
));
366 ParseSymbolizeDataOutput(buffer_
, info
);
367 info
->start
+= (addr
- info
->module_offset
); // Add the base address.
372 bool SymbolizeFrame(uptr addr
, FrameInfo
*info
) override
{
373 if (&__sanitizer_symbolize_frame
== nullptr)
375 bool result
= __sanitizer_symbolize_frame(info
->module
, info
->module_offset
,
376 buffer_
, sizeof(buffer_
));
378 ParseSymbolizeFrameOutput(buffer_
, &info
->locals
);
382 void Flush() override
{
383 if (&__sanitizer_symbolize_flush
)
384 __sanitizer_symbolize_flush();
387 const char *Demangle(const char *name
) override
{
388 if (&__sanitizer_symbolize_demangle
&&
389 __sanitizer_symbolize_demangle(name
, buffer_
, sizeof(buffer_
))) {
390 char *res_buff
= nullptr;
391 ExtractToken(buffer_
, "", &res_buff
);
398 InternalSymbolizer() {}
400 char buffer_
[16 * 1024];
402 # else // SANITIZER_SUPPORTS_WEAK_HOOKS
404 class InternalSymbolizer final
: public SymbolizerTool
{
406 static InternalSymbolizer
*get(LowLevelAllocator
*alloc
) { return 0; }
409 # endif // SANITIZER_SUPPORTS_WEAK_HOOKS
411 const char *Symbolizer::PlatformDemangle(const char *name
) {
412 return DemangleSwiftAndCXX(name
);
415 static SymbolizerTool
*ChooseExternalSymbolizer(LowLevelAllocator
*allocator
) {
416 const char *path
= common_flags()->external_symbolizer_path
;
418 if (path
&& internal_strchr(path
, '%')) {
419 char *new_path
= (char *)InternalAlloc(kMaxPathLength
);
420 SubstituteForFlagValue(path
, new_path
, kMaxPathLength
);
424 const char *binary_name
= path
? StripModuleName(path
) : "";
425 static const char kLLVMSymbolizerPrefix
[] = "llvm-symbolizer";
426 if (path
&& path
[0] == '\0') {
427 VReport(2, "External symbolizer is explicitly disabled.\n");
429 } else if (!internal_strncmp(binary_name
, kLLVMSymbolizerPrefix
,
430 internal_strlen(kLLVMSymbolizerPrefix
))) {
431 VReport(2, "Using llvm-symbolizer at user-specified path: %s\n", path
);
432 return new(*allocator
) LLVMSymbolizer(path
, allocator
);
433 } else if (!internal_strcmp(binary_name
, "atos")) {
435 VReport(2, "Using atos at user-specified path: %s\n", path
);
436 return new(*allocator
) AtosSymbolizer(path
, allocator
);
437 #else // SANITIZER_APPLE
438 Report("ERROR: Using `atos` is only supported on Darwin.\n");
440 #endif // SANITIZER_APPLE
441 } else if (!internal_strcmp(binary_name
, "addr2line")) {
442 VReport(2, "Using addr2line at user-specified path: %s\n", path
);
443 return new(*allocator
) Addr2LinePool(path
, allocator
);
445 Report("ERROR: External symbolizer path is set to '%s' which isn't "
446 "a known symbolizer. Please set the path to the llvm-symbolizer "
447 "binary or other known tool.\n", path
);
451 // Otherwise symbolizer program is unknown, let's search $PATH
452 CHECK(path
== nullptr);
454 if (const char *found_path
= FindPathToBinary("atos")) {
455 VReport(2, "Using atos found at: %s\n", found_path
);
456 return new(*allocator
) AtosSymbolizer(found_path
, allocator
);
458 #endif // SANITIZER_APPLE
459 if (const char *found_path
= FindPathToBinary("llvm-symbolizer")) {
460 VReport(2, "Using llvm-symbolizer found at: %s\n", found_path
);
461 return new(*allocator
) LLVMSymbolizer(found_path
, allocator
);
463 if (common_flags()->allow_addr2line
) {
464 if (const char *found_path
= FindPathToBinary("addr2line")) {
465 VReport(2, "Using addr2line found at: %s\n", found_path
);
466 return new(*allocator
) Addr2LinePool(found_path
, allocator
);
472 static void ChooseSymbolizerTools(IntrusiveList
<SymbolizerTool
> *list
,
473 LowLevelAllocator
*allocator
) {
474 if (!common_flags()->symbolize
) {
475 VReport(2, "Symbolizer is disabled.\n");
478 if (IsAllocatorOutOfMemory()) {
479 VReport(2, "Cannot use internal symbolizer: out of memory\n");
480 } else if (SymbolizerTool
*tool
= InternalSymbolizer::get(allocator
)) {
481 VReport(2, "Using internal symbolizer.\n");
482 list
->push_back(tool
);
485 if (SymbolizerTool
*tool
= LibbacktraceSymbolizer::get(allocator
)) {
486 VReport(2, "Using libbacktrace symbolizer.\n");
487 list
->push_back(tool
);
491 if (SymbolizerTool
*tool
= ChooseExternalSymbolizer(allocator
)) {
492 list
->push_back(tool
);
496 VReport(2, "Using dladdr symbolizer.\n");
497 list
->push_back(new(*allocator
) DlAddrSymbolizer());
498 #endif // SANITIZER_APPLE
501 Symbolizer
*Symbolizer::PlatformInit() {
502 IntrusiveList
<SymbolizerTool
> list
;
504 ChooseSymbolizerTools(&list
, &symbolizer_allocator_
);
505 return new(symbolizer_allocator_
) Symbolizer(list
);
508 void Symbolizer::LateInitialize() {
509 Symbolizer::GetOrInit();
510 InitializeSwiftDemangler();
513 } // namespace __sanitizer
515 #endif // SANITIZER_POSIX