[llvm-symbolizer] -print-source-context-lines option to print source code around the line.

[samsonov]

tools/llvm-symbolizer/llvm-symbolizer.cpp

195

This will be confusing: first you will print several blocks with function/file/lineno, and then several blocks with source code. Shouldn't they be interchanged? Probably source code printing can be implemented in DIPrinter.

[aizatsky]

review

[aizatsky]

ptal

[aizatsky]

nits

[aizatsky]

nits

[aizatsky]

nits

[samsonov]

tools/llvm-symbolizer/llvm-symbolizer.cpp

195

So, what are the drawbacks of printing source file contents from DIPrinter? We changed llvm-symbolizer to be agnostic of the way DILineInfo / DIInliningInfo is represented: and pass it directly from producer to printer, and now we return to manually writing all these loops.

Keeping that in DIPrinter would also let you write unit tests for that functionality, if needed.

[aizatsky]

moved context functionality into printer.

[aizatsky]

nits

[aizatsky]

nits

[samsonov]

LGTM (but switch to line_iterator if it's convenient).

lib/DebugInfo/Symbolize/DIPrinter.cpp

47

Can you use include/llvm/Support/LineIterator.h instead of splitting file manually?

[aizatsky]

using line iterator.

include/llvm/DebugInfo/Symbolize/DIPrinter.h

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

lib/DebugInfo/Symbolize/DIPrinter.cpp

 // This file defines the DIPrinter class, which is responsible for printing
 // structures defined in DebugInfo/DIContext.h
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/Symbolize/DIPrinter.h"
 
 #include "llvm/DebugInfo/DIContext.h"
+#include "llvm/Support/LineIterator.h"
 
 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[] = "??";
 
-void DIPrinter::printName(const DILineInfo &Info, bool Inlined) {
+// Prints source code around in the FileName the Line.
+void DIPrinter::printContext(std::string FileName, int64_t Line) {
+  if (PrintSourceContext <= 0)
+    return;
+
+  ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
+      MemoryBuffer::getFile(FileName);
+  if (!BufOrErr)
+    return;
+
+  std::unique_ptr<MemoryBuffer> Buf = std::move(BufOrErr.get());
+  int64_t FirstLine = std::max(1l, Line - PrintSourceContext / 2);
+  int64_t LastLine = FirstLine + PrintSourceContext;
+  size_t MaxLineNumberWidth = std::ceil(std::log10(LastLine));
+
+  for (line_iterator I = line_iterator(*Buf, false);
+       !I.is_at_eof() && I.line_number() <= LastLine; ++I) {
+    int64_t L = I.line_number();
+    if (L >= FirstLine && L <= LastLine) {
+      OS << format_decimal(L, MaxLineNumberWidth);
+      if (L == Line)
+        OS << " >: ";
+      else
+        OS << "  : ";
+      OS << *I << "\n";
+    }
+  }
+}
+
+void DIPrinter::print(const DILineInfo &Info, bool Inlined) {
   if (PrintFunctionNames) {
     std::string FunctionName = Info.FunctionName;
     if (FunctionName == kDILineInfoBadString)
       FunctionName = kBadString;
 
     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";
+  printContext(Filename, Info.Line);
 }
 
 DIPrinter &DIPrinter::operator<<(const DILineInfo &Info) {
-  printName(Info, false);
+  print(Info, false);
   return *this;
 }
 
 DIPrinter &DIPrinter::operator<<(const DIInliningInfo &Info) {
   uint32_t FramesNum = Info.getNumberOfFrames();
   if (FramesNum == 0) {
-    printName(DILineInfo(), false);
+    print(DILineInfo(), false);
     return *this;
   }
   for (uint32_t i = 0; i < FramesNum; i++)
-    printName(Info.getFrame(i), i > 0);
+    print(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;
 }
 
 }
 }

test/lit.cfg

 # Add site-specific substitutions.
 config.substitutions.append( ('%gold', config.gold_executable) )
 config.substitutions.append( ('%ld64', config.ld64_executable) )
 config.substitutions.append( ('%go', config.go_executable) )
 config.substitutions.append( ('%llvmshlibdir', config.llvm_shlib_dir) )
 config.substitutions.append( ('%shlibext', config.llvm_shlib_ext) )
 config.substitutions.append( ('%exeext', config.llvm_exe_ext) )
 config.substitutions.append( ('%python', config.python_executable) )
+config.substitutions.append( ('%host_cc', config.host_cc) )
 
 # OCaml substitutions.
 # Support tests for both native and bytecode builds.
 config.substitutions.append( ('%ocamlc',
     "%s ocamlc -cclib -L%s %s" %
         (config.ocamlfind_executable, llvm_lib_dir, config.ocaml_flags)) )
 if config.have_ocamlopt in ('1', 'TRUE'):
     config.substitutions.append( ('%ocamlopt',
for pattern in [r"\bbugpoint\b(?!-)",
                 r"\bllvm-profdata\b",
                 r"\bllvm-ranlib\b",
                 r"\bllvm-readobj\b",
                 r"\bllvm-rtdyld\b",
                 r"\bllvm-size\b",
                 r"\bllvm-split\b",
                 r"\bllvm-tblgen\b",
                 r"\bllvm-c-test\b",
+                NOJUNK + r"\bllvm-symbolizer\b",
                 NOJUNK + r"\bopt\b",
                 r"\bFileCheck\b",
                 r"\bobj2yaml\b",
                 NOJUNK + r"\bsancov\b",
                 r"\byaml2obj\b",
                 r"\byaml-bench\b",
                 r"\bverify-uselistorder\b",
                 # Handle these specially as they are strings searched

test/tools/llvm-symbolizer/print_context.c

+// REQUIRES: x86_64-linux
+// RUN: %host_cc -O0 -g %s -o %t 2>&1
+// RUN: %t 2>&1 | llvm-symbolizer -print-source-context-lines=5 -obj=%t | FileCheck %s --check-prefix=CHECK
+
+#include <stdio.h>
+
+int inc(int a) {
+  return a + 1;
+}
+
+int main() {
+  printf("%p\n", inc);
+  return 0;
+}
+
+// CHECK: inc
+// CHECK: print_context.c:7
+// CHECK: 5  : #include
+// CHECK: 6  :
+// CHECK: 7 >: int inc
+// CHECK: 8  :   return
+// CHECK: 9  : }

tools/llvm-symbolizer/llvm-symbolizer.cpp

 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 cl::opt<int> ClPrintSourceContextLines(
+    "print-source-context-lines", cl::init(0),
+    cl::desc("Print N number of source file context"));
+
 static bool error(std::error_code ec) {
   if (!ec)
     return false;
   errs() << "LLVMSymbolizer: error reading file: " << ec.message() << ".\n";
   return true;
 }
 
 static bool parseCommand(StringRef InputString, bool &IsData,
for (const auto &hint : ClDsymHint) {
     } else {
       errs() << "Warning: invalid dSYM hint: \"" << hint <<
                 "\" (must have the '.dSYM' extension).\n";
     }
   }
   LLVMSymbolizer Symbolizer(Opts);
 
   DIPrinter Printer(outs(), ClPrintFunctions != FunctionNameKind::None,
-                    ClPrettyPrint);
+                    ClPrettyPrint, ClPrintSourceContextLines);
 
   const int kMaxInputStringLength = 1024;
   char InputString[kMaxInputStringLength];
 
   while (true) {
     if (!fgets(InputString, sizeof(InputString), stdin))
       break;
 
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());
     } else {
       auto ResOrErr = Symbolizer.symbolizeCode(ModuleName, ModuleOffset);
       Printer << (error(ResOrErr.getError()) ? DILineInfo() : ResOrErr.get());
     }
     outs() << "\n";
     outs().flush();
   }
 
   return 0;
 }