[MC] Have MCObjectStreamer take its MCAsmBackend argument via unique_ptr.

MCObjectStreamer owns its MCCodeEmitter -- this fixes the types to reflect that,
and allows us to remove the last instance of MCObjectStreamer's weird "holding
ownership via someone else's reference" trick.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@315531 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/MC/MCELFStreamer.h b/include/llvm/MC/MCELFStreamer.h
index 7c922ef29478f05dc3d1cef6ce3eced7a0155f06..c5b66a163c8515d315b5962737ac66516c72c442 100644 (file)
--- a/include/llvm/MC/MCELFStreamer.h
+++ b/include/llvm/MC/MCELFStreamer.h
@@ -24,7 +24,7 @@ class MCInst;
 class MCELFStreamer : public MCObjectStreamer {
 public:
   MCELFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
-                raw_pwrite_stream &OS, MCCodeEmitter *Emitter);
+                raw_pwrite_stream &OS, std::unique_ptr<MCCodeEmitter> Emitter);
 
   ~MCELFStreamer() override = default;
 
@@ -92,8 +92,8 @@ private:
 MCELFStreamer *createARMELFStreamer(MCContext &Context,
                                     std::unique_ptr<MCAsmBackend> TAB,
                                     raw_pwrite_stream &OS,
-                                    MCCodeEmitter *Emitter, bool RelaxAll,
-                                    bool IsThumb);
+                                    std::unique_ptr<MCCodeEmitter> Emitter,
+                                    bool RelaxAll, bool IsThumb);
 
 } // end namespace llvm
 

diff --git a/include/llvm/MC/MCObjectStreamer.h b/include/llvm/MC/MCObjectStreamer.h
index 89ab726a47ec30f3142bd1e2860317a71691b075..183b6238f316befd79e9377dedf27d8686a1870e 100644 (file)
--- a/include/llvm/MC/MCObjectStreamer.h
+++ b/include/llvm/MC/MCObjectStreamer.h
@@ -36,6 +36,7 @@ class raw_pwrite_stream;
 class MCObjectStreamer : public MCStreamer {
   std::unique_ptr<MCObjectWriter> ObjectWriter;
   std::unique_ptr<MCAsmBackend> TAB;
+  std::unique_ptr<MCCodeEmitter> Emitter;
   std::unique_ptr<MCAssembler> Assembler;
   MCSection::iterator CurInsertionPoint;
   bool EmitEHFrame;
@@ -49,8 +50,9 @@ class MCObjectStreamer : public MCStreamer {
 
 protected:
   MCObjectStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
-                   raw_pwrite_stream &OS, MCCodeEmitter *Emitter);
-  ~MCObjectStreamer() override;
+                   raw_pwrite_stream &OS,
+                   std::unique_ptr<MCCodeEmitter> Emitter);
+  ~MCObjectStreamer();
 
 public:
   /// state management

diff --git a/include/llvm/MC/MCWasmStreamer.h b/include/llvm/MC/MCWasmStreamer.h
index 2a373358d02d6bcd0457f41abfbd927a9d62b8be..135d5e38bc937baabcd1f8d62eda712feaba2bca 100644 (file)
--- a/include/llvm/MC/MCWasmStreamer.h
+++ b/include/llvm/MC/MCWasmStreamer.h
@@ -27,8 +27,8 @@ class raw_ostream;
 class MCWasmStreamer : public MCObjectStreamer {
 public:
   MCWasmStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
-                 raw_pwrite_stream &OS, MCCodeEmitter *Emitter)
-      : MCObjectStreamer(Context, std::move(TAB), OS, Emitter),
+                 raw_pwrite_stream &OS, std::unique_ptr<MCCodeEmitter> Emitter)
+      : MCObjectStreamer(Context, std::move(TAB), OS, std::move(Emitter)),
         SeenIdent(false) {}
 
   ~MCWasmStreamer() override;

diff --git a/include/llvm/MC/MCWinCOFFStreamer.h b/include/llvm/MC/MCWinCOFFStreamer.h
index cf770a9a0b2cb59bf9e7a67a2fdcb0581abd2376..a2500c06efa1ea01341c8f38c3372fe1de20be68 100644 (file)
--- a/include/llvm/MC/MCWinCOFFStreamer.h
+++ b/include/llvm/MC/MCWinCOFFStreamer.h
@@ -28,7 +28,7 @@ class raw_pwrite_stream;
 class MCWinCOFFStreamer : public MCObjectStreamer {
 public:
   MCWinCOFFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> MAB,
-                    MCCodeEmitter &CE, raw_pwrite_stream &OS);
+                    std::unique_ptr<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
index 07b36be1325d5831fc9655c30f67b7ed2b07b5f0..21913d5f01e3a85239d3eacfa96ea18737ae366c 100644 (file)
--- a/include/llvm/Support/TargetRegistry.h
+++ b/include/llvm/Support/TargetRegistry.h
@@ -69,16 +69,19 @@ MCStreamer *createAsmStreamer(MCContext &Ctx,
 /// Takes ownership of \p TAB and \p CE.
 MCStreamer *createELFStreamer(MCContext &Ctx,
                               std::unique_ptr<MCAsmBackend> &&TAB,
-                              raw_pwrite_stream &OS, MCCodeEmitter *CE,
+                              raw_pwrite_stream &OS,
+                              std::unique_ptr<MCCodeEmitter> &&CE,
                               bool RelaxAll);
 MCStreamer *createMachOStreamer(MCContext &Ctx,
                                 std::unique_ptr<MCAsmBackend> &&TAB,
-                                raw_pwrite_stream &OS, MCCodeEmitter *CE,
+                                raw_pwrite_stream &OS,
+                                std::unique_ptr<MCCodeEmitter> &&CE,
                                 bool RelaxAll, bool DWARFMustBeAtTheEnd,
                                 bool LabelSections = false);
 MCStreamer *createWasmStreamer(MCContext &Ctx,
                                std::unique_ptr<MCAsmBackend> &&TAB,
-                               raw_pwrite_stream &OS, MCCodeEmitter *CE,
+                               raw_pwrite_stream &OS,
+                               std::unique_ptr<MCCodeEmitter> &&CE,
                                bool RelaxAll);
 
 MCRelocationInfo *createMCRelocationInfo(const Triple &TT, MCContext &Ctx);
@@ -137,22 +140,26 @@ public:
   using MCCodeEmitterCtorTy = MCCodeEmitter *(*)(const MCInstrInfo &II,
                                                  const MCRegisterInfo &MRI,
                                                  MCContext &Ctx);
-  using ELFStreamerCtorTy = MCStreamer *(*)(const Triple &T, MCContext &Ctx,
-                                            std::unique_ptr<MCAsmBackend> &&TAB,
-                                            raw_pwrite_stream &OS,
-                                            MCCodeEmitter *Emitter,
-                                            bool RelaxAll);
+  using ELFStreamerCtorTy =
+      MCStreamer *(*)(const Triple &T, MCContext &Ctx,
+                      std::unique_ptr<MCAsmBackend> &&TAB,
+                      raw_pwrite_stream &OS,
+                      std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll);
   using MachOStreamerCtorTy =
       MCStreamer *(*)(MCContext &Ctx, std::unique_ptr<MCAsmBackend> &&TAB,
-                      raw_pwrite_stream &OS, MCCodeEmitter *Emitter,
-                      bool RelaxAll, bool DWARFMustBeAtTheEnd);
+                      raw_pwrite_stream &OS,
+                      std::unique_ptr<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);
+                      raw_pwrite_stream &OS,
+                      std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll,
+                      bool IncrementalLinkerCompatible);
+  using WasmStreamerCtorTy =
+      MCStreamer *(*)(const Triple &T, MCContext &Ctx,
+                      std::unique_ptr<MCAsmBackend> &&TAB,
+                      raw_pwrite_stream &OS,
+                      std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll);
   using NullTargetStreamerCtorTy = MCTargetStreamer *(*)(MCStreamer &S);
   using AsmTargetStreamerCtorTy = MCTargetStreamer *(*)(
       MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint,
@@ -436,7 +443,7 @@ public:
   MCStreamer *createMCObjectStreamer(const Triple &T, MCContext &Ctx,
                                      std::unique_ptr<MCAsmBackend> &&TAB,
                                      raw_pwrite_stream &OS,
-                                     MCCodeEmitter *Emitter,
+                                     std::unique_ptr<MCCodeEmitter> &&Emitter,
                                      const MCSubtargetInfo &STI, bool RelaxAll,
                                      bool IncrementalLinkerCompatible,
                                      bool DWARFMustBeAtTheEnd) const {
@@ -446,28 +453,32 @@ public:
       llvm_unreachable("Unknown object format");
     case Triple::COFF:
       assert(T.isOSWindows() && "only Windows COFF is supported");
-      S = COFFStreamerCtorFn(Ctx, std::move(TAB), OS, Emitter, RelaxAll,
-                             IncrementalLinkerCompatible);
+      S = COFFStreamerCtorFn(Ctx, std::move(TAB), OS, std::move(Emitter),
+                             RelaxAll, IncrementalLinkerCompatible);
       break;
     case Triple::MachO:
       if (MachOStreamerCtorFn)
-        S = MachOStreamerCtorFn(Ctx, std::move(TAB), OS, Emitter, RelaxAll,
-                                DWARFMustBeAtTheEnd);
+        S = MachOStreamerCtorFn(Ctx, std::move(TAB), OS, std::move(Emitter),
+                                RelaxAll, DWARFMustBeAtTheEnd);
       else
-        S = createMachOStreamer(Ctx, std::move(TAB), OS, Emitter, RelaxAll,
-                                DWARFMustBeAtTheEnd);
+        S = createMachOStreamer(Ctx, std::move(TAB), OS, std::move(Emitter),
+                                RelaxAll, DWARFMustBeAtTheEnd);
       break;
     case Triple::ELF:
       if (ELFStreamerCtorFn)
-        S = ELFStreamerCtorFn(T, Ctx, std::move(TAB), OS, Emitter, RelaxAll);
+        S = ELFStreamerCtorFn(T, Ctx, std::move(TAB), OS, std::move(Emitter),
+                              RelaxAll);
       else
-        S = createELFStreamer(Ctx, std::move(TAB), OS, Emitter, RelaxAll);
+        S = createELFStreamer(Ctx, std::move(TAB), OS, std::move(Emitter),
+                              RelaxAll);
       break;
     case Triple::Wasm:
       if (WasmStreamerCtorFn)
-        S = WasmStreamerCtorFn(T, Ctx, std::move(TAB), OS, Emitter, RelaxAll);
+        S = WasmStreamerCtorFn(T, Ctx, std::move(TAB), OS, std::move(Emitter),
+                               RelaxAll);
       else
-        S = createWasmStreamer(Ctx, std::move(TAB), OS, Emitter, RelaxAll);
+        S = createWasmStreamer(Ctx, std::move(TAB), OS, std::move(Emitter),
+                               RelaxAll);
       break;
     }
     if (ObjectTargetStreamerCtorFn)

diff --git a/lib/CodeGen/LLVMTargetMachine.cpp b/lib/CodeGen/LLVMTargetMachine.cpp
index 00db011697f1c1945b9e6af5b1e812bbd65156fd..e829409f0974e06b3aacecdd444a0dbf8eb18031 100644 (file)
--- a/lib/CodeGen/LLVMTargetMachine.cpp
+++ b/lib/CodeGen/LLVMTargetMachine.cpp
@@ -22,6 +22,7 @@
 #include "llvm/IR/Verifier.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
+#include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCStreamer.h"
@@ -164,8 +165,8 @@ bool LLVMTargetMachine::addAsmPrinter(PassManagerBase &PM,
 
     Triple T(getTargetTriple().str());
     AsmStreamer.reset(getTarget().createMCObjectStreamer(
-        T, Context, std::unique_ptr<MCAsmBackend>(MAB), Out, MCE, STI,
-        Options.MCOptions.MCRelaxAll,
+        T, Context, std::unique_ptr<MCAsmBackend>(MAB), Out,
+        std::unique_ptr<MCCodeEmitter>(MCE), STI, Options.MCOptions.MCRelaxAll,
         Options.MCOptions.MCIncrementalLinkerCompatible,
         /*DWARFMustBeAtTheEnd*/ true));
     break;
@@ -240,8 +241,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, std::unique_ptr<MCAsmBackend>(MAB), Out, MCE, STI,
-      Options.MCOptions.MCRelaxAll,
+      T, *Ctx, std::unique_ptr<MCAsmBackend>(MAB), Out,
+      std::unique_ptr<MCCodeEmitter>(MCE), STI, Options.MCOptions.MCRelaxAll,
       Options.MCOptions.MCIncrementalLinkerCompatible,
       /*DWARFMustBeAtTheEnd*/ true));
 

