Alexander Potapenko | 8c07f55 | 2012-11-12 11:33:29 +0000 | [diff] [blame] | 1 | //===-- llvm-symbolizer.cpp - Simple addr2line-like symbolizer ------------===// |
| 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 utility works much like "addr2line". It is able of transforming |
| 11 | // tuples (module name, module offset) to code locations (function name, |
| 12 | // file, line number, column number). It is targeted for compiler-rt tools |
| 13 | // (especially AddressSanitizer and ThreadSanitizer) that can use it |
| 14 | // to symbolize stack traces in their error reports. |
| 15 | // |
| 16 | //===----------------------------------------------------------------------===// |
| 17 | |
Alexander Potapenko | 8c07f55 | 2012-11-12 11:33:29 +0000 | [diff] [blame] | 18 | #include "llvm/ADT/StringRef.h" |
Alexey Samsonov | d6aa820 | 2015-11-03 22:20:52 +0000 | [diff] [blame] | 19 | #include "llvm/DebugInfo/Symbolize/DIPrinter.h" |
Alexey Samsonov | 57f8837 | 2015-10-26 17:56:12 +0000 | [diff] [blame] | 20 | #include "llvm/DebugInfo/Symbolize/Symbolize.h" |
Zachary Turner | 20dbd0d | 2015-04-27 17:19:51 +0000 | [diff] [blame] | 21 | #include "llvm/Support/COM.h" |
Alexander Potapenko | 8c07f55 | 2012-11-12 11:33:29 +0000 | [diff] [blame] | 22 | #include "llvm/Support/CommandLine.h" |
| 23 | #include "llvm/Support/Debug.h" |
Alexander Potapenko | 7aaf514 | 2014-10-17 00:50:19 +0000 | [diff] [blame] | 24 | #include "llvm/Support/FileSystem.h" |
Alexander Potapenko | 8c07f55 | 2012-11-12 11:33:29 +0000 | [diff] [blame] | 25 | #include "llvm/Support/ManagedStatic.h" |
Benjamin Kramer | 16132e6 | 2015-03-23 18:07:13 +0000 | [diff] [blame] | 26 | #include "llvm/Support/Path.h" |
Alexander Potapenko | 8c07f55 | 2012-11-12 11:33:29 +0000 | [diff] [blame] | 27 | #include "llvm/Support/PrettyStackTrace.h" |
| 28 | #include "llvm/Support/Signals.h" |
| 29 | #include "llvm/Support/raw_ostream.h" |
Alexander Potapenko | 8c07f55 | 2012-11-12 11:33:29 +0000 | [diff] [blame] | 30 | #include <cstdio> |
| 31 | #include <cstring> |
Alexander Potapenko | 8c07f55 | 2012-11-12 11:33:29 +0000 | [diff] [blame] | 32 | #include <string> |
| 33 | |
| 34 | using namespace llvm; |
Alexey Samsonov | ea83baf | 2013-01-22 14:21:19 +0000 | [diff] [blame] | 35 | using namespace symbolize; |
Alexander Potapenko | 8c07f55 | 2012-11-12 11:33:29 +0000 | [diff] [blame] | 36 | |
| 37 | static cl::opt<bool> |
Alexey Samsonov | ea83baf | 2013-01-22 14:21:19 +0000 | [diff] [blame] | 38 | ClUseSymbolTable("use-symbol-table", cl::init(true), |
Alexey Samsonov | d5d7bb5 | 2013-02-15 08:54:47 +0000 | [diff] [blame] | 39 | cl::desc("Prefer names in symbol table to names " |
| 40 | "in debug info")); |
Alexander Potapenko | 8c07f55 | 2012-11-12 11:33:29 +0000 | [diff] [blame] | 41 | |
Alexey Samsonov | cd01472 | 2014-05-17 00:07:48 +0000 | [diff] [blame] | 42 | static cl::opt<FunctionNameKind> ClPrintFunctions( |
| 43 | "functions", cl::init(FunctionNameKind::LinkageName), |
| 44 | cl::desc("Print function name for a given address:"), |
| 45 | cl::values(clEnumValN(FunctionNameKind::None, "none", "omit function name"), |
| 46 | clEnumValN(FunctionNameKind::ShortName, "short", |
| 47 | "print short function name"), |
| 48 | clEnumValN(FunctionNameKind::LinkageName, "linkage", |
Mehdi Amini | 732afdd | 2016-10-08 19:41:06 +0000 | [diff] [blame] | 49 | "print function linkage name"))); |
Alexander Potapenko | 8c07f55 | 2012-11-12 11:33:29 +0000 | [diff] [blame] | 50 | |
| 51 | static cl::opt<bool> |
Zachary Turner | c007aa4 | 2015-05-06 22:26:30 +0000 | [diff] [blame] | 52 | ClUseRelativeAddress("relative-address", cl::init(false), |
| 53 | cl::desc("Interpret addresses as relative addresses"), |
| 54 | cl::ReallyHidden); |
| 55 | |
| 56 | static cl::opt<bool> |
| 57 | ClPrintInlining("inlining", cl::init(true), |
| 58 | cl::desc("Print all inlined frames for a given address")); |
Alexander Potapenko | 8c07f55 | 2012-11-12 11:33:29 +0000 | [diff] [blame] | 59 | |
| 60 | static cl::opt<bool> |
Alexey Samsonov | d5d7bb5 | 2013-02-15 08:54:47 +0000 | [diff] [blame] | 61 | ClDemangle("demangle", cl::init(true), cl::desc("Demangle function names")); |
Alexander Potapenko | 8c07f55 | 2012-11-12 11:33:29 +0000 | [diff] [blame] | 62 | |
Alexey Samsonov | 2ca6536 | 2013-06-28 08:15:40 +0000 | [diff] [blame] | 63 | static cl::opt<std::string> ClDefaultArch("default-arch", cl::init(""), |
| 64 | cl::desc("Default architecture " |
| 65 | "(for multi-arch objects)")); |
| 66 | |
Alexey Samsonov | 60e59e2 | 2013-12-24 19:33:22 +0000 | [diff] [blame] | 67 | static cl::opt<std::string> |
| 68 | ClBinaryName("obj", cl::init(""), |
| 69 | cl::desc("Path to object file to be symbolized (if not provided, " |
| 70 | "object file should be specified for each input line)")); |
| 71 | |
Alexander Potapenko | 7aaf514 | 2014-10-17 00:50:19 +0000 | [diff] [blame] | 72 | static cl::list<std::string> |
| 73 | ClDsymHint("dsym-hint", cl::ZeroOrMore, |
| 74 | cl::desc("Path to .dSYM bundles to search for debug info for the " |
| 75 | "object files")); |
Hemant Kulkarni | 80f82fb | 2015-10-12 19:26:44 +0000 | [diff] [blame] | 76 | static cl::opt<bool> |
| 77 | ClPrintAddress("print-address", cl::init(false), |
| 78 | cl::desc("Show address before line information")); |
Alexander Potapenko | 7aaf514 | 2014-10-17 00:50:19 +0000 | [diff] [blame] | 79 | |
Hemant Kulkarni | bdce12a | 2015-11-11 20:41:43 +0000 | [diff] [blame] | 80 | static cl::opt<bool> |
| 81 | ClPrettyPrint("pretty-print", cl::init(false), |
| 82 | cl::desc("Make the output more human friendly")); |
| 83 | |
Mike Aizatsky | 17dbc28 | 2016-01-09 00:14:35 +0000 | [diff] [blame] | 84 | static cl::opt<int> ClPrintSourceContextLines( |
| 85 | "print-source-context-lines", cl::init(0), |
| 86 | cl::desc("Print N number of source file context")); |
| 87 | |
David Blaikie | 0012dd5 | 2017-01-31 22:19:38 +0000 | [diff] [blame^] | 88 | static cl::opt<bool> ClVerbose("verbose", cl::init(false), |
| 89 | cl::desc("Print verbose line info")); |
| 90 | |
Reid Kleckner | f27f3f8 | 2016-06-03 20:25:09 +0000 | [diff] [blame] | 91 | template<typename T> |
| 92 | static bool error(Expected<T> &ResOrErr) { |
| 93 | if (ResOrErr) |
Alexey Samsonov | 884adda | 2015-11-04 00:30:24 +0000 | [diff] [blame] | 94 | return false; |
Reid Kleckner | f27f3f8 | 2016-06-03 20:25:09 +0000 | [diff] [blame] | 95 | logAllUnhandledErrors(ResOrErr.takeError(), errs(), |
| 96 | "LLVMSymbolizer: error reading file: "); |
Alexey Samsonov | 884adda | 2015-11-04 00:30:24 +0000 | [diff] [blame] | 97 | return true; |
| 98 | } |
| 99 | |
Mike Aizatsky | 54a7c69 | 2016-01-07 23:57:41 +0000 | [diff] [blame] | 100 | static bool parseCommand(StringRef InputString, bool &IsData, |
| 101 | std::string &ModuleName, uint64_t &ModuleOffset) { |
Dmitry Vyukov | d08bd13 | 2013-01-11 07:16:20 +0000 | [diff] [blame] | 102 | const char *kDataCmd = "DATA "; |
| 103 | const char *kCodeCmd = "CODE "; |
Mike Aizatsky | 54a7c69 | 2016-01-07 23:57:41 +0000 | [diff] [blame] | 104 | const char kDelimiters[] = " \n\r"; |
Dmitry Vyukov | d08bd13 | 2013-01-11 07:16:20 +0000 | [diff] [blame] | 105 | IsData = false; |
Alexander Potapenko | 8c07f55 | 2012-11-12 11:33:29 +0000 | [diff] [blame] | 106 | ModuleName = ""; |
Mike Aizatsky | 54a7c69 | 2016-01-07 23:57:41 +0000 | [diff] [blame] | 107 | const char *pos = InputString.data(); |
Dmitry Vyukov | d08bd13 | 2013-01-11 07:16:20 +0000 | [diff] [blame] | 108 | if (strncmp(pos, kDataCmd, strlen(kDataCmd)) == 0) { |
| 109 | IsData = true; |
| 110 | pos += strlen(kDataCmd); |
| 111 | } else if (strncmp(pos, kCodeCmd, strlen(kCodeCmd)) == 0) { |
| 112 | IsData = false; |
| 113 | pos += strlen(kCodeCmd); |
| 114 | } else { |
| 115 | // If no cmd, assume it's CODE. |
| 116 | IsData = false; |
| 117 | } |
Alexey Samsonov | 60e59e2 | 2013-12-24 19:33:22 +0000 | [diff] [blame] | 118 | // Skip delimiters and parse input filename (if needed). |
| 119 | if (ClBinaryName == "") { |
| 120 | pos += strspn(pos, kDelimiters); |
| 121 | if (*pos == '"' || *pos == '\'') { |
| 122 | char quote = *pos; |
| 123 | pos++; |
Mike Aizatsky | 54a7c69 | 2016-01-07 23:57:41 +0000 | [diff] [blame] | 124 | const char *end = strchr(pos, quote); |
Craig Topper | e6cb63e | 2014-04-25 04:24:47 +0000 | [diff] [blame] | 125 | if (!end) |
Alexey Samsonov | 60e59e2 | 2013-12-24 19:33:22 +0000 | [diff] [blame] | 126 | return false; |
| 127 | ModuleName = std::string(pos, end - pos); |
| 128 | pos = end + 1; |
| 129 | } else { |
| 130 | int name_length = strcspn(pos, kDelimiters); |
| 131 | ModuleName = std::string(pos, name_length); |
| 132 | pos += name_length; |
| 133 | } |
Alexey Samsonov | d206932 | 2013-04-05 09:22:24 +0000 | [diff] [blame] | 134 | } else { |
Alexey Samsonov | 60e59e2 | 2013-12-24 19:33:22 +0000 | [diff] [blame] | 135 | ModuleName = ClBinaryName; |
Alexander Potapenko | 8c07f55 | 2012-11-12 11:33:29 +0000 | [diff] [blame] | 136 | } |
Alexey Samsonov | d206932 | 2013-04-05 09:22:24 +0000 | [diff] [blame] | 137 | // Skip delimiters and parse module offset. |
| 138 | pos += strspn(pos, kDelimiters); |
| 139 | int offset_length = strcspn(pos, kDelimiters); |
Rafael Espindola | 2c5bcc5 | 2015-10-24 23:23:25 +0000 | [diff] [blame] | 140 | return !StringRef(pos, offset_length).getAsInteger(0, ModuleOffset); |
Alexander Potapenko | 8c07f55 | 2012-11-12 11:33:29 +0000 | [diff] [blame] | 141 | } |
| 142 | |
| 143 | int main(int argc, char **argv) { |
| 144 | // Print stack trace if we signal out. |
Richard Smith | 2ad6d48 | 2016-06-09 00:53:21 +0000 | [diff] [blame] | 145 | sys::PrintStackTraceOnErrorSignal(argv[0]); |
Alexander Potapenko | 8c07f55 | 2012-11-12 11:33:29 +0000 | [diff] [blame] | 146 | PrettyStackTraceProgram X(argc, argv); |
Alexey Samsonov | d5d7bb5 | 2013-02-15 08:54:47 +0000 | [diff] [blame] | 147 | llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. |
Alexander Potapenko | 8c07f55 | 2012-11-12 11:33:29 +0000 | [diff] [blame] | 148 | |
Zachary Turner | 20dbd0d | 2015-04-27 17:19:51 +0000 | [diff] [blame] | 149 | llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::MultiThreaded); |
| 150 | |
Alexey Samsonov | 60e59e2 | 2013-12-24 19:33:22 +0000 | [diff] [blame] | 151 | cl::ParseCommandLineOptions(argc, argv, "llvm-symbolizer\n"); |
Alexey Samsonov | 46c1ce6 | 2015-10-30 00:40:20 +0000 | [diff] [blame] | 152 | LLVMSymbolizer::Options Opts(ClPrintFunctions, ClUseSymbolTable, ClDemangle, |
Zachary Turner | c007aa4 | 2015-05-06 22:26:30 +0000 | [diff] [blame] | 153 | ClUseRelativeAddress, ClDefaultArch); |
Hemant Kulkarni | bdce12a | 2015-11-11 20:41:43 +0000 | [diff] [blame] | 154 | |
Alexander Potapenko | 7aaf514 | 2014-10-17 00:50:19 +0000 | [diff] [blame] | 155 | for (const auto &hint : ClDsymHint) { |
| 156 | if (sys::path::extension(hint) == ".dSYM") { |
| 157 | Opts.DsymHints.push_back(hint); |
| 158 | } else { |
| 159 | errs() << "Warning: invalid dSYM hint: \"" << hint << |
| 160 | "\" (must have the '.dSYM' extension).\n"; |
| 161 | } |
| 162 | } |
Alexey Samsonov | ea83baf | 2013-01-22 14:21:19 +0000 | [diff] [blame] | 163 | LLVMSymbolizer Symbolizer(Opts); |
Alexander Potapenko | 8c07f55 | 2012-11-12 11:33:29 +0000 | [diff] [blame] | 164 | |
Hemant Kulkarni | bdce12a | 2015-11-11 20:41:43 +0000 | [diff] [blame] | 165 | DIPrinter Printer(outs(), ClPrintFunctions != FunctionNameKind::None, |
David Blaikie | 0012dd5 | 2017-01-31 22:19:38 +0000 | [diff] [blame^] | 166 | ClPrettyPrint, ClPrintSourceContextLines, ClVerbose); |
Alexey Samsonov | d6aa820 | 2015-11-03 22:20:52 +0000 | [diff] [blame] | 167 | |
Mike Aizatsky | 54a7c69 | 2016-01-07 23:57:41 +0000 | [diff] [blame] | 168 | const int kMaxInputStringLength = 1024; |
| 169 | char InputString[kMaxInputStringLength]; |
| 170 | |
| 171 | while (true) { |
| 172 | if (!fgets(InputString, sizeof(InputString), stdin)) |
| 173 | break; |
| 174 | |
| 175 | bool IsData = false; |
| 176 | std::string ModuleName; |
| 177 | uint64_t ModuleOffset = 0; |
| 178 | if (!parseCommand(StringRef(InputString), IsData, ModuleName, |
| 179 | ModuleOffset)) { |
| 180 | outs() << InputString; |
| 181 | continue; |
| 182 | } |
| 183 | |
Hemant Kulkarni | 80f82fb | 2015-10-12 19:26:44 +0000 | [diff] [blame] | 184 | if (ClPrintAddress) { |
| 185 | outs() << "0x"; |
| 186 | outs().write_hex(ModuleOffset); |
Hemant Kulkarni | bdce12a | 2015-11-11 20:41:43 +0000 | [diff] [blame] | 187 | StringRef Delimiter = (ClPrettyPrint == true) ? ": " : "\n"; |
| 188 | outs() << Delimiter; |
Hemant Kulkarni | 80f82fb | 2015-10-12 19:26:44 +0000 | [diff] [blame] | 189 | } |
Alexey Samsonov | d6aa820 | 2015-11-03 22:20:52 +0000 | [diff] [blame] | 190 | if (IsData) { |
Alexey Samsonov | 884adda | 2015-11-04 00:30:24 +0000 | [diff] [blame] | 191 | auto ResOrErr = Symbolizer.symbolizeData(ModuleName, ModuleOffset); |
Reid Kleckner | f27f3f8 | 2016-06-03 20:25:09 +0000 | [diff] [blame] | 192 | Printer << (error(ResOrErr) ? DIGlobal() : ResOrErr.get()); |
Alexey Samsonov | d6aa820 | 2015-11-03 22:20:52 +0000 | [diff] [blame] | 193 | } else if (ClPrintInlining) { |
Alexey Samsonov | 884adda | 2015-11-04 00:30:24 +0000 | [diff] [blame] | 194 | auto ResOrErr = Symbolizer.symbolizeInlinedCode(ModuleName, ModuleOffset); |
Reid Kleckner | f27f3f8 | 2016-06-03 20:25:09 +0000 | [diff] [blame] | 195 | Printer << (error(ResOrErr) ? DIInliningInfo() |
Alexey Samsonov | 884adda | 2015-11-04 00:30:24 +0000 | [diff] [blame] | 196 | : ResOrErr.get()); |
Alexey Samsonov | d6aa820 | 2015-11-03 22:20:52 +0000 | [diff] [blame] | 197 | } else { |
Alexey Samsonov | 884adda | 2015-11-04 00:30:24 +0000 | [diff] [blame] | 198 | auto ResOrErr = Symbolizer.symbolizeCode(ModuleName, ModuleOffset); |
Reid Kleckner | f27f3f8 | 2016-06-03 20:25:09 +0000 | [diff] [blame] | 199 | Printer << (error(ResOrErr) ? DILineInfo() : ResOrErr.get()); |
Alexey Samsonov | d6aa820 | 2015-11-03 22:20:52 +0000 | [diff] [blame] | 200 | } |
| 201 | outs() << "\n"; |
Alexey Samsonov | ea83baf | 2013-01-22 14:21:19 +0000 | [diff] [blame] | 202 | outs().flush(); |
Alexander Potapenko | 8c07f55 | 2012-11-12 11:33:29 +0000 | [diff] [blame] | 203 | } |
Zachary Turner | 20dbd0d | 2015-04-27 17:19:51 +0000 | [diff] [blame] | 204 | |
Alexander Potapenko | 8c07f55 | 2012-11-12 11:33:29 +0000 | [diff] [blame] | 205 | return 0; |
| 206 | } |