[llvm-symbolizer] Add `--output-style` switch.

[ikudrin]

Summary

In general, llvm-symbolizer follows the output style of GNU's addr2line. However, there are still some differences; in particular, for a requested address, llvm-symbolizer prints line and column, while addr2line prints only line number.

This patch adds a new switch to select the preferred style.

Other dissimilarities might be addressed later if required.

[jhenderson]

LGTM, with one comment. Feel free to ignore the comment, if you feel strongly about using the existing input file.

test/tools/llvm-symbolizer/output-style.test

1 ↗

(On Diff #193453)

Could you put the addresses explicitly here instead of piping from a file?

[ikudrin]

Thanks! I believe you are right. I'll put explicit addresses on commit.

[rupprecht]

Thanks for splitting this change off.

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

 namespace llvm {
 struct DILineInfo;
 class DIInliningInfo;
 struct DIGlobal;
 
 namespace symbolize {
 
 class DIPrinter {
+public:
+  enum class OutputStyle { LLVM, GNU };
+
+private:
   raw_ostream &OS;
   bool PrintFunctionNames;
   bool PrintPretty;
   int PrintSourceContext;
   bool Verbose;
   bool Basenames;
+  OutputStyle Style;
 
   void print(const DILineInfo &Info, bool Inlined);
   void printContext(const std::string &FileName, int64_t Line);
 
 public:
   DIPrinter(raw_ostream &OS, bool PrintFunctionNames = true,
             bool PrintPretty = false, int PrintSourceContext = 0,
-            bool Verbose = false, bool Basenames = false)
+            bool Verbose = false, bool Basenames = false,
+            OutputStyle Style = OutputStyle::LLVM)
       : OS(OS), PrintFunctionNames(PrintFunctionNames),
         PrintPretty(PrintPretty), PrintSourceContext(PrintSourceContext),
-        Verbose(Verbose), Basenames(Basenames) {}
+        Verbose(Verbose), Basenames(Basenames), Style(Style) {}
 
   DIPrinter &operator<<(const DILineInfo &Info);
   DIPrinter &operator<<(const DIInliningInfo &Info);
   DIPrinter &operator<<(const DIGlobal &Global);
 };
 }
 }
 
 #endif
 

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

if (PrintFunctionNames) {
     OS << Prefix << FunctionName << Delimiter;
   }
   std::string Filename = Info.FileName;
   if (Filename == kDILineInfoBadString)
     Filename = kBadString;
   else if (Basenames)
     Filename = llvm::sys::path::filename(Filename);
   if (!Verbose) {
-    OS << Filename << ":" << Info.Line << ":" << Info.Column << "\n";
+    OS << Filename << ":" << Info.Line;
+    if (Style == OutputStyle::LLVM)
+      OS << ":" << Info.Column;
+    OS << "\n";
     printContext(Filename, Info.Line);
     return;
   }
   OS << "  Filename: " << Filename << "\n";
   if (Info.StartLine)
     OS << "Function start line: " << Info.StartLine << "\n";
   OS << "  Line: " << Info.Line << "\n";
   OS << "  Column: " << Info.Column << "\n";

llvm/trunk/test/tools/llvm-symbolizer/output-style.test

+RUN: llvm-symbolizer -e %p/Inputs/addr.exe 0x40054d \
+RUN:   | FileCheck %s --check-prefix=LLVM
+
+RUN: llvm-symbolizer --output-style=GNU -e %p/Inputs/addr.exe 0x40054d \
+RUN:   | FileCheck %s --check-prefix=GNU
+
+RUN: llvm-symbolizer --output-style=LLVM -e %p/Inputs/addr.exe 0x40054d \
+RUN:   | FileCheck %s --check-prefix=LLVM
+
+LLVM: {{^}}/tmp{{\\|/}}x.c:3:3{{$}}
+GNU: {{^}}/tmp{{\\|/}}x.c:3{{$}}

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

 static cl::list<std::string> ClInputAddresses(cl::Positional,
                                               cl::desc("<input addresses>..."),
                                               cl::ZeroOrMore);
 
 static cl::opt<std::string>
     ClFallbackDebugPath("fallback-debug-path", cl::init(""),
                         cl::desc("Fallback path for debug binaries."));
 
+static cl::opt<DIPrinter::OutputStyle>
+    ClOutputStyle("output-style", cl::init(DIPrinter::OutputStyle::LLVM),
+                  cl::desc("Specify print style"), cl::Hidden,
+                  cl::values(clEnumValN(DIPrinter::OutputStyle::LLVM, "LLVM",
+                                        "LLVM default style"),
+                             clEnumValN(DIPrinter::OutputStyle::GNU, "GNU",
+                                        "GNU addr2line style")));
+
 template<typename T>
 static bool error(Expected<T> &ResOrErr) {
   if (ResOrErr)
     return false;
   logAllUnhandledErrors(ResOrErr.takeError(), errs(),
                         "LLVMSymbolizer: error reading file: ");
   return true;
 }
if (sys::path::extension(hint) == ".dSYM") {
       errs() << "Warning: invalid dSYM hint: \"" << hint <<
                 "\" (must have the '.dSYM' extension).\n";
     }
   }
   LLVMSymbolizer Symbolizer(Opts);
 
   DIPrinter Printer(outs(), ClPrintFunctions != FunctionNameKind::None,
                     ClPrettyPrint, ClPrintSourceContextLines, ClVerbose,
-                    ClBasenames);
+                    ClBasenames, ClOutputStyle);
 
   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;
 }