diff --git a/lib/MC/MCELFStreamer.cpp b/lib/MC/MCELFStreamer.cpp
index 4fdbcd7511c21e6f20c98b1e1c7e4473071f4081..366125962a5e96e7718004805a02d4d42e4add22 100644 (file)
--- a/lib/MC/MCELFStreamer.cpp
+++ b/lib/MC/MCELFStreamer.cpp
@@ -41,8 +41,9 @@ 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) {}
+                             raw_pwrite_stream &OS,
+                             std::unique_ptr<MCCodeEmitter> Emitter)
+    : MCObjectStreamer(Context, std::move(TAB), OS, std::move(Emitter)) {}
 
 bool MCELFStreamer::isBundleLocked() const {
   return getCurrentSectionOnly()->isBundleLocked();
@@ -646,9 +647,11 @@ void MCELFStreamer::EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
 
 MCStreamer *llvm::createELFStreamer(MCContext &Context,
                                     std::unique_ptr<MCAsmBackend> &&MAB,
-                                    raw_pwrite_stream &OS, MCCodeEmitter *CE,
+                                    raw_pwrite_stream &OS,
+                                    std::unique_ptr<MCCodeEmitter> &&CE,
                                     bool RelaxAll) {
-  MCELFStreamer *S = new MCELFStreamer(Context, std::move(MAB), OS, CE);
+  MCELFStreamer *S =
+      new MCELFStreamer(Context, std::move(MAB), OS, std::move(CE));
   if (RelaxAll)
     S->getAssembler().setRelaxAll(true);
   return S;

diff --git a/lib/MC/MCMachOStreamer.cpp b/lib/MC/MCMachOStreamer.cpp
index 293b87d41775084431a63fc0a3a7b855a3ac2d43..a5c1b13df7ce2e0626ff7bd199663196f5b8ff44 100644 (file)
--- a/lib/MC/MCMachOStreamer.cpp
+++ b/lib/MC/MCMachOStreamer.cpp
@@ -63,9 +63,9 @@ private:
 
 public:
   MCMachOStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> MAB,
-                  raw_pwrite_stream &OS, MCCodeEmitter *Emitter,
+                  raw_pwrite_stream &OS, std::unique_ptr<MCCodeEmitter> Emitter,
                   bool DWARFMustBeAtTheEnd, bool label)
-      : MCObjectStreamer(Context, std::move(MAB), OS, Emitter),
+      : MCObjectStreamer(Context, std::move(MAB), OS, std::move(Emitter)),
         LabelSections(label), DWARFMustBeAtTheEnd(DWARFMustBeAtTheEnd),
         CreatedADWARFSection(false) {}
 
@@ -487,11 +487,13 @@ void MCMachOStreamer::FinishImpl() {
 
 MCStreamer *llvm::createMachOStreamer(MCContext &Context,
                                       std::unique_ptr<MCAsmBackend> &&MAB,
-                                      raw_pwrite_stream &OS, MCCodeEmitter *CE,
+                                      raw_pwrite_stream &OS,
+                                      std::unique_ptr<MCCodeEmitter> &&CE,
                                       bool RelaxAll, bool DWARFMustBeAtTheEnd,
                                       bool LabelSections) {
-  MCMachOStreamer *S = new MCMachOStreamer(Context, std::move(MAB), OS, CE,
-                                           DWARFMustBeAtTheEnd, LabelSections);
+  MCMachOStreamer *S =
+      new MCMachOStreamer(Context, std::move(MAB), OS, std::move(CE),
+                          DWARFMustBeAtTheEnd, LabelSections);
   const Triple &TT = Context.getObjectFileInfo()->getTargetTriple();
   if (TT.isOSDarwin()) {
     unsigned Major, Minor, Update;

diff --git a/lib/MC/MCObjectStreamer.cpp b/lib/MC/MCObjectStreamer.cpp
index ba45d24fd080881ff35d54b902de8500464ea416..2fd969de296431e8716fab96e011106a620bf22d 100644 (file)
--- a/lib/MC/MCObjectStreamer.cpp
+++ b/lib/MC/MCObjectStreamer.cpp
@@ -28,15 +28,14 @@ using namespace llvm;
 MCObjectStreamer::MCObjectStreamer(MCContext &Context,
                                    std::unique_ptr<MCAsmBackend> TAB,
                                    raw_pwrite_stream &OS,
-                                   MCCodeEmitter *Emitter_)
+                                   std::unique_ptr<MCCodeEmitter> Emitter)
     : MCStreamer(Context), ObjectWriter(TAB->createObjectWriter(OS)),
-      TAB(std::move(TAB)), Assembler(llvm::make_unique<MCAssembler>(
-                               Context, *this->TAB, *Emitter_, *ObjectWriter)),
+      TAB(std::move(TAB)), Emitter(std::move(Emitter)),
+      Assembler(llvm::make_unique<MCAssembler>(Context, *this->TAB,
+                                               *this->Emitter, *ObjectWriter)),
       EmitEHFrame(true), EmitDebugFrame(false) {}
 
-MCObjectStreamer::~MCObjectStreamer() {
-  delete &Assembler->getEmitter();
-}
+MCObjectStreamer::~MCObjectStreamer() {}
 
 void MCObjectStreamer::flushPendingLabels(MCFragment *F, uint64_t FOffset) {
   if (PendingLabels.empty())

diff --git a/lib/MC/MCWasmStreamer.cpp b/lib/MC/MCWasmStreamer.cpp
index fdf1be67e4ec353d5147b21088a065fd153f85fd..1262e891f5e14b1e2ca0623febb87db94b96abd2 100644 (file)
--- a/lib/MC/MCWasmStreamer.cpp
+++ b/lib/MC/MCWasmStreamer.cpp
@@ -202,9 +202,11 @@ void MCWasmStreamer::FinishImpl() {
 
 MCStreamer *llvm::createWasmStreamer(MCContext &Context,
                                      std::unique_ptr<MCAsmBackend> &&MAB,
-                                     raw_pwrite_stream &OS, MCCodeEmitter *CE,
+                                     raw_pwrite_stream &OS,
+                                     std::unique_ptr<MCCodeEmitter> &&CE,
                                      bool RelaxAll) {
-  MCWasmStreamer *S = new MCWasmStreamer(Context, std::move(MAB), OS, CE);
+  MCWasmStreamer *S =
+      new MCWasmStreamer(Context, std::move(MAB), OS, std::move(CE));
   if (RelaxAll)
     S->getAssembler().setRelaxAll(true);
   return S;

diff --git a/lib/MC/MCWinCOFFStreamer.cpp b/lib/MC/MCWinCOFFStreamer.cpp
index c78a2e17c8d180114d3e014cf9a9effcb250a533..7e0533b8e0073f56b0176b4c0e1569ed17e9f2a7 100644 (file)
--- a/lib/MC/MCWinCOFFStreamer.cpp
+++ b/lib/MC/MCWinCOFFStreamer.cpp
@@ -43,8 +43,10 @@ using namespace llvm;
 
 MCWinCOFFStreamer::MCWinCOFFStreamer(MCContext &Context,
                                      std::unique_ptr<MCAsmBackend> MAB,
-                                     MCCodeEmitter &CE, raw_pwrite_stream &OS)
-    : MCObjectStreamer(Context, std::move(MAB), OS, &CE), CurSymbol(nullptr) {}
+                                     std::unique_ptr<MCCodeEmitter> CE,
+                                     raw_pwrite_stream &OS)
+    : MCObjectStreamer(Context, std::move(MAB), OS, std::move(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
index 380d5acafb41be5e0f3a6f18bef5b4d145218f02..1e8a07aea8ac9c40b94ae09d0febeb3cd9559d5c 100644 (file)
--- a/lib/Target/AArch64/MCTargetDesc/AArch64ELFStreamer.cpp
+++ b/lib/Target/AArch64/MCTargetDesc/AArch64ELFStreamer.cpp
@@ -87,8 +87,9 @@ public:
   friend class AArch64TargetELFStreamer;
 
   AArch64ELFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
-                     raw_pwrite_stream &OS, MCCodeEmitter *Emitter)
-      : MCELFStreamer(Context, std::move(TAB), OS, Emitter),
+                     raw_pwrite_stream &OS,
+                     std::unique_ptr<MCCodeEmitter> Emitter)
+      : MCELFStreamer(Context, std::move(TAB), OS, std::move(Emitter)),
         MappingSymbolCounter(0), LastEMS(EMS_None) {}
 
   void ChangeSection(MCSection *Section, const MCExpr *Subsection) override {
@@ -201,9 +202,10 @@ MCTargetStreamer *createAArch64AsmTargetStreamer(MCStreamer &S,
 MCELFStreamer *createAArch64ELFStreamer(MCContext &Context,
                                         std::unique_ptr<MCAsmBackend> TAB,
                                         raw_pwrite_stream &OS,
-                                        MCCodeEmitter *Emitter, bool RelaxAll) {
+                                        std::unique_ptr<MCCodeEmitter> Emitter,
+                                        bool RelaxAll) {
   AArch64ELFStreamer *S =
-      new AArch64ELFStreamer(Context, std::move(TAB), OS, Emitter);
+      new AArch64ELFStreamer(Context, std::move(TAB), OS, std::move(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
index 5869764a90d1c3e2802638322ba3907134afedf3..19b188aa1c61ac7ddfaeff541cfb5ae2f5b829cc 100644 (file)
--- a/lib/Target/AArch64/MCTargetDesc/AArch64ELFStreamer.h
+++ b/lib/Target/AArch64/MCTargetDesc/AArch64ELFStreamer.h
@@ -21,7 +21,8 @@ namespace llvm {
 MCELFStreamer *createAArch64ELFStreamer(MCContext &Context,
                                         std::unique_ptr<MCAsmBackend> TAB,
                                         raw_pwrite_stream &OS,
-                                        MCCodeEmitter *Emitter, bool RelaxAll);
+                                        std::unique_ptr<MCCodeEmitter> Emitter,
+                                        bool RelaxAll);
 }
 
 #endif

diff --git a/lib/Target/AArch64/MCTargetDesc/AArch64MCTargetDesc.cpp b/lib/Target/AArch64/MCTargetDesc/AArch64MCTargetDesc.cpp
index b6c0c7f01f6b998f993ff0669803f739f9aa8732..c3458d625b832629bff3c539276d60a6e90ba3b4 100644 (file)
--- a/lib/Target/AArch64/MCTargetDesc/AArch64MCTargetDesc.cpp
+++ b/lib/Target/AArch64/MCTargetDesc/AArch64MCTargetDesc.cpp
@@ -16,6 +16,8 @@
 #include "AArch64MCAsmInfo.h"
 #include "AArch64WinCOFFStreamer.h"
 #include "InstPrinter/AArch64InstPrinter.h"
+#include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCInstrAnalysis.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
@@ -102,27 +104,31 @@ static MCInstPrinter *createAArch64MCInstPrinter(const Triple &T,
 static MCStreamer *createELFStreamer(const Triple &T, MCContext &Ctx,
                                      std::unique_ptr<MCAsmBackend> &&TAB,
                                      raw_pwrite_stream &OS,
-                                     MCCodeEmitter *Emitter, bool RelaxAll) {
-  return createAArch64ELFStreamer(Ctx, std::move(TAB), OS, Emitter, RelaxAll);
+                                     std::unique_ptr<MCCodeEmitter> &&Emitter,
+                                     bool RelaxAll) {
+  return createAArch64ELFStreamer(Ctx, std::move(TAB), OS, std::move(Emitter),
+                                  RelaxAll);
 }
 
 static MCStreamer *createMachOStreamer(MCContext &Ctx,
                                        std::unique_ptr<MCAsmBackend> &&TAB,
                                        raw_pwrite_stream &OS,
-                                       MCCodeEmitter *Emitter, bool RelaxAll,
+                                       std::unique_ptr<MCCodeEmitter> &&Emitter,
+                                       bool RelaxAll,
                                        bool DWARFMustBeAtTheEnd) {
-  return createMachOStreamer(Ctx, std::move(TAB), OS, Emitter, RelaxAll,
-                             DWARFMustBeAtTheEnd,
+  return createMachOStreamer(Ctx, std::move(TAB), OS, std::move(Emitter),
+                             RelaxAll, DWARFMustBeAtTheEnd,
                              /*LabelSections*/ true);
 }
 
-static MCStreamer *createWinCOFFStreamer(MCContext &Ctx,
-                                         std::unique_ptr<MCAsmBackend> &&TAB,
-                                         raw_pwrite_stream &OS,
-                                         MCCodeEmitter *Emitter, bool RelaxAll,
-                                         bool IncrementalLinkerCompatible) {
-  return createAArch64WinCOFFStreamer(Ctx, std::move(TAB), OS, Emitter,
-                                      RelaxAll, IncrementalLinkerCompatible);
+static MCStreamer *
+createWinCOFFStreamer(MCContext &Ctx, std::unique_ptr<MCAsmBackend> &&TAB,
+                      raw_pwrite_stream &OS,
+                      std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll,
+                      bool IncrementalLinkerCompatible) {
+  return createAArch64WinCOFFStreamer(Ctx, std::move(TAB), OS,
+                                      std::move(Emitter), RelaxAll,
+                                      IncrementalLinkerCompatible);
 }
 
 static MCInstrAnalysis *createAArch64InstrAnalysis(const MCInstrInfo *Info) {

diff --git a/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFStreamer.cpp b/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFStreamer.cpp
index f1ab9ffbe8425870852da0fb869afdf8e397b526..9d0f39e5f6ad9cd53d36cb985e13b2ab75ac3ddb 100644 (file)
--- a/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFStreamer.cpp
+++ b/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFStreamer.cpp
@@ -8,6 +8,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "AArch64WinCOFFStreamer.h"
+#include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCCodeEmitter.h"
 
 using namespace llvm;
 
@@ -18,18 +20,19 @@ public:
   friend class AArch64TargetWinCOFFStreamer;
 
   AArch64WinCOFFStreamer(MCContext &C, std::unique_ptr<MCAsmBackend> AB,
-                         MCCodeEmitter &CE, raw_pwrite_stream &OS)
-      : MCWinCOFFStreamer(C, std::move(AB), CE, OS) {}
+                         std::unique_ptr<MCCodeEmitter> CE,
+                         raw_pwrite_stream &OS)
+      : MCWinCOFFStreamer(C, std::move(AB), std::move(CE), OS) {}
 };
 } // end anonymous namespace
 
 namespace llvm {
-MCWinCOFFStreamer *
-createAArch64WinCOFFStreamer(MCContext &Context,
-                             std::unique_ptr<MCAsmBackend> MAB,
-                             raw_pwrite_stream &OS, MCCodeEmitter *Emitter,
-                             bool RelaxAll, bool IncrementalLinkerCompatible) {
-  auto *S = new AArch64WinCOFFStreamer(Context, std::move(MAB), *Emitter, OS);
+MCWinCOFFStreamer *createAArch64WinCOFFStreamer(
+    MCContext &Context, std::unique_ptr<MCAsmBackend> MAB,
+    raw_pwrite_stream &OS, std::unique_ptr<MCCodeEmitter> Emitter,
+    bool RelaxAll, bool IncrementalLinkerCompatible) {
+  auto *S = new AArch64WinCOFFStreamer(Context, std::move(MAB),
+                                       std::move(Emitter), OS);
   S->getAssembler().setIncrementalLinkerCompatible(IncrementalLinkerCompatible);
   return S;
 }

diff --git a/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFStreamer.h b/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFStreamer.h
index 0205a4178985e1a665e6ef9d33545f0f06ea1dbd..b67a19e883e96dbc7d0145201a70881aaa2aa1b0 100644 (file)
--- a/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFStreamer.h
+++ b/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFStreamer.h
@@ -15,7 +15,6 @@
 #define LLVM_LIB_TARGET_AARCH64_MCTARGETDESC_AARCH64WINCOFFSTREAMER_H
 
 #include "AArch64TargetStreamer.h"
-#include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCWinCOFFStreamer.h"
 
 namespace {
@@ -34,11 +33,10 @@ public:
 
 namespace llvm {
 
-MCWinCOFFStreamer *
-createAArch64WinCOFFStreamer(MCContext &Context,
-                             std::unique_ptr<MCAsmBackend> TAB,
-                             raw_pwrite_stream &OS, MCCodeEmitter *Emitter,
-                             bool RelaxAll, bool IncrementalLinkerCompatible);
+MCWinCOFFStreamer *createAArch64WinCOFFStreamer(
+    MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
+    raw_pwrite_stream &OS, std::unique_ptr<MCCodeEmitter> Emitter,
+    bool RelaxAll, bool IncrementalLinkerCompatible);
 } // end llvm namespace
 
 #endif

diff --git a/lib/Target/AMDGPU/MCTargetDesc/AMDGPUELFStreamer.cpp b/lib/Target/AMDGPU/MCTargetDesc/AMDGPUELFStreamer.cpp
index 875cdffea56027707c5523cae39a52d4e1fca8b1..1497edc7a054c7a394fc294c77504b344aa29c96 100644 (file)
--- a/lib/Target/AMDGPU/MCTargetDesc/AMDGPUELFStreamer.cpp
+++ b/lib/Target/AMDGPU/MCTargetDesc/AMDGPUELFStreamer.cpp
@@ -11,14 +11,15 @@
 #include "Utils/AMDGPUBaseInfo.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCCodeEmitter.h"
 
 using namespace llvm;
 
 AMDGPUELFStreamer::AMDGPUELFStreamer(const Triple &T, MCContext &Context,
                                      std::unique_ptr<MCAsmBackend> MAB,
                                      raw_pwrite_stream &OS,
-                                     MCCodeEmitter *Emitter)
-    : MCELFStreamer(Context, std::move(MAB), OS, Emitter) {
+                                     std::unique_ptr<MCCodeEmitter> Emitter)
+    : MCELFStreamer(Context, std::move(MAB), OS, std::move(Emitter)) {
   unsigned Arch = ELF::EF_AMDGPU_ARCH_NONE;
   switch (T.getArch()) {
   case Triple::r600:
@@ -40,6 +41,8 @@ AMDGPUELFStreamer::AMDGPUELFStreamer(const Triple &T, MCContext &Context,
 
 MCELFStreamer *llvm::createAMDGPUELFStreamer(
     const Triple &T, MCContext &Context, std::unique_ptr<MCAsmBackend> MAB,
-    raw_pwrite_stream &OS, MCCodeEmitter *Emitter, bool RelaxAll) {
-  return new AMDGPUELFStreamer(T, Context, std::move(MAB), OS, Emitter);
+    raw_pwrite_stream &OS, std::unique_ptr<MCCodeEmitter> Emitter,
+    bool RelaxAll) {
+  return new AMDGPUELFStreamer(T, Context, std::move(MAB), OS,
+                               std::move(Emitter));
 }

diff --git a/lib/Target/AMDGPU/MCTargetDesc/AMDGPUELFStreamer.h b/lib/Target/AMDGPU/MCTargetDesc/AMDGPUELFStreamer.h
index 2de1786d348f05f75416a4161cdbd3602d962c91..0cc0a4c5cd5d9f83ecec96aaeb1a1fd406e3573e 100644 (file)
--- a/lib/Target/AMDGPU/MCTargetDesc/AMDGPUELFStreamer.h
+++ b/lib/Target/AMDGPU/MCTargetDesc/AMDGPUELFStreamer.h
@@ -27,13 +27,14 @@ class AMDGPUELFStreamer : public MCELFStreamer {
 public:
   AMDGPUELFStreamer(const Triple &T, MCContext &Context,
                     std::unique_ptr<MCAsmBackend> MAB, raw_pwrite_stream &OS,
-                    MCCodeEmitter *Emitter);
+                    std::unique_ptr<MCCodeEmitter> Emitter);
 };
 
 MCELFStreamer *createAMDGPUELFStreamer(const Triple &T, MCContext &Context,
                                        std::unique_ptr<MCAsmBackend> MAB,
                                        raw_pwrite_stream &OS,
-                                       MCCodeEmitter *Emitter, bool RelaxAll);
+                                       std::unique_ptr<MCCodeEmitter> Emitter,
+                                       bool RelaxAll);
 } // namespace llvm.
 
 #endif

diff --git a/lib/Target/AMDGPU/MCTargetDesc/AMDGPUMCTargetDesc.cpp b/lib/Target/AMDGPU/MCTargetDesc/AMDGPUMCTargetDesc.cpp
index 578a3c25646d21dd219c0123d8dea62e98455694..2b321c04fb3090703ff2713e7b7a5259e3a91652 100644 (file)
--- a/lib/Target/AMDGPU/MCTargetDesc/AMDGPUMCTargetDesc.cpp
+++ b/lib/Target/AMDGPU/MCTargetDesc/AMDGPUMCTargetDesc.cpp
@@ -19,6 +19,7 @@
 #include "InstPrinter/AMDGPUInstPrinter.h"
 #include "SIDefines.h"
 #include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
@@ -81,9 +82,10 @@ static MCTargetStreamer * createAMDGPUObjectTargetStreamer(
 static MCStreamer *createMCStreamer(const Triple &T, MCContext &Context,
                                     std::unique_ptr<MCAsmBackend> &&MAB,
                                     raw_pwrite_stream &OS,
-                                    MCCodeEmitter *Emitter, bool RelaxAll) {
-  return createAMDGPUELFStreamer(T, Context, std::move(MAB), OS, Emitter,
-                                 RelaxAll);
+                                    std::unique_ptr<MCCodeEmitter> &&Emitter,
+                                    bool RelaxAll) {
+  return createAMDGPUELFStreamer(T, Context, std::move(MAB), OS,
+                                 std::move(Emitter), RelaxAll);
 }
 
 extern "C" void LLVMInitializeAMDGPUTargetMC() {

diff --git a/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp b/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp
index 872ec19c0f61da341c24b1f699058276a3f3acf3..1f995ddba7d71a1e72ef3eec4b9c6aa461c599fb 100644 (file)
--- a/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp
+++ b/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp
@@ -441,8 +441,10 @@ public:
   friend class ARMTargetELFStreamer;
 
   ARMELFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
-                 raw_pwrite_stream &OS, MCCodeEmitter *Emitter, bool IsThumb)
-      : MCELFStreamer(Context, std::move(TAB), OS, Emitter), IsThumb(IsThumb) {
+                 raw_pwrite_stream &OS, std::unique_ptr<MCCodeEmitter> Emitter,
+                 bool IsThumb)
+      : MCELFStreamer(Context, std::move(TAB), OS, std::move(Emitter)),
+        IsThumb(IsThumb) {
     EHReset();
   }
 
@@ -1488,10 +1490,10 @@ MCTargetStreamer *createARMObjectTargetStreamer(MCStreamer &S,
 MCELFStreamer *createARMELFStreamer(MCContext &Context,
                                     std::unique_ptr<MCAsmBackend> TAB,
                                     raw_pwrite_stream &OS,
-                                    MCCodeEmitter *Emitter, bool RelaxAll,
-                                    bool IsThumb) {
-  ARMELFStreamer *S =
-      new ARMELFStreamer(Context, std::move(TAB), OS, Emitter, IsThumb);
+                                    std::unique_ptr<MCCodeEmitter> Emitter,
+                                    bool RelaxAll, bool IsThumb) {
+  ARMELFStreamer *S = new ARMELFStreamer(Context, std::move(TAB), OS,
+                                         std::move(Emitter), IsThumb);
   // FIXME: This should eventually end up somewhere else where more
   // intelligent flag decisions can be made. For now we are just maintaining
   // the status quo for ARM and setting EF_ARM_EABI_VER5 as the default.

diff --git a/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.cpp b/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.cpp
index 279558883bc7f7c9e44946e181e06030168823b1..ae5bc723ee5fca2d1c9111a20898ba57195c4af9 100644 (file)
--- a/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.cpp
+++ b/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.cpp
@@ -17,6 +17,7 @@
 #include "InstPrinter/ARMInstPrinter.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCELFStreamer.h"
 #include "llvm/MC/MCInstrAnalysis.h"
 #include "llvm/MC/MCInstrInfo.h"
@@ -201,18 +202,19 @@ static MCAsmInfo *createARMMCAsmInfo(const MCRegisterInfo &MRI,
 static MCStreamer *createELFStreamer(const Triple &T, MCContext &Ctx,
                                      std::unique_ptr<MCAsmBackend> &&MAB,
                                      raw_pwrite_stream &OS,
-                                     MCCodeEmitter *Emitter, bool RelaxAll) {
+                                     std::unique_ptr<MCCodeEmitter> &&Emitter,
+                                     bool RelaxAll) {
   return createARMELFStreamer(
-      Ctx, std::move(MAB), OS, Emitter, false,
+      Ctx, std::move(MAB), OS, std::move(Emitter), false,
       (T.getArch() == Triple::thumb || T.getArch() == Triple::thumbeb));
 }
 
-static MCStreamer *createARMMachOStreamer(MCContext &Ctx,
-                                          std::unique_ptr<MCAsmBackend> &&MAB,
-                                          raw_pwrite_stream &OS,
-                                          MCCodeEmitter *Emitter, bool RelaxAll,
-                                          bool DWARFMustBeAtTheEnd) {
-  return createMachOStreamer(Ctx, std::move(MAB), OS, Emitter, false,
+static MCStreamer *
+createARMMachOStreamer(MCContext &Ctx, std::unique_ptr<MCAsmBackend> &&MAB,
+                       raw_pwrite_stream &OS,
+                       std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll,
+                       bool DWARFMustBeAtTheEnd) {
+  return createMachOStreamer(Ctx, std::move(MAB), OS, std::move(Emitter), false,
                              DWARFMustBeAtTheEnd);
 }
 

diff --git a/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.h b/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.h
index cdbc45dce22cf0891a36b4049cb0f8e6fa5148d5..0fb97e5fee977e275d12b15580ecdeea9e437bf1 100644 (file)
--- a/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.h
+++ b/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.h
@@ -96,7 +96,8 @@ MCAsmBackend *createThumbBEAsmBackend(const Target &T,
 MCStreamer *createARMWinCOFFStreamer(MCContext &Context,
                                      std::unique_ptr<MCAsmBackend> &&MAB,
                                      raw_pwrite_stream &OS,
-                                     MCCodeEmitter *Emitter, bool RelaxAll,
+                                     std::unique_ptr<MCCodeEmitter> &&Emitter,
+                                     bool RelaxAll,
                                      bool IncrementalLinkerCompatible);
 
 /// Construct an ELF Mach-O object writer.

diff --git a/lib/Target/ARM/MCTargetDesc/ARMWinCOFFStreamer.cpp b/lib/Target/ARM/MCTargetDesc/ARMWinCOFFStreamer.cpp
index d4c95c08cdd943f0a69e840e15a173eb8721f9e2..ba9246eafa9191eec4e4ec00a5ec57b31dcebe3d 100644 (file)
--- a/lib/Target/ARM/MCTargetDesc/ARMWinCOFFStreamer.cpp
+++ b/lib/Target/ARM/MCTargetDesc/ARMWinCOFFStreamer.cpp
@@ -9,6 +9,7 @@
 
 #include "ARMMCTargetDesc.h"
 #include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCWinCOFFStreamer.h"
 
 using namespace llvm;
@@ -17,8 +18,8 @@ namespace {
 class ARMWinCOFFStreamer : public MCWinCOFFStreamer {
 public:
   ARMWinCOFFStreamer(MCContext &C, std::unique_ptr<MCAsmBackend> AB,
-                     MCCodeEmitter &CE, raw_pwrite_stream &OS)
-      : MCWinCOFFStreamer(C, std::move(AB), CE, OS) {}
+                     std::unique_ptr<MCCodeEmitter> CE, raw_pwrite_stream &OS)
+      : MCWinCOFFStreamer(C, std::move(AB), std::move(CE), OS) {}
 
   void EmitAssemblerFlag(MCAssemblerFlag Flag) override;
   void EmitThumbFunc(MCSymbol *Symbol) override;
@@ -38,13 +39,12 @@ void ARMWinCOFFStreamer::EmitThumbFunc(MCSymbol *Symbol) {
 }
 }
 
-MCStreamer *llvm::createARMWinCOFFStreamer(MCContext &Context,
-                                           std::unique_ptr<MCAsmBackend> &&MAB,
-                                           raw_pwrite_stream &OS,
-                                           MCCodeEmitter *Emitter,
-                                           bool RelaxAll,
-                                           bool IncrementalLinkerCompatible) {
-  auto *S = new ARMWinCOFFStreamer(Context, std::move(MAB), *Emitter, OS);
+MCStreamer *llvm::createARMWinCOFFStreamer(
+    MCContext &Context, std::unique_ptr<MCAsmBackend> &&MAB,
+    raw_pwrite_stream &OS, std::unique_ptr<MCCodeEmitter> &&Emitter,
+    bool RelaxAll, bool IncrementalLinkerCompatible) {
+  auto *S =
+      new ARMWinCOFFStreamer(Context, std::move(MAB), std::move(Emitter), OS);
   S->getAssembler().setIncrementalLinkerCompatible(IncrementalLinkerCompatible);
   return S;
 }

diff --git a/lib/Target/BPF/MCTargetDesc/BPFMCTargetDesc.cpp b/lib/Target/BPF/MCTargetDesc/BPFMCTargetDesc.cpp
index 40459f57fee653eb5f649bf0b69ea246c6ed8f09..c8fbc0c2207b0a1841e8131d9208edb80ec5344e 100644 (file)
--- a/lib/Target/BPF/MCTargetDesc/BPFMCTargetDesc.cpp
+++ b/lib/Target/BPF/MCTargetDesc/BPFMCTargetDesc.cpp
@@ -52,8 +52,10 @@ static MCSubtargetInfo *createBPFMCSubtargetInfo(const Triple &TT,
 static MCStreamer *createBPFMCStreamer(const Triple &T, MCContext &Ctx,
                                        std::unique_ptr<MCAsmBackend> &&MAB,
                                        raw_pwrite_stream &OS,
-                                       MCCodeEmitter *Emitter, bool RelaxAll) {
-  return createELFStreamer(Ctx, std::move(MAB), OS, Emitter, RelaxAll);
+                                       std::unique_ptr<MCCodeEmitter> &&Emitter,
+                                       bool RelaxAll) {
+  return createELFStreamer(Ctx, std::move(MAB), OS, std::move(Emitter),
+                           RelaxAll);
 }
 
 static MCInstPrinter *createBPFMCInstPrinter(const Triple &T,

diff --git a/lib/Target/Hexagon/MCTargetDesc/HexagonMCELFStreamer.cpp b/lib/Target/Hexagon/MCTargetDesc/HexagonMCELFStreamer.cpp
index 85b6296d805225d1fb265125791f6c963012ecc7..691e269cb91f55ede977196654bcad0b85e04f9f 100644 (file)
--- a/lib/Target/Hexagon/MCTargetDesc/HexagonMCELFStreamer.cpp
+++ b/lib/Target/Hexagon/MCTargetDesc/HexagonMCELFStreamer.cpp
@@ -20,6 +20,7 @@
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAssembler.h"
+#include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
@@ -44,19 +45,17 @@ static cl::opt<unsigned> GPSize
    cl::Prefix,
    cl::init(8));
 
-HexagonMCELFStreamer::HexagonMCELFStreamer(MCContext &Context,
-                                           std::unique_ptr<MCAsmBackend> TAB,
-                                           raw_pwrite_stream &OS,
-                                           MCCodeEmitter *Emitter)
-    : MCELFStreamer(Context, std::move(TAB), OS, Emitter),
+HexagonMCELFStreamer::HexagonMCELFStreamer(
+    MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
+    raw_pwrite_stream &OS, std::unique_ptr<MCCodeEmitter> Emitter)
+    : MCELFStreamer(Context, std::move(TAB), OS, std::move(Emitter)),
       MCII(createHexagonMCInstrInfo()) {}
 
-HexagonMCELFStreamer::HexagonMCELFStreamer(MCContext &Context,
-                                           std::unique_ptr<MCAsmBackend> TAB,
-                                           raw_pwrite_stream &OS,
-                                           MCCodeEmitter *Emitter,
-                                           MCAssembler *Assembler)
-    : MCELFStreamer(Context, std::move(TAB), OS, Emitter),
+HexagonMCELFStreamer::HexagonMCELFStreamer(
+    MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
+    raw_pwrite_stream &OS, std::unique_ptr<MCCodeEmitter> Emitter,
+    MCAssembler *Assembler)
+    : MCELFStreamer(Context, std::move(TAB), OS, std::move(Emitter)),
       MCII(createHexagonMCInstrInfo()) {}
 
 void HexagonMCELFStreamer::EmitInstruction(const MCInst &MCB,
@@ -167,8 +166,9 @@ void HexagonMCELFStreamer::HexagonMCEmitLocalCommonSymbol(MCSymbol *Symbol,
 namespace llvm {
 MCStreamer *createHexagonELFStreamer(Triple const &TT, MCContext &Context,
                                      std::unique_ptr<MCAsmBackend> MAB,
-                                     raw_pwrite_stream &OS, MCCodeEmitter *CE) {
-  return new HexagonMCELFStreamer(Context, std::move(MAB), OS, CE);
+                                     raw_pwrite_stream &OS,
+                                     std::unique_ptr<MCCodeEmitter> CE) {
+  return new HexagonMCELFStreamer(Context, std::move(MAB), OS, std::move(CE));
   }
 
 } // end namespace llvm

diff --git a/lib/Target/Hexagon/MCTargetDesc/HexagonMCELFStreamer.h b/lib/Target/Hexagon/MCTargetDesc/HexagonMCELFStreamer.h
index 9c56dcff293fe387dd70186a810f893ed0f661c6..c6fa0021d86b58952a66b220f0fb39c77cfd98a8 100644 (file)
--- a/lib/Target/Hexagon/MCTargetDesc/HexagonMCELFStreamer.h
+++ b/lib/Target/Hexagon/MCTargetDesc/HexagonMCELFStreamer.h
@@ -23,10 +23,12 @@ class HexagonMCELFStreamer : public MCELFStreamer {
 
 public:
   HexagonMCELFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
-                       raw_pwrite_stream &OS, MCCodeEmitter *Emitter);
+                       raw_pwrite_stream &OS,
+                       std::unique_ptr<MCCodeEmitter> Emitter);
 
   HexagonMCELFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
-                       raw_pwrite_stream &OS, MCCodeEmitter *Emitter,
+                       raw_pwrite_stream &OS,
+                       std::unique_ptr<MCCodeEmitter> Emitter,
                        MCAssembler *Assembler);
 
   void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
@@ -41,7 +43,8 @@ public:
 
 MCStreamer *createHexagonELFStreamer(Triple const &TT, MCContext &Context,
                                      std::unique_ptr<MCAsmBackend> MAB,
-                                     raw_pwrite_stream &OS, MCCodeEmitter *CE);
+                                     raw_pwrite_stream &OS,
+                                     std::unique_ptr<MCCodeEmitter> CE);
 
 } // end namespace llvm
 

diff --git a/lib/Target/Hexagon/MCTargetDesc/HexagonMCTargetDesc.cpp b/lib/Target/Hexagon/MCTargetDesc/HexagonMCTargetDesc.cpp
index a695a3bdbc452211adc3441bfe95da1d3a6db790..05bbf396944d414b4185e08cd49867e01bebd7be 100644 (file)
--- a/lib/Target/Hexagon/MCTargetDesc/HexagonMCTargetDesc.cpp
+++ b/lib/Target/Hexagon/MCTargetDesc/HexagonMCTargetDesc.cpp
@@ -21,6 +21,7 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCELFStreamer.h"
@@ -228,8 +229,10 @@ createMCAsmTargetStreamer(MCStreamer &S, formatted_raw_ostream &OS,
 static MCStreamer *createMCStreamer(Triple const &T, MCContext &Context,
                                     std::unique_ptr<MCAsmBackend> &&MAB,
                                     raw_pwrite_stream &OS,
-                                    MCCodeEmitter *Emitter, bool RelaxAll) {
-  return createHexagonELFStreamer(T, Context, std::move(MAB), OS, Emitter);
+                                    std::unique_ptr<MCCodeEmitter> &&Emitter,
+                                    bool RelaxAll) {
+  return createHexagonELFStreamer(T, Context, std::move(MAB), OS,
+                                  std::move(Emitter));
 }
 
 static MCTargetStreamer *

diff --git a/lib/Target/Lanai/MCTargetDesc/LanaiMCTargetDesc.cpp b/lib/Target/Lanai/MCTargetDesc/LanaiMCTargetDesc.cpp
index a491efc322c400daaae30d01eda0445d5811a834..74d929450ed25ee276549b01e3de60a4ae4851e4 100644 (file)
--- a/lib/Target/Lanai/MCTargetDesc/LanaiMCTargetDesc.cpp
+++ b/lib/Target/Lanai/MCTargetDesc/LanaiMCTargetDesc.cpp
@@ -62,11 +62,13 @@ createLanaiMCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef FS) {
 static MCStreamer *createMCStreamer(const Triple &T, MCContext &Context,
                                     std::unique_ptr<MCAsmBackend> &&MAB,
                                     raw_pwrite_stream &OS,
-                                    MCCodeEmitter *Emitter, bool RelaxAll) {
+                                    std::unique_ptr<MCCodeEmitter> &&Emitter,
+                                    bool RelaxAll) {
   if (!T.isOSBinFormatELF())
     llvm_unreachable("OS not supported");
 
-  return createELFStreamer(Context, std::move(MAB), OS, Emitter, RelaxAll);
+  return createELFStreamer(Context, std::move(MAB), OS, std::move(Emitter),
+                           RelaxAll);
 }
 
 static MCInstPrinter *createLanaiMCInstPrinter(const Triple & /*T*/,

diff --git a/lib/Target/Mips/MCTargetDesc/MipsELFStreamer.cpp b/lib/Target/Mips/MCTargetDesc/MipsELFStreamer.cpp
index 2a8e801763cd08829d5247ea137aa8f8ee8b0868..4b8f9c7a680c1d7a8b6d757e9974e3dfbcbf2345 100644 (file)
--- a/lib/Target/Mips/MCTargetDesc/MipsELFStreamer.cpp
+++ b/lib/Target/Mips/MCTargetDesc/MipsELFStreamer.cpp
@@ -13,6 +13,7 @@
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAssembler.h"
+#include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCSymbolELF.h"
@@ -22,8 +23,9 @@ using namespace llvm;
 
 MipsELFStreamer::MipsELFStreamer(MCContext &Context,
                                  std::unique_ptr<MCAsmBackend> MAB,
-                                 raw_pwrite_stream &OS, MCCodeEmitter *Emitter)
-    : MCELFStreamer(Context, std::move(MAB), OS, Emitter) {
+                                 raw_pwrite_stream &OS,
+                                 std::unique_ptr<MCCodeEmitter> Emitter)
+    : MCELFStreamer(Context, std::move(MAB), OS, std::move(Emitter)) {
   RegInfoRecord = new MipsRegInfoRecord(this, Context);
   MipsOptionRecords.push_back(
       std::unique_ptr<MipsRegInfoRecord>(RegInfoRecord));
@@ -87,10 +89,9 @@ void MipsELFStreamer::EmitMipsOptionRecords() {
     I->EmitMipsOptionRecord();
 }
 
-MCELFStreamer *llvm::createMipsELFStreamer(MCContext &Context,
-                                           std::unique_ptr<MCAsmBackend> MAB,
-                                           raw_pwrite_stream &OS,
-                                           MCCodeEmitter *Emitter,
-                                           bool RelaxAll) {
-  return new MipsELFStreamer(Context, std::move(MAB), OS, Emitter);
+MCELFStreamer *llvm::createMipsELFStreamer(
+    MCContext &Context, std::unique_ptr<MCAsmBackend> MAB,
+    raw_pwrite_stream &OS, std::unique_ptr<MCCodeEmitter> Emitter,
+    bool RelaxAll) {
+  return new MipsELFStreamer(Context, std::move(MAB), OS, std::move(Emitter));
 }

diff --git a/lib/Target/Mips/MCTargetDesc/MipsELFStreamer.h b/lib/Target/Mips/MCTargetDesc/MipsELFStreamer.h
index e087f12f181b0cef1d38c9b4f81a141ef9c58967..2fe9b08b645ace97bd27f9fab62a219a09a5ca99 100644 (file)
--- a/lib/Target/Mips/MCTargetDesc/MipsELFStreamer.h
+++ b/lib/Target/Mips/MCTargetDesc/MipsELFStreamer.h
@@ -34,7 +34,8 @@ class MipsELFStreamer : public MCELFStreamer {
 
 public:
   MipsELFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> MAB,
-                  raw_pwrite_stream &OS, MCCodeEmitter *Emitter);
+                  raw_pwrite_stream &OS,
+                  std::unique_ptr<MCCodeEmitter> Emitter);
 
   /// Overriding this function allows us to add arbitrary behaviour before the
   /// \p Inst is actually emitted. For example, we can inspect the operands and
@@ -67,7 +68,8 @@ public:
 MCELFStreamer *createMipsELFStreamer(MCContext &Context,
                                      std::unique_ptr<MCAsmBackend> MAB,
                                      raw_pwrite_stream &OS,
-                                     MCCodeEmitter *Emitter, bool RelaxAll);
+                                     std::unique_ptr<MCCodeEmitter> Emitter,
+                                     bool RelaxAll);
 } // end namespace llvm
 
 #endif // LLVM_LIB_TARGET_MIPS_MCTARGETDESC_MIPSELFSTREAMER_H

diff --git a/lib/Target/Mips/MCTargetDesc/MipsMCNaCl.h b/lib/Target/Mips/MCTargetDesc/MipsMCNaCl.h
index cbddef7dd5f387e333724f38275120f66b33b6f6..dfacf435451645f8b7bb73d3b1838597f807b106 100644 (file)
--- a/lib/Target/Mips/MCTargetDesc/MipsMCNaCl.h
+++ b/lib/Target/Mips/MCTargetDesc/MipsMCNaCl.h
@@ -25,7 +25,8 @@ bool baseRegNeedsLoadStoreMask(unsigned Reg);
 MCELFStreamer *createMipsNaClELFStreamer(MCContext &Context,
                                          std::unique_ptr<MCAsmBackend> TAB,
                                          raw_pwrite_stream &OS,
-                                         MCCodeEmitter *Emitter, bool RelaxAll);
+                                         std::unique_ptr<MCCodeEmitter> Emitter,
+                                         bool RelaxAll);
 }
 
 #endif

diff --git a/lib/Target/Mips/MCTargetDesc/MipsMCTargetDesc.cpp b/lib/Target/Mips/MCTargetDesc/MipsMCTargetDesc.cpp
index 30474e02a2284a3ffbb27a16c993c20c01ab29c5..8fcd8aa4c19ba63e3130f6f9b63bfadc59ceb638 100644 (file)
--- a/lib/Target/Mips/MCTargetDesc/MipsMCTargetDesc.cpp
+++ b/lib/Target/Mips/MCTargetDesc/MipsMCTargetDesc.cpp
@@ -19,6 +19,7 @@
 #include "MipsMCNaCl.h"
 #include "MipsTargetStreamer.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCELFStreamer.h"
 #include "llvm/MC/MCInstrAnalysis.h"
 #include "llvm/MC/MCInstrInfo.h"
@@ -93,13 +94,15 @@ static MCInstPrinter *createMipsMCInstPrinter(const Triple &T,
 static MCStreamer *createMCStreamer(const Triple &T, MCContext &Context,
                                     std::unique_ptr<MCAsmBackend> &&MAB,
                                     raw_pwrite_stream &OS,
-                                    MCCodeEmitter *Emitter, bool RelaxAll) {
+                                    std::unique_ptr<MCCodeEmitter> &&Emitter,
+                                    bool RelaxAll) {
   MCStreamer *S;
   if (!T.isOSNaCl())
-    S = createMipsELFStreamer(Context, std::move(MAB), OS, Emitter, RelaxAll);
+    S = createMipsELFStreamer(Context, std::move(MAB), OS, std::move(Emitter),
+                              RelaxAll);
   else
-    S = createMipsNaClELFStreamer(Context, std::move(MAB), OS, Emitter,
-                                  RelaxAll);
+    S = createMipsNaClELFStreamer(Context, std::move(MAB), OS,
+                                  std::move(Emitter), RelaxAll);
   return S;
 }
 

diff --git a/lib/Target/Mips/MCTargetDesc/MipsNaClELFStreamer.cpp b/lib/Target/Mips/MCTargetDesc/MipsNaClELFStreamer.cpp
index 666876d5a32d75aaf5887abb759b3da2f28de5fa..d878cf82e26d41d59edbcc885efd5414198530db 100644 (file)
--- a/lib/Target/Mips/MCTargetDesc/MipsNaClELFStreamer.cpp
+++ b/lib/Target/Mips/MCTargetDesc/MipsNaClELFStreamer.cpp
@@ -22,6 +22,7 @@
 #include "MipsMCNaCl.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAssembler.h"
+#include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCELFStreamer.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/Support/ErrorHandling.h"
@@ -42,8 +43,9 @@ const unsigned LoadStoreStackMaskReg = Mips::T7;
 class MipsNaClELFStreamer : public MipsELFStreamer {
 public:
   MipsNaClELFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
-                      raw_pwrite_stream &OS, MCCodeEmitter *Emitter)
-      : MipsELFStreamer(Context, std::move(TAB), OS, Emitter) {}
+                      raw_pwrite_stream &OS,
+                      std::unique_ptr<MCCodeEmitter> Emitter)
+      : MipsELFStreamer(Context, std::move(TAB), OS, std::move(Emitter)) {}
 
   ~MipsNaClELFStreamer() override = default;
 
@@ -259,10 +261,10 @@ bool baseRegNeedsLoadStoreMask(unsigned Reg) {
 MCELFStreamer *createMipsNaClELFStreamer(MCContext &Context,
                                          std::unique_ptr<MCAsmBackend> TAB,
                                          raw_pwrite_stream &OS,
-                                         MCCodeEmitter *Emitter,
+                                         std::unique_ptr<MCCodeEmitter> Emitter,
                                          bool RelaxAll) {
   MipsNaClELFStreamer *S =
-      new MipsNaClELFStreamer(Context, std::move(TAB), OS, Emitter);
+      new MipsNaClELFStreamer(Context, std::move(TAB), OS, std::move(Emitter));
   if (RelaxAll)
     S->getAssembler().setRelaxAll(true);
 

diff --git a/lib/Target/X86/MCTargetDesc/X86MCTargetDesc.h b/lib/Target/X86/MCTargetDesc/X86MCTargetDesc.h
index 757ae5d197e82ea325e6f423b30f959dae67c7f9..c5859b600ad2b45980c9b6b9d61ce422191f0ca5 100644 (file)
--- a/lib/Target/X86/MCTargetDesc/X86MCTargetDesc.h
+++ b/lib/Target/X86/MCTargetDesc/X86MCTargetDesc.h
@@ -93,7 +93,8 @@ MCTargetStreamer *createX86ObjectTargetStreamer(MCStreamer &OS,
 /// Takes ownership of \p AB and \p CE.
 MCStreamer *createX86WinCOFFStreamer(MCContext &C,
                                      std::unique_ptr<MCAsmBackend> &&AB,
-                                     raw_pwrite_stream &OS, MCCodeEmitter *CE,
+                                     raw_pwrite_stream &OS,
+                                     std::unique_ptr<MCCodeEmitter> &&CE,
                                      bool RelaxAll,
                                      bool IncrementalLinkerCompatible);
 

diff --git a/lib/Target/X86/MCTargetDesc/X86WinCOFFStreamer.cpp b/lib/Target/X86/MCTargetDesc/X86WinCOFFStreamer.cpp
index 157c4c7b62b0f625bd3fa433192a22ba5c073864..5b1357ae4a7beecd9880ff822a3aa44b60316c21 100644 (file)
--- a/lib/Target/X86/MCTargetDesc/X86WinCOFFStreamer.cpp
+++ b/lib/Target/X86/MCTargetDesc/X86WinCOFFStreamer.cpp
@@ -10,6 +10,7 @@
 #include "X86MCTargetDesc.h"
 #include "X86TargetStreamer.h"
 #include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCWin64EH.h"
 #include "llvm/MC/MCWinCOFFStreamer.h"
 
@@ -20,8 +21,8 @@ class X86WinCOFFStreamer : public MCWinCOFFStreamer {
   Win64EH::UnwindEmitter EHStreamer;
 public:
   X86WinCOFFStreamer(MCContext &C, std::unique_ptr<MCAsmBackend> AB,
-                     MCCodeEmitter *CE, raw_pwrite_stream &OS)
-      : MCWinCOFFStreamer(C, std::move(AB), *CE, OS) {}
+                     std::unique_ptr<MCCodeEmitter> CE, raw_pwrite_stream &OS)
+      : MCWinCOFFStreamer(C, std::move(AB), std::move(CE), OS) {}
 
   void EmitWinEHHandlerData(SMLoc Loc) override;
   void EmitWindowsUnwindTables() override;
@@ -60,9 +61,11 @@ void X86WinCOFFStreamer::FinishImpl() {
 MCStreamer *llvm::createX86WinCOFFStreamer(MCContext &C,
                                            std::unique_ptr<MCAsmBackend> &&AB,
                                            raw_pwrite_stream &OS,
-                                           MCCodeEmitter *CE, bool RelaxAll,
+                                           std::unique_ptr<MCCodeEmitter> &&CE,
+                                           bool RelaxAll,
                                            bool IncrementalLinkerCompatible) {
-  X86WinCOFFStreamer *S = new X86WinCOFFStreamer(C, std::move(AB), CE, OS);
+  X86WinCOFFStreamer *S =
+      new X86WinCOFFStreamer(C, std::move(AB), std::move(CE), OS);
   S->getAssembler().setRelaxAll(RelaxAll);
   S->getAssembler().setIncrementalLinkerCompatible(IncrementalLinkerCompatible);
   return S;

diff --git a/tools/dsymutil/DwarfLinker.cpp b/tools/dsymutil/DwarfLinker.cpp
index 4b3a336de0e75a828d69e5e1acd6340d0435e516..eb4217e16d3a61ca59d3fcd508dab89cabed538c 100644 (file)
--- a/tools/dsymutil/DwarfLinker.cpp
+++ b/tools/dsymutil/DwarfLinker.cpp
@@ -623,8 +623,9 @@ bool DwarfStreamer::init(Triple TheTriple, StringRef OutputFilename) {
 
   MCTargetOptions MCOptions = InitMCTargetOptionsFromFlags();
   MS = TheTarget->createMCObjectStreamer(
-      TheTriple, *MC, std::unique_ptr<MCAsmBackend>(MAB), *OutFile, MCE, *MSTI,
-      MCOptions.MCRelaxAll, MCOptions.MCIncrementalLinkerCompatible,
+      TheTriple, *MC, std::unique_ptr<MCAsmBackend>(MAB), *OutFile,
+      std::unique_ptr<MCCodeEmitter>(MCE), *MSTI, MCOptions.MCRelaxAll,
+      MCOptions.MCIncrementalLinkerCompatible,
       /*DWARFMustBeAtTheEnd*/ false);
   if (!MS)
     return error("no object streamer for target " + TripleName, Context);

diff --git a/tools/llvm-dwp/llvm-dwp.cpp b/tools/llvm-dwp/llvm-dwp.cpp
index fd6559f281bbcb6c0b9b23680d4f5392b77bcdf9..59975f323bfd331ffd4ee63a3a913dc3b75a2589 100644 (file)
--- a/tools/llvm-dwp/llvm-dwp.cpp
+++ b/tools/llvm-dwp/llvm-dwp.cpp
@@ -22,6 +22,7 @@
 #include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
+#include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectFileInfo.h"
@@ -707,8 +708,9 @@ int main(int argc, char **argv) {
 
   MCTargetOptions MCOptions = InitMCTargetOptionsFromFlags();
   std::unique_ptr<MCStreamer> MS(TheTarget->createMCObjectStreamer(
-      TheTriple, MC, std::unique_ptr<MCAsmBackend>(MAB), OutFile, MCE, *MSTI,
-      MCOptions.MCRelaxAll, MCOptions.MCIncrementalLinkerCompatible,
+      TheTriple, MC, std::unique_ptr<MCAsmBackend>(MAB), OutFile,
+      std::unique_ptr<MCCodeEmitter>(MCE), *MSTI, MCOptions.MCRelaxAll,
+      MCOptions.MCIncrementalLinkerCompatible,
       /*DWARFMustBeAtTheEnd*/ false));
   if (!MS)
     return error("no object streamer for target " + TripleName, Context);

diff --git a/tools/llvm-mc/llvm-mc.cpp b/tools/llvm-mc/llvm-mc.cpp
index 01041b1f5b83615be7e6e64610e70f7d88919a2b..986fe3f686912aeb971d6941bdeef7b4556172f7 100644 (file)
--- a/tools/llvm-mc/llvm-mc.cpp
+++ b/tools/llvm-mc/llvm-mc.cpp
@@ -15,6 +15,7 @@
 #include "Disassembler.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
+#include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCInstrInfo.h"
@@ -591,8 +592,9 @@ int main(int argc, char **argv) {
     MCAsmBackend *MAB = TheTarget->createMCAsmBackend(*MRI, TripleName, MCPU,
                                                       MCOptions);
     Str.reset(TheTarget->createMCObjectStreamer(
-        TheTriple, Ctx, std::unique_ptr<MCAsmBackend>(MAB), *OS, CE, *STI,
-        MCOptions.MCRelaxAll, MCOptions.MCIncrementalLinkerCompatible,
+        TheTriple, Ctx, std::unique_ptr<MCAsmBackend>(MAB), *OS,
+        std::unique_ptr<MCCodeEmitter>(CE), *STI, MCOptions.MCRelaxAll,
+        MCOptions.MCIncrementalLinkerCompatible,
         /*DWARFMustBeAtTheEnd*/ false));
     if (NoExecStack)
       Str->InitSections(true);

diff --git a/unittests/DebugInfo/DWARF/DwarfGenerator.cpp b/unittests/DebugInfo/DWARF/DwarfGenerator.cpp
index 41a96ac845a72520242fa305ad0f026fca50e263..9047cf9bb271ad909f22da23a853c60234d51afe 100644 (file)
--- a/unittests/DebugInfo/DWARF/DwarfGenerator.cpp
+++ b/unittests/DebugInfo/DWARF/DwarfGenerator.cpp
@@ -181,8 +181,9 @@ llvm::Error dwarfgen::Generator::init(Triple TheTriple, uint16_t V) {
 
   MCTargetOptions MCOptions = InitMCTargetOptionsFromFlags();
   MS = TheTarget->createMCObjectStreamer(
-      TheTriple, *MC, std::unique_ptr<MCAsmBackend>(MAB), *Stream, MCE, *MSTI,
-      MCOptions.MCRelaxAll, MCOptions.MCIncrementalLinkerCompatible,
+      TheTriple, *MC, std::unique_ptr<MCAsmBackend>(MAB), *Stream,
+      std::unique_ptr<MCCodeEmitter>(MCE), *MSTI, MCOptions.MCRelaxAll,
+      MCOptions.MCIncrementalLinkerCompatible,
       /*DWARFMustBeAtTheEnd*/ false);
   if (!MS)
     return make_error<StringError>("no object streamer for target " +