Enhancing MCStreamer to support referential (rather than copy) emission of bytes and use that to reduce the memory footprint of llvm-dwp

[dblaikie]

Summary

MCStreamer currently always copies the contents into a temporary buffer before emitting the contents of that buffer to the file. This is problematic when the input is large and already accessible elsewhere.

This change (see the separate sub-diffs/commits within it to follow along more easily) adds support for referential emission of bytes into the object file and uses that to reduce the high water mark in a large dwp run from 9.6 GB to 2.3 GB.

The implementation is totally ad-hoc/prototype code, I don't know MC terribly well enough to know much better and /totally/ looking for input on what this should look like. Should I support referential and non-referential output to the same section? Should it collapse the contents as I've implemented it, or interleave (using the old Contents buffer as a fragment buffer and represent the non-referential chunks?)? Just not support that at all and assert fail if you mix referential and non-referential output in the same section?

Any/all ideas welcome, totally happy to rewrite this in any direction now that I've demonstrated the value in the outcome.

[dblaikie]

Oh, bother. I was hoping it would show my local commits as separately accessible/diffable changes, but it seems not.

Well, if the patch is in any way hard to follow, or you'd otherwise like to seep the smaller steps, do let me know - happy to send them as attachments, etc.

[chandlerc]

I don't really feel like I'm familiar enough with the MC layer to give a useful review, but I can try if no one else comments... But I wanted to voice some strong support of getting this kind of functionality into the tree, as it seems really awesome.

[• rafael]

David and I discussed a bit on IRC, but looks like it never got logged. Sorry.

So, from the discussion:

• dwp is not really a linker (no relocations if I remember correctly)
• dwp is not really an assembler (no relaxations)

So it seems that what needs to happen is that instead of dwp using MC,
lib/MC/ELFObjectWriter.cpp should be refactored into a small library
that bot MC and dwp can use.

Cheers,
Rafael

include/llvm/MC/MCFragment.h

 };
 
 /// Interface implemented by fragments that contain encoded instructions and/or
 /// data.
 ///
 template<unsigned ContentsSize>
 class MCEncodedFragmentWithContents : public MCEncodedFragment {
   SmallVector<char, ContentsSize> Contents;
+  SmallVector<StringRef, ContentsSize / sizeof(StringRef)> Refs;
+  size_t Size = 0;
 
 protected:
   MCEncodedFragmentWithContents(MCFragment::FragmentType FType,
                                 bool HasInstructions,
                                 MCSection *Sec)
       : MCEncodedFragment(FType, HasInstructions, Sec) {}
 
+  void collapse() {
+    assert(Contents.empty() || Refs.empty());
+    for (StringRef R : Refs)
+      Contents.append(R.begin(), R.end());
+    Refs.clear();
+    Size = 0;
+  }
+
 public:
-  SmallVectorImpl<char> &getContents() { return Contents; }
-  const SmallVectorImpl<char> &getContents() const { return Contents; }
+  size_t getSize() const { return !Refs.empty() ? Size : Contents.size(); }
+  MutableArrayRef<char> getMutableContents() { return Contents; }
+  void appendByReference(StringRef Str) {
+    assert(Contents.empty());
+    Refs.push_back(Str);
+    Size += Str.size();
+  }
+  void append(StringRef Str) {
+    collapse();
+    Contents.append(Str.begin(), Str.end());
+  }
+  void append(const MCEncodedFragmentWithContents &Frag) {
+    collapse();
+    Contents.append(Frag.Contents.begin(), Frag.Contents.end());
+  }
+  void clear() {
+    Contents.clear();
+    Refs.clear();
+    Size = 0;
+  }
+  void appendZeros(size_t Count) {
+    collapse();
+    Contents.resize(Contents.size() + Count);
+  }
+  template <typename Functor> void forEachByte(Functor F) const {
+    forEachChunk([&](StringRef Str) {
+      for (char c : Str)
+        F(c);
+    });
+  }
+  template <typename Functor> void forEachChunk(Functor F) const {
+    if (Refs.empty()) {
+      F(StringRef(Contents.data(), Contents.size()));
+      return;
+    }
+    for (StringRef R : Refs)
+      F(R);
+  }
 };
 
 /// Interface implemented by fragments that contain encoded instructions and/or
 /// data and also have fixups registered.
 ///
 template<unsigned ContentsSize, unsigned FixupsSize>
 class MCEncodedFragmentWithFixups :
   public MCEncodedFragmentWithContents<ContentsSize> {

include/llvm/MC/MCObjectStreamer.h

public:
   /// \brief Emit an instruction to a special fragment, because this instruction
   /// can change its size during relaxation.
   virtual void EmitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &);
 
   void EmitBundleAlignMode(unsigned AlignPow2) override;
   void EmitBundleLock(bool AlignToEnd) override;
   void EmitBundleUnlock() override;
   void EmitBytes(StringRef Data) override;
+  void EmitBytesByReference(StringRef Data) override;
   void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
                             unsigned ValueSize = 1,
                             unsigned MaxBytesToEmit = 0) override;
   void EmitCodeAlignment(unsigned ByteAlignment,
                          unsigned MaxBytesToEmit = 0) override;
   void emitValueToOffset(const MCExpr *Offset, unsigned char Value) override;
   void EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
                              unsigned Column, unsigned Flags,

include/llvm/MC/MCStreamer.h

public:
   /// @{
 
   /// \brief Emit the bytes in \p Data into the output.
   ///
   /// This is used to implement assembler directives such as .byte, .ascii,
   /// etc.
   virtual void EmitBytes(StringRef Data);
 
+  virtual void EmitBytesByReference(StringRef Data) { return EmitBytes(Data); }
+
   /// \brief Emit the expression \p Value into the output as a native
   /// integer of the given \p Size bytes.
   ///
   /// This is used to implement assembler directives such as .word, .quad,
   /// etc.
   ///
   /// \param Value - The value to emit.
   /// \param Size - The size of the integer (in bytes) to emit. This must

