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

Part of PR37466.

Differential Revision: https://reviews.llvm.org/D47043

llvm-svn: 332864

include/llvm/MC/MCMachObjectWriter.h

@@ -121,8 +121,7 @@ class MachObjectWriter : public MCObjectWriter {
 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;

include/llvm/MC/MCObjectWriter.h

@@ -36,22 +36,9 @@ class MCValue;
 /// 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;
@@ -61,11 +48,6 @@ public:
   /// 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
   /// @{
 
@@ -116,82 +98,6 @@ public:
   /// 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());
-  }
-
   /// @}
 };
 

lib/MC/ELFObjectWriter.cpp

@@ -164,7 +164,7 @@ public:
 
   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;

lib/MC/WasmObjectWriter.cpp

@@ -252,8 +252,7 @@ class WasmObjectWriter : public MCObjectWriter {
 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;
 

lib/MC/WinCOFFObjectWriter.cpp

@@ -227,8 +227,7 @@ void COFFSymbol::set_name_offset(uint32_t Offset) {
 
 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();
 }