MC: Remove stream and output functions from MCObjectWriter. NFCI.

[pcc]

Summary

Part of PR37466.

Depends on D47042

[echristo]

LGTM.

Thanks!

llvm/trunk/include/llvm/MC/MCMachObjectWriter.h

class MachObjectWriter : public MCObjectWriter {
 
   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
   /// @{

llvm/trunk/include/llvm/MC/MCObjectWriter.h

 /// Defines the object file and target independent interfaces used by the
 /// assembler backend to write native file format object files.
 ///
 /// The object writer contains a few callbacks used by the assembler to allow
 /// the object writer to modify the assembler data structures at appropriate
 /// points. Once assembly is complete, the object writer is given the
 /// MCAssembler instance, which contains all the symbol and section data which
 /// should be emitted as part of writeObject().
-///
-/// The object writer also contains a number of helper methods for writing
-/// binary data to the output stream.
 class MCObjectWriter {
-  raw_pwrite_stream *OS;
-
 protected:
-  unsigned IsLittleEndian : 1;
-
-  // Can only create subclasses.
-  MCObjectWriter(raw_pwrite_stream &OS, bool IsLittleEndian)
-      : OS(&OS), IsLittleEndian(IsLittleEndian) {}
-
-  unsigned getInitialOffset() {
-    return OS->tell();
-  }
+  MCObjectWriter() = default;
 
 public:
   MCObjectWriter(const MCObjectWriter &) = delete;
   MCObjectWriter &operator=(const MCObjectWriter &) = delete;
   virtual ~MCObjectWriter();
 
   /// lifetime management
   virtual void reset() {}
 
-  bool isLittleEndian() const { return IsLittleEndian; }
-
-  raw_pwrite_stream &getStream() { return *OS; }
-  void setStream(raw_pwrite_stream &NewOS) { OS = &NewOS; }
-
   /// \name High-Level API
   /// @{
 
   /// Perform any late binding of symbols (for example, to assign symbol
   /// indices for use when generating relocations).
   ///
   /// This routine is called by the assembler after layout and relaxation is
   /// complete.
public:
   /// 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 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) {
-    support::endian::write(*OS, Value, support::little);
-  }
-
-  void writeLE32(uint32_t Value) {
-    support::endian::write(*OS, Value, support::little);
-  }
-
-  void writeLE64(uint64_t Value) {
-    support::endian::write(*OS, Value, support::little);
-  }
-
-  void writeBE16(uint16_t Value) {
-    support::endian::write(*OS, Value, support::big);
-  }
-
-  void writeBE32(uint32_t Value) {
-    support::endian::write(*OS, Value, support::big);
-  }
-
-  void writeBE64(uint64_t Value) {
-    support::endian::write(*OS, Value, support::big);
-  }
-
-  void write16(uint16_t Value) {
-    if (IsLittleEndian)
-      writeLE16(Value);
-    else
-      writeBE16(Value);
-  }
-
-  void write32(uint32_t Value) {
-    if (IsLittleEndian)
-      writeLE32(Value);
-    else
-      writeBE32(Value);
-  }
-
-  void write64(uint64_t Value) {
-    if (IsLittleEndian)
-      writeLE64(Value);
-    else
-      writeBE64(Value);
-  }
-
-  void WriteZeros(unsigned N) {
-    const char Zeros[16] = {0};
-
-    for (unsigned i = 0, e = N / 16; i != e; ++i)
-      *OS << StringRef(Zeros, 16);
-
-    *OS << StringRef(Zeros, N % 16);
-  }
-
-  void writeBytes(const SmallVectorImpl<char> &ByteVec,
-                  unsigned ZeroFillSize = 0) {
-    writeBytes(StringRef(ByteVec.data(), ByteVec.size()), ZeroFillSize);
-  }
-
-  void writeBytes(StringRef Str, unsigned ZeroFillSize = 0) {
-    // TODO: this version may need to go away once all fragment contents are
-    // converted to SmallVector<char, N>
-    assert(
-        (ZeroFillSize == 0 || Str.size() <= ZeroFillSize) &&
-        "data size greater than fill size, unexpected large write will occur");
-    *OS << Str;
-    if (ZeroFillSize)
-      WriteZeros(ZeroFillSize - Str.size());
-  }
-
-  /// @}
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCOBJECTWRITER_H

llvm/trunk/lib/MC/ELFObjectWriter.cpp

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)),
+      : TargetObjectWriter(std::move(MOTW)),
         W(OS, IsLittleEndian ? support::little : support::big) {}
 
   ~ELFObjectWriter() override = default;
 
   void reset() override {
     Renames.clear();
     Relocations.clear();
     StrTabBuilder.clear();

llvm/trunk/lib/MC/WasmObjectWriter.cpp

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), W(OS, support::little),
-        TargetObjectWriter(std::move(MOTW)) {}
+      : W(OS, support::little), TargetObjectWriter(std::move(MOTW)) {}
 
   ~WasmObjectWriter() override;
 
 private:
   void reset() override {
     CodeRelocations.clear();
     DataRelocations.clear();
     TypeIndices.clear();

llvm/trunk/lib/MC/WinCOFFObjectWriter.cpp

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), W(OS, support::little),
-      TargetObjectWriter(std::move(MOTW)) {
+    : 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();
 }