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
) {
82 return swift_demangle_f(name
, internal_strlen(name
), 0, 0, 0);
87 const char *DemangleSwiftAndCXX(const char *name
) {
88 if (!name
) return nullptr;
89 if (const char *swift_demangled_name
= DemangleSwift(name
))
90 return swift_demangled_name
;
91 return DemangleCXXABI(name
);
94 static bool CreateTwoHighNumberedPipes(int *infd_
, int *outfd_
) {
97 // The client program may close its stdin and/or stdout and/or stderr
98 // thus allowing socketpair to reuse file descriptors 0, 1 or 2.
99 // In this case the communication between the forked processes may be
100 // broken if either the parent or the child tries to close or duplicate
101 // these descriptors. The loop below produces two pairs of file
102 // descriptors, each greater than 2 (stderr).
104 for (int i
= 0; i
< 5; i
++) {
105 if (pipe(sock_pair
[i
]) == -1) {
106 for (int j
= 0; j
< i
; j
++) {
107 internal_close(sock_pair
[j
][0]);
108 internal_close(sock_pair
[j
][1]);
111 } else if (sock_pair
[i
][0] > 2 && sock_pair
[i
][1] > 2) {
115 outfd
= sock_pair
[i
];
116 for (int j
= 0; j
< i
; j
++) {
117 if (sock_pair
[j
] == infd
) continue;
118 internal_close(sock_pair
[j
][0]);
119 internal_close(sock_pair
[j
][1]);
129 outfd_
[0] = outfd
[0];
130 outfd_
[1] = outfd
[1];
134 bool SymbolizerProcess::StartSymbolizerSubprocess() {
135 if (!FileExists(path_
)) {
136 if (!reported_invalid_path_
) {
137 Report("WARNING: invalid path to external symbolizer!\n");
138 reported_invalid_path_
= true;
143 const char *argv
[kArgVMax
];
144 GetArgV(path_
, argv
);
147 // Report how symbolizer is being launched for debugging purposes.
148 if (Verbosity() >= 3) {
149 // Only use `Report` for first line so subsequent prints don't get prefixed
151 Report("Launching Symbolizer process: ");
152 for (unsigned index
= 0; index
< kArgVMax
&& argv
[index
]; ++index
)
153 Printf("%s ", argv
[index
]);
157 if (use_posix_spawn_
) {
159 fd_t fd
= internal_spawn(argv
, const_cast<const char **>(GetEnvP()), &pid
);
160 if (fd
== kInvalidFd
) {
161 Report("WARNING: failed to spawn external symbolizer (errno: %d)\n",
168 #else // SANITIZER_MAC
170 #endif // SANITIZER_MAC
172 fd_t infd
[2] = {}, outfd
[2] = {};
173 if (!CreateTwoHighNumberedPipes(infd
, outfd
)) {
174 Report("WARNING: Can't create a socket pair to start "
175 "external symbolizer (errno: %d)\n", errno
);
179 pid
= StartSubprocess(path_
, argv
, GetEnvP(), /* stdin */ outfd
[0],
180 /* stdout */ infd
[1]);
182 internal_close(infd
[0]);
183 internal_close(outfd
[1]);
188 output_fd_
= outfd
[1];
193 // Check that symbolizer subprocess started successfully.
194 SleepForMillis(kSymbolizerStartupTimeMillis
);
195 if (!IsProcessRunning(pid
)) {
196 // Either waitpid failed, or child has already exited.
197 Report("WARNING: external symbolizer didn't start up correctly!\n");
204 class Addr2LineProcess final
: public SymbolizerProcess
{
206 Addr2LineProcess(const char *path
, const char *module_name
)
207 : SymbolizerProcess(path
), module_name_(internal_strdup(module_name
)) {}
209 const char *module_name() const { return module_name_
; }
212 void GetArgV(const char *path_to_binary
,
213 const char *(&argv
)[kArgVMax
]) const override
{
215 argv
[i
++] = path_to_binary
;
217 argv
[i
++] = module_name_
;
221 bool ReachedEndOfOutput(const char *buffer
, uptr length
) const override
;
223 bool ReadFromSymbolizer(char *buffer
, uptr max_length
) override
{
224 if (!SymbolizerProcess::ReadFromSymbolizer(buffer
, max_length
))
226 // The returned buffer is empty when output is valid, but exceeds
230 // We should cut out output_terminator_ at the end of given buffer,
231 // appended by addr2line to mark the end of its meaningful output.
232 // We cannot scan buffer from it's beginning, because it is legal for it
233 // to start with output_terminator_ in case given offset is invalid. So,
234 // scanning from second character.
235 char *garbage
= internal_strstr(buffer
+ 1, output_terminator_
);
236 // This should never be NULL since buffer must end up with
237 // output_terminator_.
244 const char *module_name_
; // Owned, leaked.
245 static const char output_terminator_
[];
248 const char Addr2LineProcess::output_terminator_
[] = "??\n??:0\n";
250 bool Addr2LineProcess::ReachedEndOfOutput(const char *buffer
,
252 const size_t kTerminatorLen
= sizeof(output_terminator_
) - 1;
253 // Skip, if we read just kTerminatorLen bytes, because Addr2Line output
254 // should consist at least of two pairs of lines:
255 // 1. First one, corresponding to given offset to be symbolized
256 // (may be equal to output_terminator_, if offset is not valid).
257 // 2. Second one for output_terminator_, itself to mark the end of output.
258 if (length
<= kTerminatorLen
) return false;
259 // Addr2Line output should end up with output_terminator_.
260 return !internal_memcmp(buffer
+ length
- kTerminatorLen
,
261 output_terminator_
, kTerminatorLen
);
264 class Addr2LinePool final
: public SymbolizerTool
{
266 explicit Addr2LinePool(const char *addr2line_path
,
267 LowLevelAllocator
*allocator
)
268 : addr2line_path_(addr2line_path
), allocator_(allocator
) {
269 addr2line_pool_
.reserve(16);
272 bool SymbolizePC(uptr addr
, SymbolizedStack
*stack
) override
{
273 if (const char *buf
=
274 SendCommand(stack
->info
.module
, stack
->info
.module_offset
)) {
275 ParseSymbolizePCOutput(buf
, stack
);
281 bool SymbolizeData(uptr addr
, DataInfo
*info
) override
{
286 const char *SendCommand(const char *module_name
, uptr module_offset
) {
287 Addr2LineProcess
*addr2line
= 0;
288 for (uptr i
= 0; i
< addr2line_pool_
.size(); ++i
) {
290 internal_strcmp(module_name
, addr2line_pool_
[i
]->module_name())) {
291 addr2line
= addr2line_pool_
[i
];
297 new(*allocator_
) Addr2LineProcess(addr2line_path_
, module_name
);
298 addr2line_pool_
.push_back(addr2line
);
300 CHECK_EQ(0, internal_strcmp(module_name
, addr2line
->module_name()));
301 char buffer
[kBufferSize
];
302 internal_snprintf(buffer
, kBufferSize
, "0x%zx\n0x%zx\n",
303 module_offset
, dummy_address_
);
304 return addr2line
->SendCommand(buffer
);
307 static const uptr kBufferSize
= 64;
308 const char *addr2line_path_
;
309 LowLevelAllocator
*allocator_
;
310 InternalMmapVector
<Addr2LineProcess
*> addr2line_pool_
;
311 static const uptr dummy_address_
=
312 FIRST_32_SECOND_64(UINT32_MAX
, UINT64_MAX
);
315 #if SANITIZER_SUPPORTS_WEAK_HOOKS
317 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
bool
318 __sanitizer_symbolize_code(const char *ModuleName
, u64 ModuleOffset
,
319 char *Buffer
, int MaxLength
,
320 bool SymbolizeInlineFrames
);
321 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
322 bool __sanitizer_symbolize_data(const char *ModuleName
, u64 ModuleOffset
,
323 char *Buffer
, int MaxLength
);
324 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
325 void __sanitizer_symbolize_flush();
326 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
327 int __sanitizer_symbolize_demangle(const char *Name
, char *Buffer
,
331 class InternalSymbolizer final
: public SymbolizerTool
{
333 static InternalSymbolizer
*get(LowLevelAllocator
*alloc
) {
334 if (__sanitizer_symbolize_code
!= 0 &&
335 __sanitizer_symbolize_data
!= 0) {
336 return new(*alloc
) InternalSymbolizer();
341 bool SymbolizePC(uptr addr
, SymbolizedStack
*stack
) override
{
342 bool result
= __sanitizer_symbolize_code(
343 stack
->info
.module
, stack
->info
.module_offset
, buffer_
, kBufferSize
,
344 common_flags()->symbolize_inline_frames
);
345 if (result
) ParseSymbolizePCOutput(buffer_
, stack
);
349 bool SymbolizeData(uptr addr
, DataInfo
*info
) override
{
350 bool result
= __sanitizer_symbolize_data(info
->module
, info
->module_offset
,
351 buffer_
, kBufferSize
);
353 ParseSymbolizeDataOutput(buffer_
, info
);
354 info
->start
+= (addr
- info
->module_offset
); // Add the base address.
359 void Flush() override
{
360 if (__sanitizer_symbolize_flush
)
361 __sanitizer_symbolize_flush();
364 const char *Demangle(const char *name
) override
{
365 if (__sanitizer_symbolize_demangle
) {
366 for (uptr res_length
= 1024;
367 res_length
<= InternalSizeClassMap::kMaxSize
;) {
368 char *res_buff
= static_cast<char*>(InternalAlloc(res_length
));
370 __sanitizer_symbolize_demangle(name
, res_buff
, res_length
);
371 if (req_length
> res_length
) {
372 res_length
= req_length
+ 1;
373 InternalFree(res_buff
);
383 InternalSymbolizer() { }
385 static const int kBufferSize
= 16 * 1024;
386 char buffer_
[kBufferSize
];
388 #else // SANITIZER_SUPPORTS_WEAK_HOOKS
390 class InternalSymbolizer final
: public SymbolizerTool
{
392 static InternalSymbolizer
*get(LowLevelAllocator
*alloc
) { return 0; }
395 #endif // SANITIZER_SUPPORTS_WEAK_HOOKS
397 const char *Symbolizer::PlatformDemangle(const char *name
) {
398 return DemangleSwiftAndCXX(name
);
401 static SymbolizerTool
*ChooseExternalSymbolizer(LowLevelAllocator
*allocator
) {
402 const char *path
= common_flags()->external_symbolizer_path
;
404 if (path
&& internal_strchr(path
, '%')) {
405 char *new_path
= (char *)InternalAlloc(kMaxPathLength
);
406 SubstituteForFlagValue(path
, new_path
, kMaxPathLength
);
410 const char *binary_name
= path
? StripModuleName(path
) : "";
411 static const char kLLVMSymbolizerPrefix
[] = "llvm-symbolizer";
412 if (path
&& path
[0] == '\0') {
413 VReport(2, "External symbolizer is explicitly disabled.\n");
415 } else if (!internal_strncmp(binary_name
, kLLVMSymbolizerPrefix
,
416 internal_strlen(kLLVMSymbolizerPrefix
))) {
417 VReport(2, "Using llvm-symbolizer at user-specified path: %s\n", path
);
418 return new(*allocator
) LLVMSymbolizer(path
, allocator
);
419 } else if (!internal_strcmp(binary_name
, "atos")) {
421 VReport(2, "Using atos at user-specified path: %s\n", path
);
422 return new(*allocator
) AtosSymbolizer(path
, allocator
);
423 #else // SANITIZER_MAC
424 Report("ERROR: Using `atos` is only supported on Darwin.\n");
426 #endif // SANITIZER_MAC
427 } else if (!internal_strcmp(binary_name
, "addr2line")) {
428 VReport(2, "Using addr2line at user-specified path: %s\n", path
);
429 return new(*allocator
) Addr2LinePool(path
, allocator
);
431 Report("ERROR: External symbolizer path is set to '%s' which isn't "
432 "a known symbolizer. Please set the path to the llvm-symbolizer "
433 "binary or other known tool.\n", path
);
437 // Otherwise symbolizer program is unknown, let's search $PATH
438 CHECK(path
== nullptr);
440 if (const char *found_path
= FindPathToBinary("atos")) {
441 VReport(2, "Using atos found at: %s\n", found_path
);
442 return new(*allocator
) AtosSymbolizer(found_path
, allocator
);
444 #endif // SANITIZER_MAC
445 if (const char *found_path
= FindPathToBinary("llvm-symbolizer")) {
446 VReport(2, "Using llvm-symbolizer found at: %s\n", found_path
);
447 return new(*allocator
) LLVMSymbolizer(found_path
, allocator
);
449 if (common_flags()->allow_addr2line
) {
450 if (const char *found_path
= FindPathToBinary("addr2line")) {
451 VReport(2, "Using addr2line found at: %s\n", found_path
);
452 return new(*allocator
) Addr2LinePool(found_path
, allocator
);
458 static void ChooseSymbolizerTools(IntrusiveList
<SymbolizerTool
> *list
,
459 LowLevelAllocator
*allocator
) {
460 if (!common_flags()->symbolize
) {
461 VReport(2, "Symbolizer is disabled.\n");
464 if (IsAllocatorOutOfMemory()) {
465 VReport(2, "Cannot use internal symbolizer: out of memory\n");
466 } else if (SymbolizerTool
*tool
= InternalSymbolizer::get(allocator
)) {
467 VReport(2, "Using internal symbolizer.\n");
468 list
->push_back(tool
);
471 if (SymbolizerTool
*tool
= LibbacktraceSymbolizer::get(allocator
)) {
472 VReport(2, "Using libbacktrace symbolizer.\n");
473 list
->push_back(tool
);
477 if (SymbolizerTool
*tool
= ChooseExternalSymbolizer(allocator
)) {
478 list
->push_back(tool
);
482 VReport(2, "Using dladdr symbolizer.\n");
483 list
->push_back(new(*allocator
) DlAddrSymbolizer());
484 #endif // SANITIZER_MAC
487 Symbolizer
*Symbolizer::PlatformInit() {
488 IntrusiveList
<SymbolizerTool
> list
;
490 ChooseSymbolizerTools(&list
, &symbolizer_allocator_
);
491 return new(symbolizer_allocator_
) Symbolizer(list
);
494 void Symbolizer::LateInitialize() {
495 Symbolizer::GetOrInit()->LateInitializeTools();
496 InitializeSwiftDemangler();
499 } // namespace __sanitizer
501 #endif // SANITIZER_POSIX