MC: Change object writers to use endian::Writer. NFCI.

[pcc]

Summary

Part of PR37466.

Depends on D47038

[JDevlieghere]

LGTM

llvm/tools/dsymutil/MachOUtils.cpp

493

Why not use write_zeros here too?

[pcc]

llvm/tools/dsymutil/MachOUtils.cpp

493

It seemed a little more straightforward to write the zero directly here.

[echristo]

LGTM.

llvm/lib/MC/MCLinkerOptimizationHint.cpp

39

FWIW this change feels a bit awkward. It's fine for now and I don't know if it's changed in a future patch. That said, it can easily be cleaned up later.

llvm/tools/dsymutil/MachOUtils.cpp

493

Agreed. Even more clear that it's just nul termination as well.

[pcc]

llvm/lib/MC/MCLinkerOptimizationHint.cpp

39

Yes, the whole way that LOH directives are handled seems a little odd and it may be better for it to mostly live in the Mach-O object writer. That seemed out of scope for the work that I was doing so I left it for now.

llvm/include/llvm/MC/MCMachObjectWriter.h

class MachObjectWriter : public MCObjectWriter {
   std::vector<MachSymbolData> LocalSymbolData;
   std::vector<MachSymbolData> ExternalSymbolData;
   std::vector<MachSymbolData> UndefinedSymbolData;
 
   /// @}
 
   MachSymbolData *findSymbolData(const MCSymbol &Sym);
 
+  void writeWithPadding(StringRef Str, uint64_t Size);
+
 public:
   MachObjectWriter(std::unique_ptr<MCMachObjectTargetWriter> MOTW,
                    raw_pwrite_stream &OS, bool IsLittleEndian)
       : MCObjectWriter(OS, IsLittleEndian),
-        TargetObjectWriter(std::move(MOTW)) {}
+        TargetObjectWriter(std::move(MOTW)),
+        W(OS, IsLittleEndian ? support::little : support::big) {}
+
+  support::endian::Writer W;
 
   const MCSymbol &findAliasedSymbol(const MCSymbol &Sym) const;
 
   /// \name Lifetime management Methods
   /// @{
 
   void reset() override;
 

llvm/lib/MC/ELFObjectWriter.cpp

class ELFObjectWriter : public MCObjectWriter {
 
   void align(unsigned Alignment);
 
   bool maybeWriteCompression(uint64_t Size,
                              SmallVectorImpl<char> &CompressedContents,
                              bool ZLibStyle, unsigned Alignment);
 
 public:
+  support::endian::Writer W;
+
   ELFObjectWriter(std::unique_ptr<MCELFObjectTargetWriter> MOTW,
                   raw_pwrite_stream &OS, bool IsLittleEndian)
-      : MCObjectWriter(OS, IsLittleEndian),
-        TargetObjectWriter(std::move(MOTW)) {}
+      : MCObjectWriter(OS, IsLittleEndian), TargetObjectWriter(std::move(MOTW)),
+        W(OS, IsLittleEndian ? support::little : support::big) {}
 
   ~ELFObjectWriter() override = default;
 
   void reset() override {
     Renames.clear();
     Relocations.clear();
     StrTabBuilder.clear();
     SectionTable.clear();
     MCObjectWriter::reset();
   }
 
-  void WriteWord(uint64_t W) {
+  void WriteWord(uint64_t Word) {
     if (is64Bit())
-      write64(W);
+      W.write<uint64_t>(Word);
     else
-      write32(W);
+      W.write<uint32_t>(Word);
   }
 
   template <typename T> void write(T Val) {
-    support::endian::write(getStream(), Val,
-                           IsLittleEndian ? support::little : support::big);
+    W.write(Val);
   }
 
   void writeHeader(const MCAssembler &Asm);
 
   void writeSymbol(SymbolTableWriter &Writer, uint32_t StringIndex,
                    ELFSymbolData &MSD, const MCAsmLayout &Layout);
 
   // Start and end offset of each section
public:
   void writeSection(const SectionIndexMapTy &SectionIndexMap,
                     uint32_t GroupSymbolIndex, uint64_t Offset, uint64_t Size,
                     const MCSectionELF &Section);
 };
 
 } // end anonymous namespace
 
 void ELFObjectWriter::align(unsigned Alignment) {
-  uint64_t Padding = OffsetToAlignment(getStream().tell(), Alignment);
-  WriteZeros(Padding);
+  uint64_t Padding = OffsetToAlignment(W.OS.tell(), Alignment);
+  W.OS.write_zeros(Padding);
 }
 
 unsigned ELFObjectWriter::addToSectionTable(const MCSectionELF *Sec) {
   SectionTable.push_back(Sec);
   StrTabBuilder.add(Sec->getSectionName());
   return SectionTable.size();
 }
 
void ELFObjectWriter::writeHeader(const MCAssembler &Asm) {
   // ELF Header
   // ----------
   //
   // Note
   // ----
   // emitWord method behaves differently for ELF32 and ELF64, writing
   // 4 bytes in the former and 8 in the latter.
 
-  writeBytes(ELF::ElfMagic); // e_ident[EI_MAG0] to e_ident[EI_MAG3]
+  W.OS << ELF::ElfMagic; // e_ident[EI_MAG0] to e_ident[EI_MAG3]
 
-  write8(is64Bit() ? ELF::ELFCLASS64 : ELF::ELFCLASS32); // e_ident[EI_CLASS]
+  W.OS << char(is64Bit() ? ELF::ELFCLASS64 : ELF::ELFCLASS32); // e_ident[EI_CLASS]
 
   // e_ident[EI_DATA]
-  write8(isLittleEndian() ? ELF::ELFDATA2LSB : ELF::ELFDATA2MSB);
+  W.OS << char(W.Endian == support::little ? ELF::ELFDATA2LSB
+                                           : ELF::ELFDATA2MSB);
 
-  write8(ELF::EV_CURRENT);        // e_ident[EI_VERSION]
+  W.OS << char(ELF::EV_CURRENT);        // e_ident[EI_VERSION]
   // e_ident[EI_OSABI]
-  write8(TargetObjectWriter->getOSABI());
-  write8(0);                  // e_ident[EI_ABIVERSION]
+  W.OS << char(TargetObjectWriter->getOSABI());
+  W.OS << char(0);                  // e_ident[EI_ABIVERSION]
 
-  WriteZeros(ELF::EI_NIDENT - ELF::EI_PAD);
+  W.OS.write_zeros(ELF::EI_NIDENT - ELF::EI_PAD);
 
-  write16(ELF::ET_REL);             // e_type
+  W.write<uint16_t>(ELF::ET_REL);             // e_type
 
-  write16(TargetObjectWriter->getEMachine()); // e_machine = target
+  W.write<uint16_t>(TargetObjectWriter->getEMachine()); // e_machine = target
 
-  write32(ELF::EV_CURRENT);         // e_version
+  W.write<uint32_t>(ELF::EV_CURRENT);         // e_version
   WriteWord(0);                    // e_entry, no entry point in .o file
   WriteWord(0);                    // e_phoff, no program header for .o
   WriteWord(0);                     // e_shoff = sec hdr table off in bytes
 
   // e_flags = whatever the target wants
-  write32(Asm.getELFHeaderEFlags());
+  W.write<uint32_t>(Asm.getELFHeaderEFlags());
 
   // e_ehsize = ELF header size
-  write16(is64Bit() ? sizeof(ELF::Elf64_Ehdr) : sizeof(ELF::Elf32_Ehdr));
+  W.write<uint16_t>(is64Bit() ? sizeof(ELF::Elf64_Ehdr)
+                              : sizeof(ELF::Elf32_Ehdr));
 
-  write16(0);                  // e_phentsize = prog header entry size
-  write16(0);                  // e_phnum = # prog header entries = 0
+  W.write<uint16_t>(0);                  // e_phentsize = prog header entry size
+  W.write<uint16_t>(0);                  // e_phnum = # prog header entries = 0
 
   // e_shentsize = Section header entry size
-  write16(is64Bit() ? sizeof(ELF::Elf64_Shdr) : sizeof(ELF::Elf32_Shdr));
+  W.write<uint16_t>(is64Bit() ? sizeof(ELF::Elf64_Shdr)
+                              : sizeof(ELF::Elf32_Shdr));
 
   // e_shnum     = # of section header ents
-  write16(0);
+  W.write<uint16_t>(0);
 
   // e_shstrndx  = Section # of '.shstrtab'
   assert(StringTableIndex < ELF::SHN_LORESERVE);
-  write16(StringTableIndex);
+  W.write<uint16_t>(StringTableIndex);
 }
 
