[MC] Have MCObjectStreamer take its MCAsmBackend argument via unique_…

…ptr. MCObjectStreamer owns its MCAsmBackend -- this fixes the types to reflect that, and allows us to remove another instance of MCObjectStreamer's weird "holding ownership via someone else's reference" trick. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@315410 91177308-0d34-0410-b5e6-96231b3b80d8
RPCS3 · Oct 11, 2017 · 445025a · 445025a
1 parent 061e701
commit 445025a
Show file tree

Hide file tree

Showing 39 changed files with 252 additions and 185 deletions.
diff --git a/include/llvm/MC/MCELFStreamer.h b/include/llvm/MC/MCELFStreamer.h
@@ -23,9 +23,8 @@ class MCInst;
 
 class MCELFStreamer : public MCObjectStreamer {
 public:
-  MCELFStreamer(MCContext &Context, MCAsmBackend &TAB, raw_pwrite_stream &OS,
-                MCCodeEmitter *Emitter)
-      : MCObjectStreamer(Context, TAB, OS, Emitter) {}
+  MCELFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
+                raw_pwrite_stream &OS, MCCodeEmitter *Emitter);
 
   ~MCELFStreamer() override = default;
 
@@ -90,7 +89,8 @@ class MCELFStreamer : public MCObjectStreamer {
   SmallVector<MCDataFragment *, 4> BundleGroups;
 };
 
