[MC] Plumb unique_ptr<MCWinCOFFObjectTargetWriter> through

createWinCOFFObjectWriter to WinCOFFObjectWriter's constructor.

Fixes the same ownership issue for COFF that r315245 did for MachO:
WinCOFFObjectWriter takes ownership of its MCWinCOFFObjectTargetWriter, so we
want to pass this through to the constructor via a unique_ptr, rather than a
raw ptr.

llvm-svn: 315257

llvm/include/llvm/MC/MCWinCOFFObjectWriter.h

@@ -42,8 +42,9 @@ class raw_pwrite_stream;
   /// \param MOTW - The target specific WinCOFF writer subclass.
   /// \param OS - The stream to write to.
   /// \returns The constructed object writer.
-  MCObjectWriter *createWinCOFFObjectWriter(MCWinCOFFObjectTargetWriter *MOTW,
+  MCObjectWriter *
-                                            raw_pwrite_stream &OS);
+  createWinCOFFObjectWriter(std::unique_ptr<MCWinCOFFObjectTargetWriter> MOTW,
+                            raw_pwrite_stream &OS);
 } // end namespace llvm
 
 #endif // LLVM_MC_MCWINCOFFOBJECTWRITER_H

llvm/lib/MC/WinCOFFObjectWriter.cpp

@@ -145,7 +145,8 @@ public:
 
   bool UseBigObj;
 
-  WinCOFFObjectWriter(MCWinCOFFObjectTargetWriter *MOTW, raw_pwrite_stream &OS);
+  WinCOFFObjectWriter(std::unique_ptr<MCWinCOFFObjectTargetWriter> MOTW,
+                      raw_pwrite_stream &OS);
 
   void reset() override {
     memset(&Header, 0, sizeof(Header));
@@ -222,9 +223,9 @@ void COFFSymbol::set_name_offset(uint32_t Offset) {
 //------------------------------------------------------------------------------
 // WinCOFFObjectWriter class implementation
 
-WinCOFFObjectWriter::WinCOFFObjectWriter(MCWinCOFFObjectTargetWriter *MOTW,
+WinCOFFObjectWriter::WinCOFFObjectWriter(
-                                         raw_pwrite_stream &OS)
+    std::unique_ptr<MCWinCOFFObjectTargetWriter> MOTW, raw_pwrite_stream &OS)
-    : MCObjectWriter(OS, true), TargetObjectWriter(MOTW) {
+    : MCObjectWriter(OS, true), TargetObjectWriter(std::move(MOTW)) {
   Header.Machine = TargetObjectWriter->getMachine();
 }
 
@@ -1084,8 +1085,7 @@ void MCWinCOFFObjectTargetWriter::anchor() {}
 //------------------------------------------------------------------------------
 // WinCOFFObjectWriter factory function
 
-MCObjectWriter *
+MCObjectWriter *llvm::createWinCOFFObjectWriter(
-llvm::createWinCOFFObjectWriter(MCWinCOFFObjectTargetWriter *MOTW,
+    std::unique_ptr<MCWinCOFFObjectTargetWriter> MOTW, raw_pwrite_stream &OS) {
-                                raw_pwrite_stream &OS) {
+  return new WinCOFFObjectWriter(std::move(MOTW), OS);
-  return new WinCOFFObjectWriter(MOTW, OS);
 }

llvm/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFObjectWriter.cpp

@@ -97,8 +97,8 @@ bool AArch64WinCOFFObjectWriter::recordRelocation(const MCFixup &Fixup) const {
 namespace llvm {
 
 MCObjectWriter *createAArch64WinCOFFObjectWriter(raw_pwrite_stream &OS) {
-  MCWinCOFFObjectTargetWriter *MOTW = new AArch64WinCOFFObjectWriter();
+  auto MOTW = llvm::make_unique<AArch64WinCOFFObjectWriter>();
-  return createWinCOFFObjectWriter(MOTW, OS);
+  return createWinCOFFObjectWriter(std::move(MOTW), OS);
 }
 
 } // end namespace llvm

llvm/lib/Target/ARM/MCTargetDesc/ARMWinCOFFObjectWriter.cpp

@@ -92,8 +92,8 @@ namespace llvm {
 
 MCObjectWriter *createARMWinCOFFObjectWriter(raw_pwrite_stream &OS,
                                              bool Is64Bit) {
-  MCWinCOFFObjectTargetWriter *MOTW = new ARMWinCOFFObjectWriter(Is64Bit);
+  auto MOTW = llvm::make_unique<ARMWinCOFFObjectWriter>(Is64Bit);
-  return createWinCOFFObjectWriter(MOTW, OS);
+  return createWinCOFFObjectWriter(std::move(MOTW), OS);
 }
 
 } // end namespace llvm

llvm/lib/Target/X86/MCTargetDesc/X86WinCOFFObjectWriter.cpp

@@ -106,6 +106,6 @@ unsigned X86WinCOFFObjectWriter::getRelocType(MCContext &Ctx,
 
 MCObjectWriter *llvm::createX86WinCOFFObjectWriter(raw_pwrite_stream &OS,
                                                    bool Is64Bit) {
-  MCWinCOFFObjectTargetWriter *MOTW = new X86WinCOFFObjectWriter(Is64Bit);
+  auto MOTW = llvm::make_unique<X86WinCOFFObjectWriter>(Is64Bit);
-  return createWinCOFFObjectWriter(MOTW, OS);
+  return createWinCOFFObjectWriter(std::move(MOTW), OS);
 }