Improve llvm-gsymutil performance in quiet mode.

[clayborg]

Summary

The GSYM code alwasy logging to streams even in quiet mode. When in quiet mode we would use the "nulls()" stream to avoid logging to the terminal, but this still caused logging functions to be called on DWARFDie objects and other messages which were quite expensive and not needed if we weren't logging anything. This patch switches some logs in performant areas to be "raw_ostream *" values and if the ostream pointer is NULL, then we don't call the expensive logging functions on DWARFDie and other objects which will improve performance.

[clayborg]

Remove the "Log" member variable from the DWARFTransformer class.

llvm/include/llvm/DebugInfo/GSYM/DwarfTransformer.h

 /// allows this class to be unit tested.
 class DwarfTransformer {
 public:
 
   /// Create a DWARF transformer.
   ///
   /// \param D The DWARF to use when converting to GSYM.
   ///
-  /// \param OS The stream to log warnings and non fatal issues to.
-  ///
   /// \param G The GSYM creator to populate with the function information
   /// from the debug info.
-  DwarfTransformer(DWARFContext &D, raw_ostream &OS, GsymCreator &G) :
-      DICtx(D), Log(OS), Gsym(G) {}
+  DwarfTransformer(DWARFContext &D, GsymCreator &G) : DICtx(D), Gsym(G) {}
 
   /// Extract the DWARF from the supplied object file and convert it into the
   /// Gsym format in the GsymCreator object that is passed in. Returns an
   /// error if something fatal is encountered.
   ///
+  /// \param NumThreads The number of threads that the conversion process can
+  ///                   use.
+  ///
+  /// \param OS The stream to log warnings and non fatal issues to. If NULL
+  ///           then don't log.
+  ///
   /// \returns An error indicating any fatal issues that happen when parsing
   /// the DWARF, or Error::success() if all goes well.
-  llvm::Error convert(uint32_t NumThreads);
-
-  llvm::Error verify(StringRef GsymPath);
+  llvm::Error convert(uint32_t NumThreads, raw_ostream *OS);
 
+  llvm::Error verify(StringRef GsymPath, raw_ostream &OS);
 
 private:
 
   /// Parse the DWARF in the object file and convert it into the GsymCreator.
   Error parse();
 
   /// Handle any DIE (debug info entry) from the DWARF.
   ///
   /// This function will find all DW_TAG_subprogram DIEs that convert them into
   /// GSYM FuntionInfo objects and add them to the GsymCreator supplied during
   /// construction. The DIE and all its children will be recursively parsed
   /// with calls to this function.
   ///
   /// \param Strm The thread specific log stream for any non fatal errors and
   /// warnings. Once a thread has finished parsing an entire compile unit, all
   /// information in this temporary stream will be forwarded to the member
-  /// variable log. This keeps logging thread safe.
+  /// variable log. This keeps logging thread safe. If the value is NULL, then
+  /// don't log.
   ///
   /// \param CUI The compile unit specific information that contains the DWARF
   /// line table, cached file list, and other compile unit specific
   /// information.
   ///
   /// \param Die The DWARF debug info entry to parse.
-  void handleDie(raw_ostream &Strm, CUInfo &CUI, DWARFDie Die);
+  void handleDie(raw_ostream *Strm, CUInfo &CUI, DWARFDie Die);
 
   DWARFContext &DICtx;
-  raw_ostream &Log;
   GsymCreator &Gsym;
 
   friend class DwarfTransformerTest;
 };
 
 } // namespace gsym
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_GSYM_DWARFTRANSFORMER_H

llvm/include/llvm/DebugInfo/GSYM/ObjectFileTransformer.h

 public:
   /// Extract any object file data that is needed by the GsymCreator.
   ///
   /// The extracted information includes the UUID of the binary and converting
   /// all function symbols from any symbol tables into FunctionInfo objects.
   ///
   /// \param Obj The object file that contains the DWARF debug info.
   ///
-  /// \param Log The stream to log warnings and non fatal issues to.
+  /// \param Log The stream to log warnings and non fatal issues to. If NULL,
+  ///            don't log.
   ///
   /// \param Gsym The GSYM creator to populate with the function information
   /// from the debug info.
   ///
   /// \returns An error indicating any fatal issues that happen when parsing
   /// the DWARF, or Error::success() if all goes well.
-  static llvm::Error convert(const object::ObjectFile &Obj,
-                             raw_ostream &Log,
+  static llvm::Error convert(const object::ObjectFile &Obj, raw_ostream *Log,
                              GsymCreator &Gsym);
 };
 
 } // namespace gsym
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_GSYM_OBJECTFILETRANSFORMER_H

llvm/lib/DebugInfo/GSYM/DwarfTransformer.cpp

if (!CheckChildren)
     return false;
   for (DWARFDie ChildDie : Die.children()) {
     if (hasInlineInfo(ChildDie, Depth + 1))
       return true;
   }
   return false;
 }
 
