libsanitizer/sanitizer_common/sanitizer_symbolizer.h

   1 //===-- sanitizer_symbolizer.h ----------------------------------*- C++ -*-===//
   2 //
   3 // This file is distributed under the University of Illinois Open Source
   4 // License. See LICENSE.TXT for details.
   5 //
   6 //===----------------------------------------------------------------------===//
   7 //
   8 // Symbolizer is used by sanitizers to map instruction address to a location in
   9 // source code at run-time. Symbolizer either uses __sanitizer_symbolize_*
  10 // defined in the program, or (if they are missing) tries to find and
  11 // launch "llvm-symbolizer" commandline tool in a separate process and
  12 // communicate with it.
  13 //
  14 // Generally we should try to avoid calling system library functions during
  15 // symbolization (and use their replacements from sanitizer_libc.h instead).
  16 //===----------------------------------------------------------------------===//
  17 #ifndef SANITIZER_SYMBOLIZER_H
  18 #define SANITIZER_SYMBOLIZER_H
  19
  20 #include "sanitizer_common.h"
  21 #include "sanitizer_mutex.h"
  22
  23 namespace __sanitizer {
  24
  25 struct AddressInfo {
  26   // Owns all the string members. Storage for them is
  27   // (de)allocated using sanitizer internal allocator.
  28   uptr address;
  29
  30   char *module;
  31   uptr module_offset;
  32   ModuleArch module_arch;
  33
  34   static const uptr kUnknown = ~(uptr)0;
  35   char *function;
  36   uptr function_offset;
  37
  38   char *file;
  39   int line;
  40   int column;
  41
  42   AddressInfo();
  43   // Deletes all strings and resets all fields.
  44   void Clear();
  45   void FillModuleInfo(const char *mod_name, uptr mod_offset, ModuleArch arch);
  46 };
  47
  48 // Linked list of symbolized frames (each frame is described by AddressInfo).
  49 struct SymbolizedStack {
  50   SymbolizedStack *next;
  51   AddressInfo info;
  52   static SymbolizedStack *New(uptr addr);
  53   // Deletes current, and all subsequent frames in the linked list.
  54   // The object cannot be accessed after the call to this function.
  55   void ClearAll();
  56
  57  private:
  58   SymbolizedStack();
  59 };
  60
  61 // For now, DataInfo is used to describe global variable.
  62 struct DataInfo {
  63   // Owns all the string members. Storage for them is
  64   // (de)allocated using sanitizer internal allocator.
  65   char *module;
  66   uptr module_offset;
  67   ModuleArch module_arch;
  68
  69   char *file;
  70   uptr line;
  71   char *name;
  72   uptr start;
  73   uptr size;
  74
  75   DataInfo();
  76   void Clear();
  77 };
  78
  79 class SymbolizerTool;
  80
  81 class Symbolizer final {
  82  public:
  83   /// Initialize and return platform-specific implementation of symbolizer
  84   /// (if it wasn't already initialized).
  85   static Symbolizer *GetOrInit();
  86   static void LateInitialize();
  87   // Returns a list of symbolized frames for a given address (containing
  88   // all inlined functions, if necessary).
  89   SymbolizedStack *SymbolizePC(uptr address);
  90   bool SymbolizeData(uptr address, DataInfo *info);
  91
  92   // The module names Symbolizer returns are stable and unique for every given
  93   // module.  It is safe to store and compare them as pointers.
  94   bool GetModuleNameAndOffsetForPC(uptr pc, const char **module_name,
  95                                    uptr *module_address);
  96   const char *GetModuleNameForPc(uptr pc) {
  97     const char *module_name = nullptr;
  98     uptr unused;
  99     if (GetModuleNameAndOffsetForPC(pc, &module_name, &unused))
 100       return module_name;
 101     return nullptr;
 102   }
 103
 104   // Release internal caches (if any).
 105   void Flush();
 106   // Attempts to demangle the provided C++ mangled name.
 107   const char *Demangle(const char *name);
 108   void PrepareForSandboxing();
 109
 110   // Allow user to install hooks that would be called before/after Symbolizer
 111   // does the actual file/line info fetching. Specific sanitizers may need this
 112   // to distinguish system library calls made in user code from calls made
 113   // during in-process symbolization.
 114   typedef void (*StartSymbolizationHook)();
 115   typedef void (*EndSymbolizationHook)();
 116   // May be called at most once.
 117   void AddHooks(StartSymbolizationHook start_hook,
 118                 EndSymbolizationHook end_hook);
 119
 120   void RefreshModules();
 121   const LoadedModule *FindModuleForAddress(uptr address);
 122
 123   void InvalidateModuleList();
 124
 125  private:
 126   // GetModuleNameAndOffsetForPC has to return a string to the caller.
 127   // Since the corresponding module might get unloaded later, we should create
 128   // our owned copies of the strings that we can safely return.
 129   // ModuleNameOwner does not provide any synchronization, thus calls to
 130   // its method should be protected by |mu_|.
 131   class ModuleNameOwner {
 132    public:
 133     explicit ModuleNameOwner(BlockingMutex *synchronized_by)
 134         : storage_(kInitialCapacity), last_match_(nullptr),
 135           mu_(synchronized_by) {}
 136     const char *GetOwnedCopy(const char *str);
 137
 138    private:
 139     static const uptr kInitialCapacity = 1000;
 140     InternalMmapVector<const char*> storage_;
 141     const char *last_match_;
 142
 143     BlockingMutex *mu_;
 144   } module_names_;
 145
 146   /// Platform-specific function for creating a Symbolizer object.
 147   static Symbolizer *PlatformInit();
 148
 149   bool FindModuleNameAndOffsetForAddress(uptr address, const char **module_name,
 150                                          uptr *module_offset,
 151                                          ModuleArch *module_arch);
 152   ListOfModules modules_;
 153   ListOfModules fallback_modules_;
 154   // If stale, need to reload the modules before looking up addresses.
 155   bool modules_fresh_;
 156
 157   // Platform-specific default demangler, must not return nullptr.
 158   const char *PlatformDemangle(const char *name);
 159   void PlatformPrepareForSandboxing();
 160
 161   static Symbolizer *symbolizer_;
 162   static StaticSpinMutex init_mu_;
 163
 164   // Mutex locked from public methods of |Symbolizer|, so that the internals
 165   // (including individual symbolizer tools and platform-specific methods) are
 166   // always synchronized.
 167   BlockingMutex mu_;
 168
 169   IntrusiveList<SymbolizerTool> tools_;
 170
 171   explicit Symbolizer(IntrusiveList<SymbolizerTool> tools);
 172
 173   static LowLevelAllocator symbolizer_allocator_;
 174
 175   StartSymbolizationHook start_hook_;
 176   EndSymbolizationHook end_hook_;
 177   class SymbolizerScope {
 178    public:
 179     explicit SymbolizerScope(const Symbolizer *sym);
 180     ~SymbolizerScope();
 181    private:
 182     const Symbolizer *sym_;
 183   };
 184 };
 185
 186 #ifdef SANITIZER_WINDOWS
 187 void InitializeDbgHelpIfNeeded();
 188 #endif
 189
 190 }  // namespace __sanitizer
 191
 192 #endif  // SANITIZER_SYMBOLIZER_H