 uint64_t ELFObjectWriter::SymbolValue(const MCSymbol &Sym,
                                       const MCAsmLayout &Layout) {
   if (Sym.isCommon() && Sym.isExternal())
     return Sym.getCommonAlignment();
 
   uint64_t Res;
void ELFObjectWriter::computeSymbolTable(
   // Symbol table
   unsigned EntrySize = is64Bit() ? ELF::SYMENTRY_SIZE64 : ELF::SYMENTRY_SIZE32;
   MCSectionELF *SymtabSection =
       Ctx.getELFSection(".symtab", ELF::SHT_SYMTAB, 0, EntrySize, "");
   SymtabSection->setAlignment(is64Bit() ? 8 : 4);
   SymbolTableIndex = addToSectionTable(SymtabSection);
 
   align(SymtabSection->getAlignment());
-  uint64_t SecStart = getStream().tell();
+  uint64_t SecStart = W.OS.tell();
 
   // The first entry is the undefined symbol entry.
   Writer.writeSymbol(0, 0, 0, 0, 0, 0, false);
 
   std::vector<ELFSymbolData> LocalSymbolData;
   std::vector<ELFSymbolData> ExternalSymbolData;
 
   // Add the data for the symbols.
void ELFObjectWriter::computeSymbolTable(
 
   for (ELFSymbolData &MSD : ExternalSymbolData) {
     unsigned StringIndex = StrTabBuilder.getOffset(MSD.Name);
     MSD.Symbol->setIndex(Index++);
     writeSymbol(Writer, StringIndex, MSD, Layout);
     assert(MSD.Symbol->getBinding() != ELF::STB_LOCAL);
   }
 
-  uint64_t SecEnd = getStream().tell();
+  uint64_t SecEnd = W.OS.tell();
   SectionOffsets[SymtabSection] = std::make_pair(SecStart, SecEnd);
 
   ArrayRef<uint32_t> ShndxIndexes = Writer.getShndxIndexes();
   if (ShndxIndexes.empty()) {
     assert(SymtabShndxSectionIndex == 0);
     return;
   }
   assert(SymtabShndxSectionIndex != 0);
 
-  SecStart = getStream().tell();
+  SecStart = W.OS.tell();
   const MCSectionELF *SymtabShndxSection =
       SectionTable[SymtabShndxSectionIndex - 1];
   for (uint32_t Index : ShndxIndexes)
     write(Index);
-  SecEnd = getStream().tell();
+  SecEnd = W.OS.tell();
   SectionOffsets[SymtabShndxSection] = std::make_pair(SecStart, SecEnd);
 }
 
 MCSectionELF *
 ELFObjectWriter::createRelocationSection(MCContext &Ctx,
                                          const MCSectionELF &Sec) {
   if (Relocations[&Sec].empty())
     return nullptr;
if (ZLibStyle) {
     return true;
   }
 
   // "ZLIB" followed by 8 bytes representing the uncompressed size of the section,
   // useful for consumers to preallocate a buffer to decompress into.
   const StringRef Magic = "ZLIB";
   if (Size <= Magic.size() + sizeof(Size) + CompressedContents.size())
     return false;
-  write(ArrayRef<char>(Magic.begin(), Magic.size()));
-  writeBE64(Size);
+  W.OS << Magic;
+  support::endian::write(W.OS, Size, support::big);
   return true;
 }
 
 void ELFObjectWriter::writeSectionData(const MCAssembler &Asm, MCSection &Sec,
                                        const MCAsmLayout &Layout) {
   MCSectionELF &Section = static_cast<MCSectionELF &>(Sec);
   StringRef SectionName = Section.getSectionName();
 
   auto &MC = Asm.getContext();
   const auto &MAI = MC.getAsmInfo();
 
   // Compressing debug_frame requires handling alignment fragments which is
   // more work (possibly generalizing MCAssembler.cpp:writeFragment to allow
   // for writing to arbitrary buffers) for little benefit.
   bool CompressionEnabled =
       MAI->compressDebugSections() != DebugCompressionType::None;
   if (!CompressionEnabled || !SectionName.startswith(".debug_") ||
       SectionName == ".debug_frame") {
-    Asm.writeSectionData(getStream(), &Section, Layout);
+    Asm.writeSectionData(W.OS, &Section, Layout);
     return;
   }
 
   assert((MAI->compressDebugSections() == DebugCompressionType::Z ||
           MAI->compressDebugSections() == DebugCompressionType::GNU) &&
          "expected zlib or zlib-gnu style compression");
 
   SmallVector<char, 128> UncompressedData;
   raw_svector_ostream VecOS(UncompressedData);
   Asm.writeSectionData(VecOS, &Section, Layout);
 
   SmallVector<char, 128> CompressedContents;
   if (Error E = zlib::compress(
           StringRef(UncompressedData.data(), UncompressedData.size()),
           CompressedContents)) {
     consumeError(std::move(E));
-    getStream() << UncompressedData;
+    W.OS << UncompressedData;
     return;
   }
 
   bool ZlibStyle = MAI->compressDebugSections() == DebugCompressionType::Z;
   if (!maybeWriteCompression(UncompressedData.size(), CompressedContents,
                              ZlibStyle, Sec.getAlignment())) {
-    getStream() << UncompressedData;
+    W.OS << UncompressedData;
     return;
   }
 
   if (ZlibStyle)
     // Set the compressed flag. That is zlib style.
     Section.setFlags(Section.getFlags() | ELF::SHF_COMPRESSED);
   else
     // Add "z" prefix to section name. This is zlib-gnu style.
     MC.renameELFSection(&Section, (".z" + SectionName.drop_front(1)).str());
-  getStream() << CompressedContents;
+  W.OS << CompressedContents;
 }
 
 void ELFObjectWriter::WriteSecHdrEntry(uint32_t Name, uint32_t Type,
                                        uint64_t Flags, uint64_t Address,
                                        uint64_t Offset, uint64_t Size,
                                        uint32_t Link, uint32_t Info,
                                        uint64_t Alignment,
                                        uint64_t EntrySize) {
-  write32(Name);        // sh_name: index into string table
-  write32(Type);        // sh_type
+  W.write<uint32_t>(Name);        // sh_name: index into string table
+  W.write<uint32_t>(Type);        // sh_type
   WriteWord(Flags);     // sh_flags
   WriteWord(Address);   // sh_addr
   WriteWord(Offset);    // sh_offset
   WriteWord(Size);      // sh_size
-  write32(Link);        // sh_link
-  write32(Info);        // sh_info
+  W.write<uint32_t>(Link);        // sh_link
+  W.write<uint32_t>(Info);        // sh_info
   WriteWord(Alignment); // sh_addralign
   WriteWord(EntrySize); // sh_entsize
 }
 
 void ELFObjectWriter::writeRelocations(const MCAssembler &Asm,
                                        const MCSectionELF &Sec) {
   std::vector<ELFRelocationEntry> &Relocs = Relocations[&Sec];
 
if (is64Bit()) {
         }
       }
     }
   }
 }
 
 const MCSectionELF *ELFObjectWriter::createStringTable(MCContext &Ctx) {
   const MCSectionELF *StrtabSection = SectionTable[StringTableIndex - 1];
-  StrTabBuilder.write(getStream());
+  StrTabBuilder.write(W.OS);
   return StrtabSection;
 }
 
 void ELFObjectWriter::writeSection(const SectionIndexMapTy &SectionIndexMap,
                                    uint32_t GroupSymbolIndex, uint64_t Offset,
                                    uint64_t Size, const MCSectionELF &Section) {
   uint64_t sh_link = 0;
   uint64_t sh_info = 0;
void ELFObjectWriter::writeObject(MCAssembler &Asm,
   std::vector<MCSectionELF *> Groups;
   std::vector<MCSectionELF *> Relocations;
   for (MCSection &Sec : Asm) {
     MCSectionELF &Section = static_cast<MCSectionELF &>(Sec);
 
     align(Section.getAlignment());
 
     // Remember the offset into the file for this section.
-    uint64_t SecStart = getStream().tell();
+    uint64_t SecStart = W.OS.tell();
 
     const MCSymbolELF *SignatureSymbol = Section.getGroup();
     writeSectionData(Asm, Section, Layout);
 
-    uint64_t SecEnd = getStream().tell();
+    uint64_t SecEnd = W.OS.tell();
     SectionOffsets[&Section] = std::make_pair(SecStart, SecEnd);
 
     MCSectionELF *RelSection = createRelocationSection(Ctx, Section);
 
     if (SignatureSymbol) {
       Asm.registerSymbol(*SignatureSymbol);
       unsigned &GroupIdx = RevGroupMap[SignatureSymbol];
       if (!GroupIdx) {
if (RelSection) {
       Relocations.push_back(RelSection);
     }
   }
 
   for (MCSectionELF *Group : Groups) {
     align(Group->getAlignment());
 
     // Remember the offset into the file for this section.
-    uint64_t SecStart = getStream().tell();
+    uint64_t SecStart = W.OS.tell();
 
     const MCSymbol *SignatureSymbol = Group->getGroup();
     assert(SignatureSymbol);
     write(uint32_t(ELF::GRP_COMDAT));
     for (const MCSectionELF *Member : GroupMembers[SignatureSymbol]) {
       uint32_t SecIndex = SectionIndexMap.lookup(Member);
       write(SecIndex);
     }
 
-    uint64_t SecEnd = getStream().tell();
+    uint64_t SecEnd = W.OS.tell();
     SectionOffsets[Group] = std::make_pair(SecStart, SecEnd);
   }
 
   // Compute symbol table information.
   computeSymbolTable(Asm, Layout, SectionIndexMap, RevGroupMap, SectionOffsets);
 
   for (MCSectionELF *RelSection : Relocations) {
     align(RelSection->getAlignment());
 
     // Remember the offset into the file for this section.
-    uint64_t SecStart = getStream().tell();
+    uint64_t SecStart = W.OS.tell();
 
     writeRelocations(Asm,
                      cast<MCSectionELF>(*RelSection->getAssociatedSection()));
 
-    uint64_t SecEnd = getStream().tell();
+    uint64_t SecEnd = W.OS.tell();
     SectionOffsets[RelSection] = std::make_pair(SecStart, SecEnd);
   }
 
   {
-    uint64_t SecStart = getStream().tell();
+    uint64_t SecStart = W.OS.tell();
     const MCSectionELF *Sec = createStringTable(Ctx);
-    uint64_t SecEnd = getStream().tell();
+    uint64_t SecEnd = W.OS.tell();
     SectionOffsets[Sec] = std::make_pair(SecStart, SecEnd);
   }
 
   uint64_t NaturalAlignment = is64Bit() ? 8 : 4;
   align(NaturalAlignment);
 
-  const uint64_t SectionHeaderOffset = getStream().tell();
+  const uint64_t SectionHeaderOffset = W.OS.tell();
 
   // ... then the section header table ...
   writeSectionHeader(Layout, SectionIndexMap, SectionOffsets);
 
-  uint16_t NumSections = (SectionTable.size() + 1 >= ELF::SHN_LORESERVE)
-                             ? (uint16_t)ELF::SHN_UNDEF
-                             : SectionTable.size() + 1;
-  if (sys::IsLittleEndianHost != IsLittleEndian)
-    sys::swapByteOrder(NumSections);
+  uint16_t NumSections = support::endian::byte_swap<uint16_t>(
+      (SectionTable.size() + 1 >= ELF::SHN_LORESERVE) ? (uint16_t)ELF::SHN_UNDEF
+                                                      : SectionTable.size() + 1,
+      W.Endian);
   unsigned NumSectionsOffset;
 
+  auto &Stream = static_cast<raw_pwrite_stream &>(W.OS);
   if (is64Bit()) {
-    uint64_t Val = SectionHeaderOffset;
-    if (sys::IsLittleEndianHost != IsLittleEndian)
-      sys::swapByteOrder(Val);
-    getStream().pwrite(reinterpret_cast<char *>(&Val), sizeof(Val),
-                       offsetof(ELF::Elf64_Ehdr, e_shoff));
+    uint64_t Val =
+        support::endian::byte_swap<uint64_t>(SectionHeaderOffset, W.Endian);
+    Stream.pwrite(reinterpret_cast<char *>(&Val), sizeof(Val),
     NumSectionsOffset = offsetof(ELF::Elf64_Ehdr, e_shnum);
   } else {
-    uint32_t Val = SectionHeaderOffset;
-    if (sys::IsLittleEndianHost != IsLittleEndian)
-      sys::swapByteOrder(Val);
-    getStream().pwrite(reinterpret_cast<char *>(&Val), sizeof(Val),
-                       offsetof(ELF::Elf32_Ehdr, e_shoff));
+    uint32_t Val =
+        support::endian::byte_swap<uint32_t>(SectionHeaderOffset, W.Endian);
+    Stream.pwrite(reinterpret_cast<char *>(&Val), sizeof(Val),
     NumSectionsOffset = offsetof(ELF::Elf32_Ehdr, e_shnum);
   }
-  getStream().pwrite(reinterpret_cast<char *>(&NumSections),
-                     sizeof(NumSections), NumSectionsOffset);
+  Stream.pwrite(reinterpret_cast<char *>(&NumSections), sizeof(NumSections),
+                NumSectionsOffset);
 }
 
 bool ELFObjectWriter::isSymbolRefDifferenceFullyResolvedImpl(
     const MCAssembler &Asm, const MCSymbol &SA, const MCFragment &FB,
     bool InSet, bool IsPCRel) const {
   const auto &SymA = cast<MCSymbolELF>(SA);
   if (IsPCRel) {
     assert(!InSet);

llvm/lib/MC/MCLinkerOptimizationHint.cpp

void MCLOHDirective::emit_impl(raw_ostream &OutStream,
   encodeULEB128(Kind, OutStream);
   encodeULEB128(Args.size(), OutStream);
   for (const MCSymbol *Arg : Args)
     encodeULEB128(ObjWriter.getSymbolAddress(*Arg, Layout), OutStream);
 }
 
 void MCLOHDirective::emit(MachObjectWriter &ObjWriter,
                           const MCAsmLayout &Layout) const {
-  raw_ostream &OutStream = ObjWriter.getStream();
+  raw_ostream &OutStream = ObjWriter.W.OS;
   emit_impl(OutStream, ObjWriter, Layout);
 }
 
 uint64_t MCLOHDirective::getEmitSize(const MachObjectWriter &ObjWriter,
                                      const MCAsmLayout &Layout) const {
   class raw_counting_ostream : public raw_ostream {
     uint64_t Count = 0;
 

llvm/lib/MC/MachObjectWriter.cpp

void MachObjectWriter::writeHeader(MachO::HeaderFileType Type,
   uint32_t Flags = 0;
 
   if (SubsectionsViaSymbols)
     Flags |= MachO::MH_SUBSECTIONS_VIA_SYMBOLS;
 
   // struct mach_header (28 bytes) or
   // struct mach_header_64 (32 bytes)
 
-  uint64_t Start = getStream().tell();
+  uint64_t Start = W.OS.tell();
   (void) Start;
 
-  write32(is64Bit() ? MachO::MH_MAGIC_64 : MachO::MH_MAGIC);
+  W.write<uint32_t>(is64Bit() ? MachO::MH_MAGIC_64 : MachO::MH_MAGIC);
 
-  write32(TargetObjectWriter->getCPUType());
-  write32(TargetObjectWriter->getCPUSubtype());
+  W.write<uint32_t>(TargetObjectWriter->getCPUType());
+  W.write<uint32_t>(TargetObjectWriter->getCPUSubtype());
 
-  write32(Type);
-  write32(NumLoadCommands);
-  write32(LoadCommandsSize);
-  write32(Flags);
+  W.write<uint32_t>(Type);
+  W.write<uint32_t>(NumLoadCommands);
+  W.write<uint32_t>(LoadCommandsSize);
+  W.write<uint32_t>(Flags);
   if (is64Bit())
-    write32(0); // reserved
+    W.write<uint32_t>(0); // reserved
 
-  assert(
-      getStream().tell() - Start ==
-      (is64Bit() ? sizeof(MachO::mach_header_64) : sizeof(MachO::mach_header)));
+  assert(W.OS.tell() - Start == (is64Bit() ? sizeof(MachO::mach_header_64)
+                                           : sizeof(MachO::mach_header)));
+}
+
+void MachObjectWriter::writeWithPadding(StringRef Str, uint64_t Size) {
+  assert(Size >= Str.size());
+  W.OS << Str;
+  W.OS.write_zeros(Size - Str.size());
 }
 
 /// writeSegmentLoadCommand - Write a segment load command.
 ///
 /// \param NumSections The number of sections in this segment.
 /// \param SectionDataSize The total size of the sections.
 void MachObjectWriter::writeSegmentLoadCommand(
     StringRef Name, unsigned NumSections, uint64_t VMAddr, uint64_t VMSize,
     uint64_t SectionDataStartOffset, uint64_t SectionDataSize, uint32_t MaxProt,
     uint32_t InitProt) {
   // struct segment_command (56 bytes) or
   // struct segment_command_64 (72 bytes)
 
-  uint64_t Start = getStream().tell();
+  uint64_t Start = W.OS.tell();
   (void) Start;
 
   unsigned SegmentLoadCommandSize =
     is64Bit() ? sizeof(MachO::segment_command_64):
     sizeof(MachO::segment_command);
-  write32(is64Bit() ? MachO::LC_SEGMENT_64 : MachO::LC_SEGMENT);
-  write32(SegmentLoadCommandSize +
+  W.write<uint32_t>(is64Bit() ? MachO::LC_SEGMENT_64 : MachO::LC_SEGMENT);
+  W.write<uint32_t>(SegmentLoadCommandSize +
           NumSections * (is64Bit() ? sizeof(MachO::section_64) :
                          sizeof(MachO::section)));
 
-  assert(Name.size() <= 16);
-  writeBytes(Name, 16);
+  writeWithPadding(Name, 16);
   if (is64Bit()) {
-    write64(VMAddr);                 // vmaddr
-    write64(VMSize); // vmsize
-    write64(SectionDataStartOffset); // file offset
-    write64(SectionDataSize); // file size
+    W.write<uint64_t>(VMAddr);                 // vmaddr
+    W.write<uint64_t>(VMSize); // vmsize
+    W.write<uint64_t>(SectionDataStartOffset); // file offset
+    W.write<uint64_t>(SectionDataSize); // file size
   } else {
-    write32(VMAddr);                 // vmaddr
-    write32(VMSize); // vmsize
-    write32(SectionDataStartOffset); // file offset
-    write32(SectionDataSize); // file size
+    W.write<uint32_t>(VMAddr);                 // vmaddr
+    W.write<uint32_t>(VMSize); // vmsize
+    W.write<uint32_t>(SectionDataStartOffset); // file offset
+    W.write<uint32_t>(SectionDataSize); // file size
   }
   // maxprot
-  write32(MaxProt);
+  W.write<uint32_t>(MaxProt);
   // initprot
-  write32(InitProt);
-  write32(NumSections);
-  write32(0); // flags
+  W.write<uint32_t>(InitProt);
+  W.write<uint32_t>(NumSections);
+  W.write<uint32_t>(0); // flags
 
-  assert(getStream().tell() - Start == SegmentLoadCommandSize);
+  assert(W.OS.tell() - Start == SegmentLoadCommandSize);
 }
 
 void MachObjectWriter::writeSection(const MCAsmLayout &Layout,
                                     const MCSection &Sec, uint64_t VMAddr,
                                     uint64_t FileOffset, unsigned Flags,
                                     uint64_t RelocationsStart,
                                     unsigned NumRelocations) {
   uint64_t SectionSize = Layout.getSectionAddressSize(&Sec);
   const MCSectionMachO &Section = cast<MCSectionMachO>(Sec);
 
   // The offset is unused for virtual sections.
   if (Section.isVirtualSection()) {
     assert(Layout.getSectionFileSize(&Sec) == 0 && "Invalid file size!");
     FileOffset = 0;
   }
 
   // struct section (68 bytes) or
   // struct section_64 (80 bytes)
 
-  uint64_t Start = getStream().tell();
+  uint64_t Start = W.OS.tell();
   (void) Start;
 
-  writeBytes(Section.getSectionName(), 16);
-  writeBytes(Section.getSegmentName(), 16);
+  writeWithPadding(Section.getSectionName(), 16);
+  writeWithPadding(Section.getSegmentName(), 16);
   if (is64Bit()) {
-    write64(VMAddr);      // address
-    write64(SectionSize); // size
+    W.write<uint64_t>(VMAddr);      // address
+    W.write<uint64_t>(SectionSize); // size
   } else {
-    write32(VMAddr);      // address
-    write32(SectionSize); // size
+    W.write<uint32_t>(VMAddr);      // address
+    W.write<uint32_t>(SectionSize); // size
   }
-  write32(FileOffset);
+  W.write<uint32_t>(FileOffset);
 
   assert(isPowerOf2_32(Section.getAlignment()) && "Invalid alignment!");
-  write32(Log2_32(Section.getAlignment()));
-  write32(NumRelocations ? RelocationsStart : 0);
-  write32(NumRelocations);
-  write32(Flags);
-  write32(IndirectSymBase.lookup(&Sec)); // reserved1
-  write32(Section.getStubSize()); // reserved2
+  W.write<uint32_t>(Log2_32(Section.getAlignment()));
+  W.write<uint32_t>(NumRelocations ? RelocationsStart : 0);
+  W.write<uint32_t>(NumRelocations);
+  W.write<uint32_t>(Flags);
+  W.write<uint32_t>(IndirectSymBase.lookup(&Sec)); // reserved1
+  W.write<uint32_t>(Section.getStubSize()); // reserved2
   if (is64Bit())
-    write32(0); // reserved3
+    W.write<uint32_t>(0); // reserved3
 
-  assert(getStream().tell() - Start ==
+  assert(W.OS.tell() - Start ==
          (is64Bit() ? sizeof(MachO::section_64) : sizeof(MachO::section)));
 }
 
 void MachObjectWriter::writeSymtabLoadCommand(uint32_t SymbolOffset,
                                               uint32_t NumSymbols,
                                               uint32_t StringTableOffset,
                                               uint32_t StringTableSize) {
   // struct symtab_command (24 bytes)
 
-  uint64_t Start = getStream().tell();
+  uint64_t Start = W.OS.tell();
   (void) Start;
 
-  write32(MachO::LC_SYMTAB);
-  write32(sizeof(MachO::symtab_command));
-  write32(SymbolOffset);
-  write32(NumSymbols);
-  write32(StringTableOffset);
-  write32(StringTableSize);
+  W.write<uint32_t>(MachO::LC_SYMTAB);
+  W.write<uint32_t>(sizeof(MachO::symtab_command));
+  W.write<uint32_t>(SymbolOffset);
+  W.write<uint32_t>(NumSymbols);
+  W.write<uint32_t>(StringTableOffset);
+  W.write<uint32_t>(StringTableSize);
 
-  assert(getStream().tell() - Start == sizeof(MachO::symtab_command));
+  assert(W.OS.tell() - Start == sizeof(MachO::symtab_command));
 }
 
 void MachObjectWriter::writeDysymtabLoadCommand(uint32_t FirstLocalSymbol,
                                                 uint32_t NumLocalSymbols,
                                                 uint32_t FirstExternalSymbol,
                                                 uint32_t NumExternalSymbols,
                                                 uint32_t FirstUndefinedSymbol,
                                                 uint32_t NumUndefinedSymbols,
                                                 uint32_t IndirectSymbolOffset,
                                                 uint32_t NumIndirectSymbols) {
   // struct dysymtab_command (80 bytes)
 
-  uint64_t Start = getStream().tell();
+  uint64_t Start = W.OS.tell();
   (void) Start;
 
-  write32(MachO::LC_DYSYMTAB);
-  write32(sizeof(MachO::dysymtab_command));
-  write32(FirstLocalSymbol);
-  write32(NumLocalSymbols);
-  write32(FirstExternalSymbol);
-  write32(NumExternalSymbols);
-  write32(FirstUndefinedSymbol);
-  write32(NumUndefinedSymbols);
-  write32(0); // tocoff
-  write32(0); // ntoc
-  write32(0); // modtaboff
-  write32(0); // nmodtab
-  write32(0); // extrefsymoff
-  write32(0); // nextrefsyms
-  write32(IndirectSymbolOffset);
-  write32(NumIndirectSymbols);
-  write32(0); // extreloff
-  write32(0); // nextrel
-  write32(0); // locreloff
-  write32(0); // nlocrel
+  W.write<uint32_t>(MachO::LC_DYSYMTAB);
+  W.write<uint32_t>(sizeof(MachO::dysymtab_command));
+  W.write<uint32_t>(FirstLocalSymbol);
+  W.write<uint32_t>(NumLocalSymbols);
+  W.write<uint32_t>(FirstExternalSymbol);
+  W.write<uint32_t>(NumExternalSymbols);
+  W.write<uint32_t>(FirstUndefinedSymbol);
+  W.write<uint32_t>(NumUndefinedSymbols);
+  W.write<uint32_t>(0); // tocoff
+  W.write<uint32_t>(0); // ntoc
+  W.write<uint32_t>(0); // modtaboff
+  W.write<uint32_t>(0); // nmodtab
+  W.write<uint32_t>(0); // extrefsymoff
+  W.write<uint32_t>(0); // nextrefsyms
+  W.write<uint32_t>(IndirectSymbolOffset);
+  W.write<uint32_t>(NumIndirectSymbols);
+  W.write<uint32_t>(0); // extreloff
+  W.write<uint32_t>(0); // nextrel
+  W.write<uint32_t>(0); // locreloff
+  W.write<uint32_t>(0); // nlocrel
 
-  assert(getStream().tell() - Start == sizeof(MachO::dysymtab_command));
+  assert(W.OS.tell() - Start == sizeof(MachO::dysymtab_command));
 }
 
 MachObjectWriter::MachSymbolData *
 MachObjectWriter::findSymbolData(const MCSymbol &Sym) {
   for (auto *SymbolData :
        {&LocalSymbolData, &ExternalSymbolData, &UndefinedSymbolData})
     for (MachSymbolData &Entry : *SymbolData)
       if (Entry.Symbol == &Sym)
void MachObjectWriter::writeNlist(MachSymbolData &MSD,
   else if (Symbol->isCommon()) {
     // Common symbols are encoded with the size in the address
     // field, and their alignment in the flags.
     Address = Symbol->getCommonSize();
   }
 
   // struct nlist (12 bytes)
 
-  write32(MSD.StringIndex);
-  write8(Type);
-  write8(SectionIndex);
+  W.write<uint32_t>(MSD.StringIndex);
+  W.OS << char(Type);
+  W.OS << char(SectionIndex);
 
   // The Mach-O streamer uses the lowest 16-bits of the flags for the 'desc'
   // value.
   bool EncodeAsAltEntry =
     IsAlias && cast<MCSymbolMachO>(OrigSymbol).isAltEntry();
-  write16(cast<MCSymbolMachO>(Symbol)->getEncodedFlags(EncodeAsAltEntry));
+  W.write<uint16_t>(cast<MCSymbolMachO>(Symbol)->getEncodedFlags(EncodeAsAltEntry));
   if (is64Bit())
-    write64(Address);
+    W.write<uint64_t>(Address);
   else
-    write32(Address);
+    W.write<uint32_t>(Address);
 }
 
 void MachObjectWriter::writeLinkeditLoadCommand(uint32_t Type,
                                                 uint32_t DataOffset,
                                                 uint32_t DataSize) {
-  uint64_t Start = getStream().tell();
+  uint64_t Start = W.OS.tell();
   (void) Start;
 
-  write32(Type);
-  write32(sizeof(MachO::linkedit_data_command));
-  write32(DataOffset);
-  write32(DataSize);
+  W.write<uint32_t>(Type);
+  W.write<uint32_t>(sizeof(MachO::linkedit_data_command));
+  W.write<uint32_t>(DataOffset);
+  W.write<uint32_t>(DataSize);
 
-  assert(getStream().tell() - Start == sizeof(MachO::linkedit_data_command));
+  assert(W.OS.tell() - Start == sizeof(MachO::linkedit_data_command));
 }
 
 static unsigned ComputeLinkerOptionsLoadCommandSize(
   const std::vector<std::string> &Options, bool is64Bit)
 {
   unsigned Size = sizeof(MachO::linker_option_command);
   for (const std::string &Option : Options)
     Size += Option.size() + 1;
   return alignTo(Size, is64Bit ? 8 : 4);
 }
 
 void MachObjectWriter::writeLinkerOptionsLoadCommand(
   const std::vector<std::string> &Options)
 {
   unsigned Size = ComputeLinkerOptionsLoadCommandSize(Options, is64Bit());
-  uint64_t Start = getStream().tell();
+  uint64_t Start = W.OS.tell();
   (void) Start;
 
-  write32(MachO::LC_LINKER_OPTION);
-  write32(Size);
-  write32(Options.size());
+  W.write<uint32_t>(MachO::LC_LINKER_OPTION);
+  W.write<uint32_t>(Size);
+  W.write<uint32_t>(Options.size());
   uint64_t BytesWritten = sizeof(MachO::linker_option_command);
   for (const std::string &Option : Options) {
     // Write each string, including the null byte.
-    writeBytes(Option, Option.size() + 1);
+    W.OS << Option << '\0';
     BytesWritten += Option.size() + 1;
   }
 
   // Pad to a multiple of the pointer size.
-  writeBytes("", OffsetToAlignment(BytesWritten, is64Bit() ? 8 : 4));
+  W.OS.write_zeros(OffsetToAlignment(BytesWritten, is64Bit() ? 8 : 4));
 
-  assert(getStream().tell() - Start == Size);
+  assert(W.OS.tell() - Start == Size);
 }
 
 void MachObjectWriter::recordRelocation(MCAssembler &Asm,
                                         const MCAsmLayout &Layout,
                                         const MCFragment *Fragment,
                                         const MCFixup &Fixup, MCValue Target,
                                         uint64_t &FixedValue) {
   TargetObjectWriter->recordRelocation(this, Asm, Layout, Fragment, Fixup,
void MachObjectWriter::computeSymbolTable(
   for (const MCSection &Section : Asm) {
     for (RelAndSymbol &Rel : Relocations[&Section]) {
       if (!Rel.Sym)
         continue;
 
       // Set the Index and the IsExtern bit.
       unsigned Index = Rel.Sym->getIndex();
       assert(isInt<24>(Index));
-      if (IsLittleEndian)
+      if (W.Endian == support::little)
         Rel.MRE.r_word1 = (Rel.MRE.r_word1 & (~0U << 24)) | Index | (1 << 27);
       else
         Rel.MRE.r_word1 = (Rel.MRE.r_word1 & 0xff) | Index << 8 | (1 << 4);
     }
   }
 }
 
 void MachObjectWriter::computeSectionAddresses(const MCAssembler &Asm,
void MachObjectWriter::writeObject(MCAssembler &Asm,
   if (VersionInfo.Major != 0) {
     assert(VersionInfo.Update < 256 && "unencodable update target version");
     assert(VersionInfo.Minor < 256 && "unencodable minor target version");
     assert(VersionInfo.Major < 65536 && "unencodable major target version");
     uint32_t EncodedVersion = VersionInfo.Update | (VersionInfo.Minor << 8) |
       (VersionInfo.Major << 16);
     if (VersionInfo.EmitBuildVersion) {
       // FIXME: Currently empty tools. Add clang version in the future.
-      write32(MachO::LC_BUILD_VERSION);
-      write32(sizeof(MachO::build_version_command));
-      write32(VersionInfo.TypeOrPlatform.Platform);
-      write32(EncodedVersion);
-      write32(0);         // SDK version.
-      write32(0);         // Empty tools list.
+      W.write<uint32_t>(MachO::LC_BUILD_VERSION);
+      W.write<uint32_t>(sizeof(MachO::build_version_command));
+      W.write<uint32_t>(VersionInfo.TypeOrPlatform.Platform);
+      W.write<uint32_t>(EncodedVersion);
+      W.write<uint32_t>(0);         // SDK version.
+      W.write<uint32_t>(0);         // Empty tools list.
     } else {
       MachO::LoadCommandType LCType
         = getLCFromMCVM(VersionInfo.TypeOrPlatform.Type);
-      write32(LCType);
-      write32(sizeof(MachO::version_min_command));
-      write32(EncodedVersion);
-      write32(0);         // reserved.
+      W.write<uint32_t>(LCType);
+      W.write<uint32_t>(sizeof(MachO::version_min_command));
+      W.write<uint32_t>(EncodedVersion);
+      W.write<uint32_t>(0);         // reserved.
     }
   }
 
   // Write the data-in-code load command, if used.
   uint64_t DataInCodeTableEnd = RelocTableEnd + NumDataRegions * 8;
   if (NumDataRegions) {
     uint64_t DataRegionsOffset = RelocTableEnd;
     uint64_t DataRegionsSize = NumDataRegions * 8;
void MachObjectWriter::writeObject(MCAssembler &Asm,
   }
 
   // Write the linker options load commands.
   for (const auto &Option : Asm.getLinkerOptions())
     writeLinkerOptionsLoadCommand(Option);
 
   // Write the actual section data.
   for (const MCSection &Sec : Asm) {
-    Asm.writeSectionData(getStream(), &Sec, Layout);
+    Asm.writeSectionData(W.OS, &Sec, Layout);
 
     uint64_t Pad = getPaddingSize(&Sec, Layout);
-    WriteZeros(Pad);
+    W.OS.write_zeros(Pad);
   }
 
   // Write the extra padding.
-  WriteZeros(SectionDataPadding);
+  W.OS.write_zeros(SectionDataPadding);
 
   // Write the relocation entries.
   for (const MCSection &Sec : Asm) {
     // Write the section relocation entries, in reverse order to match 'as'
     // (approximately, the exact algorithm is more complicated than this).
     std::vector<RelAndSymbol> &Relocs = Relocations[&Sec];
     for (const RelAndSymbol &Rel : make_range(Relocs.rbegin(), Relocs.rend())) {
-      write32(Rel.MRE.r_word0);
-      write32(Rel.MRE.r_word1);
+      W.write<uint32_t>(Rel.MRE.r_word0);
+      W.write<uint32_t>(Rel.MRE.r_word1);
     }
   }
 
   // Write out the data-in-code region payload, if there is one.
   for (MCAssembler::const_data_region_iterator
          it = Asm.data_region_begin(), ie = Asm.data_region_end();
          it != ie; ++it) {
     const DataRegionData *Data = &(*it);
     uint64_t Start = getSymbolAddress(*Data->Start, Layout);
     uint64_t End;
     if (Data->End) 
       End = getSymbolAddress(*Data->End, Layout);
     else
       report_fatal_error("Data region not terminated");
 
     LLVM_DEBUG(dbgs() << "data in code region-- kind: " << Data->Kind
                       << "  start: " << Start << "(" << Data->Start->getName()
                       << ")"
                       << "  end: " << End << "(" << Data->End->getName() << ")"
                       << "  size: " << End - Start << "\n");
-    write32(Start);
-    write16(End - Start);
-    write16(Data->Kind);
+    W.write<uint32_t>(Start);
+    W.write<uint16_t>(End - Start);
+    W.write<uint16_t>(Data->Kind);
   }
 
   // Write out the loh commands, if there is one.
   if (LOHSize) {
 #ifndef NDEBUG
-    unsigned Start = getStream().tell();
+    unsigned Start = W.OS.tell();
 #endif
     Asm.getLOHContainer().emit(*this, Layout);
     // Pad to a multiple of the pointer size.
-    writeBytes("", OffsetToAlignment(LOHRawSize, is64Bit() ? 8 : 4));
-    assert(getStream().tell() - Start == LOHSize);
+    W.OS.write_zeros(OffsetToAlignment(LOHRawSize, is64Bit() ? 8 : 4));
+    assert(W.OS.tell() - Start == LOHSize);
   }
 
   // Write the symbol table data, if used.
   if (NumSymbols) {
     // Write the indirect symbol entries.
     for (MCAssembler::const_indirect_symbol_iterator
            it = Asm.indirect_symbol_begin(),
            ie = Asm.indirect_symbol_end(); it != ie; ++it) {
       // Indirect symbols in the non-lazy symbol pointer section have some
       // special handling.
       const MCSectionMachO &Section =
           static_cast<const MCSectionMachO &>(*it->Section);
       if (Section.getType() == MachO::S_NON_LAZY_SYMBOL_POINTERS) {
         // If this symbol is defined and internal, mark it as such.
         if (it->Symbol->isDefined() && !it->Symbol->isExternal()) {
           uint32_t Flags = MachO::INDIRECT_SYMBOL_LOCAL;
           if (it->Symbol->isAbsolute())
             Flags |= MachO::INDIRECT_SYMBOL_ABS;
-          write32(Flags);
+          W.write<uint32_t>(Flags);
           continue;
         }
       }
 
-      write32(it->Symbol->getIndex());
+      W.write<uint32_t>(it->Symbol->getIndex());
     }
 
     // FIXME: Check that offsets match computed ones.
 
     // Write the symbol table entries.
     for (auto *SymbolData :
          {&LocalSymbolData, &ExternalSymbolData, &UndefinedSymbolData})
       for (MachSymbolData &Entry : *SymbolData)
         writeNlist(Entry, Layout);
 
     // Write the string table.
-    StringTable.write(getStream());
+    StringTable.write(W.OS);
   }
 }
 
 std::unique_ptr<MCObjectWriter>
 llvm::createMachObjectWriter(std::unique_ptr<MCMachObjectTargetWriter> MOTW,
                              raw_pwrite_stream &OS, bool IsLittleEndian) {
   return llvm::make_unique<MachObjectWriter>(std::move(MOTW), OS,
                                              IsLittleEndian);
 }

llvm/lib/MC/WasmObjectWriter.cpp

 #if !defined(NDEBUG)
 raw_ostream &operator<<(raw_ostream &OS, const WasmRelocationEntry &Rel) {
   Rel.print(OS);
   return OS;
 }
 #endif
 
 class WasmObjectWriter : public MCObjectWriter {
+  support::endian::Writer W;
+
   /// The target specific Wasm writer instance.
   std::unique_ptr<MCWasmObjectTargetWriter> TargetObjectWriter;
 
   // Relocations for fixing up references in the code section.
   std::vector<WasmRelocationEntry> CodeRelocations;
   uint32_t CodeSectionIndex;
 
   // Relocations for fixing up references in the data section.
class WasmObjectWriter : public MCObjectWriter {
 
   void startSection(SectionBookkeeping &Section, unsigned SectionId);
   void startCustomSection(SectionBookkeeping &Section, StringRef Name);
   void endSection(SectionBookkeeping &Section);
 
 public:
   WasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
                    raw_pwrite_stream &OS)
-      : MCObjectWriter(OS, /*IsLittleEndian=*/true),
+      : MCObjectWriter(OS, /*IsLittleEndian=*/true), W(OS, support::little),
         TargetObjectWriter(std::move(MOTW)) {}
 
   ~WasmObjectWriter() override;
 
 private:
   void reset() override {
     CodeRelocations.clear();
     DataRelocations.clear();
void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
                         MCValue Target, uint64_t &FixedValue) override;
 
   void executePostLayoutBinding(MCAssembler &Asm,
                                 const MCAsmLayout &Layout) override;
 
   void writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
 
   void writeString(const StringRef Str) {
-    encodeULEB128(Str.size(), getStream());
-    writeBytes(Str);
+    encodeULEB128(Str.size(), W.OS);
+    W.OS << Str;
   }
 
   void writeValueType(wasm::ValType Ty) {
-    write8(static_cast<uint8_t>(Ty));
+    W.OS << static_cast<char>(Ty);
   }
 
   void writeTypeSection(ArrayRef<WasmFunctionType> FunctionTypes);
   void writeImportSection(ArrayRef<wasm::WasmImport> Imports, uint32_t DataSize,
                           uint32_t NumElements);
   void writeFunctionSection(ArrayRef<WasmFunction> Functions);
   void writeGlobalSection();
   void writeExportSection(ArrayRef<wasm::WasmExport> Exports);

 } // end anonymous namespace
 
 WasmObjectWriter::~WasmObjectWriter() {}
 
 // Write out a section header and a patchable section size field.
 void WasmObjectWriter::startSection(SectionBookkeeping &Section,
                                     unsigned SectionId) {
   LLVM_DEBUG(dbgs() << "startSection " << SectionId << "\n");
-  write8(SectionId);
+  W.OS << char(SectionId);
 
-  Section.SizeOffset = getStream().tell();
+  Section.SizeOffset = W.OS.tell();
 
   // The section size. We don't know the size yet, so reserve enough space
   // for any 32-bit value; we'll patch it later.
-  encodeULEB128(UINT32_MAX, getStream());
+  encodeULEB128(UINT32_MAX, W.OS);
 
   // The position where the section starts, for measuring its size.
-  Section.ContentsOffset = getStream().tell();
-  Section.PayloadOffset = getStream().tell();
+  Section.ContentsOffset = W.OS.tell();
+  Section.PayloadOffset = W.OS.tell();
   Section.Index = SectionCount++;
 }
 
 void WasmObjectWriter::startCustomSection(SectionBookkeeping &Section,
                                           StringRef Name) {
   LLVM_DEBUG(dbgs() << "startCustomSection " << Name << "\n");
   startSection(Section, wasm::WASM_SEC_CUSTOM);
 
   // The position where the section header ends, for measuring its size.
-  Section.PayloadOffset = getStream().tell();
+  Section.PayloadOffset = W.OS.tell();
 
   // Custom sections in wasm also have a string identifier.
   writeString(Name);
 
   // The position where the custom section starts.
-  Section.ContentsOffset = getStream().tell();
+  Section.ContentsOffset = W.OS.tell();
 }
 
 // Now that the section is complete and we know how big it is, patch up the
 // section size field at the start of the section.
 void WasmObjectWriter::endSection(SectionBookkeeping &Section) {
-  uint64_t Size = getStream().tell() - Section.PayloadOffset;
+  uint64_t Size = W.OS.tell() - Section.PayloadOffset;
   if (uint32_t(Size) != Size)
     report_fatal_error("section size does not fit in a uint32_t");
 
   LLVM_DEBUG(dbgs() << "endSection size=" << Size << "\n");
 
   // Write the final section size to the payload_len field, which follows
   // the section id byte.
   uint8_t Buffer[16];
   unsigned SizeLen = encodeULEB128(Size, Buffer, 5);
   assert(SizeLen == 5);
-  getStream().pwrite((char *)Buffer, SizeLen, Section.SizeOffset);
+  static_cast<raw_pwrite_stream &>(W.OS).pwrite((char *)Buffer, SizeLen,
+                                                Section.SizeOffset);
 }
 
 // Emit the Wasm header.
 void WasmObjectWriter::writeHeader(const MCAssembler &Asm) {
-  writeBytes(StringRef(wasm::WasmMagic, sizeof(wasm::WasmMagic)));
-  writeLE32(wasm::WasmVersion);
+  W.OS.write(wasm::WasmMagic, sizeof(wasm::WasmMagic));
+  W.write<uint32_t>(wasm::WasmVersion);
 }
 
 void WasmObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
                                                 const MCAsmLayout &Layout) {
   // Build a map of sections to the function that defines them, for use
   // in recordRelocation.
   for (const MCSymbol &S : Asm.symbols()) {
     const auto &WS = static_cast<const MCSymbolWasm &>(S);
WasmObjectWriter::getRelocationIndexValue(const WasmRelocationEntry &RelEntry) {
 
   return RelEntry.Symbol->getIndex();
 }
 
 // Apply the portions of the relocation records that we can handle ourselves
 // directly.
 void WasmObjectWriter::applyRelocations(
     ArrayRef<WasmRelocationEntry> Relocations, uint64_t ContentsOffset) {
-  raw_pwrite_stream &Stream = getStream();
+  auto &Stream = static_cast<raw_pwrite_stream &>(W.OS);
   for (const WasmRelocationEntry &RelEntry : Relocations) {
     uint64_t Offset = ContentsOffset +
                       RelEntry.FixupSection->getSectionOffset() +
                       RelEntry.Offset;
 
     LLVM_DEBUG(dbgs() << "applyRelocation: " << RelEntry << "\n");
     uint32_t Value = getProvisionalValue(RelEntry);
 

 void WasmObjectWriter::writeTypeSection(
     ArrayRef<WasmFunctionType> FunctionTypes) {
   if (FunctionTypes.empty())
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_TYPE);
 
-  encodeULEB128(FunctionTypes.size(), getStream());
+  encodeULEB128(FunctionTypes.size(), W.OS);
 
   for (const WasmFunctionType &FuncTy : FunctionTypes) {
-    write8(wasm::WASM_TYPE_FUNC);
-    encodeULEB128(FuncTy.Params.size(), getStream());
+    W.OS << char(wasm::WASM_TYPE_FUNC);
+    encodeULEB128(FuncTy.Params.size(), W.OS);
     for (wasm::ValType Ty : FuncTy.Params)
       writeValueType(Ty);
-    encodeULEB128(FuncTy.Returns.size(), getStream());
+    encodeULEB128(FuncTy.Returns.size(), W.OS);
     for (wasm::ValType Ty : FuncTy.Returns)
       writeValueType(Ty);
   }
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeImportSection(ArrayRef<wasm::WasmImport> Imports,
                                           uint32_t DataSize,
                                           uint32_t NumElements) {
   if (Imports.empty())
     return;
 
   uint32_t NumPages = (DataSize + wasm::WasmPageSize - 1) / wasm::WasmPageSize;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_IMPORT);
 
-  encodeULEB128(Imports.size(), getStream());
+  encodeULEB128(Imports.size(), W.OS);
   for (const wasm::WasmImport &Import : Imports) {
     writeString(Import.Module);
     writeString(Import.Field);
-    write8(Import.Kind);
+    W.OS << char(Import.Kind);
 
     switch (Import.Kind) {
     case wasm::WASM_EXTERNAL_FUNCTION:
-      encodeULEB128(Import.SigIndex, getStream());
+      encodeULEB128(Import.SigIndex, W.OS);
       break;
     case wasm::WASM_EXTERNAL_GLOBAL:
-      write8(Import.Global.Type);
-      write8(Import.Global.Mutable ? 1 : 0);
+      W.OS << char(Import.Global.Type);
+      W.OS << char(Import.Global.Mutable ? 1 : 0);
       break;
     case wasm::WASM_EXTERNAL_MEMORY:
-      encodeULEB128(0, getStream()); // flags
-      encodeULEB128(NumPages, getStream()); // initial
+      encodeULEB128(0, W.OS); // flags
+      encodeULEB128(NumPages, W.OS); // initial
       break;
     case wasm::WASM_EXTERNAL_TABLE:
-      write8(Import.Table.ElemType);
-      encodeULEB128(0, getStream()); // flags
-      encodeULEB128(NumElements, getStream()); // initial
+      W.OS << char(Import.Table.ElemType);
+      encodeULEB128(0, W.OS); // flags
+      encodeULEB128(NumElements, W.OS); // initial
       break;
     default:
       llvm_unreachable("unsupported import kind");
     }
   }
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeFunctionSection(ArrayRef<WasmFunction> Functions) {
   if (Functions.empty())
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_FUNCTION);
 
-  encodeULEB128(Functions.size(), getStream());
+  encodeULEB128(Functions.size(), W.OS);
   for (const WasmFunction &Func : Functions)
-    encodeULEB128(Func.Type, getStream());
+    encodeULEB128(Func.Type, W.OS);
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeGlobalSection() {
   if (Globals.empty())
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_GLOBAL);
 
-  encodeULEB128(Globals.size(), getStream());
+  encodeULEB128(Globals.size(), W.OS);
   for (const WasmGlobal &Global : Globals) {
     writeValueType(static_cast<wasm::ValType>(Global.Type.Type));
-    write8(Global.Type.Mutable);
+    W.OS << char(Global.Type.Mutable);
 
-    write8(wasm::WASM_OPCODE_I32_CONST);
-    encodeSLEB128(Global.InitialValue, getStream());
-    write8(wasm::WASM_OPCODE_END);
+    W.OS << char(wasm::WASM_OPCODE_I32_CONST);
+    encodeSLEB128(Global.InitialValue, W.OS);
+    W.OS << char(wasm::WASM_OPCODE_END);
   }
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeExportSection(ArrayRef<wasm::WasmExport> Exports) {
   if (Exports.empty())
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_EXPORT);
 
-  encodeULEB128(Exports.size(), getStream());
+  encodeULEB128(Exports.size(), W.OS);
   for (const wasm::WasmExport &Export : Exports) {
     writeString(Export.Name);
-    write8(Export.Kind);
-    encodeULEB128(Export.Index, getStream());
+    W.OS << char(Export.Kind);
+    encodeULEB128(Export.Index, W.OS);
   }
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeElemSection(ArrayRef<uint32_t> TableElems) {
   if (TableElems.empty())
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_ELEM);
 
-  encodeULEB128(1, getStream()); // number of "segments"
-  encodeULEB128(0, getStream()); // the table index
+  encodeULEB128(1, W.OS); // number of "segments"
+  encodeULEB128(0, W.OS); // the table index
 
   // init expr for starting offset
-  write8(wasm::WASM_OPCODE_I32_CONST);
-  encodeSLEB128(kInitialTableOffset, getStream());
-  write8(wasm::WASM_OPCODE_END);
+  W.OS << char(wasm::WASM_OPCODE_I32_CONST);
+  encodeSLEB128(kInitialTableOffset, W.OS);
+  W.OS << char(wasm::WASM_OPCODE_END);
 
-  encodeULEB128(TableElems.size(), getStream());
+  encodeULEB128(TableElems.size(), W.OS);
   for (uint32_t Elem : TableElems)
-    encodeULEB128(Elem, getStream());
+    encodeULEB128(Elem, W.OS);
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeCodeSection(const MCAssembler &Asm,
                                         const MCAsmLayout &Layout,
                                         ArrayRef<WasmFunction> Functions) {
   if (Functions.empty())
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_CODE);
   CodeSectionIndex = Section.Index;
 
-  encodeULEB128(Functions.size(), getStream());
+  encodeULEB128(Functions.size(), W.OS);
 
   for (const WasmFunction &Func : Functions) {
     auto &FuncSection = static_cast<MCSectionWasm &>(Func.Sym->getSection());
 
     int64_t Size = 0;
     if (!Func.Sym->getSize()->evaluateAsAbsolute(Size, Layout))
       report_fatal_error(".size expression must be evaluatable");
 
-    encodeULEB128(Size, getStream());
-    FuncSection.setSectionOffset(getStream().tell() - Section.ContentsOffset);
-    Asm.writeSectionData(getStream(), &FuncSection, Layout);
+    encodeULEB128(Size, W.OS);
+    FuncSection.setSectionOffset(W.OS.tell() - Section.ContentsOffset);
+    Asm.writeSectionData(W.OS, &FuncSection, Layout);
   }
 
   // Apply fixups.
   applyRelocations(CodeRelocations, Section.ContentsOffset);
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeDataSection() {
   if (DataSegments.empty())
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_DATA);
   DataSectionIndex = Section.Index;
 
-  encodeULEB128(DataSegments.size(), getStream()); // count
+  encodeULEB128(DataSegments.size(), W.OS); // count
 
   for (const WasmDataSegment &Segment : DataSegments) {
-    encodeULEB128(0, getStream()); // memory index
-    write8(wasm::WASM_OPCODE_I32_CONST);
-    encodeSLEB128(Segment.Offset, getStream()); // offset
-    write8(wasm::WASM_OPCODE_END);
-    encodeULEB128(Segment.Data.size(), getStream()); // size
-    Segment.Section->setSectionOffset(getStream().tell() - Section.ContentsOffset);
-    writeBytes(Segment.Data); // data
+    encodeULEB128(0, W.OS); // memory index
+    W.OS << char(wasm::WASM_OPCODE_I32_CONST);
+    encodeSLEB128(Segment.Offset, W.OS); // offset
+    W.OS << char(wasm::WASM_OPCODE_END);
+    encodeULEB128(Segment.Data.size(), W.OS); // size
+    Segment.Section->setSectionOffset(W.OS.tell() - Section.ContentsOffset);
+    W.OS << Segment.Data; // data
   }
 
   // Apply fixups.
   applyRelocations(DataRelocations, Section.ContentsOffset);
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeRelocSection(
     uint32_t SectionIndex, StringRef Name,
     ArrayRef<WasmRelocationEntry> Relocations) {
   // See: https://github.com/WebAssembly/tool-conventions/blob/master/Linking.md
   // for descriptions of the reloc sections.
 
   if (Relocations.empty())
     return;
 
   SectionBookkeeping Section;
   startCustomSection(Section, std::string("reloc.") + Name.str());
 
-  raw_pwrite_stream &Stream = getStream();
-
-  encodeULEB128(SectionIndex, Stream);
-  encodeULEB128(Relocations.size(), Stream);
+  encodeULEB128(SectionIndex, W.OS);
+  encodeULEB128(Relocations.size(), W.OS);
   for (const WasmRelocationEntry& RelEntry : Relocations) {
     uint64_t Offset = RelEntry.Offset +
                       RelEntry.FixupSection->getSectionOffset();
     uint32_t Index = getRelocationIndexValue(RelEntry);
 
-    write8(RelEntry.Type);
-    encodeULEB128(Offset, Stream);
-    encodeULEB128(Index, Stream);
+    W.OS << char(RelEntry.Type);
+    encodeULEB128(Offset, W.OS);
+    encodeULEB128(Index, W.OS);
     if (RelEntry.hasAddend())
-      encodeSLEB128(RelEntry.Addend, Stream);
+      encodeSLEB128(RelEntry.Addend, W.OS);
   }
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeCustomRelocSections() {
   for (const auto &Sec : CustomSections) {
     auto &Relocations = CustomSectionsRelocations[Sec.Section];
     writeRelocSection(Sec.OutputIndex, Sec.Name, Relocations);
   }
 }
 
 void WasmObjectWriter::writeLinkingMetaDataSection(
     ArrayRef<wasm::WasmSymbolInfo> SymbolInfos,
     ArrayRef<std::pair<uint16_t, uint32_t>> InitFuncs,
     const std::map<StringRef, std::vector<WasmComdatEntry>> &Comdats) {
   SectionBookkeeping Section;
   startCustomSection(Section, "linking");
-  encodeULEB128(wasm::WasmMetadataVersion, getStream());
+  encodeULEB128(wasm::WasmMetadataVersion, W.OS);
 
   SectionBookkeeping SubSection;
   if (SymbolInfos.size() != 0) {
     startSection(SubSection, wasm::WASM_SYMBOL_TABLE);
-    encodeULEB128(SymbolInfos.size(), getStream());
+    encodeULEB128(SymbolInfos.size(), W.OS);
     for (const wasm::WasmSymbolInfo &Sym : SymbolInfos) {
-      encodeULEB128(Sym.Kind, getStream());
-      encodeULEB128(Sym.Flags, getStream());
+      encodeULEB128(Sym.Kind, W.OS);
+      encodeULEB128(Sym.Flags, W.OS);
       switch (Sym.Kind) {
       case wasm::WASM_SYMBOL_TYPE_FUNCTION:
       case wasm::WASM_SYMBOL_TYPE_GLOBAL:
-        encodeULEB128(Sym.ElementIndex, getStream());
+        encodeULEB128(Sym.ElementIndex, W.OS);
         if ((Sym.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0)
           writeString(Sym.Name);
         break;
       case wasm::WASM_SYMBOL_TYPE_DATA:
         writeString(Sym.Name);
         if ((Sym.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0) {
-          encodeULEB128(Sym.DataRef.Segment, getStream());
-          encodeULEB128(Sym.DataRef.Offset, getStream());
-          encodeULEB128(Sym.DataRef.Size, getStream());
+          encodeULEB128(Sym.DataRef.Segment, W.OS);
+          encodeULEB128(Sym.DataRef.Offset, W.OS);
+          encodeULEB128(Sym.DataRef.Size, W.OS);
         }
         break;
       case wasm::WASM_SYMBOL_TYPE_SECTION: {
         const uint32_t SectionIndex =
             CustomSections[Sym.ElementIndex].OutputIndex;
-        encodeULEB128(SectionIndex, getStream());
+        encodeULEB128(SectionIndex, W.OS);
         break;
       }
       default:
         llvm_unreachable("unexpected kind");
       }
     }
     endSection(SubSection);
   }
 
   if (DataSegments.size()) {
     startSection(SubSection, wasm::WASM_SEGMENT_INFO);
-    encodeULEB128(DataSegments.size(), getStream());
+    encodeULEB128(DataSegments.size(), W.OS);
     for (const WasmDataSegment &Segment : DataSegments) {
       writeString(Segment.Name);
-      encodeULEB128(Segment.Alignment, getStream());
-      encodeULEB128(Segment.Flags, getStream());
+      encodeULEB128(Segment.Alignment, W.OS);
+      encodeULEB128(Segment.Flags, W.OS);
     }
     endSection(SubSection);
   }
 
   if (!InitFuncs.empty()) {
     startSection(SubSection, wasm::WASM_INIT_FUNCS);
-    encodeULEB128(InitFuncs.size(), getStream());
+    encodeULEB128(InitFuncs.size(), W.OS);
     for (auto &StartFunc : InitFuncs) {
-      encodeULEB128(StartFunc.first, getStream()); // priority
-      encodeULEB128(StartFunc.second, getStream()); // function index
+      encodeULEB128(StartFunc.first, W.OS); // priority
+      encodeULEB128(StartFunc.second, W.OS); // function index
     }
     endSection(SubSection);
   }
 
   if (Comdats.size()) {
     startSection(SubSection, wasm::WASM_COMDAT_INFO);
-    encodeULEB128(Comdats.size(), getStream());
+    encodeULEB128(Comdats.size(), W.OS);
     for (const auto &C : Comdats) {
       writeString(C.first);
-      encodeULEB128(0, getStream()); // flags for future use
-      encodeULEB128(C.second.size(), getStream());
+      encodeULEB128(0, W.OS); // flags for future use
+      encodeULEB128(C.second.size(), W.OS);
       for (const WasmComdatEntry &Entry : C.second) {
-        encodeULEB128(Entry.Kind, getStream());
-        encodeULEB128(Entry.Index, getStream());
+        encodeULEB128(Entry.Kind, W.OS);
+        encodeULEB128(Entry.Index, W.OS);
       }
     }
     endSection(SubSection);
   }
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeCustomSections(const MCAssembler &Asm,
                                            const MCAsmLayout &Layout) {
   for (auto &CustomSection : CustomSections) {
     SectionBookkeeping Section;
     auto *Sec = CustomSection.Section;
     startCustomSection(Section, CustomSection.Name);
 
-    Sec->setSectionOffset(getStream().tell() - Section.ContentsOffset);
-    Asm.writeSectionData(getStream(), Sec, Layout);
+    Sec->setSectionOffset(W.OS.tell() - Section.ContentsOffset);
+    Asm.writeSectionData(W.OS, Sec, Layout);
 
     CustomSection.OutputContentsOffset = Section.ContentsOffset;
     CustomSection.OutputIndex = Section.Index;
 
     endSection(Section);
 
     // Apply fixups.
     auto &Relocations = CustomSectionsRelocations[CustomSection.Section];

llvm/lib/MC/WinCOFFObjectWriter.cpp

public:
   COFFSymbol *Symbol = nullptr;
   relocations Relocations;
 
   COFFSection(StringRef Name) : Name(Name) {}
 };
 
 class WinCOFFObjectWriter : public MCObjectWriter {
 public:
+  support::endian::Writer W;
+
   using symbols = std::vector<std::unique_ptr<COFFSymbol>>;
   using sections = std::vector<std::unique_ptr<COFFSection>>;
 
   using symbol_map = DenseMap<MCSymbol const *, COFFSymbol *>;
   using section_map = DenseMap<MCSection const *, COFFSection *>;
 
   std::unique_ptr<MCWinCOFFObjectTargetWriter> TargetObjectWriter;
 
void COFFSymbol::set_name_offset(uint32_t Offset) {
   write32le(Data.Name + 4, Offset);
 }
 
 //------------------------------------------------------------------------------
 // WinCOFFObjectWriter class implementation
 
 WinCOFFObjectWriter::WinCOFFObjectWriter(
     std::unique_ptr<MCWinCOFFObjectTargetWriter> MOTW, raw_pwrite_stream &OS)
-    : MCObjectWriter(OS, true), TargetObjectWriter(std::move(MOTW)) {
+    : MCObjectWriter(OS, true), W(OS, support::little),
+      TargetObjectWriter(std::move(MOTW)) {
   Header.Machine = TargetObjectWriter->getMachine();
 }
 
 COFFSymbol *WinCOFFObjectWriter::createSymbol(StringRef Name) {
   Symbols.push_back(make_unique<COFFSymbol>(Name));
   return Symbols.back().get();
 }
 
return (S->Header.Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA) ==
          0;
 }
 
 //------------------------------------------------------------------------------
 // entity writing methods
 
 void WinCOFFObjectWriter::WriteFileHeader(const COFF::header &Header) {
   if (UseBigObj) {
-    writeLE16(COFF::IMAGE_FILE_MACHINE_UNKNOWN);
-    writeLE16(0xFFFF);
-    writeLE16(COFF::BigObjHeader::MinBigObjectVersion);
-    writeLE16(Header.Machine);
-    writeLE32(Header.TimeDateStamp);
-    writeBytes(StringRef(COFF::BigObjMagic, sizeof(COFF::BigObjMagic)));
-    writeLE32(0);
-    writeLE32(0);
-    writeLE32(0);
-    writeLE32(0);
-    writeLE32(Header.NumberOfSections);
-    writeLE32(Header.PointerToSymbolTable);
-    writeLE32(Header.NumberOfSymbols);
+    W.write<uint16_t>(COFF::IMAGE_FILE_MACHINE_UNKNOWN);
+    W.write<uint16_t>(0xFFFF);
+    W.write<uint16_t>(COFF::BigObjHeader::MinBigObjectVersion);
+    W.write<uint16_t>(Header.Machine);
+    W.write<uint32_t>(Header.TimeDateStamp);
+    W.OS.write(COFF::BigObjMagic, sizeof(COFF::BigObjMagic));
+    W.write<uint32_t>(0);
+    W.write<uint32_t>(0);
+    W.write<uint32_t>(0);
+    W.write<uint32_t>(0);
+    W.write<uint32_t>(Header.NumberOfSections);
+    W.write<uint32_t>(Header.PointerToSymbolTable);
+    W.write<uint32_t>(Header.NumberOfSymbols);
   } else {
-    writeLE16(Header.Machine);
-    writeLE16(static_cast<int16_t>(Header.NumberOfSections));
-    writeLE32(Header.TimeDateStamp);
-    writeLE32(Header.PointerToSymbolTable);
-    writeLE32(Header.NumberOfSymbols);
-    writeLE16(Header.SizeOfOptionalHeader);
-    writeLE16(Header.Characteristics);
+    W.write<uint16_t>(Header.Machine);
+    W.write<uint16_t>(static_cast<int16_t>(Header.NumberOfSections));
+    W.write<uint32_t>(Header.TimeDateStamp);
+    W.write<uint32_t>(Header.PointerToSymbolTable);
+    W.write<uint32_t>(Header.NumberOfSymbols);
+    W.write<uint16_t>(Header.SizeOfOptionalHeader);
+    W.write<uint16_t>(Header.Characteristics);
   }
 }
 
 void WinCOFFObjectWriter::WriteSymbol(const COFFSymbol &S) {
-  writeBytes(StringRef(S.Data.Name, COFF::NameSize));
-  writeLE32(S.Data.Value);
+  W.OS.write(S.Data.Name, COFF::NameSize);
+  W.write<uint32_t>(S.Data.Value);
   if (UseBigObj)
-    writeLE32(S.Data.SectionNumber);
+    W.write<uint32_t>(S.Data.SectionNumber);
   else
-    writeLE16(static_cast<int16_t>(S.Data.SectionNumber));
-  writeLE16(S.Data.Type);
-  write8(S.Data.StorageClass);
-  write8(S.Data.NumberOfAuxSymbols);
+    W.write<uint16_t>(static_cast<int16_t>(S.Data.SectionNumber));
+  W.write<uint16_t>(S.Data.Type);
+  W.OS << char(S.Data.StorageClass);
+  W.OS << char(S.Data.NumberOfAuxSymbols);
   WriteAuxiliarySymbols(S.Aux);
 }
 
 void WinCOFFObjectWriter::WriteAuxiliarySymbols(
     const COFFSymbol::AuxiliarySymbols &S) {
   for (const AuxSymbol &i : S) {
     switch (i.AuxType) {
     case ATFunctionDefinition:
-      writeLE32(i.Aux.FunctionDefinition.TagIndex);
-      writeLE32(i.Aux.FunctionDefinition.TotalSize);
-      writeLE32(i.Aux.FunctionDefinition.PointerToLinenumber);
-      writeLE32(i.Aux.FunctionDefinition.PointerToNextFunction);
-      WriteZeros(sizeof(i.Aux.FunctionDefinition.unused));
+      W.write<uint32_t>(i.Aux.FunctionDefinition.TagIndex);
+      W.write<uint32_t>(i.Aux.FunctionDefinition.TotalSize);
+      W.write<uint32_t>(i.Aux.FunctionDefinition.PointerToLinenumber);
+      W.write<uint32_t>(i.Aux.FunctionDefinition.PointerToNextFunction);
+      W.OS.write_zeros(sizeof(i.Aux.FunctionDefinition.unused));
       if (UseBigObj)
-        WriteZeros(COFF::Symbol32Size - COFF::Symbol16Size);
+        W.OS.write_zeros(COFF::Symbol32Size - COFF::Symbol16Size);
       break;
     case ATbfAndefSymbol:
-      WriteZeros(sizeof(i.Aux.bfAndefSymbol.unused1));
-      writeLE16(i.Aux.bfAndefSymbol.Linenumber);
-      WriteZeros(sizeof(i.Aux.bfAndefSymbol.unused2));
-      writeLE32(i.Aux.bfAndefSymbol.PointerToNextFunction);
-      WriteZeros(sizeof(i.Aux.bfAndefSymbol.unused3));
+      W.OS.write_zeros(sizeof(i.Aux.bfAndefSymbol.unused1));
+      W.write<uint16_t>(i.Aux.bfAndefSymbol.Linenumber);
+      W.OS.write_zeros(sizeof(i.Aux.bfAndefSymbol.unused2));
+      W.write<uint32_t>(i.Aux.bfAndefSymbol.PointerToNextFunction);
+      W.OS.write_zeros(sizeof(i.Aux.bfAndefSymbol.unused3));
       if (UseBigObj)
-        WriteZeros(COFF::Symbol32Size - COFF::Symbol16Size);
+        W.OS.write_zeros(COFF::Symbol32Size - COFF::Symbol16Size);
       break;
     case ATWeakExternal:
-      writeLE32(i.Aux.WeakExternal.TagIndex);
-      writeLE32(i.Aux.WeakExternal.Characteristics);
-      WriteZeros(sizeof(i.Aux.WeakExternal.unused));
+      W.write<uint32_t>(i.Aux.WeakExternal.TagIndex);
+      W.write<uint32_t>(i.Aux.WeakExternal.Characteristics);
+      W.OS.write_zeros(sizeof(i.Aux.WeakExternal.unused));
       if (UseBigObj)
-        WriteZeros(COFF::Symbol32Size - COFF::Symbol16Size);
+        W.OS.write_zeros(COFF::Symbol32Size - COFF::Symbol16Size);
       break;
     case ATFile:
-      writeBytes(
-          StringRef(reinterpret_cast<const char *>(&i.Aux),
-                    UseBigObj ? COFF::Symbol32Size : COFF::Symbol16Size));
+      W.OS.write(reinterpret_cast<const char *>(&i.Aux),
+                        UseBigObj ? COFF::Symbol32Size : COFF::Symbol16Size);
       break;
     case ATSectionDefinition:
-      writeLE32(i.Aux.SectionDefinition.Length);
-      writeLE16(i.Aux.SectionDefinition.NumberOfRelocations);
-      writeLE16(i.Aux.SectionDefinition.NumberOfLinenumbers);
-      writeLE32(i.Aux.SectionDefinition.CheckSum);
-      writeLE16(static_cast<int16_t>(i.Aux.SectionDefinition.Number));
-      write8(i.Aux.SectionDefinition.Selection);
-      WriteZeros(sizeof(i.Aux.SectionDefinition.unused));
-      writeLE16(static_cast<int16_t>(i.Aux.SectionDefinition.Number >> 16));
+      W.write<uint32_t>(i.Aux.SectionDefinition.Length);
+      W.write<uint16_t>(i.Aux.SectionDefinition.NumberOfRelocations);
+      W.write<uint16_t>(i.Aux.SectionDefinition.NumberOfLinenumbers);
+      W.write<uint32_t>(i.Aux.SectionDefinition.CheckSum);
+      W.write<uint16_t>(static_cast<int16_t>(i.Aux.SectionDefinition.Number));
+      W.OS << char(i.Aux.SectionDefinition.Selection);
+      W.OS.write_zeros(sizeof(i.Aux.SectionDefinition.unused));
+      W.write<uint16_t>(static_cast<int16_t>(i.Aux.SectionDefinition.Number >> 16));
       if (UseBigObj)
-        WriteZeros(COFF::Symbol32Size - COFF::Symbol16Size);
+        W.OS.write_zeros(COFF::Symbol32Size - COFF::Symbol16Size);
       break;
     }
   }
 }
 
 // Write the section header.
 void WinCOFFObjectWriter::writeSectionHeaders() {
   // Section numbers must be monotonically increasing in the section
void WinCOFFObjectWriter::writeSectionHeaders() {
 
   for (auto &Section : Arr) {
     if (Section->Number == -1)
       continue;
 
     COFF::section &S = Section->Header;
     if (Section->Relocations.size() >= 0xffff)
       S.Characteristics |= COFF::IMAGE_SCN_LNK_NRELOC_OVFL;
-    writeBytes(StringRef(S.Name, COFF::NameSize));
-    writeLE32(S.VirtualSize);
-    writeLE32(S.VirtualAddress);
-    writeLE32(S.SizeOfRawData);
-    writeLE32(S.PointerToRawData);
-    writeLE32(S.PointerToRelocations);
-    writeLE32(S.PointerToLineNumbers);
-    writeLE16(S.NumberOfRelocations);
-    writeLE16(S.NumberOfLineNumbers);
-    writeLE32(S.Characteristics);
+    W.OS.write(S.Name, COFF::NameSize);
+    W.write<uint32_t>(S.VirtualSize);
+    W.write<uint32_t>(S.VirtualAddress);
+    W.write<uint32_t>(S.SizeOfRawData);
+    W.write<uint32_t>(S.PointerToRawData);
+    W.write<uint32_t>(S.PointerToRelocations);
+    W.write<uint32_t>(S.PointerToLineNumbers);
+    W.write<uint16_t>(S.NumberOfRelocations);
+    W.write<uint16_t>(S.NumberOfLineNumbers);
+    W.write<uint32_t>(S.Characteristics);
   }
 }
 
 void WinCOFFObjectWriter::WriteRelocation(const COFF::relocation &R) {
-  writeLE32(R.VirtualAddress);
-  writeLE32(R.SymbolTableIndex);
-  writeLE16(R.Type);
+  W.write<uint32_t>(R.VirtualAddress);
+  W.write<uint32_t>(R.SymbolTableIndex);
+  W.write<uint16_t>(R.Type);
 }
 
 // Write MCSec's contents. What this function does is essentially
 // "Asm.writeSectionData(&MCSec, Layout)", but it's a bit complicated
 // because it needs to compute a CRC.
 uint32_t WinCOFFObjectWriter::writeSectionContents(MCAssembler &Asm,
                                                    const MCAsmLayout &Layout,
                                                    const MCSection &MCSec) {
   // Save the contents of the section to a temporary buffer, we need this
   // to CRC the data before we dump it into the object file.
   SmallVector<char, 128> Buf;
   raw_svector_ostream VecOS(Buf);
   Asm.writeSectionData(VecOS, &MCSec, Layout);
 
   // Write the section contents to the object file.
-  getStream() << Buf;
+  W.OS << Buf;
 
   // Calculate our CRC with an initial value of '0', this is not how
   // JamCRC is specified but it aligns with the expected output.
   JamCRC JC(/*Init=*/0);
   JC.update(Buf);
   return JC.getCRC();
 }
 
 void WinCOFFObjectWriter::writeSection(MCAssembler &Asm,
                                        const MCAsmLayout &Layout,
                                        const COFFSection &Sec,
                                        const MCSection &MCSec) {
   if (Sec.Number == -1)
     return;
 
   // Write the section contents.
   if (Sec.Header.PointerToRawData != 0) {
-    assert(getStream().tell() <= Sec.Header.PointerToRawData &&
+    assert(W.OS.tell() <= Sec.Header.PointerToRawData &&
            "Section::PointerToRawData is insane!");
 
-    unsigned PaddingSize = Sec.Header.PointerToRawData - getStream().tell();
+    unsigned PaddingSize = Sec.Header.PointerToRawData - W.OS.tell();
     assert(PaddingSize < 4 &&
            "Should only need at most three bytes of padding!");
-    WriteZeros(PaddingSize);
+    W.OS.write_zeros(PaddingSize);
 
     uint32_t CRC = writeSectionContents(Asm, Layout, MCSec);
 
     // Update the section definition auxiliary symbol to record the CRC.
     COFFSection *Sec = SectionMap[&MCSec];
     COFFSymbol::AuxiliarySymbols &AuxSyms = Sec->Symbol->Aux;
     assert(AuxSyms.size() == 1 && AuxSyms[0].AuxType == ATSectionDefinition);
     AuxSymbol &SecDef = AuxSyms[0];
     SecDef.Aux.SectionDefinition.CheckSum = CRC;
   }
 
   // Write relocations for this section.
   if (Sec.Relocations.empty()) {
     assert(Sec.Header.PointerToRelocations == 0 &&
            "Section::PointerToRelocations is insane!");
     return;
   }
 
-  assert(getStream().tell() == Sec.Header.PointerToRelocations &&
+  assert(W.OS.tell() == Sec.Header.PointerToRelocations &&
          "Section::PointerToRelocations is insane!");
 
   if (Sec.Relocations.size() >= 0xffff) {
     // In case of overflow, write actual relocation count as first
     // relocation. Including the synthetic reloc itself (+ 1).
     COFF::relocation R;
     R.VirtualAddress = Sec.Relocations.size() + 1;
     R.SymbolTableIndex = 0;
void WinCOFFObjectWriter::assignSectionNumbers() {
   for (const std::unique_ptr<COFFSection> &Section : Sections)
     if (isAssociative(*Section))
       Assign(*Section);
 }
 
 // Assign file offsets to COFF object file structures.
 void WinCOFFObjectWriter::assignFileOffsets(MCAssembler &Asm,
                                             const MCAsmLayout &Layout) {
-  unsigned Offset = getInitialOffset();
+  unsigned Offset = W.OS.tell();
 
   Offset += UseBigObj ? COFF::Header32Size : COFF::Header16Size;
   Offset += COFF::SectionSize * Header.NumberOfSections;
 
   for (const auto &Section : Asm) {
     COFFSection *Sec = SectionMap[&Section];
 
     if (Sec->Number == -1)
void WinCOFFObjectWriter::writeObject(MCAssembler &Asm,
   // Write section contents.
   sections::iterator I = Sections.begin();
   sections::iterator IE = Sections.end();
   MCAssembler::iterator J = Asm.begin();
   MCAssembler::iterator JE = Asm.end();
   for (; I != IE && J != JE; ++I, ++J)
     writeSection(Asm, Layout, **I, *J);
 
-  assert(getStream().tell() == Header.PointerToSymbolTable &&
+  assert(W.OS.tell() == Header.PointerToSymbolTable &&
          "Header::PointerToSymbolTable is insane!");
 
   // Write a symbol table.
   for (auto &Symbol : Symbols)
     if (Symbol->getIndex() != -1)
       WriteSymbol(*Symbol);
 
   // Write a string table, which completes the entire COFF file.
-  Strings.write(getStream());
+  Strings.write(W.OS);
 }
 
 MCWinCOFFObjectTargetWriter::MCWinCOFFObjectTargetWriter(unsigned Machine_)
     : Machine(Machine_) {}
 
 // Pin the vtable to this file.
 void MCWinCOFFObjectTargetWriter::anchor() {}
 
 //------------------------------------------------------------------------------
 // WinCOFFObjectWriter factory function
 
 std::unique_ptr<MCObjectWriter> llvm::createWinCOFFObjectWriter(
     std::unique_ptr<MCWinCOFFObjectTargetWriter> MOTW, raw_pwrite_stream &OS) {
   return llvm::make_unique<WinCOFFObjectWriter>(std::move(MOTW), OS);
 }

llvm/tools/dsymutil/MachOUtils.cpp

 // The function also tries to find a hole in the address map to fit the __DWARF
 // segment of \a DwarfSegmentSize size. \a EndAddress is updated to point at the
 // highest segment address.
 // When the __LINKEDIT segment is transferred, its offset and size are set resp.
 // to \a LinkeditOffset and \a LinkeditSize.
 template <typename SegmentTy>
 static void transferSegmentAndSections(
     const object::MachOObjectFile::LoadCommandInfo &LCI, SegmentTy Segment,
-    const object::MachOObjectFile &Obj, MCObjectWriter &Writer,
+    const object::MachOObjectFile &Obj, MachObjectWriter &Writer,
     uint64_t LinkeditOffset, uint64_t LinkeditSize, uint64_t DwarfSegmentSize,
     uint64_t &GapForDwarf, uint64_t &EndAddress) {
   if (StringRef("__DWARF") == Segment.segname)
     return;
 
   Segment.fileoff = Segment.filesize = 0;
 
   if (StringRef("__LINKEDIT") == Segment.segname) {
if (GapForDwarf == UINT64_MAX && Segment.vmaddr > EndAddress &&
     GapForDwarf = EndAddress;
 
   // The segments are not necessarily sorted by their vmaddr.
   EndAddress =
       std::max<uint64_t>(PrevEndAddress, Segment.vmaddr + Segment.vmsize);
   unsigned nsects = Segment.nsects;
   if (Obj.isLittleEndian() != sys::IsLittleEndianHost)
     MachO::swapStruct(Segment);
-  Writer.writeBytes(
-      StringRef(reinterpret_cast<char *>(&Segment), sizeof(Segment)));
+  Writer.W.OS.write(reinterpret_cast<char *>(&Segment), sizeof(Segment));
   for (unsigned i = 0; i < nsects; ++i) {
     auto Sect = getSection(Obj, Segment, LCI, i);
     Sect.offset = Sect.reloff = Sect.nreloc = 0;
     if (Obj.isLittleEndian() != sys::IsLittleEndianHost)
       MachO::swapStruct(Sect);
-    Writer.writeBytes(StringRef(reinterpret_cast<char *>(&Sect), sizeof(Sect)));
+    Writer.W.OS.write(reinterpret_cast<char *>(&Sect), sizeof(Sect));
   }
 }
 
 // Write the __DWARF segment load command to the output file.
 static void createDwarfSegment(uint64_t VMAddr, uint64_t FileOffset,
                                uint64_t FileSize, unsigned NumSections,
                                MCAsmLayout &Layout, MachObjectWriter &Writer) {
   Writer.writeSegmentLoadCommand("__DWARF", NumSections, VMAddr,
bool generateDsymCompanion(const DebugMap &DM, MCStreamer &MS,
   SymtabStart = alignTo(SymtabStart, 0x1000);
 
   // We gathered all the information we need, start emitting the output file.
   Writer.writeHeader(MachO::MH_DSYM, NumLoadCommands, LoadCommandSize, false);
 
   // Write the load commands.
   assert(OutFile.tell() == HeaderSize);
   if (UUIDCmd.cmd != 0) {
-    Writer.write32(UUIDCmd.cmd);
-    Writer.write32(UUIDCmd.cmdsize);
-    Writer.writeBytes(
-        StringRef(reinterpret_cast<const char *>(UUIDCmd.uuid), 16));
+    Writer.W.write<uint32_t>(UUIDCmd.cmd);
+    Writer.W.write<uint32_t>(UUIDCmd.cmdsize);
+    OutFile.write(reinterpret_cast<const char *>(UUIDCmd.uuid), 16);
     assert(OutFile.tell() == HeaderSize + sizeof(UUIDCmd));
   }
 
   assert(SymtabCmd.cmd && "No symbol table.");
   uint64_t StringStart = SymtabStart + NumSyms * NListSize;
   if (ShouldEmitSymtab)
     Writer.writeSymtabLoadCommand(SymtabStart, NumSyms, StringStart,
                                   NewStringsSize);
if (DwarfVMAddr == UINT64_MAX)
            "output file streaming");
   }
 
   // Write the load command for the __DWARF segment.
   createDwarfSegment(DwarfVMAddr, DwarfSegmentStart, DwarfSegmentSize,
                      NumDwarfSections, Layout, Writer);
 
   assert(OutFile.tell() == LoadCommandSize + HeaderSize);
-  Writer.WriteZeros(SymtabStart - (LoadCommandSize + HeaderSize));
+  OutFile.write_zeros(SymtabStart - (LoadCommandSize + HeaderSize));
   assert(OutFile.tell() == SymtabStart);
 
   // Transfer symbols.
   if (ShouldEmitSymtab) {
-    Writer.writeBytes(NewSymtab.str());
+    OutFile << NewSymtab.str();
     assert(OutFile.tell() == StringStart);
 
     // Transfer string table.
     // FIXME: The NonRelocatableStringpool starts with an empty string, but
     // dsymutil-classic starts the reconstructed string table with 2 of these.
     // Reproduce that behavior for now (there is corresponding code in
     // transferSymbol).
-    Writer.WriteZeros(1);
+    OutFile << '\0';
     std::vector<DwarfStringPoolEntryRef> Strings = NewStrings.getEntries();
     for (auto EntryRef : Strings) {
       if (EntryRef.getIndex() == -1U)
         break;
-      StringRef ZeroTerminated(EntryRef.getString().data(),
-                               EntryRef.getString().size() + 1);
-      Writer.writeBytes(ZeroTerminated);
+      OutFile.write(EntryRef.getString().data(),
     }
   }
 
   assert(OutFile.tell() == StringStart + NewStringsSize);
 
   // Pad till the Dwarf segment start.
-  Writer.WriteZeros(DwarfSegmentStart - (StringStart + NewStringsSize));
+  OutFile.write_zeros(DwarfSegmentStart - (StringStart + NewStringsSize));
   assert(OutFile.tell() == DwarfSegmentStart);
 
   // Emit the Dwarf sections contents.
   for (const MCSection &Sec : MCAsm) {
     if (Sec.begin() == Sec.end())
       continue;
 
     uint64_t Pos = OutFile.tell();
-    Writer.WriteZeros(alignTo(Pos, Sec.getAlignment()) - Pos);
+    OutFile.write_zeros(alignTo(Pos, Sec.getAlignment()) - Pos);
     MCAsm.writeSectionData(OutFile, &Sec, Layout);
   }
 
   return true;
 }
 } // namespace MachOUtils
 } // namespace dsymutil
 } // namespace llvm