1//===-- sanitizer_symbolizer_internal.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// Header for internal classes and functions to be used by implementations of
9// symbolizers.
10//
11//===----------------------------------------------------------------------===//
12#ifndef SANITIZER_SYMBOLIZER_INTERNAL_H
13#define SANITIZER_SYMBOLIZER_INTERNAL_H
14
15#include "sanitizer_symbolizer.h"
16#include "sanitizer_file.h"
17
18namespace __sanitizer {
19
20// Parsing helpers, 'str' is searched for delimiter(s) and a string or uptr
21// is extracted. When extracting a string, a newly allocated (using
22// InternalAlloc) and null-terminataed buffer is returned. They return a pointer
23// to the next characted after the found delimiter.
24const char *ExtractToken(const char *str, const char *delims, char **result);
25const char *ExtractInt(const char *str, const char *delims, int *result);
26const char *ExtractUptr(const char *str, const char *delims, uptr *result);
27const char *ExtractTokenUpToDelimiter(const char *str, const char *delimiter,
28                                      char **result);
29
30const char *DemangleSwiftAndCXX(const char *name);
31
32// SymbolizerTool is an interface that is implemented by individual "tools"
33// that can perform symbolication (external llvm-symbolizer, libbacktrace,
34// Windows DbgHelp symbolizer, etc.).
35class SymbolizerTool {
36 public:
37  // The main |Symbolizer| class implements a "fallback chain" of symbolizer
38  // tools. In a request to symbolize an address, if one tool returns false,
39  // the next tool in the chain will be tried.
40  SymbolizerTool *next;
41
42  SymbolizerTool() : next(nullptr) { }
43
44  // Can't declare pure virtual functions in sanitizer runtimes:
45  // __cxa_pure_virtual might be unavailable.
46
47  // The |stack| parameter is inout. It is pre-filled with the address,
48  // module base and module offset values and is to be used to construct
49  // other stack frames.
50  virtual bool SymbolizePC(uptr addr, SymbolizedStack *stack) {
51    UNIMPLEMENTED();
52  }
53
54  // The |info| parameter is inout. It is pre-filled with the module base
55  // and module offset values.
56  virtual bool SymbolizeData(uptr addr, DataInfo *info) {
57    UNIMPLEMENTED();
58  }
59
60  virtual void Flush() {}
61
62  // Return nullptr to fallback to the default platform-specific demangler.
63  virtual const char *Demangle(const char *name) {
64    return nullptr;
65  }
66};
67
68// SymbolizerProcess encapsulates communication between the tool and
69// external symbolizer program, running in a different subprocess.
70// SymbolizerProcess may not be used from two threads simultaneously.
71class SymbolizerProcess {
72 public:
73  explicit SymbolizerProcess(const char *path, bool use_forkpty = false);
74  const char *SendCommand(const char *command);
75
76 protected:
77  virtual bool ReachedEndOfOutput(const char *buffer, uptr length) const {
78    UNIMPLEMENTED();
79  }
80
81  /// The maximum number of arguments required to invoke a tool process.
82  enum { kArgVMax = 6 };
83
84  /// Fill in an argv array to invoke the child process.
85  virtual void GetArgV(const char *path_to_binary,
86                       const char *(&argv)[kArgVMax]) const {
87    UNIMPLEMENTED();
88  }
89
90  virtual bool ReadFromSymbolizer(char *buffer, uptr max_length);
91
92 private:
93  bool Restart();
94  const char *SendCommandImpl(const char *command);
95  bool WriteToSymbolizer(const char *buffer, uptr length);
96  bool StartSymbolizerSubprocess();
97
98  const char *path_;
99  fd_t input_fd_;
100  fd_t output_fd_;
101
102  static const uptr kBufferSize = 16 * 1024;
103  char buffer_[kBufferSize];
104
105  static const uptr kMaxTimesRestarted = 5;
106  static const int kSymbolizerStartupTimeMillis = 10;
107  uptr times_restarted_;
108  bool failed_to_start_;
109  bool reported_invalid_path_;
110  bool use_forkpty_;
111};
112
113class LLVMSymbolizerProcess;
114
115// This tool invokes llvm-symbolizer in a subprocess. It should be as portable
116// as the llvm-symbolizer tool is.
117class LLVMSymbolizer : public SymbolizerTool {
118 public:
119  explicit LLVMSymbolizer(const char *path, LowLevelAllocator *allocator);
120
121  bool SymbolizePC(uptr addr, SymbolizedStack *stack) override;
122
123  bool SymbolizeData(uptr addr, DataInfo *info) override;
124
125 private:
126  const char *FormatAndSendCommand(bool is_data, const char *module_name,
127                                   uptr module_offset, ModuleArch arch);
128
129  LLVMSymbolizerProcess *symbolizer_process_;
130  static const uptr kBufferSize = 16 * 1024;
131  char buffer_[kBufferSize];
132};
133
134// Parses one or more two-line strings in the following format:
135//   <function_name>
136//   <file_name>:<line_number>[:<column_number>]
137// Used by LLVMSymbolizer, Addr2LinePool and InternalSymbolizer, since all of
138// them use the same output format.  Returns true if any useful debug
139// information was found.
140void ParseSymbolizePCOutput(const char *str, SymbolizedStack *res);
141
142// Parses a two-line string in the following format:
143//   <symbol_name>
144//   <start_address> <size>
145// Used by LLVMSymbolizer and InternalSymbolizer.
146void ParseSymbolizeDataOutput(const char *str, DataInfo *info);
147
148}  // namespace __sanitizer
149
150#endif  // SANITIZER_SYMBOLIZER_INTERNAL_H
151