1//===-- sanitizer_symbolizer_libcdep.cpp ----------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file is shared between AddressSanitizer and ThreadSanitizer
10// run-time libraries.
11//===----------------------------------------------------------------------===//
12
13#include "sanitizer_allocator_internal.h"
14#include "sanitizer_internal_defs.h"
15#include "sanitizer_platform.h"
16#include "sanitizer_symbolizer_internal.h"
17
18namespace __sanitizer {
19
20Symbolizer *Symbolizer::GetOrInit() {
21 SpinMutexLock l(&init_mu_);
22 if (symbolizer_)
23 return symbolizer_;
24 symbolizer_ = PlatformInit();
25 CHECK(symbolizer_);
26 return symbolizer_;
27}
28
29// See sanitizer_symbolizer_markup.cpp.
30#if !SANITIZER_SYMBOLIZER_MARKUP
31
32const char *ExtractToken(const char *str, const char *delims, char **result) {
33 uptr prefix_len = internal_strcspn(s: str, reject: delims);
34 *result = (char *)InternalAlloc(size: prefix_len + 1);
35 internal_memcpy(dest: *result, src: str, n: prefix_len);
36 (*result)[prefix_len] = '\0';
37 const char *prefix_end = str + prefix_len;
38 if (*prefix_end != '\0')
39 prefix_end++;
40 return prefix_end;
41}
42
43const char *ExtractInt(const char *str, const char *delims, int *result) {
44 char *buff = nullptr;
45 const char *ret = ExtractToken(str, delims, result: &buff);
46 if (buff) {
47 *result = (int)internal_atoll(nptr: buff);
48 }
49 InternalFree(p: buff);
50 return ret;
51}
52
53const char *ExtractUptr(const char *str, const char *delims, uptr *result) {
54 char *buff = nullptr;
55 const char *ret = ExtractToken(str, delims, result: &buff);
56 if (buff) {
57 *result = (uptr)internal_atoll(nptr: buff);
58 }
59 InternalFree(p: buff);
60 return ret;
61}
62
63const char *ExtractSptr(const char *str, const char *delims, sptr *result) {
64 char *buff = nullptr;
65 const char *ret = ExtractToken(str, delims, result: &buff);
66 if (buff) {
67 *result = (sptr)internal_atoll(nptr: buff);
68 }
69 InternalFree(p: buff);
70 return ret;
71}
72
73const char *ExtractTokenUpToDelimiter(const char *str, const char *delimiter,
74 char **result) {
75 const char *found_delimiter = internal_strstr(haystack: str, needle: delimiter);
76 uptr prefix_len =
77 found_delimiter ? found_delimiter - str : internal_strlen(s: str);
78 *result = (char *)InternalAlloc(size: prefix_len + 1);
79 internal_memcpy(dest: *result, src: str, n: prefix_len);
80 (*result)[prefix_len] = '\0';
81 const char *prefix_end = str + prefix_len;
82 if (*prefix_end != '\0')
83 prefix_end += internal_strlen(s: delimiter);
84 return prefix_end;
85}
86
87SymbolizedStack *Symbolizer::SymbolizePC(uptr addr) {
88 Lock l(&mu_);
89 SymbolizedStack *res = SymbolizedStack::New(addr);
90 auto *mod = FindModuleForAddress(address: addr);
91 if (!mod)
92 return res;
93 // Always fill data about module name and offset.
94 res->info.FillModuleInfo(mod: *mod);
95 for (auto &tool : tools_) {
96 SymbolizerScope sym_scope(this);
97 if (tool.SymbolizePC(addr, stack: res)) {
98 return res;
99 }
100 }
101 return res;
102}
103
104SymbolizedStack* Symbolizer::SymbolizeModuleOffset(const char* module_name,
105 uptr module_offset) {
106 Lock l(&mu_);
107 SymbolizedStack* res = SymbolizedStack::New(addr: module_offset);
108 res->info.FillModuleInfo(mod_name: module_name, mod_offset: module_offset, arch: kModuleArchUnknown);
109 for (auto& tool : tools_) {
110 SymbolizerScope sym_scope(this);
111 if (tool.SymbolizePC(addr: module_offset, stack: res))
112 return res;
113 }
114 return res;
115}
116
117bool Symbolizer::SymbolizeModuleData(const char* module_name,
118 uptr module_offset, DataInfo* info) {
119 Lock l(&mu_);
120 info->Clear();
121 info->module = internal_strdup(s: module_name);
122 info->module_offset = module_offset;
123 info->module_arch = kModuleArchUnknown;
124 for (auto& tool : tools_) {
125 SymbolizerScope sym_scope(this);
126 if (tool.SymbolizeData(addr: module_offset, info))
127 return true;
128 }
129 return false;
130}
131
132bool Symbolizer::SymbolizeData(uptr addr, DataInfo *info) {
133 Lock l(&mu_);
134 const char *module_name = nullptr;
135 uptr module_offset;
136 ModuleArch arch;
137 if (!FindModuleNameAndOffsetForAddress(address: addr, module_name: &module_name, module_offset: &module_offset,
138 module_arch: &arch))
139 return false;
140 info->Clear();
141 info->module = internal_strdup(s: module_name);
142 info->module_offset = module_offset;
143 info->module_arch = arch;
144 for (auto &tool : tools_) {
145 SymbolizerScope sym_scope(this);
146 if (tool.SymbolizeData(addr, info)) {
147 return true;
148 }
149 }
150 return false;
151}
152
153bool Symbolizer::SymbolizeFrame(uptr addr, FrameInfo *info) {
154 Lock l(&mu_);
155 const char *module_name = nullptr;
156 if (!FindModuleNameAndOffsetForAddress(
157 address: addr, module_name: &module_name, module_offset: &info->module_offset, module_arch: &info->module_arch))
158 return false;
159 info->module = internal_strdup(s: module_name);
160 for (auto &tool : tools_) {
161 SymbolizerScope sym_scope(this);
162 if (tool.SymbolizeFrame(addr, info)) {
163 return true;
164 }
165 }
166 return false;
167}
168
169bool Symbolizer::GetModuleNameAndOffsetForPC(uptr pc, const char **module_name,
170 uptr *module_address) {
171 Lock l(&mu_);
172 const char *internal_module_name = nullptr;
173 ModuleArch arch;
174 if (!FindModuleNameAndOffsetForAddress(address: pc, module_name: &internal_module_name,
175 module_offset: module_address, module_arch: &arch))
176 return false;
177
178 if (module_name)
179 *module_name = module_names_.GetOwnedCopy(str: internal_module_name);
180 return true;
181}
182
183void Symbolizer::Flush() {
184 Lock l(&mu_);
185 for (auto &tool : tools_) {
186 SymbolizerScope sym_scope(this);
187 tool.Flush();
188 }
189}
190
191const char *Symbolizer::Demangle(const char *name) {
192 CHECK(name);
193 Lock l(&mu_);
194 for (auto &tool : tools_) {
195 SymbolizerScope sym_scope(this);
196 if (const char *demangled = tool.Demangle(name))
197 return demangled;
198 }
199 if (const char *demangled = PlatformDemangle(name))
200 return demangled;
201 return name;
202}
203
204bool Symbolizer::FindModuleNameAndOffsetForAddress(uptr address,
205 const char **module_name,
206 uptr *module_offset,
207 ModuleArch *module_arch) {
208 const LoadedModule *module = FindModuleForAddress(address);
209 if (!module)
210 return false;
211 *module_name = module->full_name();
212 *module_offset = address - module->base_address();
213 *module_arch = module->arch();
214 return true;
215}
216
217void Symbolizer::RefreshModules() {
218 modules_.init();
219 fallback_modules_.fallbackInit();
220 RAW_CHECK(modules_.size() > 0);
221 modules_fresh_ = true;
222}
223
224const ListOfModules &Symbolizer::GetRefreshedListOfModules() {
225 if (!modules_fresh_)
226 RefreshModules();
227
228 return modules_;
229}
230
231static const LoadedModule *SearchForModule(const ListOfModules &modules,
232 uptr address) {
233 for (uptr i = 0; i < modules.size(); i++) {
234 if (modules[i].containsAddress(address)) {
235 return &modules[i];
236 }
237 }
238 return nullptr;
239}
240
241const LoadedModule *Symbolizer::FindModuleForAddress(uptr address) {
242 bool modules_were_reloaded = false;
243 if (!modules_fresh_) {
244 RefreshModules();
245 modules_were_reloaded = true;
246 }
247 const LoadedModule *module = SearchForModule(modules: modules_, address);
248 if (module)
249 return module;
250
251 // dlopen/dlclose interceptors invalidate the module list, but when
252 // interception is disabled, we need to retry if the lookup fails in
253 // case the module list changed.
254# if !SANITIZER_INTERCEPT_DLOPEN_DLCLOSE
255 if (!modules_were_reloaded) {
256 RefreshModules();
257 module = SearchForModule(modules: modules_, address);
258 if (module)
259 return module;
260 }
261# endif
262
263 if (fallback_modules_.size()) {
264 module = SearchForModule(modules: fallback_modules_, address);
265 }
266 return module;
267}
268
269// For now we assume the following protocol:
270// For each request of the form
271// <module_name> <module_offset>
272// passed to STDIN, external symbolizer prints to STDOUT response:
273// <function_name>
274// <file_name>:<line_number>:<column_number>
275// <function_name>
276// <file_name>:<line_number>:<column_number>
277// ...
278// <empty line>
279class LLVMSymbolizerProcess final : public SymbolizerProcess {
280 public:
281 explicit LLVMSymbolizerProcess(const char *path)
282 : SymbolizerProcess(path, /*use_posix_spawn=*/SANITIZER_APPLE) {}
283
284 private:
285 bool ReachedEndOfOutput(const char *buffer, uptr length) const override {
286 // Empty line marks the end of llvm-symbolizer output.
287 return length >= 2 && buffer[length - 1] == '\n' &&
288 buffer[length - 2] == '\n';
289 }
290
291 // When adding a new architecture, don't forget to also update
292 // script/asan_symbolize.py and sanitizer_common.h.
293 void GetArgV(const char *path_to_binary,
294 const char *(&argv)[kArgVMax]) const override {
295# if defined(__x86_64h__)
296 const char *const kSymbolizerArch = "--default-arch=x86_64h";
297# elif defined(__x86_64__)
298 const char *const kSymbolizerArch = "--default-arch=x86_64";
299# elif defined(__i386__)
300 const char *const kSymbolizerArch = "--default-arch=i386";
301# elif SANITIZER_LOONGARCH64
302 const char *const kSymbolizerArch = "--default-arch=loongarch64";
303# elif SANITIZER_RISCV64
304 const char *const kSymbolizerArch = "--default-arch=riscv64";
305# elif defined(__aarch64__)
306 const char *const kSymbolizerArch = "--default-arch=arm64";
307# elif defined(__arm__)
308 const char *const kSymbolizerArch = "--default-arch=arm";
309# elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
310 const char *const kSymbolizerArch = "--default-arch=powerpc64";
311# elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
312 const char *const kSymbolizerArch = "--default-arch=powerpc64le";
313# elif defined(__s390x__)
314 const char *const kSymbolizerArch = "--default-arch=s390x";
315# elif defined(__s390__)
316 const char *const kSymbolizerArch = "--default-arch=s390";
317# else
318 const char *const kSymbolizerArch = "--default-arch=unknown";
319# endif
320
321 const char *const demangle_flag =
322 common_flags()->demangle ? "--demangle" : "--no-demangle";
323 const char *const inline_flag =
324 common_flags()->symbolize_inline_frames ? "--inlines" : "--no-inlines";
325 int i = 0;
326 argv[i++] = path_to_binary;
327 argv[i++] = demangle_flag;
328 argv[i++] = inline_flag;
329 argv[i++] = kSymbolizerArch;
330 argv[i++] = nullptr;
331 CHECK_LE(i, kArgVMax);
332 }
333};
334
335LLVMSymbolizer::LLVMSymbolizer(const char *path, LowLevelAllocator *allocator)
336 : symbolizer_process_(new(*allocator) LLVMSymbolizerProcess(path)) {}
337
338// Parse a <file>:<line>[:<column>] buffer. The file path may contain colons on
339// Windows, so extract tokens from the right hand side first. The column info is
340// also optional.
341static const char *ParseFileLineInfo(AddressInfo *info, const char *str) {
342 char *file_line_info = nullptr;
343 str = ExtractToken(str, delims: "\n", result: &file_line_info);
344 CHECK(file_line_info);
345
346 if (uptr size = internal_strlen(s: file_line_info)) {
347 char *back = file_line_info + size - 1;
348 for (int i = 0; i < 2; ++i) {
349 while (back > file_line_info && IsDigit(c: *back)) --back;
350 if (*back != ':' || !IsDigit(c: back[1]))
351 break;
352 info->column = info->line;
353 info->line = internal_atoll(nptr: back + 1);
354 // Truncate the string at the colon to keep only filename.
355 *back = '\0';
356 --back;
357 }
358 ExtractToken(str: file_line_info, delims: "", result: &info->file);
359 }
360
361 InternalFree(p: file_line_info);
362 return str;
363}
364
365// Parses one or more two-line strings in the following format:
366// <function_name>
367// <file_name>:<line_number>[:<column_number>]
368// Used by LLVMSymbolizer, Addr2LinePool and InternalSymbolizer, since all of
369// them use the same output format.
370void ParseSymbolizePCOutput(const char *str, SymbolizedStack *res) {
371 bool top_frame = true;
372 SymbolizedStack *last = res;
373 while (true) {
374 char *function_name = nullptr;
375 str = ExtractToken(str, delims: "\n", result: &function_name);
376 CHECK(function_name);
377 if (function_name[0] == '\0') {
378 // There are no more frames.
379 InternalFree(p: function_name);
380 break;
381 }
382 SymbolizedStack *cur;
383 if (top_frame) {
384 cur = res;
385 top_frame = false;
386 } else {
387 cur = SymbolizedStack::New(addr: res->info.address);
388 cur->info.FillModuleInfo(mod_name: res->info.module, mod_offset: res->info.module_offset,
389 arch: res->info.module_arch);
390 last->next = cur;
391 last = cur;
392 }
393
394 AddressInfo *info = &cur->info;
395 info->function = function_name;
396 str = ParseFileLineInfo(info, str);
397
398 // Functions and filenames can be "??", in which case we write 0
399 // to address info to mark that names are unknown.
400 if (0 == internal_strcmp(s1: info->function, s2: "??")) {
401 InternalFree(p: info->function);
402 info->function = 0;
403 }
404 if (info->file && 0 == internal_strcmp(s1: info->file, s2: "??")) {
405 InternalFree(p: info->file);
406 info->file = 0;
407 }
408 }
409}
410
411// Parses a two- or three-line string in the following format:
412// <symbol_name>
413// <start_address> <size>
414// <filename>:<column>
415// Used by LLVMSymbolizer and InternalSymbolizer. LLVMSymbolizer added support
416// for symbolizing the third line in D123538, but we support the older two-line
417// information as well.
418void ParseSymbolizeDataOutput(const char *str, DataInfo *info) {
419 str = ExtractToken(str, delims: "\n", result: &info->name);
420 str = ExtractUptr(str, delims: " ", result: &info->start);
421 str = ExtractUptr(str, delims: "\n", result: &info->size);
422 // Note: If the third line isn't present, these calls will set info.{file,
423 // line} to empty strings.
424 str = ExtractToken(str, delims: ":", result: &info->file);
425 str = ExtractUptr(str, delims: "\n", result: &info->line);
426}
427
428void ParseSymbolizeFrameOutput(const char *str,
429 InternalMmapVector<LocalInfo> *locals) {
430 if (internal_strncmp(s1: str, s2: "??", n: 2) == 0)
431 return;
432
433 while (*str) {
434 LocalInfo local;
435 str = ExtractToken(str, delims: "\n", result: &local.function_name);
436 str = ExtractToken(str, delims: "\n", result: &local.name);
437
438 AddressInfo addr;
439 str = ParseFileLineInfo(info: &addr, str);
440 local.decl_file = addr.file;
441 local.decl_line = addr.line;
442
443 local.has_frame_offset = internal_strncmp(s1: str, s2: "??", n: 2) != 0;
444 str = ExtractSptr(str, delims: " ", result: &local.frame_offset);
445
446 local.has_size = internal_strncmp(s1: str, s2: "??", n: 2) != 0;
447 str = ExtractUptr(str, delims: " ", result: &local.size);
448
449 local.has_tag_offset = internal_strncmp(s1: str, s2: "??", n: 2) != 0;
450 str = ExtractUptr(str, delims: "\n", result: &local.tag_offset);
451
452 locals->push_back(element: local);
453 }
454}
455
456bool LLVMSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
457 AddressInfo *info = &stack->info;
458 const char *buf = FormatAndSendCommand(
459 command_prefix: "CODE", module_name: info->module, module_offset: info->module_offset, arch: info->module_arch);
460 if (!buf)
461 return false;
462 ParseSymbolizePCOutput(str: buf, res: stack);
463 return true;
464}
465
466bool LLVMSymbolizer::SymbolizeData(uptr addr, DataInfo *info) {
467 const char *buf = FormatAndSendCommand(
468 command_prefix: "DATA", module_name: info->module, module_offset: info->module_offset, arch: info->module_arch);
469 if (!buf)
470 return false;
471 ParseSymbolizeDataOutput(str: buf, info);
472 info->start += (addr - info->module_offset); // Add the base address.
473 return true;
474}
475
476bool LLVMSymbolizer::SymbolizeFrame(uptr addr, FrameInfo *info) {
477 const char *buf = FormatAndSendCommand(
478 command_prefix: "FRAME", module_name: info->module, module_offset: info->module_offset, arch: info->module_arch);
479 if (!buf)
480 return false;
481 ParseSymbolizeFrameOutput(str: buf, locals: &info->locals);
482 return true;
483}
484
485const char *LLVMSymbolizer::FormatAndSendCommand(const char *command_prefix,
486 const char *module_name,
487 uptr module_offset,
488 ModuleArch arch) {
489 CHECK(module_name);
490 int size_needed = 0;
491 if (arch == kModuleArchUnknown)
492 size_needed = internal_snprintf(buffer: buffer_, length: kBufferSize, format: "%s \"%s\" 0x%zx\n",
493 command_prefix, module_name, module_offset);
494 else
495 size_needed = internal_snprintf(
496 buffer: buffer_, length: kBufferSize, format: "%s \"%s:%s\" 0x%zx\n", command_prefix,
497 module_name, ModuleArchToString(arch), module_offset);
498
499 if (size_needed >= static_cast<int>(kBufferSize)) {
500 Report(format: "WARNING: Command buffer too small");
501 return nullptr;
502 }
503
504 return symbolizer_process_->SendCommand(command: buffer_);
505}
506
507SymbolizerProcess::SymbolizerProcess(const char* path, bool use_posix_spawn)
508 : path_(path),
509 input_fd_(kInvalidFd),
510 output_fd_(kInvalidFd),
511 child_stdin_fd_(kInvalidFd),
512 times_restarted_(0),
513 failed_to_start_(false),
514 reported_invalid_path_(false),
515 use_posix_spawn_(use_posix_spawn) {
516 CHECK(path_);
517 CHECK_NE(path_[0], '\0');
518}
519
520SymbolizerProcess::~SymbolizerProcess() {
521 if (child_stdin_fd_ != kInvalidFd)
522 CloseFile(child_stdin_fd_);
523}
524
525static bool IsSameModule(const char *path) {
526 if (const char *ProcessName = GetProcessName()) {
527 if (const char *SymbolizerName = StripModuleName(module: path)) {
528 return !internal_strcmp(s1: ProcessName, s2: SymbolizerName);
529 }
530 }
531 return false;
532}
533
534const char *SymbolizerProcess::SendCommand(const char *command) {
535 if (failed_to_start_)
536 return nullptr;
537 if (IsSameModule(path: path_)) {
538 Report(format: "WARNING: Symbolizer was blocked from starting itself!\n");
539 failed_to_start_ = true;
540 return nullptr;
541 }
542 for (; times_restarted_ < kMaxTimesRestarted; times_restarted_++) {
543 // Start or restart symbolizer if we failed to send command to it.
544 if (const char *res = SendCommandImpl(command))
545 return res;
546 Restart();
547 }
548 if (!failed_to_start_) {
549 Report(format: "WARNING: Failed to use and restart external symbolizer!\n");
550 failed_to_start_ = true;
551 }
552 return nullptr;
553}
554
555const char *SymbolizerProcess::SendCommandImpl(const char *command) {
556 if (input_fd_ == kInvalidFd || output_fd_ == kInvalidFd)
557 return nullptr;
558 if (!WriteToSymbolizer(buffer: command, length: internal_strlen(s: command)))
559 return nullptr;
560 if (!ReadFromSymbolizer())
561 return nullptr;
562 return buffer_.data();
563}
564
565bool SymbolizerProcess::Restart() {
566 if (input_fd_ != kInvalidFd)
567 CloseFile(input_fd_);
568 if (output_fd_ != kInvalidFd)
569 CloseFile(output_fd_);
570 if (child_stdin_fd_ != kInvalidFd) {
571 CloseFile(child_stdin_fd_);
572 child_stdin_fd_ = kInvalidFd; // Don't free in destructor
573 }
574 return StartSymbolizerSubprocess();
575}
576
577bool SymbolizerProcess::ReadFromSymbolizer() {
578 buffer_.clear();
579 constexpr uptr max_length = 1024;
580 bool ret = true;
581 do {
582 uptr just_read = 0;
583 uptr size_before = buffer_.size();
584 buffer_.resize(new_size: size_before + max_length);
585 buffer_.resize(new_size: buffer_.capacity());
586 ret = ReadFromFile(fd: input_fd_, buff: &buffer_[size_before],
587 buff_size: buffer_.size() - size_before, bytes_read: &just_read);
588
589 if (!ret)
590 just_read = 0;
591
592 buffer_.resize(new_size: size_before + just_read);
593
594 // We can't read 0 bytes, as we don't expect external symbolizer to close
595 // its stdout.
596 if (just_read == 0) {
597 Report(format: "WARNING: Can't read from symbolizer at fd %d\n", input_fd_);
598 ret = false;
599 break;
600 }
601 } while (!ReachedEndOfOutput(buffer: buffer_.data(), length: buffer_.size()));
602 buffer_.push_back(element: '\0');
603 return ret;
604}
605
606bool SymbolizerProcess::WriteToSymbolizer(const char *buffer, uptr length) {
607 if (length == 0)
608 return true;
609 uptr write_len = 0;
610 bool success = WriteToFile(fd: output_fd_, buff: buffer, buff_size: length, bytes_written: &write_len);
611 if (!success || write_len != length) {
612 Report(format: "WARNING: Can't write to symbolizer at fd %d\n", output_fd_);
613 return false;
614 }
615 return true;
616}
617
618#endif // !SANITIZER_SYMBOLIZER_MARKUP
619
620} // namespace __sanitizer
621