NFC. Refactored DIPrinter for support embedded source.

[aorlov]

Summary

This patch introduces source loading and pruning functions.
It will allow to use the DWARF embedded source and use the same code for JSON printout.
No functional changes.

[dblaikie]

Looks good, thanks!

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

 class DIInliningInfo;
 struct DIGlobal;
 struct DILocal;
 class ErrorInfoBase;
 class raw_ostream;
 
 namespace symbolize {
 
+class SourceCode;
+
 struct Request {
   StringRef ModuleName;
   Optional<uint64_t> Address;
 };
 
 class DIPrinter {
 public:
   DIPrinter() {}
protected:
   raw_ostream &OS;
   raw_ostream &ES;
   PrinterConfig Config;
 
   void print(const DILineInfo &Info, bool Inlined);
   void printFunctionName(StringRef FunctionName, bool Inlined);
   virtual void printSimpleLocation(StringRef Filename,
                                    const DILineInfo &Info) = 0;
-  void printContext(StringRef FileName, int64_t Line);
+  void printContext(SourceCode SourceCode);
   void printVerbose(StringRef Filename, const DILineInfo &Info);
   virtual void printFooter() {}
 
 private:
   void printHeader(uint64_t Address);
 
 public:
   PlainPrinterBase(raw_ostream &OS, raw_ostream &ES, PrinterConfig &Config)

llvm/lib/DebugInfo/Symbolize/DIPrinter.cpp

 #include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <string>
 
 namespace llvm {
 namespace symbolize {
 
+class SourceCode {
+  std::unique_ptr<MemoryBuffer> MemBuf;
+
+  const Optional<StringRef> load(StringRef FileName,
+                                 const Optional<StringRef> &EmbeddedSource) {
+    if (Lines <= 0)
+      return None;
+
+    if (EmbeddedSource)
+      return EmbeddedSource;
+    else {
+      ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
+          MemoryBuffer::getFile(FileName);
+      if (!BufOrErr)
+        return None;
+      MemBuf = std::move(*BufOrErr);
+      return MemBuf->getBuffer();
+    }
+  }
+
+  const Optional<StringRef> pruneSource(const Optional<StringRef> &Source) {
+    if (!Source)
+      return None;
+    size_t FirstLinePos = StringRef::npos, Pos = 0;
+    for (int64_t L = 1; L <= LastLine; ++L, ++Pos) {
+      if (L == FirstLine)
+        FirstLinePos = Pos;
+      Pos = Source->find('\n', Pos);
+      if (Pos == StringRef::npos)
+        break;
+    }
+    if (FirstLinePos == StringRef::npos)
+      return None;
+    return Source->substr(FirstLinePos, (Pos == StringRef::npos)
+                                            ? StringRef::npos
+                                            : Pos - FirstLinePos);
+  }
+
+public:
+  const int64_t Line;
+  const int Lines;
+  const int64_t FirstLine;
+  const int64_t LastLine;
+  const Optional<StringRef> PrunedSource;
+
+  SourceCode(
+      StringRef FileName, int64_t Line, int Lines,
+      const Optional<StringRef> &EmbeddedSource = Optional<StringRef>(None))
+      : Line(Line), Lines(Lines),
+        FirstLine(std::max(static_cast<int64_t>(1), Line - Lines / 2)),
+        LastLine(FirstLine + Lines - 1),
+        PrunedSource(pruneSource(load(FileName, EmbeddedSource))) {}
+};
+
 void PlainPrinterBase::printHeader(uint64_t Address) {
   if (Config.PrintAddress) {
     OS << "0x";
     OS.write_hex(Address);
     StringRef Delimiter = Config.Pretty ? ": " : "\n";
     OS << Delimiter;
   }
 }
 
 // Prints source code around in the FileName the Line.
-void PlainPrinterBase::printContext(StringRef FileName, int64_t Line) {
-  if (Config.SourceContextLines <= 0)
+void PlainPrinterBase::printContext(SourceCode SourceCode) {
+  if (!SourceCode.PrunedSource)
     return;
 
-  ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
-      MemoryBuffer::getFile(FileName);
-  if (!BufOrErr)
-    return;
+  StringRef Source = *SourceCode.PrunedSource;
+  std::string SourceCopy;
+  if (*Source.end() != '\0') {
+    SourceCopy = Source.str();
+    Source = SourceCopy;
+  }
 
-  std::unique_ptr<MemoryBuffer> Buf = std::move(BufOrErr.get());
-  int64_t FirstLine =
-      std::max(static_cast<int64_t>(1), Line - Config.SourceContextLines / 2);
-  int64_t LastLine = FirstLine + Config.SourceContextLines;
-  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";
-    }
+  size_t MaxLineNumberWidth = std::ceil(std::log10(SourceCode.LastLine));
+  for (line_iterator I = line_iterator(MemoryBufferRef(Source, ""), false);
+       !I.is_at_eof(); ++I) {
+    int64_t L = SourceCode.FirstLine + I.line_number() - 1;
+    if (L == SourceCode.Line)
+    OS << *I << '\n';
   }
 }
 
 void PlainPrinterBase::printFunctionName(StringRef FunctionName, bool Inlined) {
   if (Config.PrintFunctions) {
     if (FunctionName == DILineInfo::BadString)
       FunctionName = DILineInfo::Addr2LineBadString;
     StringRef Delimiter = Config.Pretty ? " at " : "\n";
     StringRef Prefix = (Config.Pretty && Inlined) ? " (inlined by) " : "";
     OS << Prefix << FunctionName << Delimiter;
   }
 }
 
 void LLVMPrinter::printSimpleLocation(StringRef Filename,
                                       const DILineInfo &Info) {
   OS << Filename << ':' << Info.Line << ':' << Info.Column << '\n';
-  printContext(Filename, Info.Line);
+  printContext(SourceCode(Filename, Info.Line, Config.SourceContextLines));
 }
 
 void GNUPrinter::printSimpleLocation(StringRef Filename,
                                      const DILineInfo &Info) {
   OS << Filename << ':' << Info.Line;
   if (Info.Discriminator)
     OS << " (discriminator " << Info.Discriminator << ')';
   OS << '\n';
-  printContext(Filename, Info.Line);
+  printContext(SourceCode(Filename, Info.Line, Config.SourceContextLines));
 }
 
 void PlainPrinterBase::printVerbose(StringRef Filename,
                                     const DILineInfo &Info) {
   OS << "  Filename: " << Filename << '\n';
   if (Info.StartLine) {
     OS << "  Function start filename: " << Info.StartFileName << '\n';
     OS << "  Function start line: " << Info.StartLine << '\n';