-MCELFStreamer *createARMELFStreamer(MCContext &Context, MCAsmBackend &TAB,
+MCELFStreamer *createARMELFStreamer(MCContext &Context,
+                                    std::unique_ptr<MCAsmBackend> TAB,
                                     raw_pwrite_stream &OS,
                                     MCCodeEmitter *Emitter, bool RelaxAll,
                                     bool IsThumb);

diff --git a/include/llvm/MC/MCObjectStreamer.h b/include/llvm/MC/MCObjectStreamer.h
@@ -35,6 +35,7 @@ class raw_pwrite_stream;
 /// implementation.
 class MCObjectStreamer : public MCStreamer {
   std::unique_ptr<MCObjectWriter> ObjectWriter;
+  std::unique_ptr<MCAsmBackend> TAB;
   std::unique_ptr<MCAssembler> Assembler;
   MCSection::iterator CurInsertionPoint;
   bool EmitEHFrame;
@@ -47,8 +48,8 @@ class MCObjectStreamer : public MCStreamer {
   MCSymbol *EmitCFILabel() override;
 
 protected:
-  MCObjectStreamer(MCContext &Context, MCAsmBackend &TAB, raw_pwrite_stream &OS,
-                   MCCodeEmitter *Emitter);
+  MCObjectStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
+                   raw_pwrite_stream &OS, MCCodeEmitter *Emitter);
   ~MCObjectStreamer() override;
 
 public:

diff --git a/include/llvm/MC/MCWasmStreamer.h b/include/llvm/MC/MCWasmStreamer.h
@@ -26,9 +26,10 @@ class raw_ostream;
 
 class MCWasmStreamer : public MCObjectStreamer {
 public:
-  MCWasmStreamer(MCContext &Context, MCAsmBackend &TAB, raw_pwrite_stream &OS,
-                 MCCodeEmitter *Emitter)
-      : MCObjectStreamer(Context, TAB, OS, Emitter), SeenIdent(false) {}
+  MCWasmStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
+                 raw_pwrite_stream &OS, MCCodeEmitter *Emitter)
+      : MCObjectStreamer(Context, std::move(TAB), OS, Emitter),
+        SeenIdent(false) {}
 
   ~MCWasmStreamer() override;
 

diff --git a/include/llvm/MC/MCWinCOFFStreamer.h b/include/llvm/MC/MCWinCOFFStreamer.h
@@ -27,8 +27,8 @@ class raw_pwrite_stream;
 
 class MCWinCOFFStreamer : public MCObjectStreamer {
 public:
-  MCWinCOFFStreamer(MCContext &Context, MCAsmBackend &MAB, MCCodeEmitter &CE,
-                    raw_pwrite_stream &OS);
+  MCWinCOFFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> MAB,
+                    MCCodeEmitter &CE, raw_pwrite_stream &OS);
 
   /// state management
   void reset() override {

diff --git a/include/llvm/Support/TargetRegistry.h b/include/llvm/Support/TargetRegistry.h
@@ -67,14 +67,17 @@ MCStreamer *createAsmStreamer(MCContext &Ctx,
                               MCAsmBackend *TAB, bool ShowInst);
 
 /// Takes ownership of \p TAB and \p CE.
-MCStreamer *createELFStreamer(MCContext &Ctx, MCAsmBackend &TAB,
+MCStreamer *createELFStreamer(MCContext &Ctx,
+                              std::unique_ptr<MCAsmBackend> &&TAB,
                               raw_pwrite_stream &OS, MCCodeEmitter *CE,
                               bool RelaxAll);
-MCStreamer *createMachOStreamer(MCContext &Ctx, MCAsmBackend &TAB,
+MCStreamer *createMachOStreamer(MCContext &Ctx,
+                                std::unique_ptr<MCAsmBackend> &&TAB,
                                 raw_pwrite_stream &OS, MCCodeEmitter *CE,
                                 bool RelaxAll, bool DWARFMustBeAtTheEnd,
                                 bool LabelSections = false);
-MCStreamer *createWasmStreamer(MCContext &Ctx, MCAsmBackend &TAB,
+MCStreamer *createWasmStreamer(MCContext &Ctx,
+                               std::unique_ptr<MCAsmBackend> &&TAB,
                                raw_pwrite_stream &OS, MCCodeEmitter *CE,
                                bool RelaxAll);
 
@@ -135,25 +138,21 @@ class Target {
                                                  const MCRegisterInfo &MRI,
                                                  MCContext &Ctx);
   using ELFStreamerCtorTy = MCStreamer *(*)(const Triple &T, MCContext &Ctx,
-                                            MCAsmBackend &TAB,
+                                            std::unique_ptr<MCAsmBackend> &&TAB,
                                             raw_pwrite_stream &OS,
                                             MCCodeEmitter *Emitter,
                                             bool RelaxAll);
-  using MachOStreamerCtorTy = MCStreamer *(*)(MCContext &Ctx, MCAsmBackend &TAB,
-                                              raw_pwrite_stream &OS,
-                                              MCCodeEmitter *Emitter,
-                                              bool RelaxAll,
-                                              bool DWARFMustBeAtTheEnd);
-  using COFFStreamerCtorTy = MCStreamer *(*)(MCContext &Ctx, MCAsmBackend &TAB,
-                                             raw_pwrite_stream &OS,
-                                             MCCodeEmitter *Emitter,
-                                             bool RelaxAll,
-                                             bool IncrementalLinkerCompatible);
-  using WasmStreamerCtorTy = MCStreamer *(*)(const Triple &T, MCContext &Ctx,
-                                             MCAsmBackend &TAB,
-                                             raw_pwrite_stream &OS,
-                                             MCCodeEmitter *Emitter,
-                                             bool RelaxAll);
+  using MachOStreamerCtorTy =
+      MCStreamer *(*)(MCContext &Ctx, std::unique_ptr<MCAsmBackend> &&TAB,
+                      raw_pwrite_stream &OS, MCCodeEmitter *Emitter,
+                      bool RelaxAll, bool DWARFMustBeAtTheEnd);
+  using COFFStreamerCtorTy =
+      MCStreamer *(*)(MCContext &Ctx, std::unique_ptr<MCAsmBackend> &&TAB,
+                      raw_pwrite_stream &OS, MCCodeEmitter *Emitter,
+                      bool RelaxAll, bool IncrementalLinkerCompatible);
+  using WasmStreamerCtorTy = MCStreamer
+      *(*)(const Triple &T, MCContext &Ctx, std::unique_ptr<MCAsmBackend> &&TAB,
+           raw_pwrite_stream &OS, MCCodeEmitter *Emitter, bool RelaxAll);
   using NullTargetStreamerCtorTy = MCTargetStreamer *(*)(MCStreamer &S);
   using AsmTargetStreamerCtorTy = MCTargetStreamer *(*)(
       MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint,
@@ -435,7 +434,8 @@ class Target {
   /// \param Emitter The target independent assembler object.Takes ownership.
   /// \param RelaxAll Relax all fixups?
   MCStreamer *createMCObjectStreamer(const Triple &T, MCContext &Ctx,
-                                     MCAsmBackend &TAB, raw_pwrite_stream &OS,
+                                     std::unique_ptr<MCAsmBackend> &&TAB,
+                                     raw_pwrite_stream &OS,
                                      MCCodeEmitter *Emitter,
                                      const MCSubtargetInfo &STI, bool RelaxAll,
                                      bool IncrementalLinkerCompatible,
@@ -446,28 +446,28 @@ class Target {
       llvm_unreachable("Unknown object format");
     case Triple::COFF:
       assert(T.isOSWindows() && "only Windows COFF is supported");
-      S = COFFStreamerCtorFn(Ctx, TAB, OS, Emitter, RelaxAll,
+      S = COFFStreamerCtorFn(Ctx, std::move(TAB), OS, Emitter, RelaxAll,
                              IncrementalLinkerCompatible);
       break;
     case Triple::MachO:
       if (MachOStreamerCtorFn)
-        S = MachOStreamerCtorFn(Ctx, TAB, OS, Emitter, RelaxAll,
+        S = MachOStreamerCtorFn(Ctx, std::move(TAB), OS, Emitter, RelaxAll,
                                 DWARFMustBeAtTheEnd);
       else
-        S = createMachOStreamer(Ctx, TAB, OS, Emitter, RelaxAll,
+        S = createMachOStreamer(Ctx, std::move(TAB), OS, Emitter, RelaxAll,
                                 DWARFMustBeAtTheEnd);
       break;
     case Triple::ELF:
       if (ELFStreamerCtorFn)
-        S = ELFStreamerCtorFn(T, Ctx, TAB, OS, Emitter, RelaxAll);
+        S = ELFStreamerCtorFn(T, Ctx, std::move(TAB), OS, Emitter, RelaxAll);
       else
-        S = createELFStreamer(Ctx, TAB, OS, Emitter, RelaxAll);
+        S = createELFStreamer(Ctx, std::move(TAB), OS, Emitter, RelaxAll);
       break;
     case Triple::Wasm:
       if (WasmStreamerCtorFn)
-        S = WasmStreamerCtorFn(T, Ctx, TAB, OS, Emitter, RelaxAll);
+        S = WasmStreamerCtorFn(T, Ctx, std::move(TAB), OS, Emitter, RelaxAll);
       else
-        S = createWasmStreamer(Ctx, TAB, OS, Emitter, RelaxAll);
+        S = createWasmStreamer(Ctx, std::move(TAB), OS, Emitter, RelaxAll);
       break;
     }
     if (ObjectTargetStreamerCtorFn)

diff --git a/lib/CodeGen/LLVMTargetMachine.cpp b/lib/CodeGen/LLVMTargetMachine.cpp
@@ -20,6 +20,7 @@
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Verifier.h"
+#include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInstrInfo.h"
@@ -163,7 +164,8 @@ bool LLVMTargetMachine::addAsmPrinter(PassManagerBase &PM,
 
     Triple T(getTargetTriple().str());
     AsmStreamer.reset(getTarget().createMCObjectStreamer(
-        T, Context, *MAB, Out, MCE, STI, Options.MCOptions.MCRelaxAll,
+        T, Context, std::unique_ptr<MCAsmBackend>(MAB), Out, MCE, STI,
+        Options.MCOptions.MCRelaxAll,
         Options.MCOptions.MCIncrementalLinkerCompatible,
         /*DWARFMustBeAtTheEnd*/ true));
     break;
@@ -238,7 +240,8 @@ bool LLVMTargetMachine::addPassesToEmitMC(PassManagerBase &PM, MCContext *&Ctx,
   const Triple &T = getTargetTriple();
   const MCSubtargetInfo &STI = *getMCSubtargetInfo();
   std::unique_ptr<MCStreamer> AsmStreamer(getTarget().createMCObjectStreamer(
-      T, *Ctx, *MAB, Out, MCE, STI, Options.MCOptions.MCRelaxAll,
+      T, *Ctx, std::unique_ptr<MCAsmBackend>(MAB), Out, MCE, STI,
+      Options.MCOptions.MCRelaxAll,
       Options.MCOptions.MCIncrementalLinkerCompatible,
       /*DWARFMustBeAtTheEnd*/ true));
 

diff --git a/lib/MC/MCELFStreamer.cpp b/lib/MC/MCELFStreamer.cpp
@@ -39,6 +39,11 @@
 
 using namespace llvm;
 
+MCELFStreamer::MCELFStreamer(MCContext &Context,
+                             std::unique_ptr<MCAsmBackend> TAB,
+                             raw_pwrite_stream &OS, MCCodeEmitter *Emitter)
+    : MCObjectStreamer(Context, std::move(TAB), OS, Emitter) {}
+
 bool MCELFStreamer::isBundleLocked() const {
   return getCurrentSectionOnly()->isBundleLocked();
 }
@@ -639,10 +644,11 @@ void MCELFStreamer::EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
   llvm_unreachable("ELF doesn't support this directive");
 }
 
-MCStreamer *llvm::createELFStreamer(MCContext &Context, MCAsmBackend &MAB,
+MCStreamer *llvm::createELFStreamer(MCContext &Context,
+                                    std::unique_ptr<MCAsmBackend> &&MAB,
                                     raw_pwrite_stream &OS, MCCodeEmitter *CE,
                                     bool RelaxAll) {
-  MCELFStreamer *S = new MCELFStreamer(Context, MAB, OS, CE);
+  MCELFStreamer *S = new MCELFStreamer(Context, std::move(MAB), OS, CE);
   if (RelaxAll)
     S->getAssembler().setRelaxAll(true);
   return S;

diff --git a/lib/MC/MCMachOStreamer.cpp b/lib/MC/MCMachOStreamer.cpp
@@ -62,10 +62,12 @@ class MCMachOStreamer : public MCObjectStreamer {
   void EmitDataRegionEnd();
 
 public:
-  MCMachOStreamer(MCContext &Context, MCAsmBackend &MAB, raw_pwrite_stream &OS,
-                  MCCodeEmitter *Emitter, bool DWARFMustBeAtTheEnd, bool label)
-      : MCObjectStreamer(Context, MAB, OS, Emitter), LabelSections(label),
-        DWARFMustBeAtTheEnd(DWARFMustBeAtTheEnd), CreatedADWARFSection(false) {}
+  MCMachOStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> MAB,
+                  raw_pwrite_stream &OS, MCCodeEmitter *Emitter,
+                  bool DWARFMustBeAtTheEnd, bool label)
+      : MCObjectStreamer(Context, std::move(MAB), OS, Emitter),
+        LabelSections(label), DWARFMustBeAtTheEnd(DWARFMustBeAtTheEnd),
+        CreatedADWARFSection(false) {}
 
   /// state management
   void reset() override {
@@ -483,11 +485,12 @@ void MCMachOStreamer::FinishImpl() {
   this->MCObjectStreamer::FinishImpl();
 }
 
-MCStreamer *llvm::createMachOStreamer(MCContext &Context, MCAsmBackend &MAB,
+MCStreamer *llvm::createMachOStreamer(MCContext &Context,
+                                      std::unique_ptr<MCAsmBackend> &&MAB,
                                       raw_pwrite_stream &OS, MCCodeEmitter *CE,
                                       bool RelaxAll, bool DWARFMustBeAtTheEnd,
                                       bool LabelSections) {
-  MCMachOStreamer *S = new MCMachOStreamer(Context, MAB, OS, CE,
+  MCMachOStreamer *S = new MCMachOStreamer(Context, std::move(MAB), OS, CE,
                                            DWARFMustBeAtTheEnd, LabelSections);
   const Triple &TT = Context.getObjectFileInfo()->getTargetTriple();
   if (TT.isOSDarwin()) {

diff --git a/lib/MC/MCObjectStreamer.cpp b/lib/MC/MCObjectStreamer.cpp
@@ -25,16 +25,16 @@
 #include "llvm/Support/TargetRegistry.h"
 using namespace llvm;
 
-MCObjectStreamer::MCObjectStreamer(MCContext &Context, MCAsmBackend &TAB,
+MCObjectStreamer::MCObjectStreamer(MCContext &Context,
+                                   std::unique_ptr<MCAsmBackend> TAB,
                                    raw_pwrite_stream &OS,
                                    MCCodeEmitter *Emitter_)
-    : MCStreamer(Context), ObjectWriter(TAB.createObjectWriter(OS)),
-      Assembler(llvm::make_unique<MCAssembler>(Context, TAB, *Emitter_,
-                                               *ObjectWriter)),
+    : MCStreamer(Context), ObjectWriter(TAB->createObjectWriter(OS)),
+      TAB(std::move(TAB)), Assembler(llvm::make_unique<MCAssembler>(
+                               Context, *this->TAB, *Emitter_, *ObjectWriter)),
       EmitEHFrame(true), EmitDebugFrame(false) {}
 
 MCObjectStreamer::~MCObjectStreamer() {
-  delete &Assembler->getBackend();
   delete &Assembler->getEmitter();
 }
 

diff --git a/lib/MC/MCWasmStreamer.cpp b/lib/MC/MCWasmStreamer.cpp
@@ -200,10 +200,11 @@ void MCWasmStreamer::FinishImpl() {
   this->MCObjectStreamer::FinishImpl();
 }
 
-MCStreamer *llvm::createWasmStreamer(MCContext &Context, MCAsmBackend &MAB,
+MCStreamer *llvm::createWasmStreamer(MCContext &Context,
+                                     std::unique_ptr<MCAsmBackend> &&MAB,
                                      raw_pwrite_stream &OS, MCCodeEmitter *CE,
                                      bool RelaxAll) {
-  MCWasmStreamer *S = new MCWasmStreamer(Context, MAB, OS, CE);
+  MCWasmStreamer *S = new MCWasmStreamer(Context, std::move(MAB), OS, CE);
   if (RelaxAll)
     S->getAssembler().setRelaxAll(true);
   return S;

diff --git a/lib/MC/MCWinCOFFStreamer.cpp b/lib/MC/MCWinCOFFStreamer.cpp
@@ -41,9 +41,10 @@ using namespace llvm;
 
 #define DEBUG_TYPE "WinCOFFStreamer"
 
-MCWinCOFFStreamer::MCWinCOFFStreamer(MCContext &Context, MCAsmBackend &MAB,
+MCWinCOFFStreamer::MCWinCOFFStreamer(MCContext &Context,
+                                     std::unique_ptr<MCAsmBackend> MAB,
                                      MCCodeEmitter &CE, raw_pwrite_stream &OS)
-    : MCObjectStreamer(Context, MAB, OS, &CE), CurSymbol(nullptr) {}
+    : MCObjectStreamer(Context, std::move(MAB), OS, &CE), CurSymbol(nullptr) {}
 
 void MCWinCOFFStreamer::EmitInstToData(const MCInst &Inst,
                                        const MCSubtargetInfo &STI) {

diff --git a/lib/Target/AArch64/MCTargetDesc/AArch64ELFStreamer.cpp b/lib/Target/AArch64/MCTargetDesc/AArch64ELFStreamer.cpp
@@ -86,10 +86,10 @@ class AArch64ELFStreamer : public MCELFStreamer {
 public:
   friend class AArch64TargetELFStreamer;
 
-  AArch64ELFStreamer(MCContext &Context, MCAsmBackend &TAB,
+  AArch64ELFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
                      raw_pwrite_stream &OS, MCCodeEmitter *Emitter)
-      : MCELFStreamer(Context, TAB, OS, Emitter), MappingSymbolCounter(0),
-        LastEMS(EMS_None) {}
+      : MCELFStreamer(Context, std::move(TAB), OS, Emitter),
+        MappingSymbolCounter(0), LastEMS(EMS_None) {}
 
   void ChangeSection(MCSection *Section, const MCExpr *Subsection) override {
     // We have to keep track of the mapping symbol state of any sections we
@@ -198,10 +198,12 @@ MCTargetStreamer *createAArch64AsmTargetStreamer(MCStreamer &S,
   return new AArch64TargetAsmStreamer(S, OS);
 }
 
-MCELFStreamer *createAArch64ELFStreamer(MCContext &Context, MCAsmBackend &TAB,
+MCELFStreamer *createAArch64ELFStreamer(MCContext &Context,
+                                        std::unique_ptr<MCAsmBackend> TAB,
                                         raw_pwrite_stream &OS,
                                         MCCodeEmitter *Emitter, bool RelaxAll) {
-  AArch64ELFStreamer *S = new AArch64ELFStreamer(Context, TAB, OS, Emitter);
+  AArch64ELFStreamer *S =
+      new AArch64ELFStreamer(Context, std::move(TAB), OS, Emitter);
   if (RelaxAll)
     S->getAssembler().setRelaxAll(true);
   return S;

diff --git a/lib/Target/AArch64/MCTargetDesc/AArch64ELFStreamer.h b/lib/Target/AArch64/MCTargetDesc/AArch64ELFStreamer.h
@@ -18,7 +18,8 @@
 
 namespace llvm {
 
-MCELFStreamer *createAArch64ELFStreamer(MCContext &Context, MCAsmBackend &TAB,
+MCELFStreamer *createAArch64ELFStreamer(MCContext &Context,
+                                        std::unique_ptr<MCAsmBackend> TAB,
                                         raw_pwrite_stream &OS,
                                         MCCodeEmitter *Emitter, bool RelaxAll);
 }

diff --git a/lib/Target/AArch64/MCTargetDesc/AArch64MCTargetDesc.cpp b/lib/Target/AArch64/MCTargetDesc/AArch64MCTargetDesc.cpp
@@ -100,26 +100,29 @@ static MCInstPrinter *createAArch64MCInstPrinter(const Triple &T,
 }
 
 static MCStreamer *createELFStreamer(const Triple &T, MCContext &Ctx,
-                                     MCAsmBackend &TAB, raw_pwrite_stream &OS,
+                                     std::unique_ptr<MCAsmBackend> &&TAB,
+                                     raw_pwrite_stream &OS,
                                      MCCodeEmitter *Emitter, bool RelaxAll) {
-  return createAArch64ELFStreamer(Ctx, TAB, OS, Emitter, RelaxAll);
+  return createAArch64ELFStreamer(Ctx, std::move(TAB), OS, Emitter, RelaxAll);
 }
 
-static MCStreamer *createMachOStreamer(MCContext &Ctx, MCAsmBackend &TAB,
+static MCStreamer *createMachOStreamer(MCContext &Ctx,
+                                       std::unique_ptr<MCAsmBackend> &&TAB,
                                        raw_pwrite_stream &OS,
                                        MCCodeEmitter *Emitter, bool RelaxAll,
                                        bool DWARFMustBeAtTheEnd) {
-  return createMachOStreamer(Ctx, TAB, OS, Emitter, RelaxAll,
+  return createMachOStreamer(Ctx, std::move(TAB), OS, Emitter, RelaxAll,
                              DWARFMustBeAtTheEnd,
                              /*LabelSections*/ true);
 }
 
-static MCStreamer *createWinCOFFStreamer(MCContext &Ctx, MCAsmBackend &TAB,
+static MCStreamer *createWinCOFFStreamer(MCContext &Ctx,
+                                         std::unique_ptr<MCAsmBackend> &&TAB,
                                          raw_pwrite_stream &OS,
                                          MCCodeEmitter *Emitter, bool RelaxAll,
                                          bool IncrementalLinkerCompatible) {
-  return createAArch64WinCOFFStreamer(Ctx, TAB, OS, Emitter, RelaxAll,
-                                      IncrementalLinkerCompatible);
+  return createAArch64WinCOFFStreamer(Ctx, std::move(TAB), OS, Emitter,
+                                      RelaxAll, IncrementalLinkerCompatible);
 }
 
 static MCInstrAnalysis *createAArch64InstrAnalysis(const MCInstrInfo *Info) {