Resurrect RegisterAsmStreamer

[arsenm]

Summary

HSAIL needs to override this to avoid emission of any of the directives the standard MCAsmStreamer tries to emit, most notably anything indicating the start of a section.

[arsenm]

Rebase to remove unrelated context from diff

[• rafael]

To be clear, the idea is to avoid *creating* the sections, no avoiding
printing them, correct?

Ins't all that you need to do is overload (or add an if to) InitSections?

[• rafael]

For what it is worth, WebAssembly seems to manage to just use nullptr:

TextSection = nullptr;
  DataSection = nullptr;
  BSSSection = nullptr;
  ReadOnlySection = nullptr;

[arsenm]

In D11822#219402, @rafael wrote:

To be clear, the idea is to avoid *creating* the sections, no avoiding
printing them, correct?

Yes, although the specific problem is they are printed. We don't have meaningful sections in the text format.

Ins't all that you need to do is overload (or add an if to) InitSections?

Probably, but that would still require a new custom MCAsmStreamer subclass. Essentially all we want out of the MCStreamer is what MCBasicAsmStreamer has in it. Essentially anything other than printing instructions and labels are going to be incorrect.

In D11822#219403, @rafael wrote:

For what it is worth, WebAssembly seems to manage to just use nullptr:

TextSection = nullptr;
  DataSection = nullptr;
  BSSSection = nullptr;
  ReadOnlySection = nullptr;

This was one of the first things I tried and it doesn't work. WebAssembly does current print .text / .data directives.

[arsenm]

ping

include/llvm/Support/TargetRegistry.h

typedef MCStreamer *(*MachOStreamerCtorTy)(MCContext &Ctx, MCAsmBackend &TAB,
                                              raw_pwrite_stream &OS,
                                              MCCodeEmitter *Emitter,
                                              bool RelaxAll,
                                              bool DWARFMustBeAtTheEnd);
   typedef MCStreamer *(*COFFStreamerCtorTy)(MCContext &Ctx, MCAsmBackend &TAB,
                                             raw_pwrite_stream &OS,
                                             MCCodeEmitter *Emitter,
                                             bool RelaxAll);
+  typedef MCStreamer *(*AsmStreamerCtorTy)(MCContext &Ctx,
+                                           std::unique_ptr<formatted_raw_ostream> OS,
+                                           bool IsVerboseAsm,
+                                           bool UseDwarfDirectory,
+                                           MCInstPrinter *InstPrint,
+                                           MCCodeEmitter *CE,
+                                           MCAsmBackend *TAB,
+                                           bool ShowInst);
+
   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)(const Triple &TT,
                                                       MCContext &Ctx);
private:
   /// CodeEmitter, if registered.
   MCCodeEmitterCtorTy MCCodeEmitterCtorFn;
 
   // Construction functions for the various object formats, if registered.
   COFFStreamerCtorTy COFFStreamerCtorFn;
   MachOStreamerCtorTy MachOStreamerCtorFn;
   ELFStreamerCtorTy ELFStreamerCtorFn;
 
+  /// AsmStreamerCtorFn - Construction function for this target's
+  /// AsmStreamer, if registered (default = llvm::createAsmStreamer).
+  AsmStreamerCtorTy AsmStreamerCtorFn;
+
   /// Construction function for this target's null TargetStreamer, if
   /// registered (default = nullptr).
   NullTargetStreamerCtorTy NullTargetStreamerCtorFn;
 
   /// Construction function for this target's asm TargetStreamer, if
   /// 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;
 
   /// MCSymbolizerCtorFn - Construction function for this target's
   /// MCSymbolizer, if registered (default = llvm::createMCSymbolizer)
   MCSymbolizerCtorTy MCSymbolizerCtorFn;
 
 public:
   Target()
       : COFFStreamerCtorFn(nullptr), MachOStreamerCtorFn(nullptr),
-        ELFStreamerCtorFn(nullptr), NullTargetStreamerCtorFn(nullptr),
+        ELFStreamerCtorFn(nullptr), AsmStreamerCtorFn(nullptr),
+        NullTargetStreamerCtorFn(nullptr),
         AsmTargetStreamerCtorFn(nullptr), ObjectTargetStreamerCtorFn(nullptr),
         MCRelocationInfoCtorFn(nullptr), MCSymbolizerCtorFn(nullptr) {}
 
   /// @name Target Information
   /// @{
 
   // getNext - Return the next registered target.
   const Target *getNext() const { return Next; }
public:
   }
 
   MCStreamer *createAsmStreamer(MCContext &Ctx,
                                 std::unique_ptr<formatted_raw_ostream> OS,
                                 bool IsVerboseAsm, bool UseDwarfDirectory,
                                 MCInstPrinter *InstPrint, MCCodeEmitter *CE,
                                 MCAsmBackend *TAB, bool ShowInst) const {
     formatted_raw_ostream &OSRef = *OS;
-    MCStreamer *S = llvm::createAsmStreamer(Ctx, std::move(OS), IsVerboseAsm,
-                                            UseDwarfDirectory, InstPrint, CE,
-                                            TAB, ShowInst);
+
+    MCStreamer *S;
+    if (AsmStreamerCtorFn) {
+      S = AsmStreamerCtorFn(Ctx, std::move(OS), IsVerboseAsm,
+                            UseDwarfDirectory, InstPrint, CE,
+                            TAB, ShowInst);
+    } else {
+      S = llvm::createAsmStreamer(Ctx, std::move(OS), IsVerboseAsm,
+    }
+
     createAsmTargetStreamer(*S, OSRef, InstPrint, IsVerboseAsm);
     return S;
   }
 
   MCTargetStreamer *createAsmTargetStreamer(MCStreamer &S,
                                             formatted_raw_ostream &OS,
                                             MCInstPrinter *InstPrint,
                                             bool IsVerboseAsm) const {
struct TargetRegistry {
   static void RegisterMachOStreamer(Target &T, Target::MachOStreamerCtorTy Fn) {
     T.MachOStreamerCtorFn = Fn;
   }
 
   static void RegisterELFStreamer(Target &T, Target::ELFStreamerCtorTy Fn) {
     T.ELFStreamerCtorFn = Fn;
   }
 
+  /// RegisterAsmStreamer - Register an assembly MCStreamer implementation
+  /// for the given target.
+  ///
+  /// Clients are responsible for ensuring that registration doesn't occur
+  /// while another thread is attempting to access the registry. Typically
+  /// this is done by initializing all targets at program startup.
+  ///
+  /// @param T - The target being registered.
+  /// @param Fn - A function to construct an MCStreamer for the target.
+  static void RegisterAsmStreamer(Target &T, Target::AsmStreamerCtorTy Fn) {
+    T.AsmStreamerCtorFn = Fn;
+  }
+
   static void RegisterNullTargetStreamer(Target &T,
                                          Target::NullTargetStreamerCtorTy Fn) {
     T.NullTargetStreamerCtorFn = Fn;
   }
 
   static void RegisterAsmTargetStreamer(Target &T,
                                         Target::AsmTargetStreamerCtorTy Fn) {
     T.AsmTargetStreamerCtorFn = Fn;