Split the object streamer callback in one per file format.

There are two main advantages to doing this

* Targets that only need to handle one of the formats specially don't have
  to worry about the others. For example, x86 now only registers a
  constructor for the COFF streamer.

* Changes to the arguments passed to one format constructor will not impact
  the other formats.

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

include/llvm/MC/MCStreamer.h

@@ -748,20 +748,6 @@ MCStreamer *createAsmStreamer(MCContext &Ctx, formatted_raw_ostream &OS,
                               bool isVerboseAsm, bool useDwarfDirectory,
                               MCInstPrinter *InstPrint, MCCodeEmitter *CE,
                               MCAsmBackend *TAB, bool ShowInst);
-
-/// Create a machine code streamer which will generate Mach-O format object
-/// files.
-///
-/// Takes ownership of \p TAB and \p CE.
-MCStreamer *createMachOStreamer(MCContext &Ctx, MCAsmBackend &TAB,
-                                raw_ostream &OS, MCCodeEmitter *CE,
-                                bool RelaxAll, bool LabelSections = false);
-
-/// Create a machine code streamer which will generate ELF format object files.
-MCStreamer *createELFStreamer(MCContext &Ctx, MCAsmBackend &TAB,
-                              raw_ostream &OS, MCCodeEmitter *CE,
-                              bool RelaxAll);
-
 } // end namespace llvm
 
 #endif

include/llvm/Support/TargetRegistry.h

@@ -58,10 +58,14 @@ namespace llvm {
                                 bool isVerboseAsm, bool useDwarfDirectory,
                                 MCInstPrinter *InstPrint, MCCodeEmitter *CE,
                                 MCAsmBackend *TAB, bool ShowInst);
-  MCStreamer *createObjectStreamer(const Triple &T, MCContext &Ctx,
+
-                                   MCAsmBackend &TAB, raw_ostream &OS,
+  /// Takes ownership of \p TAB and \p CE.
-                                   MCCodeEmitter *Emitter,
+  MCStreamer *createELFStreamer(MCContext &Ctx, MCAsmBackend &TAB,
-                                   const MCSubtargetInfo &STI, bool RelaxAll);
+                                raw_ostream &OS, MCCodeEmitter *CE,
+                                bool RelaxAll);
+  MCStreamer *createMachOStreamer(MCContext &Ctx, MCAsmBackend &TAB,
+                                  raw_ostream &OS, MCCodeEmitter *CE,
+                                  bool RelaxAll, bool LabelSections = false);
 
   MCRelocationInfo *createMCRelocationInfo(StringRef TT, MCContext &Ctx);
 
