diff --git a/llvm/docs/CommandGuide/llvm-symbolizer.rst b/llvm/docs/CommandGuide/llvm-symbolizer.rst index 9d54b75..c942d80 100644 --- a/llvm/docs/CommandGuide/llvm-symbolizer.rst +++ b/llvm/docs/CommandGuide/llvm-symbolizer.rst @@ -1,121 +1,121 @@ llvm-symbolizer - convert addresses into source code locations ============================================================== SYNOPSIS -------- :program:`llvm-symbolizer` [options] DESCRIPTION ----------- :program:`llvm-symbolizer` reads object file names and addresses from standard input and prints corresponding source code locations to standard output. If object file is specified in command line, :program:`llvm-symbolizer` processes only addresses from standard input, the rest is output verbatim. This program uses debug info sections and symbol table in the object files. EXAMPLE -------- .. code-block:: console $ cat addr.txt a.out 0x4004f4 /tmp/b.out 0x400528 /tmp/c.so 0x710 /tmp/mach_universal_binary:i386 0x1f84 /tmp/mach_universal_binary:x86_64 0x100000f24 $ llvm-symbolizer < addr.txt main /tmp/a.cc:4 f(int, int) /tmp/b.cc:11 h_inlined_into_g /tmp/header.h:2 g_inlined_into_f /tmp/header.h:7 f_inlined_into_main /tmp/source.cc:3 main /tmp/source.cc:8 _main /tmp/source_i386.cc:8 _main /tmp/source_x86_64.cc:8 $ cat addr2.txt 0x4004f4 0x401000 $ llvm-symbolizer -obj=a.out < addr2.txt main /tmp/a.cc:4 foo(int) /tmp/a.cc:12 $cat addr.txt 0x40054d $llvm-symbolizer -inlining -print-address -pretty-print -obj=addr.exe < addr.txt 0x40054d: inc at /tmp/x.c:3:3 (inlined by) main at /tmp/x.c:9:0 $llvm-symbolizer -inlining -pretty-print -obj=addr.exe < addr.txt inc at /tmp/x.c:3:3 (inlined by) main at /tmp/x.c:9:0 OPTIONS ------- -.. option:: -obj +.. option:: -obj, -exe, -e Path to object file to be symbolized. .. option:: -functions=[none|short|linkage] Specify the way function names are printed (omit function name, print short function name, or print full linkage name, respectively). Defaults to ``linkage``. .. option:: -use-symbol-table Prefer function names stored in symbol table to function names in debug info sections. Defaults to true. .. option:: -demangle Print demangled function names. Defaults to true. .. option:: -inlining If a source code location is in an inlined function, prints all the inlnied frames. Defaults to true. .. option:: -default-arch If a binary contains object files for multiple architectures (e.g. it is a Mach-O universal binary), symbolize the object file for a given architecture. You can also specify architecture by writing ``binary_name:arch_name`` in the input (see example above). If architecture is not specified in either way, address will not be symbolized. Defaults to empty string. .. option:: -dsym-hint= (Darwin-only flag). If the debug info for a binary isn't present in the default location, look for the debug info at the .dSYM path provided via the ``-dsym-hint`` flag. This flag can be used multiple times. .. option:: -print-address Print address before the source code location. Defaults to false. .. option:: -pretty-print, -p Print human readable output. If ``-inlining`` is specified, enclosing scope is prefixed by (inlined by). Refer to listed examples. EXIT STATUS ----------- :program:`llvm-symbolizer` returns 0. Other exit codes imply internal program error. diff --git a/llvm/test/tools/llvm-symbolizer/basic.s b/llvm/test/tools/llvm-symbolizer/basic.s index 0ee3084..c966f98 100644 --- a/llvm/test/tools/llvm-symbolizer/basic.s +++ b/llvm/test/tools/llvm-symbolizer/basic.s @@ -1,19 +1,23 @@ # REQUIRES: x86-registered-target foo: .space 10 nop nop # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o -g # Check input addresses specified on stdin. # RUN: echo -e "0xa\n0xb" | llvm-symbolizer --obj=%t.o | FileCheck %s # RUN: echo -e "10\n11" | llvm-symbolizer --obj=%t.o | FileCheck %s # Check input addresses specified on the command-line. # RUN: llvm-symbolizer 0xa 0xb --obj=%t.o | FileCheck %s # RUN: llvm-symbolizer 10 11 --obj=%t.o | FileCheck %s +# Check --obj aliases --exe, -e +# RUN: llvm-symbolizer 0xa 0xb --exe=%t.o | FileCheck %s +# RUN: llvm-symbolizer 0xa 0xb -e=%t.o | FileCheck %s + # CHECK: basic.s:5:0 # CHECK: basic.s:6:0 diff --git a/llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp b/llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp index 1549fb3..c53332b 100644 --- a/llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp +++ b/llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp @@ -1,214 +1,222 @@ //===-- llvm-symbolizer.cpp - Simple addr2line-like symbolizer ------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This utility works much like "addr2line". It is able of transforming // tuples (module name, module offset) to code locations (function name, // file, line number, column number). It is targeted for compiler-rt tools // (especially AddressSanitizer and ThreadSanitizer) that can use it // to symbolize stack traces in their error reports. // //===----------------------------------------------------------------------===// #include "llvm/ADT/StringRef.h" #include "llvm/DebugInfo/Symbolize/DIPrinter.h" #include "llvm/DebugInfo/Symbolize/Symbolize.h" #include "llvm/Support/COM.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/Debug.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/InitLLVM.h" #include "llvm/Support/Path.h" #include "llvm/Support/raw_ostream.h" #include #include #include using namespace llvm; using namespace symbolize; static cl::opt ClUseSymbolTable("use-symbol-table", cl::init(true), cl::desc("Prefer names in symbol table to names " "in debug info")); static cl::opt ClPrintFunctions( "functions", cl::init(FunctionNameKind::LinkageName), cl::desc("Print function name for a given address:"), cl::values(clEnumValN(FunctionNameKind::None, "none", "omit function name"), clEnumValN(FunctionNameKind::ShortName, "short", "print short function name"), clEnumValN(FunctionNameKind::LinkageName, "linkage", "print function linkage name"))); static cl::opt ClUseRelativeAddress("relative-address", cl::init(false), cl::desc("Interpret addresses as relative addresses"), cl::ReallyHidden); static cl::opt ClPrintInlining("inlining", cl::init(true), cl::desc("Print all inlined frames for a given address")); static cl::opt ClDemangle("demangle", cl::init(true), cl::desc("Demangle function names")); static cl::opt ClDefaultArch("default-arch", cl::init(""), cl::desc("Default architecture " "(for multi-arch objects)")); +// -obj, -exe, -e static cl::opt ClBinaryName("obj", cl::init(""), cl::desc("Path to object file to be symbolized (if not provided, " "object file should be specified for each input line)")); +static cl::alias +ClBinaryNameAliasExe("exe", cl::desc("Alias for -obj"), + cl::NotHidden, cl::aliasopt(ClBinaryName)); +static cl::alias +ClBinaryNameAliasE("e", cl::desc("Alias for -obj"), + cl::NotHidden, cl::aliasopt(ClBinaryName)); + static cl::opt ClDwpName("dwp", cl::init(""), cl::desc("Path to DWP file to be use for any split CUs")); static cl::list ClDsymHint("dsym-hint", cl::ZeroOrMore, cl::desc("Path to .dSYM bundles to search for debug info for the " "object files")); static cl::opt ClPrintAddress("print-address", cl::init(false), cl::desc("Show address before line information")); // -pretty-print, -p static cl::opt ClPrettyPrint("pretty-print", cl::init(false), cl::desc("Make the output more human friendly")); static cl::alias ClPrettyPrintShort("p", cl::desc("Alias for -pretty-print"), cl::NotHidden, cl::aliasopt(ClPrettyPrint)); static cl::opt ClPrintSourceContextLines( "print-source-context-lines", cl::init(0), cl::desc("Print N number of source file context")); static cl::opt ClVerbose("verbose", cl::init(false), cl::desc("Print verbose line info")); static cl::list ClInputAddresses(cl::Positional, cl::desc("..."), cl::ZeroOrMore); template static bool error(Expected &ResOrErr) { if (ResOrErr) return false; logAllUnhandledErrors(ResOrErr.takeError(), errs(), "LLVMSymbolizer: error reading file: "); return true; } static bool parseCommand(StringRef InputString, bool &IsData, std::string &ModuleName, uint64_t &ModuleOffset) { const char kDelimiters[] = " \n\r"; ModuleName = ""; if (InputString.consume_front("CODE ")) { IsData = false; } else if (InputString.consume_front("DATA ")) { IsData = true; } else { // If no cmd, assume it's CODE. IsData = false; } const char *pos = InputString.data(); // Skip delimiters and parse input filename (if needed). if (ClBinaryName.empty()) { pos += strspn(pos, kDelimiters); if (*pos == '"' || *pos == '\'') { char quote = *pos; pos++; const char *end = strchr(pos, quote); if (!end) return false; ModuleName = std::string(pos, end - pos); pos = end + 1; } else { int name_length = strcspn(pos, kDelimiters); ModuleName = std::string(pos, name_length); pos += name_length; } } else { ModuleName = ClBinaryName; } // Skip delimiters and parse module offset. pos += strspn(pos, kDelimiters); int offset_length = strcspn(pos, kDelimiters); return !StringRef(pos, offset_length).getAsInteger(0, ModuleOffset); } static void symbolizeInput(StringRef InputString, LLVMSymbolizer &Symbolizer, DIPrinter &Printer) { bool IsData = false; std::string ModuleName; uint64_t ModuleOffset = 0; if (!parseCommand(StringRef(InputString), IsData, ModuleName, ModuleOffset)) { outs() << InputString; return; } if (ClPrintAddress) { outs() << "0x"; outs().write_hex(ModuleOffset); StringRef Delimiter = ClPrettyPrint ? ": " : "\n"; outs() << Delimiter; } if (IsData) { auto ResOrErr = Symbolizer.symbolizeData(ModuleName, ModuleOffset); Printer << (error(ResOrErr) ? DIGlobal() : ResOrErr.get()); } else if (ClPrintInlining) { auto ResOrErr = Symbolizer.symbolizeInlinedCode(ModuleName, ModuleOffset, ClDwpName); Printer << (error(ResOrErr) ? DIInliningInfo() : ResOrErr.get()); } else { auto ResOrErr = Symbolizer.symbolizeCode(ModuleName, ModuleOffset, ClDwpName); Printer << (error(ResOrErr) ? DILineInfo() : ResOrErr.get()); } outs() << "\n"; outs().flush(); } int main(int argc, char **argv) { InitLLVM X(argc, argv); llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::MultiThreaded); cl::ParseCommandLineOptions(argc, argv, "llvm-symbolizer\n"); LLVMSymbolizer::Options Opts(ClPrintFunctions, ClUseSymbolTable, ClDemangle, ClUseRelativeAddress, ClDefaultArch); for (const auto &hint : ClDsymHint) { if (sys::path::extension(hint) == ".dSYM") { Opts.DsymHints.push_back(hint); } else { errs() << "Warning: invalid dSYM hint: \"" << hint << "\" (must have the '.dSYM' extension).\n"; } } LLVMSymbolizer Symbolizer(Opts); DIPrinter Printer(outs(), ClPrintFunctions != FunctionNameKind::None, ClPrettyPrint, ClPrintSourceContextLines, ClVerbose); if (ClInputAddresses.empty()) { const int kMaxInputStringLength = 1024; char InputString[kMaxInputStringLength]; while (fgets(InputString, sizeof(InputString), stdin)) symbolizeInput(InputString, Symbolizer, Printer); } else { for (StringRef Address : ClInputAddresses) symbolizeInput(Address, Symbolizer, Printer); } return 0; }