MC: Have the object writers return the number of bytes written. NFCI.

[pcc]

Summary

This removes the last external use of the stream.

Part of PR37466.

Depends on D47040

[echristo]

LGTM.

Thanks!

-eric

llvm/include/llvm/MC/MCMachObjectWriter.h

bool isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
                                               const MCSymbol &B,
                                               bool InSet) const override;
 
   bool isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
                                               const MCSymbol &SymA,
                                               const MCFragment &FB, bool InSet,
                                               bool IsPCRel) const override;
 
-  void writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
+  uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
 };
 
 /// Construct a new Mach-O writer instance.
 ///
 /// This routine takes ownership of the target writer subclass.
 ///
 /// \param MOTW - The target specific Mach-O writer subclass.
 /// \param OS - The stream to write to.
 /// \returns The constructed object writer.
 std::unique_ptr<MCObjectWriter>
 createMachObjectWriter(std::unique_ptr<MCMachObjectTargetWriter> MOTW,
                        raw_pwrite_stream &OS, bool IsLittleEndian);
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCMACHOBJECTWRITER_H

llvm/include/llvm/MC/MCObjectWriter.h

virtual bool isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
                                                       bool InSet) const;
 
   virtual bool isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
                                                       const MCSymbol &SymA,
                                                       const MCFragment &FB,
                                                       bool InSet,
                                                       bool IsPCRel) const;
 
-  /// Write the object file.
+  /// Write the object file and returns the number of bytes written.
   ///
   /// This routine is called by the assembler after layout and relaxation is
   /// complete, fixups have been evaluated and applied, and relocations
   /// generated.
-  virtual void writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) = 0;
+  virtual uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) = 0;
 
   /// @}
   /// \name Binary Output
   /// @{
 
   void write8(uint8_t Value) { *OS << char(Value); }
 
   void writeLE16(uint16_t Value) {

llvm/lib/MC/ELFObjectWriter.cpp

public:
   void writeRelocations(const MCAssembler &Asm, const MCSectionELF &Sec);
 
   using MCObjectWriter::isSymbolRefDifferenceFullyResolvedImpl;
   bool isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
                                               const MCSymbol &SymA,
                                               const MCFragment &FB, bool InSet,
                                               bool IsPCRel) const override;
 
-  void writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
+  uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
   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) {
for (const MCSectionELF *Section : SectionTable) {
     else
       Size = Offsets.second - Offsets.first;
 
     writeSection(SectionIndexMap, GroupSymbolIndex, Offsets.first, Size,
                  *Section);
   }
 }
 
-void ELFObjectWriter::writeObject(MCAssembler &Asm,
+uint64_t ELFObjectWriter::writeObject(MCAssembler &Asm,
                                       const MCAsmLayout &Layout) {
+  uint64_t StartOffset = W.OS.tell();
+
   MCContext &Ctx = Asm.getContext();
   MCSectionELF *StrtabSection =
       Ctx.getELFSection(".strtab", ELF::SHT_STRTAB, 0);
   StringTableIndex = addToSectionTable(StrtabSection);
 
   RevGroupMapTy RevGroupMap;
   SectionIndexMapTy SectionIndexMap;
 
if (is64Bit()) {
     uint32_t Val =
         support::endian::byte_swap<uint32_t>(SectionHeaderOffset, W.Endian);
     Stream.pwrite(reinterpret_cast<char *>(&Val), sizeof(Val),
                   offsetof(ELF::Elf32_Ehdr, e_shoff));
     NumSectionsOffset = offsetof(ELF::Elf32_Ehdr, e_shnum);
   }
   Stream.pwrite(reinterpret_cast<char *>(&NumSections), sizeof(NumSections),
                 NumSectionsOffset);
+
+  return W.OS.tell() - StartOffset;
 }
 
 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/MCAssembler.cpp

void MCAssembler::layout(MCAsmLayout &Layout) {
   }
 }
 
 void MCAssembler::Finish() {
   // Create the layout object.
   MCAsmLayout Layout(*this);
   layout(Layout);
 
-  raw_ostream &OS = getWriter().getStream();
-  uint64_t StartOffset = OS.tell();
-
   // Write the object file.
-  getWriter().writeObject(*this, Layout);
-
-  stats::ObjectBytes += OS.tell() - StartOffset;
+  stats::ObjectBytes += getWriter().writeObject(*this, Layout);
 }
 
 bool MCAssembler::fixupNeedsRelaxation(const MCFixup &Fixup,
                                        const MCRelaxableFragment *DF,
                                        const MCAsmLayout &Layout) const {
   assert(getBackendPtr() && "Expected assembler backend");
   MCValue Target;
   uint64_t Value;

llvm/lib/MC/MachObjectWriter.cpp

static MachO::LoadCommandType getLCFromMCVM(MCVersionMinType Type) {
   case MCVM_OSXVersionMin:     return MachO::LC_VERSION_MIN_MACOSX;
   case MCVM_IOSVersionMin:     return MachO::LC_VERSION_MIN_IPHONEOS;
   case MCVM_TvOSVersionMin:    return MachO::LC_VERSION_MIN_TVOS;
   case MCVM_WatchOSVersionMin: return MachO::LC_VERSION_MIN_WATCHOS;
   }
   llvm_unreachable("Invalid mc version min type");
 }
 