lib/MC/MCAssembler.cpp

bool MCAssembler::evaluateFixup(const MCAsmLayout &Layout,
 
   return IsResolved;
 }
 
 uint64_t MCAssembler::computeFragmentSize(const MCAsmLayout &Layout,
                                           const MCFragment &F) const {
   switch (F.getKind()) {
   case MCFragment::FT_Data:
-    return cast<MCDataFragment>(F).getContents().size();
+    return cast<MCDataFragment>(F).getSize();
   case MCFragment::FT_Relaxable:
-    return cast<MCRelaxableFragment>(F).getContents().size();
+    return cast<MCRelaxableFragment>(F).getSize();
   case MCFragment::FT_CompactEncodedInst:
-    return cast<MCCompactEncodedInstFragment>(F).getContents().size();
+    return cast<MCCompactEncodedInstFragment>(F).getSize();
   case MCFragment::FT_Fill:
     return cast<MCFillFragment>(F).getSize();
 
   case MCFragment::FT_LEB:
     return cast<MCLEBFragment>(F).getContents().size();
 
   case MCFragment::FT_SafeSEH:
     return 4;
uint64_t MCAssembler::computeFragmentSize(const MCAsmLayout &Layout,
 
   case MCFragment::FT_Dwarf:
     return cast<MCDwarfLineAddrFragment>(F).getContents().size();
   case MCFragment::FT_DwarfFrame:
     return cast<MCDwarfCallFrameFragment>(F).getContents().size();
   case MCFragment::FT_CVInlineLines:
     return cast<MCCVInlineLineTableFragment>(F).getContents().size();
   case MCFragment::FT_CVDefRange:
-    return cast<MCCVDefRangeFragment>(F).getContents().size();
+    return cast<MCCVDefRangeFragment>(F).getSize();
   case MCFragment::FT_Dummy:
     llvm_unreachable("Should not have been added");
   }
 
   llvm_unreachable("invalid fragment kind");
 }
 
 void MCAsmLayout::layoutFragment(MCFragment *F) {
for (uint64_t i = 0; i != Count; ++i) {
       case 8: OW->write64(uint64_t(AF.getValue())); break;
       }
     }
     break;
   }
 
   case MCFragment::FT_Data: 
     ++stats::EmittedDataFragments;
-    OW->writeBytes(cast<MCDataFragment>(F).getContents());
+    cast<MCDataFragment>(F).forEachChunk(
+        [&](StringRef Chunk) { OW->writeBytes(Chunk); });
     break;
 
   case MCFragment::FT_Relaxable:
     ++stats::EmittedRelaxableFragments;
-    OW->writeBytes(cast<MCRelaxableFragment>(F).getContents());
+    cast<MCRelaxableFragment>(F).forEachChunk(
+        [&](StringRef Str) { OW->writeBytes(Str); });
     break;
 
   case MCFragment::FT_CompactEncodedInst:
     ++stats::EmittedCompactEncodedInstFragments;
-    OW->writeBytes(cast<MCCompactEncodedInstFragment>(F).getContents());
+    cast<MCCompactEncodedInstFragment>(F).forEachChunk(
+        [&](StringRef Str) { OW->writeBytes(Str); });
     break;
 
   case MCFragment::FT_Fill: {
     ++stats::EmittedFillFragments;
     const MCFillFragment &FF = cast<MCFillFragment>(F);
     uint8_t V = FF.getValue();
     const unsigned MaxChunkSize = 16;
     char Data[MaxChunkSize];
case MCFragment::FT_DwarfFrame: {
     break;
   }
   case MCFragment::FT_CVInlineLines: {
     const auto &OF = cast<MCCVInlineLineTableFragment>(F);
     OW->writeBytes(OF.getContents());
     break;
   }
   case MCFragment::FT_CVDefRange: {
-    const auto &DRF = cast<MCCVDefRangeFragment>(F);
-    OW->writeBytes(DRF.getContents());
+    cast<MCCVDefRangeFragment>(F).forEachChunk(
+        [&](StringRef Str) { OW->writeBytes(Str); });
     break;
   }
   case MCFragment::FT_Dummy:
     llvm_unreachable("Should not have been added");
   }
 
   assert(OW->getStream().tell() - Start == FragmentSize &&
          "The stream should advance by fragment size");