-static void parseInlineInfo(GsymCreator &Gsym, raw_ostream &Log, CUInfo &CUI,
+static void parseInlineInfo(GsymCreator &Gsym, raw_ostream *Log, CUInfo &CUI,
                             DWARFDie Die, uint32_t Depth, FunctionInfo &FI,
                             InlineInfo &parent) {
   if (!hasInlineInfo(Die, Depth))
     return;
 
   dwarf::Tag Tag = Die.getTag();
   if (Tag == dwarf::DW_TAG_inlined_subroutine) {
     // create new InlineInfo and append to parent.children
     InlineInfo II;
     Expected<DWARFAddressRangesVector> RangesOrError = Die.getAddressRanges();
     if (RangesOrError) {
       for (const DWARFAddressRange &Range : RangesOrError.get()) {
         // Check that the inlined function is within the any of the range the
         // parent InlineInfo. If it isn't remove it!
         AddressRange InlineRange(Range.LowPC, Range.HighPC);
         if (parent.Ranges.contains(InlineRange)) {
           II.Ranges.insert(InlineRange);
-        } else {
-          Log << "error: inlined function DIE at " << HEX32(Die.getOffset())
+        } else if (Log) {
+          *Log << "error: inlined function DIE at " << HEX32(Die.getOffset())
                << " has a range [" << HEX64(Range.LowPC) << " - "
                << HEX64(Range.HighPC) << ") that isn't contained in any parent "
                << "address ranges, this inline range will be removed.\n";
         }
       }
     }
     if (II.Ranges.empty())
       return;
 
     if (auto NameIndex = getQualifiedNameIndex(Die, CUI.Language, Gsym))
       II.Name = *NameIndex;
     II.CallFile = CUI.DWARFToGSYMFileIndex(
         Gsym, dwarf::toUnsigned(Die.find(dwarf::DW_AT_call_file), 0));
     II.CallLine = dwarf::toUnsigned(Die.find(dwarf::DW_AT_call_line), 0);
     // parse all children and append to parent
     for (DWARFDie ChildDie : Die.children())
       parseInlineInfo(Gsym, Log, CUI, ChildDie, Depth + 1, FI, II);
     parent.Children.emplace_back(std::move(II));
     return;
   }
   if (Tag == dwarf::DW_TAG_subprogram || Tag == dwarf::DW_TAG_lexical_block) {
     // skip this Die and just recurse down
     for (DWARFDie ChildDie : Die.children())
       parseInlineInfo(Gsym, Log, CUI, ChildDie, Depth + 1, FI, parent);
   }
 }
 
-static void convertFunctionLineTable(raw_ostream &Log, CUInfo &CUI,
+static void convertFunctionLineTable(raw_ostream *Log, CUInfo &CUI,
                                      DWARFDie Die, GsymCreator &Gsym,
                                      FunctionInfo &FI) {
   std::vector<uint32_t> RowVector;
   const uint64_t StartAddress = FI.startAddress();
   const uint64_t EndAddress = FI.endAddress();
   const uint64_t RangeSize = EndAddress - StartAddress;
   const object::SectionedAddress SecAddress{
       StartAddress, object::SectionedAddress::UndefSection};
for (uint32_t RowIndex : RowVector) {
     // Watch out for a RowAddress that is in the middle of a line table entry
     // in the DWARF. If we pass an address in between two line table entries
     // we will get a RowIndex for the previous valid line table row which won't
     // be contained in our function. This is usually a bug in the DWARF due to
     // linker problems or LTO or other DWARF re-linking so it is worth emitting
     // an error, but not worth stopping the creation of the GSYM.
     if (!FI.Range.contains(RowAddress)) {
       if (RowAddress < FI.Range.start()) {
-        Log << "error: DIE has a start address whose LowPC is between the "
+        if (Log) {
+          *Log << "error: DIE has a start address whose LowPC is between the "
                   "line table Row[" << RowIndex << "] with address "
                << HEX64(RowAddress) << " and the next one.\n";
-        Die.dump(Log, 0, DIDumpOptions::getForSingleDIE());
+          Die.dump(*Log, 0, DIDumpOptions::getForSingleDIE());
+        }
         RowAddress = FI.Range.start();
       } else {
         continue;
       }
     }
 
     LineEntry LE(RowAddress, FileIdx, Row.Line);
     if (RowIndex != RowVector[0] && Row.Address < PrevRow.Address) {
       // We have seen full duplicate line tables for functions in some
       // DWARF files. Watch for those here by checking the the last
       // row was the function's end address (HighPC) and that the
       // current line table entry's address is the same as the first
       // line entry we already have in our "function_info.Lines". If
       // so break out after printing a warning.
       auto FirstLE = FI.OptLineTable->first();
       if (FirstLE && *FirstLE == LE) {
-        if (!Gsym.isQuiet()) {
-          Log << "warning: duplicate line table detected for DIE:\n";
-          Die.dump(Log, 0, DIDumpOptions::getForSingleDIE());
+        if (Log && !Gsym.isQuiet()) {
+          *Log << "warning: duplicate line table detected for DIE:\n";
+          Die.dump(*Log, 0, DIDumpOptions::getForSingleDIE());
         }
       } else {
-        // Print out (ignore if os == nulls as this is expensive)
-        Log << "error: line table has addresses that do not "
+        if (Log) {
+          *Log << "error: line table has addresses that do not "
                << "monotonically increase:\n";
-        for (uint32_t RowIndex2 : RowVector) {
-          CUI.LineTable->Rows[RowIndex2].dump(Log);
+          for (uint32_t RowIndex2 : RowVector)
+            CUI.LineTable->Rows[RowIndex2].dump(*Log);
+          Die.dump(*Log, 0, DIDumpOptions::getForSingleDIE());
         }
-        Die.dump(Log, 0, DIDumpOptions::getForSingleDIE());
       }
       break;
     }
 
     // Skip multiple line entries for the same file and line.
     auto LastLE = FI.OptLineTable->last();
     if (LastLE && LastLE->File == FileIdx && LastLE->Line == Row.Line)
         continue;
for (uint32_t RowIndex : RowVector) {
     }
   }
   // If not line table rows were added, clear the line table so we don't encode
   // on in the GSYM file.
   if (FI.OptLineTable->empty())
     FI.OptLineTable = std::nullopt;
 }
 
-void DwarfTransformer::handleDie(raw_ostream &OS, CUInfo &CUI, DWARFDie Die) {
+void DwarfTransformer::handleDie(raw_ostream *OS, CUInfo &CUI, DWARFDie Die) {
   switch (Die.getTag()) {
   case dwarf::DW_TAG_subprogram: {
     Expected<DWARFAddressRangesVector> RangesOrError = Die.getAddressRanges();
     if (!RangesOrError) {
       consumeError(RangesOrError.takeError());
       break;
     }
     const DWARFAddressRangesVector &Ranges = RangesOrError.get();
     if (Ranges.empty())
       break;
     auto NameIndex = getQualifiedNameIndex(Die, CUI.Language, Gsym);
     if (!NameIndex) {
-      OS << "error: function at " << HEX64(Die.getOffset())
+      if (OS) {
+        *OS << "error: function at " << HEX64(Die.getOffset())
             << " has no name\n ";
-      Die.dump(OS, 0, DIDumpOptions::getForSingleDIE());
+        Die.dump(*OS, 0, DIDumpOptions::getForSingleDIE());
+      }
       break;
     }
 
     // Create a function_info for each range
     for (const DWARFAddressRange &Range : Ranges) {
       // The low PC must be less than the high PC. Many linkers don't remove
       // DWARF for functions that don't get linked into the final executable.
       // If both the high and low pc have relocations, linkers will often set
for (const DWARFAddressRange &Range : Ranges) {
       if (!Gsym.IsValidTextAddress(Range.LowPC)) {
         // We expect zero and -1 to be invalid addresses in DWARF depending
         // on the linker of the DWARF. This indicates a function was stripped
         // and the debug info wasn't able to be stripped from the DWARF. If
         // the LowPC isn't zero or -1, then we should emit an error.
         if (Range.LowPC != 0) {
           if (!Gsym.isQuiet()) {
             // Unexpected invalid address, emit a warning
-            OS << "warning: DIE has an address range whose start address is "
-                  "not in any executable sections ("
+            if (OS) {
+              *OS << "warning: DIE has an address range whose start address "
+                     "is not in any executable sections ("
                   << *Gsym.GetValidTextRanges()
                   << ") and will not be processed:\n";
-            Die.dump(OS, 0, DIDumpOptions::getForSingleDIE());
+              Die.dump(*OS, 0, DIDumpOptions::getForSingleDIE());
+            }
           }
         }
         break;
       }
 
       FunctionInfo FI;
       FI.Range = {Range.LowPC, Range.HighPC};
       FI.Name = *NameIndex;
for (const DWARFAddressRange &Range : Ranges) {
         // from the function info. We have seen cases where LTO tries to modify
         // the DWARF for functions and it messes up the address ranges for
         // the inline functions so it is no longer valid.
         //
         // By checking if there are any valid children on the top level inline
         // information object, we will know if we got anything valid from the
         // debug info.
         if (FI.Inline->Children.empty()) {
-          if (!Gsym.isQuiet()) {
-            OS << "warning: DIE contains inline function information that has "
+          if (OS && !Gsym.isQuiet()) {
+            *OS << "warning: DIE contains inline function information that has "
                   "no valid ranges, removing inline information:\n";
-            Die.dump(OS, 0, DIDumpOptions::getForSingleDIE());
+            Die.dump(*OS, 0, DIDumpOptions::getForSingleDIE());
           }
           FI.Inline = std::nullopt;
         }
       }
       Gsym.addFunctionInfo(std::move(FI));
     }
   } break;
   default:
     break;
   }
   for (DWARFDie ChildDie : Die.children())
     handleDie(OS, CUI, ChildDie);
 }
 
-Error DwarfTransformer::convert(uint32_t NumThreads) {
+Error DwarfTransformer::convert(uint32_t NumThreads, raw_ostream *OS) {
   size_t NumBefore = Gsym.getNumFunctionInfos();
   auto getDie = [&](DWARFUnit &DwarfUnit) -> DWARFDie {
     DWARFDie ReturnDie = DwarfUnit.getUnitDIE(false);
     if (std::optional<uint64_t> DWOId = DwarfUnit.getDWOId()) {
       DWARFUnit *DWOCU = DwarfUnit.getNonSkeletonUnitDIE(false).getDwarfUnit();
-      if (!DWOCU->isDWOUnit()) {
+      if (OS && !DWOCU->isDWOUnit()) {
         std::string DWOName = dwarf::toString(
             DwarfUnit.getUnitDIE().find(
                 {dwarf::DW_AT_dwo_name, dwarf::DW_AT_GNU_dwo_name}),
             "");
-        Log << "warning: Unable to retrieve DWO .debug_info section for "
+        *OS << "warning: Unable to retrieve DWO .debug_info section for "
             << DWOName << "\n";
       } else {
         ReturnDie = DWOCU->getUnitDIE(false);
       }
     }
     return ReturnDie;
   };
   if (NumThreads == 1) {
     // Parse all DWARF data from this thread, use the same string/file table
     // for everything
     for (const auto &CU : DICtx.compile_units()) {
       DWARFDie Die = getDie(*CU);
       CUInfo CUI(DICtx, dyn_cast<DWARFCompileUnit>(CU.get()));
-      handleDie(Log, CUI, Die);
+      handleDie(OS, CUI, Die);
     }
   } else {
     // LLVM Dwarf parser is not thread-safe and we need to parse all DWARF up
     // front before we start accessing any DIEs since there might be
     // cross compile unit references in the DWARF. If we don't do this we can
     // end up crashing.
 
     // We need to call getAbbreviations sequentially first so that getUnitDIE()
if (NumThreads == 1) {
     pool.wait();
 
     // Now convert all DWARF to GSYM in a thread pool.
     std::mutex LogMutex;
     for (const auto &CU : DICtx.compile_units()) {
       DWARFDie Die = getDie(*CU);
       if (Die) {
         CUInfo CUI(DICtx, dyn_cast<DWARFCompileUnit>(CU.get()));
-        pool.async([this, CUI, &LogMutex, Die]() mutable {
+        pool.async([this, CUI, &LogMutex, OS, Die]() mutable {
           std::string ThreadLogStorage;
           raw_string_ostream ThreadOS(ThreadLogStorage);
-          handleDie(ThreadOS, CUI, Die);
+          handleDie(OS ? &ThreadOS: nullptr, CUI, Die);
           ThreadOS.flush();
-          if (!ThreadLogStorage.empty()) {
+          if (OS && !ThreadLogStorage.empty()) {
             // Print ThreadLogStorage lines into an actual stream under a lock
             std::lock_guard<std::mutex> guard(LogMutex);
-            Log << ThreadLogStorage;
+            *OS << ThreadLogStorage;
           }
         });
       }
     }
     pool.wait();
   }
   size_t FunctionsAddedCount = Gsym.getNumFunctionInfos() - NumBefore;
-  Log << "Loaded " << FunctionsAddedCount << " functions from DWARF.\n";
+  if (OS)
+    *OS << "Loaded " << FunctionsAddedCount << " functions from DWARF.\n";
   return Error::success();
 }
 
-llvm::Error DwarfTransformer::verify(StringRef GsymPath) {
+llvm::Error DwarfTransformer::verify(StringRef GsymPath, raw_ostream &Log) {
   Log << "Verifying GSYM file \"" << GsymPath << "\":\n";
 
   auto Gsym = GsymReader::openFile(GsymPath);
   if (!Gsym)
     return Gsym.takeError();
 
   auto NumAddrs = Gsym->getNumAddresses();
   DILineInfoSpecifier DLIS(

llvm/lib/DebugInfo/GSYM/ObjectFileTransformer.cpp

for (const object::SectionRef &Sect : Obj.sections()) {
         }
       }
     }
   }
   return UUID;
 }
 
 llvm::Error ObjectFileTransformer::convert(const object::ObjectFile &Obj,
-                                           raw_ostream &Log,
+                                           raw_ostream *Log,
                                            GsymCreator &Gsym) {
   using namespace llvm::object;
 
   const bool IsMachO = isa<MachOObjectFile>(&Obj);
   const bool IsELF = isa<ELFObjectFileBase>(&Obj);
 
   // Read build ID.
   Gsym.setUUID(getUUID(Obj));
for (const object::SymbolRef &Sym : Obj.symbols()) {
     if (SymType.get() != SymbolRef::Type::ST_Function ||
         !Gsym.IsValidTextAddress(*AddrOrErr))
       continue;
     // Function size for MachO files will be 0
     constexpr bool NoCopy = false;
     const uint64_t size = IsELF ? ELFSymbolRef(Sym).getSize() : 0;
     Expected<StringRef> Name = Sym.getName();
     if (!Name) {
-      logAllUnhandledErrors(Name.takeError(), Log, "ObjectFileTransformer: ");
+      if (Log)
+        logAllUnhandledErrors(Name.takeError(), *Log,
+                              "ObjectFileTransformer: ");
+      else
+        consumeError(Name.takeError());
       continue;
     }
     // Remove the leading '_' character in any symbol names if there is one
     // for mach-o files.
     if (IsMachO)
       Name->consume_front("_");
     Gsym.addFunctionInfo(
         FunctionInfo(*AddrOrErr, size, Gsym.insertString(*Name, NoCopy)));
   }
   size_t FunctionsAddedCount = Gsym.getNumFunctionInfos() - NumBefore;
-  Log << "Loaded " << FunctionsAddedCount << " functions from symbol table.\n";
+  if (Log)
+    *Log << "Loaded " << FunctionsAddedCount
+         << " functions from symbol table.\n";
   return Error::success();
 }

llvm/tools/llvm-gsymutil/llvm-gsymutil.cpp

static llvm::Error handleObjectFile(ObjectFile &Obj,
                                     const std::string &OutFile) {
   auto ThreadCount =
       NumThreads > 0 ? NumThreads : std::thread::hardware_concurrency();
   auto &OS = outs();
   // Make a stream refernce that will become a /dev/null log stream if
   // Quiet is true, or normal output if Quiet is false. This can stop the
   // errors and warnings from being displayed and producing too much output
   // when they aren't desired.
-  auto &LogOS = Quiet ? nulls() : outs();
+  raw_ostream *LogOS = Quiet ? nullptr : &outs();
 
   GsymCreator Gsym(Quiet);
 
   // See if we can figure out the base address for a given object file, and if
   // we can, then set the base address to use to this value. This will ease
   // symbolication since clients can slide the GSYM lookup addresses by using
   // the load bias of the shared library.
   if (auto ImageBaseAddr = getImageBaseAddress(Obj))
static llvm::Error handleObjectFile(ObjectFile &Obj,
   // Make sure there is DWARF to convert first.
   std::unique_ptr<DWARFContext> DICtx = DWARFContext::create(Obj);
   if (!DICtx)
     return createStringError(std::errc::invalid_argument,
                              "unable to create DWARF context");
 
   // Make a DWARF transformer object and populate the ranges of the code
   // so we don't end up adding invalid functions to GSYM data.
-  DwarfTransformer DT(*DICtx, LogOS, Gsym);
+  DwarfTransformer DT(*DICtx, Gsym);
   if (!TextRanges.empty())
     Gsym.SetValidTextRanges(TextRanges);
 
   // Convert all DWARF to GSYM.
-  if (auto Err = DT.convert(ThreadCount))
+  if (auto Err = DT.convert(ThreadCount, LogOS))
     return Err;
 
   // Get the UUID and convert symbol table to GSYM.
   if (auto Err = ObjectFileTransformer::convert(Obj, LogOS, Gsym))
     return Err;
 
   // Finalize the GSYM to make it ready to save to disk. This will remove
   // duplicate FunctionInfo entries where we might have found an entry from
static llvm::Error handleObjectFile(ObjectFile &Obj,
   if (SegmentSize > 0)
     OptSegmentSize = SegmentSize;
   if (auto Err = Gsym.save(OutFile, Endian, OptSegmentSize))
     return Err;
 
   // Verify the DWARF if requested. This will ensure all the info in the DWARF
   // can be looked up in the GSYM and that all lookups get matching data.
   if (Verify) {
-    if (auto Err = DT.verify(OutFile))
+    if (auto Err = DT.verify(OutFile, OS))
       return Err;
   }
 
   return Error::success();
 }
 
 static llvm::Error handleBuffer(StringRef Filename, MemoryBufferRef Buffer,
                                 const std::string &OutFile) {

llvm/unittests/DebugInfo/GSYM/GSYMTest.cpp

TEST(GSYMTest, TestDWARFFunctionWithAddresses) {
   )";
   auto ErrOrSections = DWARFYAML::emitDebugSections(yamldata);
   ASSERT_THAT_EXPECTED(ErrOrSections, Succeeded());
   std::unique_ptr<DWARFContext> DwarfContext =
       DWARFContext::create(*ErrOrSections, 8);
   ASSERT_TRUE(DwarfContext.get() != nullptr);
   auto &OS = llvm::nulls();
   GsymCreator GC;
-  DwarfTransformer DT(*DwarfContext, OS, GC);
+  DwarfTransformer DT(*DwarfContext, GC);
   const uint32_t ThreadCount = 1;
-  ASSERT_THAT_ERROR(DT.convert(ThreadCount), Succeeded());
+  ASSERT_THAT_ERROR(DT.convert(ThreadCount, &OS), Succeeded());
   ASSERT_THAT_ERROR(GC.finalize(OS), Succeeded());
   SmallString<512> Str;
   raw_svector_ostream OutStrm(Str);
   const auto ByteOrder = support::endian::system_endianness();
   FileWriter FW(OutStrm, ByteOrder);
   ASSERT_THAT_ERROR(GC.encode(FW), Succeeded());
   Expected<GsymReader> GR = GsymReader::copyBuffer(OutStrm.str());
   ASSERT_THAT_EXPECTED(GR, Succeeded());
TEST(GSYMTest, TestDWARFFunctionWithAddressAndOffset) {
   )";
   auto ErrOrSections = DWARFYAML::emitDebugSections(yamldata);
   ASSERT_THAT_EXPECTED(ErrOrSections, Succeeded());
   std::unique_ptr<DWARFContext> DwarfContext =
       DWARFContext::create(*ErrOrSections, 8);
   ASSERT_TRUE(DwarfContext.get() != nullptr);
   auto &OS = llvm::nulls();
   GsymCreator GC;
-  DwarfTransformer DT(*DwarfContext, OS, GC);
+  DwarfTransformer DT(*DwarfContext, GC);
   const uint32_t ThreadCount = 1;
-  ASSERT_THAT_ERROR(DT.convert(ThreadCount), Succeeded());
+  ASSERT_THAT_ERROR(DT.convert(ThreadCount, &OS), Succeeded());
   ASSERT_THAT_ERROR(GC.finalize(OS), Succeeded());
   SmallString<512> Str;
   raw_svector_ostream OutStrm(Str);
   const auto ByteOrder = support::endian::system_endianness();
   FileWriter FW(OutStrm, ByteOrder);
   ASSERT_THAT_ERROR(GC.encode(FW), Succeeded());
   Expected<GsymReader> GR = GsymReader::copyBuffer(OutStrm.str());
   ASSERT_THAT_EXPECTED(GR, Succeeded());
TEST(GSYMTest, TestDWARFStructMethodNoMangled) {
   )";
   auto ErrOrSections = DWARFYAML::emitDebugSections(yamldata);
   ASSERT_THAT_EXPECTED(ErrOrSections, Succeeded());
   std::unique_ptr<DWARFContext> DwarfContext =
       DWARFContext::create(*ErrOrSections, 8);
   ASSERT_TRUE(DwarfContext.get() != nullptr);
   auto &OS = llvm::nulls();
   GsymCreator GC;
-  DwarfTransformer DT(*DwarfContext, OS, GC);
+  DwarfTransformer DT(*DwarfContext, GC);
   const uint32_t ThreadCount = 1;
-  ASSERT_THAT_ERROR(DT.convert(ThreadCount), Succeeded());
+  ASSERT_THAT_ERROR(DT.convert(ThreadCount, &OS), Succeeded());
   ASSERT_THAT_ERROR(GC.finalize(OS), Succeeded());
   SmallString<512> Str;
   raw_svector_ostream OutStrm(Str);
   const auto ByteOrder = support::endian::system_endianness();
   FileWriter FW(OutStrm, ByteOrder);
   ASSERT_THAT_ERROR(GC.encode(FW), Succeeded());
   Expected<GsymReader> GR = GsymReader::copyBuffer(OutStrm.str());
   ASSERT_THAT_EXPECTED(GR, Succeeded());
TEST(GSYMTest, TestDWARFTextRanges) {
   )";
   auto ErrOrSections = DWARFYAML::emitDebugSections(yamldata);
   ASSERT_THAT_EXPECTED(ErrOrSections, Succeeded());
   std::unique_ptr<DWARFContext> DwarfContext =
       DWARFContext::create(*ErrOrSections, 8);
   ASSERT_TRUE(DwarfContext.get() != nullptr);
   auto &OS = llvm::nulls();
   GsymCreator GC;
-  DwarfTransformer DT(*DwarfContext, OS, GC);
+  DwarfTransformer DT(*DwarfContext, GC);
   // Only allow addresses between [0x1000 - 0x2000) to be linked into the
   // GSYM.
   AddressRanges TextRanges;
   TextRanges.insert(AddressRange(0x1000, 0x2000));
   GC.SetValidTextRanges(TextRanges);
   const uint32_t ThreadCount = 1;
-  ASSERT_THAT_ERROR(DT.convert(ThreadCount), Succeeded());
+  ASSERT_THAT_ERROR(DT.convert(ThreadCount, &OS), Succeeded());
   ASSERT_THAT_ERROR(GC.finalize(OS), Succeeded());
   SmallString<512> Str;
   raw_svector_ostream OutStrm(Str);
   const auto ByteOrder = support::endian::system_endianness();
   FileWriter FW(OutStrm, ByteOrder);
   ASSERT_THAT_ERROR(GC.encode(FW), Succeeded());
   Expected<GsymReader> GR = GsymReader::copyBuffer(OutStrm.str());
   ASSERT_THAT_EXPECTED(GR, Succeeded());
TEST(GSYMTest, TestDWARFInlineInfo) {
   )";
   auto ErrOrSections = DWARFYAML::emitDebugSections(yamldata);
   ASSERT_THAT_EXPECTED(ErrOrSections, Succeeded());
   std::unique_ptr<DWARFContext> DwarfContext =
       DWARFContext::create(*ErrOrSections, 8);
   ASSERT_TRUE(DwarfContext.get() != nullptr);
   auto &OS = llvm::nulls();
   GsymCreator GC;
-  DwarfTransformer DT(*DwarfContext, OS, GC);
+  DwarfTransformer DT(*DwarfContext, GC);
   const uint32_t ThreadCount = 1;
-  ASSERT_THAT_ERROR(DT.convert(ThreadCount), Succeeded());
+  ASSERT_THAT_ERROR(DT.convert(ThreadCount, &OS), Succeeded());
   ASSERT_THAT_ERROR(GC.finalize(OS), Succeeded());
   SmallString<512> Str;
   raw_svector_ostream OutStrm(Str);
   const auto ByteOrder = support::endian::system_endianness();
   FileWriter FW(OutStrm, ByteOrder);
   ASSERT_THAT_ERROR(GC.encode(FW), Succeeded());
   Expected<GsymReader> GR = GsymReader::copyBuffer(OutStrm.str());
   ASSERT_THAT_EXPECTED(GR, Succeeded());
TEST(GSYMTest, TestDWARFNoLines) {
   )";
   auto ErrOrSections = DWARFYAML::emitDebugSections(yamldata);
   ASSERT_THAT_EXPECTED(ErrOrSections, Succeeded());
   std::unique_ptr<DWARFContext> DwarfContext =
       DWARFContext::create(*ErrOrSections, 8);
   ASSERT_TRUE(DwarfContext.get() != nullptr);
   auto &OS = llvm::nulls();
   GsymCreator GC;
-  DwarfTransformer DT(*DwarfContext, OS, GC);
+  DwarfTransformer DT(*DwarfContext, GC);
   const uint32_t ThreadCount = 1;
-  ASSERT_THAT_ERROR(DT.convert(ThreadCount), Succeeded());
+  ASSERT_THAT_ERROR(DT.convert(ThreadCount, &OS), Succeeded());
   ASSERT_THAT_ERROR(GC.finalize(OS), Succeeded());
   SmallString<512> Str;
   raw_svector_ostream OutStrm(Str);
   const auto ByteOrder = support::endian::system_endianness();
   FileWriter FW(OutStrm, ByteOrder);
   ASSERT_THAT_ERROR(GC.encode(FW), Succeeded());
   Expected<GsymReader> GR = GsymReader::copyBuffer(OutStrm.str());
   ASSERT_THAT_EXPECTED(GR, Succeeded());
TEST(GSYMTest, TestDWARFDeadStripAddr4) {
   )";
   auto ErrOrSections = DWARFYAML::emitDebugSections(yamldata);
   ASSERT_THAT_EXPECTED(ErrOrSections, Succeeded());
   std::unique_ptr<DWARFContext> DwarfContext =
       DWARFContext::create(*ErrOrSections, 4);
   ASSERT_TRUE(DwarfContext.get() != nullptr);
   auto &OS = llvm::nulls();
   GsymCreator GC;
-  DwarfTransformer DT(*DwarfContext, OS, GC);
+  DwarfTransformer DT(*DwarfContext, GC);
   const uint32_t ThreadCount = 1;
-  ASSERT_THAT_ERROR(DT.convert(ThreadCount), Succeeded());
+  ASSERT_THAT_ERROR(DT.convert(ThreadCount, &OS), Succeeded());
   ASSERT_THAT_ERROR(GC.finalize(OS), Succeeded());
   SmallString<512> Str;
   raw_svector_ostream OutStrm(Str);
   const auto ByteOrder = support::endian::system_endianness();
   FileWriter FW(OutStrm, ByteOrder);
   ASSERT_THAT_ERROR(GC.encode(FW), Succeeded());
   Expected<GsymReader> GR = GsymReader::copyBuffer(OutStrm.str());
   ASSERT_THAT_EXPECTED(GR, Succeeded());
TEST(GSYMTest, TestDWARFDeadStripAddr8) {
   )";
   auto ErrOrSections = DWARFYAML::emitDebugSections(yamldata);
   ASSERT_THAT_EXPECTED(ErrOrSections, Succeeded());
   std::unique_ptr<DWARFContext> DwarfContext =
       DWARFContext::create(*ErrOrSections, 8);
   ASSERT_TRUE(DwarfContext.get() != nullptr);
   auto &OS = llvm::nulls();
   GsymCreator GC;
-  DwarfTransformer DT(*DwarfContext, OS, GC);
+  DwarfTransformer DT(*DwarfContext, GC);
   const uint32_t ThreadCount = 1;
-  ASSERT_THAT_ERROR(DT.convert(ThreadCount), Succeeded());
+  ASSERT_THAT_ERROR(DT.convert(ThreadCount, &OS), Succeeded());
   ASSERT_THAT_ERROR(GC.finalize(OS), Succeeded());
   SmallString<512> Str;
   raw_svector_ostream OutStrm(Str);
   const auto ByteOrder = support::endian::system_endianness();
   FileWriter FW(OutStrm, ByteOrder);
   ASSERT_THAT_ERROR(GC.encode(FW), Succeeded());
   Expected<GsymReader> GR = GsymReader::copyBuffer(OutStrm.str());
   ASSERT_THAT_EXPECTED(GR, Succeeded());
TEST(GSYMTest, TestDWARFInlineRangeScopes) {
   auto ErrOrSections = DWARFYAML::emitDebugSections(yamldata);
   ASSERT_THAT_EXPECTED(ErrOrSections, Succeeded());
   std::unique_ptr<DWARFContext> DwarfContext =
       DWARFContext::create(*ErrOrSections, 8);
   ASSERT_TRUE(DwarfContext.get() != nullptr);
   std::string errors;
   raw_string_ostream OS(errors);
   GsymCreator GC;
-  DwarfTransformer DT(*DwarfContext, OS, GC);
+  DwarfTransformer DT(*DwarfContext, GC);
   const uint32_t ThreadCount = 1;
-  ASSERT_THAT_ERROR(DT.convert(ThreadCount), Succeeded());
+  ASSERT_THAT_ERROR(DT.convert(ThreadCount, &OS), Succeeded());
   ASSERT_THAT_ERROR(GC.finalize(OS), Succeeded());
   SmallString<512> Str;
   raw_svector_ostream OutStrm(Str);
   const auto ByteOrder = support::endian::system_endianness();
   FileWriter FW(OutStrm, ByteOrder);
   ASSERT_THAT_ERROR(GC.encode(FW), Succeeded());
   Expected<GsymReader> GR = GsymReader::copyBuffer(OutStrm.str());
   ASSERT_THAT_EXPECTED(GR, Succeeded());
TEST(GSYMTest, TestDWARFEmptyInline) {
   auto ErrOrSections = DWARFYAML::emitDebugSections(yamldata);
   ASSERT_THAT_EXPECTED(ErrOrSections, Succeeded());
   std::unique_ptr<DWARFContext> DwarfContext =
       DWARFContext::create(*ErrOrSections, 8);
   ASSERT_TRUE(DwarfContext.get() != nullptr);
   std::string errors;
   raw_string_ostream OS(errors);
   GsymCreator GC;
-  DwarfTransformer DT(*DwarfContext, OS, GC);
+  DwarfTransformer DT(*DwarfContext, GC);
   const uint32_t ThreadCount = 1;
-  ASSERT_THAT_ERROR(DT.convert(ThreadCount), Succeeded());
+  ASSERT_THAT_ERROR(DT.convert(ThreadCount, &OS), Succeeded());
   ASSERT_THAT_ERROR(GC.finalize(OS), Succeeded());
   SmallString<512> Str;
   raw_svector_ostream OutStrm(Str);
   const auto ByteOrder = support::endian::system_endianness();
   FileWriter FW(OutStrm, ByteOrder);
   ASSERT_THAT_ERROR(GC.encode(FW), Succeeded());
   Expected<GsymReader> GR = GsymReader::copyBuffer(OutStrm.str());
   ASSERT_THAT_EXPECTED(GR, Succeeded());
TEST(GSYMTest, TestFinalizeForLineTables) {
   auto ErrOrSections = DWARFYAML::emitDebugSections(yamldata);
   ASSERT_THAT_EXPECTED(ErrOrSections, Succeeded());
   std::unique_ptr<DWARFContext> DwarfContext =
       DWARFContext::create(*ErrOrSections, 8);
   ASSERT_TRUE(DwarfContext.get() != nullptr);
   std::string errors;
   raw_string_ostream OS(errors);
   GsymCreator GC;
-  DwarfTransformer DT(*DwarfContext, OS, GC);
+  DwarfTransformer DT(*DwarfContext, GC);
   const uint32_t ThreadCount = 1;
-  ASSERT_THAT_ERROR(DT.convert(ThreadCount), Succeeded());
+  ASSERT_THAT_ERROR(DT.convert(ThreadCount, &OS), Succeeded());
   ASSERT_THAT_ERROR(GC.finalize(OS), Succeeded());
   SmallString<512> Str;
   raw_svector_ostream OutStrm(Str);
   const auto ByteOrder = support::endian::system_endianness();
   FileWriter FW(OutStrm, ByteOrder);
   ASSERT_THAT_ERROR(GC.encode(FW), Succeeded());
   Expected<GsymReader> GR = GsymReader::copyBuffer(OutStrm.str());
   ASSERT_THAT_EXPECTED(GR, Succeeded());