contrib/compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_mac.cc

   1 //===-- sanitizer_symbolizer_mac.cc ---------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file is shared between various sanitizers' runtime libraries.
  11 //
  12 // Implementation of Mac-specific "atos" symbolizer.
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "sanitizer_platform.h"
  16 #if SANITIZER_MAC
  17
  18 #include "sanitizer_allocator_internal.h"
  19 #include "sanitizer_mac.h"
  20 #include "sanitizer_symbolizer_mac.h"
  21
  22 #include <dlfcn.h>
  23 #include <errno.h>
  24 #include <stdlib.h>
  25 #include <sys/wait.h>
  26 #include <unistd.h>
  27 #include <util.h>
  28
  29 namespace __sanitizer {
  30
  31 bool DlAddrSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
  32   Dl_info info;
  33   int result = dladdr((const void *)addr, &info);
  34   if (!result) return false;
  35   const char *demangled = DemangleSwiftAndCXX(info.dli_sname);
  36   if (!demangled) return false;
  37   stack->info.function = internal_strdup(demangled);
  38   return true;
  39 }
  40
  41 bool DlAddrSymbolizer::SymbolizeData(uptr addr, DataInfo *datainfo) {
  42   Dl_info info;
  43   int result = dladdr((const void *)addr, &info);
  44   if (!result) return false;
  45   const char *demangled = DemangleSwiftAndCXX(info.dli_sname);
  46   datainfo->name = internal_strdup(demangled);
  47   datainfo->start = (uptr)info.dli_saddr;
  48   return true;
  49 }
  50
  51 class AtosSymbolizerProcess : public SymbolizerProcess {
  52  public:
  53   explicit AtosSymbolizerProcess(const char *path, pid_t parent_pid)
  54       : SymbolizerProcess(path, /*use_forkpty*/ true) {
  55     // Put the string command line argument in the object so that it outlives
  56     // the call to GetArgV.
  57     internal_snprintf(pid_str_, sizeof(pid_str_), "%d", parent_pid);
  58   }
  59
  60  private:
  61   bool ReachedEndOfOutput(const char *buffer, uptr length) const override {
  62     return (length >= 1 && buffer[length - 1] == '\n');
  63   }
  64
  65   void GetArgV(const char *path_to_binary,
  66                const char *(&argv)[kArgVMax]) const override {
  67     int i = 0;
  68     argv[i++] = path_to_binary;
  69     argv[i++] = "-p";
  70     argv[i++] = &pid_str_[0];
  71     if (GetMacosVersion() == MACOS_VERSION_MAVERICKS) {
  72       // On Mavericks atos prints a deprecation warning which we suppress by
  73       // passing -d. The warning isn't present on other OSX versions, even the
  74       // newer ones.
  75       argv[i++] = "-d";
  76     }
  77     argv[i++] = nullptr;
  78   }
  79
  80   char pid_str_[16];
  81 };
  82
  83 static bool ParseCommandOutput(const char *str, uptr addr, char **out_name,
  84                                char **out_module, char **out_file, uptr *line,
  85                                uptr *start_address) {
  86   // Trim ending newlines.
  87   char *trim;
  88   ExtractTokenUpToDelimiter(str, "\n", &trim);
  89
  90   // The line from `atos` is in one of these formats:
  91   //   myfunction (in library.dylib) (sourcefile.c:17)
  92   //   myfunction (in library.dylib) + 0x1fe
  93   //   myfunction (in library.dylib) + 15
  94   //   0xdeadbeef (in library.dylib) + 0x1fe
  95   //   0xdeadbeef (in library.dylib) + 15
  96   //   0xdeadbeef (in library.dylib)
  97   //   0xdeadbeef
  98
  99   const char *rest = trim;
 100   char *symbol_name;
 101   rest = ExtractTokenUpToDelimiter(rest, " (in ", &symbol_name);
 102   if (rest[0] == '\0') {
 103     InternalFree(symbol_name);
 104     InternalFree(trim);
 105     return false;
 106   }
 107
 108   if (internal_strncmp(symbol_name, "0x", 2) != 0)
 109     *out_name = symbol_name;
 110   else
 111     InternalFree(symbol_name);
 112   rest = ExtractTokenUpToDelimiter(rest, ") ", out_module);
 113
 114   if (rest[0] == '(') {
 115     if (out_file) {
 116       rest++;
 117       rest = ExtractTokenUpToDelimiter(rest, ":", out_file);
 118       char *extracted_line_number;
 119       rest = ExtractTokenUpToDelimiter(rest, ")", &extracted_line_number);
 120       if (line) *line = (uptr)internal_atoll(extracted_line_number);
 121       InternalFree(extracted_line_number);
 122     }
 123   } else if (rest[0] == '+') {
 124     rest += 2;
 125     uptr offset = internal_atoll(rest);
 126     if (start_address) *start_address = addr - offset;
 127   }
 128
 129   InternalFree(trim);
 130   return true;
 131 }
 132
 133 AtosSymbolizer::AtosSymbolizer(const char *path, LowLevelAllocator *allocator)
 134     : process_(new(*allocator) AtosSymbolizerProcess(path, getpid())) {}
 135
 136 bool AtosSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
 137   if (!process_) return false;
 138   if (addr == 0) return false;
 139   char command[32];
 140   internal_snprintf(command, sizeof(command), "0x%zx\n", addr);
 141   const char *buf = process_->SendCommand(command);
 142   if (!buf) return false;
 143   uptr line;
 144   if (!ParseCommandOutput(buf, addr, &stack->info.function, &stack->info.module,
 145                           &stack->info.file, &line, nullptr)) {
 146     process_ = nullptr;
 147     return false;
 148   }
 149   stack->info.line = (int)line;
 150   return true;
 151 }
 152
 153 bool AtosSymbolizer::SymbolizeData(uptr addr, DataInfo *info) {
 154   if (!process_) return false;
 155   char command[32];
 156   internal_snprintf(command, sizeof(command), "0x%zx\n", addr);
 157   const char *buf = process_->SendCommand(command);
 158   if (!buf) return false;
 159   if (!ParseCommandOutput(buf, addr, &info->name, &info->module, nullptr,
 160                           nullptr, &info->start)) {
 161     process_ = nullptr;
 162     return false;
 163   }
 164   return true;
 165 }
 166
 167 }  // namespace __sanitizer
 168
 169 #endif  // SANITIZER_MAC