compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_libcdep.cpp

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