for (const MCFragment &F : *Sec) {
       default: llvm_unreachable("Invalid fragment in virtual section!");
       case MCFragment::FT_Data: {
         // Check that we aren't trying to write a non-zero contents (or fixups)
         // into a virtual section. This is to support clients which use standard
         // directives to fill the contents of virtual sections.
         const MCDataFragment &DF = cast<MCDataFragment>(F);
         assert(DF.fixup_begin() == DF.fixup_end() &&
                "Cannot have fixups in virtual section!");
-        for (unsigned i = 0, e = DF.getContents().size(); i != e; ++i)
-          if (DF.getContents()[i]) {
+        DF.forEachByte([&](char c) {
+          if (c) {
             if (auto *ELFSec = dyn_cast<const MCSectionELF>(Sec))
               report_fatal_error("non-zero initializer found in section '" +
                   ELFSec->getSectionName() + "'");
             else
               report_fatal_error("non-zero initializer found in virtual section");
           }
+        });
         break;
       }
       case MCFragment::FT_Align:
         // Check that we aren't trying to write a non-zero value into a virtual
         // section.
         assert((cast<MCAlignFragment>(F).getValueSize() == 0 ||
                 cast<MCAlignFragment>(F).getValue() == 0) &&
                "Invalid align in virtual section!");
for (MCFragment &Frag : Sec) {
           isa<MCCompactEncodedInstFragment>(&Frag))
         continue;
       if (!isa<MCEncodedFragment>(&Frag) && !isa<MCCVDefRangeFragment>(&Frag))
         continue;
       ArrayRef<MCFixup> Fixups;
       MutableArrayRef<char> Contents;
       if (auto *FragWithFixups = dyn_cast<MCDataFragment>(&Frag)) {
         Fixups = FragWithFixups->getFixups();
-        Contents = FragWithFixups->getContents();
+        Contents = FragWithFixups->getMutableContents();
       } else if (auto *FragWithFixups = dyn_cast<MCRelaxableFragment>(&Frag)) {
         Fixups = FragWithFixups->getFixups();
-        Contents = FragWithFixups->getContents();
+        Contents = FragWithFixups->getMutableContents();
       } else if (auto *FragWithFixups = dyn_cast<MCCVDefRangeFragment>(&Frag)) {
         Fixups = FragWithFixups->getFixups();
-        Contents = FragWithFixups->getContents();
+        Contents = FragWithFixups->getMutableContents();
       } else
         llvm_unreachable("Unknown fragment with fixups!");
       for (const MCFixup &Fixup : Fixups) {
         uint64_t FixedValue;
         bool IsPCRel;
         std::tie(FixedValue, IsPCRel) = handleFixup(Layout, Frag, Fixup);
         getBackend().applyFixup(Fixup, Contents.data(),
                                 Contents.size(), FixedValue, IsPCRel);
bool MCAssembler::relaxInstruction(MCAsmLayout &Layout,
   // probably do so more efficiently in many cases.
   SmallVector<MCFixup, 4> Fixups;
   SmallString<256> Code;
   raw_svector_ostream VecOS(Code);
   getEmitter().encodeInstruction(Relaxed, VecOS, Fixups, F.getSubtargetInfo());
 
   // Update the fragment.
   F.setInst(Relaxed);
-  F.getContents() = Code;
+  F.clear();
+  F.append(Code);
   F.getFixups() = Fixups;
 
   return true;
 }
 
 bool MCAssembler::relaxLEB(MCAsmLayout &Layout, MCLEBFragment &LF) {
   uint64_t OldSize = LF.getContents().size();
   int64_t Value;
bool MCAssembler::relaxCVInlineLineTable(MCAsmLayout &Layout,
                                          MCCVInlineLineTableFragment &F) {
   unsigned OldSize = F.getContents().size();
   getContext().getCVContext().encodeInlineLineTable(Layout, F);
   return OldSize != F.getContents().size();
 }
 
 bool MCAssembler::relaxCVDefRange(MCAsmLayout &Layout,
                                   MCCVDefRangeFragment &F) {
-  unsigned OldSize = F.getContents().size();
+  unsigned OldSize = F.getSize();
   getContext().getCVContext().encodeDefRange(Layout, F);
-  return OldSize != F.getContents().size();
+  return OldSize != F.getSize();
 }
 
 bool MCAssembler::layoutSectionOnce(MCAsmLayout &Layout, MCSection &Sec) {
   // Holds the first fragment which needed relaxing during this layout. It will
   // remain NULL if none were relaxed.
   // When a fragment is relaxed, all the fragments following it should get
   // invalidated because their offset is going to change.
   MCFragment *FirstRelaxedFragment = nullptr;

lib/MC/MCCodeView.cpp

bool CodeViewContext::addFile(unsigned FileNumber, StringRef Filename) {
   Filenames[Idx] = Filename;
   return true;
 }
 
 MCDataFragment *CodeViewContext::getStringTableFragment() {
   if (!StrTabFragment) {
     StrTabFragment = new MCDataFragment();
     // Start a new string table out with a null byte.
-    StrTabFragment->getContents().push_back('\0');
+    StrTabFragment->append(StringRef("\0", 1));
   }
   return StrTabFragment;
 }
 
 StringRef CodeViewContext::addToStringTable(StringRef S) {
-  SmallVectorImpl<char> &Contents = getStringTableFragment()->getContents();
-  auto Insertion =
-      StringTable.insert(std::make_pair(S, unsigned(Contents.size())));
+  auto &Frag = *getStringTableFragment();
+  auto Insertion = StringTable.insert(std::make_pair(S, Frag.getSize()));
   // Return the string from the table, since it is stable.
   S = Insertion.first->first();
   if (Insertion.second) {
     // The string map key is always null terminated.
-    Contents.append(S.begin(), S.end() + 1);
+    Frag.append(StringRef(S.begin(), S.size() + 1));
   }
   return S;
 }
 
 unsigned CodeViewContext::getStringTableOffset(StringRef S) {
   // A string table offset of zero is always the empty string.
   if (S.empty())
     return 0;
void CodeViewContext::encodeInlineLineTable(MCAsmLayout &Layout,
 
   compressAnnotation(ChangeCodeLength, Buffer);
   compressAnnotation(std::min(EndSymLength, LocAfterLength), Buffer);
 }
 
 void CodeViewContext::encodeDefRange(MCAsmLayout &Layout,
                                      MCCVDefRangeFragment &Frag) {
   MCContext &Ctx = Layout.getAssembler().getContext();
-  SmallVectorImpl<char> &Contents = Frag.getContents();
-  Contents.clear();
+  SmallVector<char, 64> Contents;
   SmallVectorImpl<MCFixup> &Fixups = Frag.getFixups();
   Fixups.clear();
   raw_svector_ostream OS(Contents);
 
   // Write down each range where the variable is defined.
   for (std::pair<const MCSymbol *, const MCSymbol *> Range : Frag.getRanges()) {
     unsigned RangeSize = computeLabelDiff(Layout, Range.first, Range.second);
     unsigned Bias = 0;
do {
       // Write down the range's extent.
       support::endian::Writer<support::little>(OS).write<uint16_t>(Chunk);
 
       // Move on to the next range.
       Bias += Chunk;
       RangeSize -= Chunk;
     } while (RangeSize > 0);
   }
+  Frag.clear();
+  Frag.append(StringRef(Contents.begin(), Contents.size()));
 }
 
 //
 // This is called when an instruction is assembled into the specified section
 // and if there is information from the last .cv_loc directive that has yet to have
 // a line entry made for it is made.
 //
 void MCCVLineEntry::Make(MCObjectStreamer *MCOS) {

lib/MC/MCELFStreamer.cpp

 MCELFStreamer::~MCELFStreamer() {
 }
 
 void MCELFStreamer::mergeFragment(MCDataFragment *DF,
                                   MCDataFragment *EF) {
   MCAssembler &Assembler = getAssembler();
 
   if (Assembler.isBundlingEnabled() && Assembler.getRelaxAll()) {
-    uint64_t FSize = EF->getContents().size();
+    uint64_t FSize = EF->getSize();
 
     if (FSize > Assembler.getBundleAlignSize())
       report_fatal_error("Fragment can't be larger than a bundle size");
 
-    uint64_t RequiredBundlePadding = computeBundlePadding(
-        Assembler, EF, DF->getContents().size(), FSize);
+    uint64_t RequiredBundlePadding =
+        computeBundlePadding(Assembler, EF, DF->getSize(), FSize);
 
     if (RequiredBundlePadding > UINT8_MAX)
       report_fatal_error("Padding cannot exceed 255 bytes");
 
     if (RequiredBundlePadding > 0) {
       SmallString<256> Code;
       raw_svector_ostream VecOS(Code);
       MCObjectWriter *OW = Assembler.getBackend().createObjectWriter(VecOS);
 
       EF->setBundlePadding(static_cast<uint8_t>(RequiredBundlePadding));
 
       Assembler.writeFragmentPadding(*EF, FSize, OW);
       delete OW;
 
-      DF->getContents().append(Code.begin(), Code.end());
+      DF->append(Code);
     }
   }
 
-  flushPendingLabels(DF, DF->getContents().size());
+  flushPendingLabels(DF, DF->getSize());
 
   for (unsigned i = 0, e = EF->getFixups().size(); i != e; ++i) {
     EF->getFixups()[i].setOffset(EF->getFixups()[i].getOffset() +
-                                 DF->getContents().size());
+                                 DF->getSize());
     DF->getFixups().push_back(EF->getFixups()[i]);
   }
   DF->setHasInstructions(true);
-  DF->getContents().append(EF->getContents().begin(), EF->getContents().end());
+  DF->append(*EF);
 }
 
 void MCELFStreamer::InitSections(bool NoExecStack) {
   MCContext &Ctx = getContext();
   SwitchSection(Ctx.getObjectFileInfo()->getTextSection());
   EmitCodeAlignment(4);
 
   if (NoExecStack)
else if (isBundleLocked() && !Sec.isBundleGroupBeforeFirstInst())
       // The bundle-locking directive ensures this is a new data fragment.
       DF = cast<MCDataFragment>(getCurrentFragment());
     else if (!isBundleLocked() && Fixups.size() == 0) {
       // Optimize memory usage by emitting the instruction to a
       // MCCompactEncodedInstFragment when not in a bundle-locked group and
       // there are no fixups registered.
       MCCompactEncodedInstFragment *CEIF = new MCCompactEncodedInstFragment();
       insert(CEIF);
-      CEIF->getContents().append(Code.begin(), Code.end());
+      CEIF->append(Code);
       return;
     } else {
       DF = new MCDataFragment();
       insert(DF);
     }
     if (Sec.getBundleLockState() == MCSection::BundleLockedAlignToEnd) {
       // If this fragment is for a group marked "align_to_end", set a flag
       // in the fragment. This can happen after the fragment has already been
       // created if there are nested bundle_align groups and an inner one
       // is the one marked align_to_end.
       DF->setAlignToBundleEnd(true);
     }
 
     // We're now emitting an instruction in a bundle group, so this flag has
     // to be turned off.
     Sec.setBundleGroupBeforeFirstInst(false);
   } else {
     DF = getOrCreateDataFragment();
   }
 
   // Add the fixups and data.
   for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
-    Fixups[i].setOffset(Fixups[i].getOffset() + DF->getContents().size());
+    Fixups[i].setOffset(Fixups[i].getOffset() + DF->getSize());
     DF->getFixups().push_back(Fixups[i]);
   }
   DF->setHasInstructions(true);
-  DF->getContents().append(Code.begin(), Code.end());
+  DF->append(Code);
 
   if (Assembler.isBundlingEnabled() && Assembler.getRelaxAll()) {
     if (!isBundleLocked()) {
       mergeFragment(getOrCreateDataFragment(), DF);
       delete DF;
     }
   }
 }

lib/MC/MCFragment.cpp

OS << "<MCFixup" << " Offset:" << AF.getOffset()
      << " Value:" << *AF.getValue()
      << " Kind:" << AF.getKind() << ">";
   return OS;
 }
 
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+template <unsigned ContentsSize>
+static void
+dumpContents(raw_ostream &OS,
+             const MCEncodedFragmentWithContents<ContentsSize> &Frag) {
+  OS << "\n       ";
+  OS << " Contents:[";
+  bool first = true;
+  Frag.forEachByte([&](char c) {
+    if (!first)
+      OS << ',';
+    first = false;
+    OS << hexdigit((c >> 4) & 0xF) << hexdigit(c & 0xF);
+  });
+  OS << "] (" << Frag.getSize() << " bytes)";
+}
 LLVM_DUMP_METHOD void MCFragment::dump() {
   raw_ostream &OS = llvm::errs();
 
   OS << "<";
   switch (getKind()) {
   case MCFragment::FT_Align: OS << "MCAlignFragment"; break;
   case MCFragment::FT_Data:  OS << "MCDataFragment"; break;
   case MCFragment::FT_CompactEncodedInst:
case MCFragment::FT_Align: {
     OS << "\n       ";
     OS << " Alignment:" << AF->getAlignment()
        << " Value:" << AF->getValue() << " ValueSize:" << AF->getValueSize()
        << " MaxBytesToEmit:" << AF->getMaxBytesToEmit() << ">";
     break;
   }
   case MCFragment::FT_Data:  {
     const MCDataFragment *DF = cast<MCDataFragment>(this);
-    OS << "\n       ";
-    OS << " Contents:[";
-    const SmallVectorImpl<char> &Contents = DF->getContents();
-    for (unsigned i = 0, e = Contents.size(); i != e; ++i) {
-      if (i) OS << ",";
-      OS << hexdigit((Contents[i] >> 4) & 0xF) << hexdigit(Contents[i] & 0xF);
-    }
-    OS << "] (" << Contents.size() << " bytes)";
+    dumpContents(OS, *DF);
 
     if (DF->fixup_begin() != DF->fixup_end()) {
       OS << ",\n       ";
       OS << " Fixups:[";
       for (MCDataFragment::const_fixup_iterator it = DF->fixup_begin(),
              ie = DF->fixup_end(); it != ie; ++it) {
         if (it != DF->fixup_begin()) OS << ",\n                ";
         OS << *it;
       }
       OS << "]";
     }
     break;
   }
   case MCFragment::FT_CompactEncodedInst: {
     const MCCompactEncodedInstFragment *CEIF =
       cast<MCCompactEncodedInstFragment>(this);
     OS << "\n       ";
-    OS << " Contents:[";
-    const SmallVectorImpl<char> &Contents = CEIF->getContents();
-    for (unsigned i = 0, e = Contents.size(); i != e; ++i) {
-      if (i) OS << ",";
-      OS << hexdigit((Contents[i] >> 4) & 0xF) << hexdigit(Contents[i] & 0xF);
-    }
-    OS << "] (" << Contents.size() << " bytes)";
+    dumpContents(OS, *CEIF);
     break;
   }
   case MCFragment::FT_Fill:  {
     const MCFillFragment *FF = cast<MCFillFragment>(this);
     OS << " Value:" << FF->getValue() << " Size:" << FF->getSize();
     break;
   }
   case MCFragment::FT_Relaxable:  {

lib/MC/MCMachOStreamer.cpp

void MCMachOStreamer::EmitInstToData(const MCInst &Inst,
 
   SmallVector<MCFixup, 4> Fixups;
   SmallString<256> Code;
   raw_svector_ostream VecOS(Code);
   getAssembler().getEmitter().encodeInstruction(Inst, VecOS, Fixups, STI);
 
   // Add the fixups and data.
   for (MCFixup &Fixup : Fixups) {
-    Fixup.setOffset(Fixup.getOffset() + DF->getContents().size());
+    Fixup.setOffset(Fixup.getOffset() + DF->getSize());
     DF->getFixups().push_back(Fixup);
   }
-  DF->getContents().append(Code.begin(), Code.end());
+  DF->append(Code);
 }
 
 void MCMachOStreamer::FinishImpl() {
   EmitFrames(&getAssembler().getBackend());
 
   // We have to set the fragment atom associations so we can relax properly for
   // Mach-O.
 

lib/MC/MCObjectStreamer.cpp

void MCObjectStreamer::EmitCFISections(bool EH, bool Debug) {
   EmitEHFrame = EH;
   EmitDebugFrame = Debug;
 }
 
 void MCObjectStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
                                      SMLoc Loc) {
   MCStreamer::EmitValueImpl(Value, Size, Loc);
   MCDataFragment *DF = getOrCreateDataFragment();
-  flushPendingLabels(DF, DF->getContents().size());
+  flushPendingLabels(DF, DF->getSize());
 
   MCCVLineEntry::Make(this);
   MCDwarfLineEntry::Make(this, getCurrentSection().first);
 
   // Avoid fixups when possible.
   int64_t AbsValue;
   if (Value->evaluateAsAbsolute(AbsValue, getAssembler())) {
     EmitIntValue(AbsValue, Size);
     return;
   }
-  DF->getFixups().push_back(
-      MCFixup::create(DF->getContents().size(), Value,
-                      MCFixup::getKindForSize(Size, false), Loc));
-  DF->getContents().resize(DF->getContents().size() + Size, 0);
+  DF->getFixups().push_back(MCFixup::create(
+      DF->getSize(), Value, MCFixup::getKindForSize(Size, false), Loc));
+  DF->appendZeros(Size);
 }
 
 void MCObjectStreamer::EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) {
   // We need to create a local symbol to avoid relocations.
   Frame.Begin = getContext().createTempSymbol();
   EmitLabel(Frame.Begin);
 }
 
void MCObjectStreamer::EmitLabel(MCSymbol *Symbol) {
 
   // If there is a current fragment, mark the symbol as pointing into it.
   // Otherwise queue the label and set its fragment pointer when we emit the
   // next fragment.
   auto *F = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
   if (F && !(getAssembler().isBundlingEnabled() &&
              getAssembler().getRelaxAll())) {
     Symbol->setFragment(F);
-    Symbol->setOffset(F->getContents().size());
+    Symbol->setOffset(F->getSize());
   } else {
     PendingLabels.push_back(Symbol);
   }
 }
 
 void MCObjectStreamer::EmitULEB128Value(const MCExpr *Value) {
   int64_t IntValue;
   if (Value->evaluateAsAbsolute(IntValue, getAssembler())) {
void MCObjectStreamer::EmitInstToFragment(const MCInst &Inst,
   // during relaxation.
   MCRelaxableFragment *IF = new MCRelaxableFragment(Inst, STI);
   insert(IF);
 
   SmallString<128> Code;
   raw_svector_ostream VecOS(Code);
   getAssembler().getEmitter().encodeInstruction(Inst, VecOS, IF->getFixups(),
                                                 STI);
-  IF->getContents().append(Code.begin(), Code.end());
+  IF->append(Code);
 }
 
 #ifndef NDEBUG
 static const char *const BundlingNotImplementedMsg =
   "Aligned bundling is not implemented for this object format";
 #endif
 
 void MCObjectStreamer::EmitBundleAlignMode(unsigned AlignPow2) {
void MCObjectStreamer::EmitCVFileChecksumsDirective() {
   getContext().getCVContext().emitFileChecksums(*this);
 }
 
 
 void MCObjectStreamer::EmitBytes(StringRef Data) {
   MCCVLineEntry::Make(this);
   MCDwarfLineEntry::Make(this, getCurrentSection().first);
   MCDataFragment *DF = getOrCreateDataFragment();
-  flushPendingLabels(DF, DF->getContents().size());
-  DF->getContents().append(Data.begin(), Data.end());
+  flushPendingLabels(DF, DF->getSize());
+  DF->append(Data);
+}
+
+void MCObjectStreamer::EmitBytesByReference(StringRef Data) {
+  MCCVLineEntry::Make(this);
+  MCDwarfLineEntry::Make(this, getCurrentSection().first);
+  MCDataFragment *DF = getOrCreateDataFragment();
+  flushPendingLabels(DF, DF->getSize());
+  DF->appendByReference(Data);
 }
 
 void MCObjectStreamer::EmitValueToAlignment(unsigned ByteAlignment,
                                             int64_t Value,
                                             unsigned ValueSize,
                                             unsigned MaxBytesToEmit) {
   if (MaxBytesToEmit == 0)
     MaxBytesToEmit = ByteAlignment;

 void MCObjectStreamer::emitValueToOffset(const MCExpr *Offset,
                                          unsigned char Value) {
   insert(new MCOrgFragment(*Offset, Value));
 }
 
 // Associate GPRel32 fixup with data and resize data area
 void MCObjectStreamer::EmitGPRel32Value(const MCExpr *Value) {
   MCDataFragment *DF = getOrCreateDataFragment();
-  flushPendingLabels(DF, DF->getContents().size());
+  flushPendingLabels(DF, DF->getSize());
 
-  DF->getFixups().push_back(MCFixup::create(DF->getContents().size(), 
-                                            Value, FK_GPRel_4));
-  DF->getContents().resize(DF->getContents().size() + 4, 0);
+  DF->getFixups().push_back(MCFixup::create(DF->getSize(), Value, FK_GPRel_4));
+  DF->appendZeros(4);
 }
 
 // Associate GPRel32 fixup with data and resize data area
 void MCObjectStreamer::EmitGPRel64Value(const MCExpr *Value) {
   MCDataFragment *DF = getOrCreateDataFragment();
-  flushPendingLabels(DF, DF->getContents().size());
+  flushPendingLabels(DF, DF->getSize());
 
-  DF->getFixups().push_back(MCFixup::create(DF->getContents().size(), 
-                                            Value, FK_GPRel_4));
-  DF->getContents().resize(DF->getContents().size() + 8, 0);
+  DF->getFixups().push_back(MCFixup::create(DF->getSize(), Value, FK_GPRel_4));
+  DF->appendZeros(8);
 }
 
 bool MCObjectStreamer::EmitRelocDirective(const MCExpr &Offset, StringRef Name,
                                           const MCExpr *Expr, SMLoc Loc) {
   int64_t OffsetValue;
   if (!Offset.evaluateAsAbsolute(OffsetValue))
     llvm_unreachable("Offset is not absolute");
 
   if (OffsetValue < 0)
     llvm_unreachable("Offset is negative");
 
   MCDataFragment *DF = getOrCreateDataFragment();
-  flushPendingLabels(DF, DF->getContents().size());
+  flushPendingLabels(DF, DF->getSize());
 
   Optional<MCFixupKind> MaybeKind = Assembler->getBackend().getFixupKind(Name);
   if (!MaybeKind.hasValue())
     return true;
 
   MCFixupKind Kind = *MaybeKind;
 
   if (Expr == nullptr)

lib/MC/WinCOFFStreamer.cpp

void MCWinCOFFStreamer::EmitInstToData(const MCInst &Inst,
 
   SmallVector<MCFixup, 4> Fixups;
   SmallString<256> Code;
   raw_svector_ostream VecOS(Code);
   getAssembler().getEmitter().encodeInstruction(Inst, VecOS, Fixups, STI);
 
   // Add the fixups and data.
   for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
-    Fixups[i].setOffset(Fixups[i].getOffset() + DF->getContents().size());
+    Fixups[i].setOffset(Fixups[i].getOffset() + DF->getSize());
     DF->getFixups().push_back(Fixups[i]);
   }
 
-  DF->getContents().append(Code.begin(), Code.end());
+  DF->append(Code);
 }
 
 void MCWinCOFFStreamer::InitSections(bool NoExecStack) {
   // FIXME: this is identical to the ELF one.
   // This emulates the same behavior of GNU as. This makes it easier
   // to compare the output as the major sections are in the same order.
   SwitchSection(getContext().getObjectFileInfo()->getTextSection());
   EmitCodeAlignment(4);
void MCWinCOFFStreamer::EmitCOFFSafeSEH(MCSymbol const *Symbol) {
   // function. Go ahead and oblige it here.
   CSymbol->setType(COFF::IMAGE_SYM_DTYPE_FUNCTION
                    << COFF::SCT_COMPLEX_TYPE_SHIFT);
 }
 
 void MCWinCOFFStreamer::EmitCOFFSectionIndex(MCSymbol const *Symbol) {
   MCDataFragment *DF = getOrCreateDataFragment();
   const MCSymbolRefExpr *SRE = MCSymbolRefExpr::create(Symbol, getContext());
-  MCFixup Fixup = MCFixup::create(DF->getContents().size(), SRE, FK_SecRel_2);
+  MCFixup Fixup = MCFixup::create(DF->getSize(), SRE, FK_SecRel_2);
   DF->getFixups().push_back(Fixup);
-  DF->getContents().resize(DF->getContents().size() + 2, 0);
+  DF->appendZeros(2);
 }
 
 void MCWinCOFFStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol) {
   MCDataFragment *DF = getOrCreateDataFragment();
   const MCSymbolRefExpr *SRE = MCSymbolRefExpr::create(Symbol, getContext());
-  MCFixup Fixup = MCFixup::create(DF->getContents().size(), SRE, FK_SecRel_4);
+  MCFixup Fixup = MCFixup::create(DF->getSize(), SRE, FK_SecRel_4);
   DF->getFixups().push_back(Fixup);
-  DF->getContents().resize(DF->getContents().size() + 4, 0);
+  DF->appendZeros(4);
 }
 
 void MCWinCOFFStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                                          unsigned ByteAlignment) {
   assert((!Symbol->isInSection() ||
           Symbol->getSection().getVariant() == MCSection::SV_COFF) &&
          "Got non-COFF section in the COFF backend!");
 

lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp

 
 inline void ARMELFStreamer::SwitchToExIdxSection(const MCSymbol &FnStart) {
   SwitchToEHSection(".ARM.exidx", ELF::SHT_ARM_EXIDX,
                     ELF::SHF_ALLOC | ELF::SHF_LINK_ORDER,
                     SectionKind::getData(), FnStart);
 }
 void ARMELFStreamer::EmitFixup(const MCExpr *Expr, MCFixupKind Kind) {
   MCDataFragment *Frag = getOrCreateDataFragment();
-  Frag->getFixups().push_back(MCFixup::create(Frag->getContents().size(), Expr,
-                                              Kind));
+  Frag->getFixups().push_back(MCFixup::create(Frag->getSize(), Expr, Kind));
 }
 
 void ARMELFStreamer::EHReset() {
   ExTab = nullptr;
   FnStart = nullptr;
   Personality = nullptr;
   PersonalityIndex = ARM::EHABI::NUM_PERSONALITY_INDEX;
   FPReg = ARM::SP;

 void ARMELFStreamer::EmitPersonalityFixup(StringRef Name) {
   const MCSymbol *PersonalitySym = getContext().getOrCreateSymbol(Name);
 
   const MCSymbolRefExpr *PersonalityRef = MCSymbolRefExpr::create(
       PersonalitySym, MCSymbolRefExpr::VK_ARM_NONE, getContext());
 
   visitUsedExpr(*PersonalityRef);
   MCDataFragment *DF = getOrCreateDataFragment();
-  DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
-                                            PersonalityRef,
+  DF->getFixups().push_back(MCFixup::create(DF->getSize(), PersonalityRef,
                                             MCFixup::getKindForSize(4, false)));
 }
 
 void ARMELFStreamer::FlushPendingOffset() {
   if (PendingOffset != 0) {
     UnwindOpAsm.EmitSPOffset(-PendingOffset);
     PendingOffset = 0;
   }

tools/llvm-dwp/llvm-dwp.cpp

+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"

 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Options.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
-#include <list>
 #include <iostream>
+#include <list>
 #include <memory>
 #include <system_error>
 #include <unordered_set>
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace cl;
 
 OptionCategory DwpCategory("Specific Options");
 static list<std::string> InputFiles(Positional, OneOrMore,
                                     desc("<input files>"), cat(DwpCategory));
 
 static opt<std::string> OutputFilename(Required, "o",
                                        desc("Specify the output file."),
                                        value_desc("filename"),
                                        cat(DwpCategory));
 
 static int error(const Twine &Error, const Twine &Context) {
   errs() << Twine("while processing ") + Context + ":\n";
   errs() << Twine("error: ") + Error + "\n";
   return 1;
 }
 
 static std::error_code
-writeStringsAndOffsets(MCStreamer &Out, StringMap<uint32_t> &Strings,
+writeStringsAndOffsets(MCStreamer &Out, DenseMap<StringRef, uint32_t> &Strings,
                        uint32_t &StringOffset, MCSection *StrSection,
                        MCSection *StrOffsetSection, StringRef CurStrSection,
                        StringRef CurStrOffsetSection) {
   // Could possibly produce an error or warning if one of these was non-null but
   // the other was null.
   if (CurStrSection.empty() || CurStrOffsetSection.empty())
     return std::error_code();
 
   DenseMap<uint32_t, uint32_t> OffsetRemapping;
 
   DataExtractor Data(CurStrSection, true, 0);
   uint32_t LocalOffset = 0;
   uint32_t PrevOffset = 0;
   while (const char *s = Data.getCStr(&LocalOffset)) {
     StringRef Str(s, LocalOffset - PrevOffset - 1);
     auto Pair = Strings.insert(std::make_pair(Str, StringOffset));
     if (Pair.second) {
       Out.SwitchSection(StrSection);
-      Out.EmitBytes(
-          StringRef(Pair.first->getKeyData(), Pair.first->getKeyLength() + 1));
+      Out.EmitBytesByReference(StringRef(Str.data(), Str.size() + 1));
       StringOffset += Str.size() + 1;
     }
     OffsetRemapping[PrevOffset] = Pair.first->second;
     PrevOffset = LocalOffset;
   }
 
   Data = DataExtractor(CurStrOffsetSection, true, 0);
 
for (const DWARFUnitIndex::Entry &E : TUIndex.getRows()) {
     Entry.Contributions[0] = {};
     for (auto Kind : TUIndex.getColumnKinds()) {
       auto &C = Entry.Contributions[Kind - DW_SECT_INFO];
       C.Offset += I->Offset;
       C.Length = I->Length;
       ++I;
     }
     auto &C = Entry.Contributions[DW_SECT_TYPES - DW_SECT_INFO];
-    Out.EmitBytes(Types.substr(
+    Out.EmitBytesByReference(Types.substr(
         C.Offset - TUEntry.Contributions[DW_SECT_TYPES - DW_SECT_INFO].Offset,
         C.Length));
     C.Offset = TypesOffset;
     TypesOffset += C.Length;
   }
 }
 
 static void addAllTypes(MCStreamer &Out,
while (Data.isValidOffset(Offset)) {
     Data.getU8(&Offset);  // Address size
     auto Signature = Data.getU64(&Offset);
     Offset = PrevOffset + C.Length;
 
     auto P = TypeIndexEntries.insert(std::make_pair(Signature, Entry));
     if (!P.second)
       continue;
 
-    Out.EmitBytes(Types.substr(PrevOffset, C.Length));
+    Out.EmitBytesByReference(Types.substr(PrevOffset, C.Length));
     TypesOffset += C.Length;
   }
 }
 
 static void
 writeIndexTable(MCStreamer &Out, ArrayRef<unsigned> ContributionOffsets,
                 const MapVector<uint64_t, UnitIndexEntry> &IndexEntries,
                 uint32_t DWARFUnitIndex::Entry::SectionContribution::*Field) {
const StringMap<std::pair<MCSection *, DWARFSectionKind>> KnownSections = {
       {"debug_line.dwo", {MCOFI.getDwarfLineDWOSection(), DW_SECT_LINE}},
       {"debug_abbrev.dwo", {MCOFI.getDwarfAbbrevDWOSection(), DW_SECT_ABBREV}},
       {"debug_cu_index", {CUIndexSection, static_cast<DWARFSectionKind>(0)}},
       {"debug_tu_index", {TUIndexSection, static_cast<DWARFSectionKind>(0)}}};
 
   MapVector<uint64_t, UnitIndexEntry> IndexEntries;
   MapVector<uint64_t, UnitIndexEntry> TypeIndexEntries;
 
-  StringMap<uint32_t> Strings;
+  DenseMap<StringRef, uint32_t> Strings;
   uint32_t StringOffset = 0;
 
   uint32_t ContributionOffsets[8] = {};
 
+  SmallVector<SmallString<32>, 4> UncompressedSections;
+
+  SmallVector<OwningBinary<object::ObjectFile>, 128> Objects;
+  Objects.reserve(Inputs.size());
   for (const auto &Input : Inputs) {
     auto ErrOrObj = object::ObjectFile::createObjectFile(Input);
     if (!ErrOrObj)
       return ErrOrObj.getError();
 
+    Objects.push_back(std::move(*ErrOrObj));
+
+    auto &Obj = *Objects.back().getBinary();
+
     UnitIndexEntry CurEntry = {};
 
     StringRef CurStrSection;
     StringRef CurStrOffsetSection;
     StringRef CurTypesSection;
     StringRef InfoSection;
     StringRef AbbrevSection;
     StringRef CurCUIndexSection;
     StringRef CurTUIndexSection;
 
-    SmallVector<SmallString<32>, 4> UncompressedSections;
-
-    for (const auto &Section : ErrOrObj->getBinary()->sections()) {
+    for (const auto &Section : Obj.sections()) {
       if (Section.isBSS())
         continue;
       if (Section.isVirtual())
         continue;
 
       StringRef Name;
       if (std::error_code Err = Section.getName(Name))
         return Err;
for (const auto &Section : Obj.sections()) {
       else if (OutSection == TypesSection)
         CurTypesSection = Contents;
       else if (OutSection == CUIndexSection)
         CurCUIndexSection = Contents;
       else if (OutSection == TUIndexSection)
         CurTUIndexSection = Contents;
       else {
         Out.SwitchSection(OutSection);
-        Out.EmitBytes(Contents);
+        Out.EmitBytesByReference(Contents);
       }
     }
 
     if (InfoSection.empty())
       continue;
 
     if (!CurCUIndexSection.empty()) {
       DWARFUnitIndex CUIndex(DW_SECT_INFO);
-      DataExtractor CUIndexData(CurCUIndexSection,
-                                ErrOrObj->getBinary()->isLittleEndian(), 0);
+      DataExtractor CUIndexData(CurCUIndexSection, Obj.isLittleEndian(), 0);
       if (!CUIndex.parse(CUIndexData))
         return make_error_code(std::errc::invalid_argument);
 
       for (const DWARFUnitIndex::Entry &E : CUIndex.getRows()) {
         auto *I = E.getOffsets();
         if (!I)
           continue;
         auto P =
if (!CurCUIndexSection.empty()) {
           ++I;
         }
       }
 
       if (!CurTypesSection.empty()) {
         if (CurTUIndexSection.empty())
           return make_error_code(std::errc::invalid_argument);
         DWARFUnitIndex TUIndex(DW_SECT_TYPES);
-        DataExtractor TUIndexData(CurTUIndexSection,
-                                  ErrOrObj->getBinary()->isLittleEndian(), 0);
+        DataExtractor TUIndexData(CurTUIndexSection, Obj.isLittleEndian(), 0);
         if (!TUIndex.parse(TUIndexData))
           return make_error_code(std::errc::invalid_argument);
         addAllTypesFromDWP(Out, TypeIndexEntries, TUIndex, TypesSection,
                            CurTypesSection, CurEntry,
                            ContributionOffsets[DW_SECT_TYPES - DW_SECT_INFO]);
       }
     } else {
       auto P = IndexEntries.insert(
static std::error_code write(MCStreamer &Out, ArrayRef<std::string> Inputs) {
 
   // Lie about the type contribution
   ContributionOffsets[DW_SECT_TYPES - DW_SECT_INFO] = 0;
   // Unlie about the info contribution
   ContributionOffsets[0] = 1;
 
   writeIndex(Out, MCOFI.getDwarfCUIndexSection(), ContributionOffsets,
              IndexEntries);
-
+  Out.Finish();
   return std::error_code();
 }
 
 int main(int argc, char **argv) {
 
   ParseCommandLineOptions(argc, argv, "merge split dwarf (.dwo) files");
 
   llvm::InitializeAllTargetInfos();
std::unique_ptr<MCStreamer> MS(TheTarget->createMCObjectStreamer(
       TheTriple, MC, *MAB, OutFile, MCE, *MSTI, MCOptions.MCRelaxAll,
       MCOptions.MCIncrementalLinkerCompatible,
       /*DWARFMustBeAtTheEnd*/ false));
   if (!MS)
     return error("no object streamer for target " + TripleName, Context);
 
   if (auto Err = write(*MS, InputFiles))
     return error(Err.message(), "Writing DWP file");
-
-  MS->Finish();
 }