@@ -130,13 +134,25 @@ namespace llvm {
     typedef MCCodeEmitter *(*MCCodeEmitterCtorTy)(const MCInstrInfo &II,
                                                   const MCRegisterInfo &MRI,
                                                   MCContext &Ctx);
-    typedef MCStreamer *(*MCObjectStreamerCtorTy)(
+    typedef MCStreamer *(*ELFStreamerCtorTy)(const Triple &T, MCContext &Ctx,
-        const Triple &T, MCContext &Ctx, MCAsmBackend &TAB, raw_ostream &OS,
+                                             MCAsmBackend &TAB, raw_ostream &OS,
-        MCCodeEmitter *Emitter, const MCSubtargetInfo &STI, bool RelaxAll);
+                                             MCCodeEmitter *Emitter,
+                                             bool RelaxAll);
+    typedef MCStreamer *(*MachOStreamerCtorTy)(MCContext &Ctx,
+                                               MCAsmBackend &TAB,
+                                               raw_ostream &OS,
+                                               MCCodeEmitter *Emitter,
+                                               bool RelaxAll);
+    typedef MCStreamer *(*COFFStreamerCtorTy)(MCContext &Ctx, MCAsmBackend &TAB,
+                                              raw_ostream &OS,
+                                              MCCodeEmitter *Emitter,
+                                              bool RelaxAll);
     typedef MCTargetStreamer *(*NullTargetStreamerCtorTy)(MCStreamer &S);
     typedef MCTargetStreamer *(*AsmTargetStreamerCtorTy)(
         MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint,
         bool IsVerboseAsm);
+    typedef MCTargetStreamer *(*ObjectTargetStreamerCtorTy)(
+        MCStreamer &S, const MCSubtargetInfo &STI);
     typedef MCRelocationInfo *(*MCRelocationInfoCtorTy)(StringRef TT,
                                                         MCContext &Ctx);
     typedef MCSymbolizer *(*MCSymbolizerCtorTy)(
@@ -213,9 +229,10 @@ namespace llvm {
     /// CodeEmitter, if registered.
     MCCodeEmitterCtorTy MCCodeEmitterCtorFn;
 
-    /// MCObjectStreamerCtorFn - Construction function for this target's
+    // Construction functions for the various object formats, if registered.
-    /// MCObjectStreamer, if registered.
+    COFFStreamerCtorTy COFFStreamerCtorFn;
-    MCObjectStreamerCtorTy MCObjectStreamerCtorFn;
+    MachOStreamerCtorTy MachOStreamerCtorFn;
+    ELFStreamerCtorTy ELFStreamerCtorFn;
 
     /// Construction function for this target's null TargetStreamer, if
     /// registered (default = nullptr).
@@ -225,6 +242,10 @@ namespace llvm {
     /// registered (default = nullptr).
     AsmTargetStreamerCtorTy AsmTargetStreamerCtorFn;
 
+    /// Construction function for this target's obj TargetStreamer, if
+    /// registered (default = nullptr).
+    ObjectTargetStreamerCtorTy ObjectTargetStreamerCtorFn;
+
     /// MCRelocationInfoCtorFn - Construction function for this target's
     /// MCRelocationInfo, if registered (default = llvm::createMCRelocationInfo)
     MCRelocationInfoCtorTy MCRelocationInfoCtorFn;
@@ -235,9 +256,10 @@ namespace llvm {
 
   public:
     Target()
-        : MCObjectStreamerCtorFn(nullptr), NullTargetStreamerCtorFn(nullptr),
+        : COFFStreamerCtorFn(nullptr), MachOStreamerCtorFn(nullptr),
-          AsmTargetStreamerCtorFn(nullptr), MCRelocationInfoCtorFn(nullptr),
+          ELFStreamerCtorFn(nullptr), NullTargetStreamerCtorFn(nullptr),
-          MCSymbolizerCtorFn(nullptr) {}
+          AsmTargetStreamerCtorFn(nullptr), ObjectTargetStreamerCtorFn(nullptr),
+          MCRelocationInfoCtorFn(nullptr), MCSymbolizerCtorFn(nullptr) {}
 
     /// @name Target Information
     /// @{
@@ -423,10 +445,30 @@ namespace llvm {
                                        MCCodeEmitter *Emitter,
                                        const MCSubtargetInfo &STI,
                                        bool RelaxAll) const {
-      if (!MCObjectStreamerCtorFn)
+      MCStreamer *S;
-        return llvm::createObjectStreamer(T, Ctx, TAB, OS, Emitter, STI,
+      switch (T.getObjectFormat()) {
-                                          RelaxAll);
+      default:
-      return MCObjectStreamerCtorFn(T, Ctx, TAB, OS, Emitter, STI, RelaxAll);
+        llvm_unreachable("Unknown object format");
+      case Triple::COFF:
+        assert(T.isOSWindows() && "only Windows COFF is supported");
+        S = COFFStreamerCtorFn(Ctx, TAB, OS, Emitter, RelaxAll);
+        break;
+      case Triple::MachO:
+        if (MachOStreamerCtorFn)
+          S = MachOStreamerCtorFn(Ctx, TAB, OS, Emitter, RelaxAll);
+        else
+          S = createMachOStreamer(Ctx, TAB, OS, Emitter, RelaxAll);
+        break;
+      case Triple::ELF:
+        if (ELFStreamerCtorFn)
+          S = ELFStreamerCtorFn(T, Ctx, TAB, OS, Emitter, RelaxAll);
+        else
+          S = createELFStreamer(Ctx, TAB, OS, Emitter, RelaxAll);
+        break;
+      }
+      if (ObjectTargetStreamerCtorFn)
+        ObjectTargetStreamerCtorFn(*S, STI);
+      return S;
     }
 
     MCStreamer *createAsmStreamer(MCContext &Ctx, formatted_raw_ostream &OS,
@@ -760,18 +802,17 @@ namespace llvm {
       T.MCCodeEmitterCtorFn = Fn;
     }
 
-    /// RegisterMCObjectStreamer - Register a object code MCStreamer
+    static void RegisterCOFFStreamer(Target &T, Target::COFFStreamerCtorTy Fn) {
-    /// implementation for the given target.
+      T.COFFStreamerCtorFn = Fn;
-    ///
+    }
-    /// Clients are responsible for ensuring that registration doesn't occur
+
-    /// while another thread is attempting to access the registry. Typically
+    static void RegisterMachOStreamer(Target &T,
-    /// this is done by initializing all targets at program startup.
+                                      Target::MachOStreamerCtorTy Fn) {
-    ///
+      T.MachOStreamerCtorFn = Fn;
-    /// @param T - The target being registered.
+    }
-    /// @param Fn - A function to construct an MCStreamer for the target.
+
-    static void RegisterMCObjectStreamer(Target &T,
+    static void RegisterELFStreamer(Target &T, Target::ELFStreamerCtorTy Fn) {
-                                         Target::MCObjectStreamerCtorTy Fn) {
+      T.ELFStreamerCtorFn = Fn;
-      T.MCObjectStreamerCtorFn = Fn;
     }
 
     static void
@@ -784,6 +825,12 @@ namespace llvm {
       T.AsmTargetStreamerCtorFn = Fn;
     }
 
+    static void
+    RegisterObjectTargetStreamer(Target &T,
+                                 Target::ObjectTargetStreamerCtorTy Fn) {
+      T.ObjectTargetStreamerCtorFn = Fn;
+    }
+
     /// RegisterMCRelocationInfo - Register an MCRelocationInfo
     /// implementation for the given target.
     ///

lib/MC/MCELFStreamer.cpp

@@ -32,6 +32,7 @@
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;

lib/MC/MCMachOStreamer.cpp

@@ -26,6 +26,7 @@
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;

lib/MC/MCObjectStreamer.cpp

@@ -423,16 +423,3 @@ void MCObjectStreamer::FinishImpl() {
   flushPendingLabels(nullptr);
   getAssembler().Finish();
 }
-
-MCStreamer *llvm::createObjectStreamer(const Triple &T, MCContext &Ctx,
-                                       MCAsmBackend &TAB, raw_ostream &OS,
-                                       MCCodeEmitter *Emitter,
-                                       const MCSubtargetInfo &STI,
-                                       bool RelaxAll) {
-  switch (T.getObjectFormat()) {
-  default:
-    return nullptr;
-  case Triple::ELF:
-    return createELFStreamer(Ctx, TAB, OS, Emitter, RelaxAll);
-  }
-}

lib/Target/AArch64/MCTargetDesc/AArch64ELFStreamer.cpp

@@ -214,9 +214,16 @@ MCELFStreamer *createAArch64ELFStreamer(MCContext &Context, MCAsmBackend &TAB,
                                         raw_ostream &OS, MCCodeEmitter *Emitter,
                                         bool RelaxAll) {
   AArch64ELFStreamer *S = new AArch64ELFStreamer(Context, TAB, OS, Emitter);
-  new AArch64TargetELFStreamer(*S);
   if (RelaxAll)
     S->getAssembler().setRelaxAll(true);
   return S;
 }
+
+MCTargetStreamer *
+createAArch64ObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo &STI) {
+  Triple TT(STI.getTargetTriple());
+  if (TT.getObjectFormat() == Triple::ELF)
+    return new AArch64TargetELFStreamer(S);
+  return nullptr;
+}
 }

lib/Target/AArch64/MCTargetDesc/AArch64MCTargetDesc.cpp

@@ -123,15 +123,17 @@ static MCInstPrinter *createAArch64MCInstPrinter(const Target &T,
   return nullptr;
 }
 
-static MCStreamer *createMCStreamer(const Triple &T, MCContext &Ctx,
+static MCStreamer *createELFStreamer(const Triple &T, MCContext &Ctx,
                                      MCAsmBackend &TAB, raw_ostream &OS,
-                                    MCCodeEmitter *Emitter,
+                                     MCCodeEmitter *Emitter, bool RelaxAll) {
-                                    const MCSubtargetInfo &STI, bool RelaxAll) {
+  return createAArch64ELFStreamer(Ctx, TAB, OS, Emitter, RelaxAll);
-  if (T.isOSDarwin())
+}
+
+static MCStreamer *createMachOStreamer(MCContext &Ctx, MCAsmBackend &TAB,
+                                       raw_ostream &OS, MCCodeEmitter *Emitter,
+                                       bool RelaxAll) {
   return createMachOStreamer(Ctx, TAB, OS, Emitter, RelaxAll,
                              /*LabelSections*/ true);
-
-  return createAArch64ELFStreamer(Ctx, TAB, OS, Emitter, RelaxAll);
 }
 
 // Force static initialization.
@@ -156,8 +158,13 @@ extern "C" void LLVMInitializeAArch64TargetMC() {
     // Register the MC Code Emitter
     TargetRegistry::RegisterMCCodeEmitter(*T, createAArch64MCCodeEmitter);
 
-    // Register the object streamer.
+    // Register the obj streamers.
-    TargetRegistry::RegisterMCObjectStreamer(*T, createMCStreamer);
+    TargetRegistry::RegisterELFStreamer(*T, createELFStreamer);
+    TargetRegistry::RegisterMachOStreamer(*T, createMachOStreamer);
+
+    // Register the obj target streamer.
+    TargetRegistry::RegisterObjectTargetStreamer(
+        *T, createAArch64ObjectTargetStreamer);
 
     // Register the asm streamer.
     TargetRegistry::RegisterAsmTargetStreamer(*T,

lib/Target/AArch64/MCTargetDesc/AArch64MCTargetDesc.h

@@ -31,6 +31,7 @@ class MCSubtargetInfo;
 class MCTargetStreamer;
 class StringRef;
 class Target;
+class Triple;
 class raw_ostream;
 
 extern Target TheAArch64leTarget;
@@ -57,6 +58,10 @@ MCTargetStreamer *createAArch64AsmTargetStreamer(MCStreamer &S,
                                                  formatted_raw_ostream &OS,
                                                  MCInstPrinter *InstPrint,
                                                  bool isVerboseAsm);
+
+MCTargetStreamer *createAArch64ObjectTargetStreamer(MCStreamer &S,
+                                                    const MCSubtargetInfo &STI);
+
 } // End llvm namespace
 
 // Defines symbolic names for AArch64 registers.  This defines a mapping from

lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp

@@ -1374,11 +1374,18 @@ MCTargetStreamer *createARMNullTargetStreamer(MCStreamer &S) {
   return new ARMTargetStreamer(S);
 }
 
+MCTargetStreamer *createARMObjectTargetStreamer(MCStreamer &S,
+                                                const MCSubtargetInfo &STI) {
+  Triple TT(STI.getTargetTriple());
+  if (TT.getObjectFormat() == Triple::ELF)
+    return new ARMTargetELFStreamer(S);
+  return new ARMTargetStreamer(S);
+}
+
 MCELFStreamer *createARMELFStreamer(MCContext &Context, MCAsmBackend &TAB,
                                     raw_ostream &OS, MCCodeEmitter *Emitter,
                                     bool RelaxAll, bool IsThumb) {
     ARMELFStreamer *S = new ARMELFStreamer(Context, TAB, OS, Emitter, IsThumb);
-    new ARMTargetELFStreamer(*S);
     // 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.

lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.cpp

@@ -298,25 +298,18 @@ static MCCodeGenInfo *createARMMCCodeGenInfo(StringRef TT, Reloc::Model RM,
   return X;
 }
 
-// This is duplicated code. Refactor this.
+static MCStreamer *createELFStreamer(const Triple &T, MCContext &Ctx,
-static MCStreamer *createMCStreamer(const Triple &T, MCContext &Ctx,
                                      MCAsmBackend &MAB, raw_ostream &OS,
-                                    MCCodeEmitter *Emitter,
+                                     MCCodeEmitter *Emitter, bool RelaxAll) {
-                                    const MCSubtargetInfo &STI, bool RelaxAll) {
-  switch (T.getObjectFormat()) {
-  default: llvm_unreachable("unsupported object format");
-  case Triple::MachO: {
-    MCStreamer *S = createMachOStreamer(Ctx, MAB, OS, Emitter, false);
-    new ARMTargetStreamer(*S);
-    return S;
-  }
-  case Triple::COFF:
-    assert(T.isOSWindows() && "non-Windows ARM COFF is not supported");
-    return createARMWinCOFFStreamer(Ctx, MAB, *Emitter, OS);
-  case Triple::ELF:
   return createARMELFStreamer(Ctx, MAB, OS, Emitter, false,
                               T.getArch() == Triple::thumb);
-  }
+}
+
+static MCStreamer *createARMMachOStreamer(MCContext &Ctx, MCAsmBackend &MAB,
+                                          raw_ostream &OS,
+                                          MCCodeEmitter *Emitter,
+                                          bool RelaxAll) {
+  return createMachOStreamer(Ctx, MAB, OS, Emitter, false);
 }
 
 static MCInstPrinter *createARMMCInstPrinter(const Target &T,
@@ -401,8 +394,13 @@ extern "C" void LLVMInitializeARMTargetMC() {
     // Register the MC instruction analyzer.
     TargetRegistry::RegisterMCInstrAnalysis(*T, createARMMCInstrAnalysis);
 
-    // Register the object streamer.
+    TargetRegistry::RegisterELFStreamer(*T, createELFStreamer);
-    TargetRegistry::RegisterMCObjectStreamer(*T, createMCStreamer);
+    TargetRegistry::RegisterCOFFStreamer(*T, createARMWinCOFFStreamer);
+    TargetRegistry::RegisterMachOStreamer(*T, createARMMachOStreamer);
+
+    // Register the obj target streamer.
+    TargetRegistry::RegisterObjectTargetStreamer(*T,
+                                                 createARMObjectTargetStreamer);
 
     // Register the asm streamer.
     TargetRegistry::RegisterAsmTargetStreamer(*T, createARMTargetAsmStreamer);

lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.h

@@ -32,6 +32,7 @@ class MCRelocationInfo;
 class MCTargetStreamer;
 class StringRef;
 class Target;
+class Triple;
 class raw_ostream;
 
 extern Target TheARMLETarget, TheThumbLETarget;
@@ -52,6 +53,8 @@ MCTargetStreamer *createARMTargetAsmStreamer(MCStreamer &S,
                                              formatted_raw_ostream &OS,
                                              MCInstPrinter *InstPrint,
                                              bool isVerboseAsm);
+MCTargetStreamer *createARMObjectTargetStreamer(MCStreamer &S,
+                                                const MCSubtargetInfo &STI);
 
 MCCodeEmitter *createARMLEMCCodeEmitter(const MCInstrInfo &MCII,
                                         const MCRegisterInfo &MRI,
@@ -77,10 +80,11 @@ MCAsmBackend *createThumbLEAsmBackend(const Target &T, const MCRegisterInfo &MRI
 MCAsmBackend *createThumbBEAsmBackend(const Target &T, const MCRegisterInfo &MRI,
                                       StringRef TT, StringRef CPU);
 
-/// createARMWinCOFFStreamer - Construct a PE/COFF machine code streamer which
+// Construct a PE/COFF machine code streamer which will generate a PE/COFF
-/// will generate a PE/COFF object file.
+// object file.
 MCStreamer *createARMWinCOFFStreamer(MCContext &Context, MCAsmBackend &MAB,
-                                     MCCodeEmitter &Emitter, raw_ostream &OS);
+                                     raw_ostream &OS, MCCodeEmitter *Emitter,
+                                     bool RelaxAll);
 
 /// createARMELFObjectWriter - Construct an ELF Mach-O object writer.
 MCObjectWriter *createARMELFObjectWriter(raw_ostream &OS,

lib/Target/ARM/MCTargetDesc/ARMWinCOFFStreamer.cpp

@@ -37,10 +37,10 @@ void ARMWinCOFFStreamer::EmitThumbFunc(MCSymbol *Symbol) {
 }
 }
 
-namespace llvm {
+MCStreamer *llvm::createARMWinCOFFStreamer(MCContext &Context,
-MCStreamer *createARMWinCOFFStreamer(MCContext &Context, MCAsmBackend &MAB,
+                                           MCAsmBackend &MAB, raw_ostream &OS,
-                                     MCCodeEmitter &Emitter, raw_ostream &OS) {
+                                           MCCodeEmitter *Emitter,
-  return new ARMWinCOFFStreamer(Context, MAB, Emitter, OS);
+                                           bool RelaxAll) {
-}
+  return new ARMWinCOFFStreamer(Context, MAB, *Emitter, OS);
 }
 

lib/Target/Mips/MCTargetDesc/MipsELFStreamer.cpp

@@ -69,11 +69,9 @@ void MipsELFStreamer::EmitMipsOptionRecords() {
     I->EmitMipsOptionRecord();
 }
 
-namespace llvm {
+MCELFStreamer *llvm::createMipsELFStreamer(MCContext &Context,
-MCELFStreamer *createMipsELFStreamer(MCContext &Context, MCAsmBackend &MAB,
+                                           MCAsmBackend &MAB, raw_ostream &OS,
-                                     raw_ostream &OS, MCCodeEmitter *Emitter,
+                                           MCCodeEmitter *Emitter,
-                                     const MCSubtargetInfo &STI,
                                            bool RelaxAll) {
-  return new MipsELFStreamer(Context, MAB, OS, Emitter, STI);
+  return new MipsELFStreamer(Context, MAB, OS, Emitter);
-}
 }

lib/Target/Mips/MCTargetDesc/MipsELFStreamer.h

@@ -34,7 +34,7 @@ class MipsELFStreamer : public MCELFStreamer {
 
 public:
   MipsELFStreamer(MCContext &Context, MCAsmBackend &MAB, raw_ostream &OS,
-                  MCCodeEmitter *Emitter, const MCSubtargetInfo &STI)
+                  MCCodeEmitter *Emitter)
       : MCELFStreamer(Context, MAB, OS, Emitter) {
 
     RegInfoRecord = new MipsRegInfoRecord(this, Context);
@@ -69,6 +69,6 @@ public:
 
 MCELFStreamer *createMipsELFStreamer(MCContext &Context, MCAsmBackend &MAB,
                                      raw_ostream &OS, MCCodeEmitter *Emitter,
-                                     const MCSubtargetInfo &STI, bool RelaxAll);
+                                     bool RelaxAll);
 } // namespace llvm.
 #endif

lib/Target/Mips/MCTargetDesc/MipsMCNaCl.h

@@ -25,7 +25,6 @@ bool baseRegNeedsLoadStoreMask(unsigned Reg);
 MCELFStreamer *createMipsNaClELFStreamer(MCContext &Context, MCAsmBackend &TAB,
                                          raw_ostream &OS,
                                          MCCodeEmitter *Emitter,
-                                         const MCSubtargetInfo &STI,
                                          bool RelaxAll);
 }
 

lib/Target/Mips/MCTargetDesc/MipsMCTargetDesc.cpp

@@ -108,14 +108,12 @@ static MCInstPrinter *createMipsMCInstPrinter(const Target &T,
 
 static MCStreamer *createMCStreamer(const Triple &T, MCContext &Context,
                                     MCAsmBackend &MAB, raw_ostream &OS,
-                                    MCCodeEmitter *Emitter,
+                                    MCCodeEmitter *Emitter, bool RelaxAll) {
-                                    const MCSubtargetInfo &STI, bool RelaxAll) {
   MCStreamer *S;
   if (!T.isOSNaCl())
-    S = createMipsELFStreamer(Context, MAB, OS, Emitter, STI, RelaxAll);
+    S = createMipsELFStreamer(Context, MAB, OS, Emitter, RelaxAll);
   else
-    S = createMipsNaClELFStreamer(Context, MAB, OS, Emitter, STI, RelaxAll);
+    S = createMipsNaClELFStreamer(Context, MAB, OS, Emitter, RelaxAll);
-  new MipsTargetELFStreamer(*S, STI);
   return S;
 }
 
@@ -130,6 +128,11 @@ static MCTargetStreamer *createMipsNullTargetStreamer(MCStreamer &S) {
   return new MipsTargetStreamer(S);
 }
 
+static MCTargetStreamer *
+createMipsObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo &STI) {
+  return new MipsTargetELFStreamer(S, STI);
+}
+
 extern "C" void LLVMInitializeMipsTargetMC() {
   for (Target *T : {&TheMipsTarget, &TheMipselTarget, &TheMips64Target,
                     &TheMips64elTarget}) {
@@ -145,8 +148,8 @@ extern "C" void LLVMInitializeMipsTargetMC() {
     // Register the MC register info.
     TargetRegistry::RegisterMCRegInfo(*T, createMipsMCRegisterInfo);
 
-    // Register the object streamer.
+    // Register the elf streamer.
-    TargetRegistry::RegisterMCObjectStreamer(*T, createMCStreamer);
+    TargetRegistry::RegisterELFStreamer(*T, createMCStreamer);
 
     // Register the asm target streamer.
     TargetRegistry::RegisterAsmTargetStreamer(*T, createMipsAsmTargetStreamer);
@@ -159,6 +162,9 @@ extern "C" void LLVMInitializeMipsTargetMC() {
 
     // Register the MCInstPrinter.
     TargetRegistry::RegisterMCInstPrinter(*T, createMipsMCInstPrinter);
+
+    TargetRegistry::RegisterObjectTargetStreamer(
+        *T, createMipsObjectTargetStreamer);
   }
 
   // Register the MC Code Emitter

lib/Target/Mips/MCTargetDesc/MipsNaClELFStreamer.cpp

@@ -37,8 +37,8 @@ const unsigned LoadStoreStackMaskReg = Mips::T7;
 class MipsNaClELFStreamer : public MipsELFStreamer {
 public:
   MipsNaClELFStreamer(MCContext &Context, MCAsmBackend &TAB, raw_ostream &OS,
-                      MCCodeEmitter *Emitter, const MCSubtargetInfo &STI)
+                      MCCodeEmitter *Emitter)
-    : MipsELFStreamer(Context, TAB, OS, Emitter, STI), PendingCall(false) {}
+      : MipsELFStreamer(Context, TAB, OS, Emitter), PendingCall(false) {}
 
   ~MipsNaClELFStreamer() {}
 
@@ -254,10 +254,8 @@ bool baseRegNeedsLoadStoreMask(unsigned Reg) {
 MCELFStreamer *createMipsNaClELFStreamer(MCContext &Context, MCAsmBackend &TAB,
                                          raw_ostream &OS,
                                          MCCodeEmitter *Emitter,
-                                         const MCSubtargetInfo &STI,
                                          bool RelaxAll) {
-  MipsNaClELFStreamer *S = new MipsNaClELFStreamer(Context, TAB, OS, Emitter,
+  MipsNaClELFStreamer *S = new MipsNaClELFStreamer(Context, TAB, OS, Emitter);
-                                                   STI);
   if (RelaxAll)
     S->getAssembler().setRelaxAll(true);
 

lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp

@@ -223,22 +223,6 @@ public:
 };
 }
 
-// This is duplicated code. Refactor this.
-static MCStreamer *createMCStreamer(const Triple &T, MCContext &Ctx,
-                                    MCAsmBackend &MAB, raw_ostream &OS,
-                                    MCCodeEmitter *Emitter,
-                                    const MCSubtargetInfo &STI, bool RelaxAll) {
-  if (T.isOSDarwin()) {
-    MCStreamer *S = createMachOStreamer(Ctx, MAB, OS, Emitter, RelaxAll);
-    new PPCTargetMachOStreamer(*S);
-    return S;
-  }
-
-  MCStreamer *S = createELFStreamer(Ctx, MAB, OS, Emitter, RelaxAll);
-  new PPCTargetELFStreamer(*S);
-  return S;
-}
-
 static MCTargetStreamer *createAsmTargetStreamer(MCStreamer &S,
                                                  formatted_raw_ostream &OS,
                                                  MCInstPrinter *InstPrint,
@@ -246,6 +230,14 @@ static MCTargetStreamer *createAsmTargetStreamer(MCStreamer &S,
   return new PPCTargetAsmStreamer(S, OS);
 }
 
+static MCTargetStreamer *
+createObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo &STI) {
+  Triple TT(STI.getTargetTriple());
+  if (TT.getObjectFormat() == Triple::ELF)
+    return new PPCTargetELFStreamer(S);
+  return new PPCTargetMachOStreamer(S);
+}
+
 static MCInstPrinter *createPPCMCInstPrinter(const Target &T,
                                              unsigned SyntaxVariant,
                                              const MCAsmInfo &MAI,
@@ -279,8 +271,9 @@ extern "C" void LLVMInitializePowerPCTargetMC() {
     // Register the asm backend.
     TargetRegistry::RegisterMCAsmBackend(*T, createPPCAsmBackend);
 
-    // Register the object streamer.
+    // Register the object target streamer.
-    TargetRegistry::RegisterMCObjectStreamer(*T, createMCStreamer);
+    TargetRegistry::RegisterObjectTargetStreamer(*T,
+                                                 createObjectTargetStreamer);
 
     // Register the asm target streamer.
     TargetRegistry::RegisterAsmTargetStreamer(*T, createAsmTargetStreamer);

lib/Target/Sparc/MCTargetDesc/SparcMCTargetDesc.cpp

@@ -122,13 +122,9 @@ static MCCodeGenInfo *createSparcV9MCCodeGenInfo(StringRef TT, Reloc::Model RM,
   return X;
 }
 
-static MCStreamer *createMCStreamer(const Triple &T, MCContext &Context,
+static MCTargetStreamer *
-                                    MCAsmBackend &MAB, raw_ostream &OS,
+createObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo &STI) {
-                                    MCCodeEmitter *Emitter,
+  return new SparcTargetELFStreamer(S);
-                                    const MCSubtargetInfo &STI, bool RelaxAll) {
-  MCStreamer *S = createELFStreamer(Context, MAB, OS, Emitter, RelaxAll);
-  new SparcTargetELFStreamer(*S);
-  return S;
 }
 
 static MCTargetStreamer *createTargetAsmStreamer(MCStreamer &S,
@@ -168,8 +164,9 @@ extern "C" void LLVMInitializeSparcTargetMC() {
     // Register the asm backend.
     TargetRegistry::RegisterMCAsmBackend(*T, createSparcAsmBackend);
 
-    // Register the object streamer.
+    // Register the object target streamer.
-    TargetRegistry::RegisterMCObjectStreamer(*T, createMCStreamer);
+    TargetRegistry::RegisterObjectTargetStreamer(*T,
+                                                 createObjectTargetStreamer);
 
     // Register the asm streamer.
     TargetRegistry::RegisterAsmTargetStreamer(*T, createTargetAsmStreamer);

lib/Target/X86/MCTargetDesc/X86MCTargetDesc.cpp

@@ -344,22 +344,6 @@ static MCCodeGenInfo *createX86MCCodeGenInfo(StringRef TT, Reloc::Model RM,
   return X;
 }
 
-static MCStreamer *createMCStreamer(const Triple &T, MCContext &Ctx,
-                                    MCAsmBackend &MAB, raw_ostream &OS,
-                                    MCCodeEmitter *Emitter,
-                                    const MCSubtargetInfo &STI, bool RelaxAll) {
-  switch (T.getObjectFormat()) {
-  default: llvm_unreachable("unsupported object format");
-  case Triple::MachO:
-    return createMachOStreamer(Ctx, MAB, OS, Emitter, RelaxAll);
-  case Triple::COFF:
-    assert(T.isOSWindows() && "only Windows COFF is supported");
-    return createX86WinCOFFStreamer(Ctx, MAB, Emitter, OS, RelaxAll);
-  case Triple::ELF:
-    return createELFStreamer(Ctx, MAB, OS, Emitter, RelaxAll);
-  }
-}
-
 static MCInstPrinter *createX86MCInstPrinter(const Target &T,
                                              unsigned SyntaxVariant,
                                              const MCAsmInfo &MAI,
@@ -414,7 +398,7 @@ extern "C" void LLVMInitializeX86TargetMC() {
     TargetRegistry::RegisterMCCodeEmitter(*T, createX86MCCodeEmitter);
 
     // Register the object streamer.
-    TargetRegistry::RegisterMCObjectStreamer(*T, createMCStreamer);
+    TargetRegistry::RegisterCOFFStreamer(*T, createX86WinCOFFStreamer);
 
     // Register the MCInstPrinter.
     TargetRegistry::RegisterMCInstPrinter(*T, createX86MCInstPrinter);

lib/Target/X86/MCTargetDesc/X86MCTargetDesc.h

@@ -85,12 +85,12 @@ MCAsmBackend *createX86_32AsmBackend(const Target &T, const MCRegisterInfo &MRI,
 MCAsmBackend *createX86_64AsmBackend(const Target &T, const MCRegisterInfo &MRI,
                                      StringRef TT, StringRef CPU);
 
-/// createX86WinCOFFStreamer - Construct an X86 Windows COFF machine code
+/// Construct an X86 Windows COFF machine code streamer which will generate
-/// streamer which will generate PE/COFF format object files.
+/// PE/COFF format object files.
 ///
 /// Takes ownership of \p AB and \p CE.
 MCStreamer *createX86WinCOFFStreamer(MCContext &C, MCAsmBackend &AB,
-                                     MCCodeEmitter *CE, raw_ostream &OS,
+                                     raw_ostream &OS, MCCodeEmitter *CE,
                                      bool RelaxAll);
 
 /// createX86MachObjectWriter - Construct an X86 Mach-O object writer.

lib/Target/X86/MCTargetDesc/X86WinCOFFStreamer.cpp

@@ -48,13 +48,11 @@ void X86WinCOFFStreamer::FinishImpl() {
 }
 }
 
-namespace llvm {
+MCStreamer *llvm::createX86WinCOFFStreamer(MCContext &C, MCAsmBackend &AB,
-MCStreamer *createX86WinCOFFStreamer(MCContext &C, MCAsmBackend &AB,
+                                           raw_ostream &OS, MCCodeEmitter *CE,
-                                     MCCodeEmitter *CE, raw_ostream &OS,
                                            bool RelaxAll) {
   X86WinCOFFStreamer *S = new X86WinCOFFStreamer(C, AB, CE, OS);
   S->getAssembler().setRelaxAll(RelaxAll);
   return S;
 }
-}