Add -pretty-print option to llvm-symbolizer

[khemant]

Summary

Add addr2line equivalent of -pretty-print

[khemant]

Comments?

[samsonov]

docs/CommandGuide/llvm-symbolizer.rst

105 ↗

(On Diff #37154)

Consider providing more details about the output difference (closer to how -pretty-print is described in "man addr2line"). You can also expand EXAMPLE section.

tools/llvm-symbolizer/LLVMSymbolize.h

49 ↗

(On Diff #37154)

Let's keep the same order of members and ctor args.

tools/llvm-symbolizer/llvm-symbolizer.cpp

164 ↗

(On Diff #37154)

You can just use ternary operator here (and above).

[samsonov]

You will need to update it after r251316. Also see http://reviews.llvm.org/D14099 with a brief plan of future changes - in case you want to hold this off until we factor out DILineInfo / DIInliningInfo rendering into separate class (PrettyPrint should be used there). It's fine if you want to proceed with this earlier, though,

[khemant]

I can wait till you re-factor the code. When are you planning to merge the patch that has SymbolizableObjectFile ?

[samsonov]

I've changed a bunch of related code recently. Probably now you will need to add this functionality to DIPrinter implementation.

[khemant]

I was looking at it at this very moment.

[khemant]

Changed for new design.

[samsonov]

include/llvm/DebugInfo/Symbolize/Symbolize.h

41 ↗

(On Diff #39257)

You don't need this now, do you?

lib/DebugInfo/Symbolize/DIPrinter.cpp

27 ↗

(On Diff #39257)

argument/variable names start with capital letters (here and below)

36 ↗

(On Diff #39257)

Just make this function print all the data to OS instead of creating a string.

48 ↗

(On Diff #39257)

extra semicolon?

55 ↗

(On Diff #39257)

Do you need to use printName here?

58 ↗

(On Diff #39257)

i is always less than FrameNum
This whole block can be just

OS << printName(Info.getFrame(i), i > 0);

[khemant]

Did some clean up.

[samsonov]

include/llvm/DebugInfo/Symbolize/DIPrinter.h

31 ↗

(On Diff #39380)

"InlinedFrame"? (also, CamelCase for variables).

lib/DebugInfo/Symbolize/DIPrinter.cpp

36 ↗

(On Diff #39380)

I still don't see why you need std::string here - just pass all the stuff you print directly to OS.

58 ↗

(On Diff #39380)

CamelCase. Also, probably you don't need extra var for this.

tools/llvm-symbolizer/llvm-symbolizer.cpp

82 ↗

(On Diff #39380)

"readable". Also, I would prefer smth. along the lines of Make the output more human friendly.

[khemant]

Done with the changes.

[samsonov]

Looks almost fine, minor remaining comments below.

docs/CommandGuide/llvm-symbolizer.rst

113 ↗

(On Diff #39713)

You probably need to enclose "-inlining" in double ticks as we do with other flags (check generated file).

114 ↗

(On Diff #39713)

Grammar: "refer to"

lib/DebugInfo/Symbolize/DIPrinter.cpp

33 ↗

(On Diff #39713)

Delimiter (CamelCase)

35 ↗

(On Diff #39713)

OS << Prefix << FunctionName << Delimiter;

41 ↗

(On Diff #39713)

run this with clang-format.

56–57 ↗

(On Diff #39713)

Please address

[khemant]

Camelcased all variables.

[samsonov]

lib/DebugInfo/Symbolize/DIPrinter.cpp

35 ↗

(On Diff #39843)

Please address. I don't think you need .str calls, or even extra vars:

if (PrintPretty && Inlined)
  OS << " (inlined by) ";
OS << FunctionName;
OS << (PrintPretty ? " at " : "\n");

40 ↗

(On Diff #39843)

Do you still need std::to_string calls?

[samsonov]

LGTM. Thanks for implementing this, and for patience!

llvm/trunk/docs/CommandGuide/llvm-symbolizer.rst

.. code-block:: console
   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
 
   Path to object file to be symbolized.
 

 
  (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
+ 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.

llvm/trunk/include/llvm/DebugInfo/Symbolize/DIPrinter.h

 class DIInliningInfo;
 struct DIGlobal;
 
 namespace symbolize {
 
 class DIPrinter {
   raw_ostream &OS;
   bool PrintFunctionNames;
+  bool PrintPretty;
+  void printName(const DILineInfo &Info, bool Inlined);
 
 public:
-  DIPrinter(raw_ostream &OS, bool PrintFunctionNames = true)
-      : OS(OS), PrintFunctionNames(PrintFunctionNames) {}
+  DIPrinter(raw_ostream &OS, bool PrintFunctionNames = true,
+            bool PrintPretty = false)
+      : OS(OS), PrintFunctionNames(PrintFunctionNames),
+        PrintPretty(PrintPretty) {}
 
   DIPrinter &operator<<(const DILineInfo &Info);
   DIPrinter &operator<<(const DIInliningInfo &Info);
   DIPrinter &operator<<(const DIGlobal &Global);
 };
 }
 }
 
 #endif
 

llvm/trunk/lib/DebugInfo/Symbolize/DIPrinter.cpp

 namespace llvm {
 namespace symbolize {
 
 // By default, DILineInfo contains "<invalid>" for function/filename it
 // cannot fetch. We replace it to "??" to make our output closer to addr2line.
 static const char kDILineInfoBadString[] = "<invalid>";
 static const char kBadString[] = "??";
 
-DIPrinter &DIPrinter::operator<<(const DILineInfo &Info) {
+void DIPrinter::printName(const DILineInfo &Info, bool Inlined) {
   if (PrintFunctionNames) {
     std::string FunctionName = Info.FunctionName;
     if (FunctionName == kDILineInfoBadString)
       FunctionName = kBadString;
-    OS << FunctionName << "\n";
+
+    StringRef Delimiter = (PrintPretty == true) ? " at " : "\n";
+    StringRef Prefix = (PrintPretty && Inlined) ? " (inlined by) " : "";
+    OS << Prefix << FunctionName << Delimiter;
   }
   std::string Filename = Info.FileName;
   if (Filename == kDILineInfoBadString)
     Filename = kBadString;
   OS << Filename << ":" << Info.Line << ":" << Info.Column << "\n";
+}
+
+DIPrinter &DIPrinter::operator<<(const DILineInfo &Info) {
+  printName(Info, false);
   return *this;
 }
 
 DIPrinter &DIPrinter::operator<<(const DIInliningInfo &Info) {
   uint32_t FramesNum = Info.getNumberOfFrames();
-  if (FramesNum == 0)
-    return (*this << DILineInfo());
-  for (uint32_t i = 0; i < FramesNum; i++) {
-    *this << Info.getFrame(i);
+  if (FramesNum == 0) {
+    printName(DILineInfo(), false);
+    return *this;
   }
+  for (uint32_t i = 0; i < FramesNum; i++)
+    printName(Info.getFrame(i), i > 0);
   return *this;
 }
 
 DIPrinter &DIPrinter::operator<<(const DIGlobal &Global) {
   std::string Name = Global.Name;
   if (Name == kDILineInfoBadString)
     Name = kBadString;
   OS << Name << "\n";
   OS << Global.Start << " " << Global.Size << "\n";
   return *this;
 }
 
 }
 }

llvm/trunk/test/tools/llvm-symbolizer/sym.test

 #Source:
 ##include <stdio.h>
-#static inline int inc (int *a) {
+#static inline int inctwo (int *a) {
 #  printf ("%d\n",(*a)++);
 #  return (*a)++;
 #}
+#static inline int inc (int *a) {
+#  printf ("%d\n",inctwo(a));
+#  return (*a)++;
+#}
+#
 #
 #int main () {
 #  int x = 1;
 #  return inc(&x);
 #}
+#
 #Build as : clang -g -O2 addr.c
 
-RUN: llvm-symbolizer -inlining -print-address -obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck %s
+RUN: llvm-symbolizer -print-address -obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck %s
+RUN: llvm-symbolizer -inlining -print-address -pretty-print -obj=%p/Inputs/addr.exe < %p/Inputs/addr.inp | FileCheck --check-prefix="PRETTY" %s 
 
 #CHECK: 0x40054d
 #CHECK: main
-#CHECK: {{[/\]+}}tmp{{[/\]+}}x.c:9:0
+#CHECK: {{[/\]+}}tmp{{[/\]+}}x.c:14:0
+#
+#PRETTY: {{[0x]+}}40054d: inctwo at {{[/\]+}}tmp{{[/\]+}}x.c:3:3
+#PRETTY:  (inlined by) inc at {{[/\]+}}tmp{{[/\]+}}x.c:7:0
+#PRETTY   (inlined by) main at {{[/\]+}}tmp{{[/\]+}}x.c:14:0
 

llvm/trunk/tools/llvm-symbolizer/llvm-symbolizer.cpp

 static cl::list<std::string>
 ClDsymHint("dsym-hint", cl::ZeroOrMore,
            cl::desc("Path to .dSYM bundles to search for debug info for the "
                     "object files"));
 static cl::opt<bool>
     ClPrintAddress("print-address", cl::init(false),
                    cl::desc("Show address before line information"));
 
+static cl::opt<bool>
+    ClPrettyPrint("pretty-print", cl::init(false),
+                  cl::desc("Make the output more human friendly"));
+
 static bool error(std::error_code ec) {
   if (!ec)
     return false;
   errs() << "LLVMSymbolizer: error reading file: " << ec.message() << ".\n";
   return true;
 }
 
 static bool parseCommand(bool &IsData, std::string &ModuleName,
int main(int argc, char **argv) {
   PrettyStackTraceProgram X(argc, argv);
   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
 
   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);
 
   bool IsData = false;
   std::string ModuleName;
   uint64_t ModuleOffset;
-  DIPrinter Printer(outs(), ClPrintFunctions != FunctionNameKind::None);
+  DIPrinter Printer(outs(), ClPrintFunctions != FunctionNameKind::None,
+                    ClPrettyPrint);
 
   while (parseCommand(IsData, ModuleName, ModuleOffset)) {
     if (ClPrintAddress) {
       outs() << "0x";
       outs().write_hex(ModuleOffset);
-      outs() << "\n";
+      StringRef Delimiter = (ClPrettyPrint == true) ? ": " : "\n";
+      outs() << Delimiter;
     }
     if (IsData) {
       auto ResOrErr = Symbolizer.symbolizeData(ModuleName, ModuleOffset);
       Printer << (error(ResOrErr.getError()) ? DIGlobal() : ResOrErr.get());
     } else if (ClPrintInlining) {
       auto ResOrErr = Symbolizer.symbolizeInlinedCode(ModuleName, ModuleOffset);
       Printer << (error(ResOrErr.getError()) ? DIInliningInfo()
                                              : ResOrErr.get());