-void MachObjectWriter::writeObject(MCAssembler &Asm,
+uint64_t MachObjectWriter::writeObject(MCAssembler &Asm,
                                        const MCAsmLayout &Layout) {
+  uint64_t StartOffset = W.OS.tell();
+
   // Compute symbol table information and bind symbol indices.
   computeSymbolTable(Asm, LocalSymbolData, ExternalSymbolData,
                      UndefinedSymbolData);
 
   unsigned NumSections = Asm.size();
   const MCAssembler::VersionInfoType &VersionInfo =
     Layout.getAssembler().getVersionInfo();
 
if (NumSymbols) {
     for (auto *SymbolData :
          {&LocalSymbolData, &ExternalSymbolData, &UndefinedSymbolData})
       for (MachSymbolData &Entry : *SymbolData)
         writeNlist(Entry, Layout);
 
     // Write the string table.
     StringTable.write(W.OS);
   }
+
+  return W.OS.tell() - StartOffset;
 }
 
 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

private:
 
   void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
                         const MCFragment *Fragment, const MCFixup &Fixup,
                         MCValue Target, uint64_t &FixedValue) override;
 
   void executePostLayoutBinding(MCAssembler &Asm,
                                 const MCAsmLayout &Layout) override;
 
-  void writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
+  uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
 
   void writeString(const StringRef Str) {
     encodeULEB128(Str.size(), W.OS);
     W.OS << Str;
   }
 
   void writeValueType(wasm::ValType Ty) {
     W.OS << static_cast<char>(Ty);
if (Sym.isTemporary() && Sym.isData() && !Sym.getSize())
     return false;
 
   if (Sym.isSection())
     return false;
 
   return true;
 }
 
-void WasmObjectWriter::writeObject(MCAssembler &Asm,
+uint64_t WasmObjectWriter::writeObject(MCAssembler &Asm,
                                        const MCAsmLayout &Layout) {
+  uint64_t StartOffset = W.OS.tell();
+
   LLVM_DEBUG(dbgs() << "WasmObjectWriter::writeObject\n");
   MCContext &Ctx = Asm.getContext();
 
   // Collect information from the available symbols.
   SmallVector<WasmFunction, 4> Functions;
   SmallVector<uint32_t, 4> TableElems;
   SmallVector<wasm::WasmImport, 4> Imports;
   SmallVector<wasm::WasmExport, 4> Exports;
uint64_t WasmObjectWriter::writeObject(MCAssembler &Asm,
   writeDataSection();
   writeCustomSections(Asm, Layout);
   writeLinkingMetaDataSection(SymbolInfos, InitFuncs, Comdats);
   writeRelocSection(CodeSectionIndex, "CODE", CodeRelocations);
   writeRelocSection(DataSectionIndex, "DATA", DataRelocations);
   writeCustomRelocSections();
 
   // TODO: Translate the .comment section to the output.
+  return W.OS.tell() - StartOffset;
 }
 
 std::unique_ptr<MCObjectWriter>
 llvm::createWasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
                              raw_pwrite_stream &OS) {
   return llvm::make_unique<WasmObjectWriter>(std::move(MOTW), OS);
 }

llvm/lib/MC/WinCOFFObjectWriter.cpp

public:
   void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
                         const MCFragment *Fragment, const MCFixup &Fixup,
                         MCValue Target, uint64_t &FixedValue) override;
 
   void createFileSymbols(MCAssembler &Asm);
   void assignSectionNumbers();
   void assignFileOffsets(MCAssembler &Asm, const MCAsmLayout &Layout);
 
-  void writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
+  uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
 };
 
 } // end anonymous namespace
 
 //------------------------------------------------------------------------------
 // Symbol class implementation
 
 // In the case that the name does not fit within 8 bytes, the offset
Aux.Aux.SectionDefinition.NumberOfRelocations =
         Sec->Header.NumberOfRelocations;
     Aux.Aux.SectionDefinition.NumberOfLinenumbers =
         Sec->Header.NumberOfLineNumbers;
   }
 
   Header.PointerToSymbolTable = Offset;
 }
 
-void WinCOFFObjectWriter::writeObject(MCAssembler &Asm,
+uint64_t WinCOFFObjectWriter::writeObject(MCAssembler &Asm,
                                           const MCAsmLayout &Layout) {
+  uint64_t StartOffset = W.OS.tell();
+
   if (Sections.size() > INT32_MAX)
     report_fatal_error(
         "PE COFF object files can't have more than 2147483647 sections");
 
   UseBigObj = Sections.size() > COFF::MaxNumberOfSections16;
   Header.NumberOfSections = Sections.size();
   Header.NumberOfSymbols = 0;
 
uint64_t WinCOFFObjectWriter::writeObject(MCAssembler &Asm,
 
   // 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(W.OS);
+
+  return W.OS.tell() - StartOffset;
 }
 
 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);
 }