Introduce Target::createNullTargetStreamer and use it from IRObjectFile.

[pcc]

Summary

A null MCTargetStreamer allows IRObjectFile to ignore target-specific
directives. Previously we were crashing.

[• rafael]

With this TargetRegistry::RegisterNullStreamer becomes redundant, no? It will always be llvm::createNullStreamer + the new hook.

If so, please add a FIXME about it.

include/llvm/Support/TargetRegistry.h

465 ↗

(On Diff #20129)

nullptr

[pcc]

With this TargetRegistry::RegisterNullStreamer becomes redundant, no? It will always be llvm::createNullStreamer + the new hook.

If so, please add a FIXME about it.

Correct. It was simple enough to remove the hook though, which I did in r229799.

include/llvm/Support/TargetRegistry.h

465 ↗

(On Diff #20129)

Done

llvm/trunk/include/llvm/Support/TargetRegistry.h

namespace llvm {
   class MCInstrInfo;
   class MCRegisterInfo;
   class MCStreamer;
   class MCSubtargetInfo;
   class MCSymbolizer;
   class MCRelocationInfo;
   class MCTargetAsmParser;
   class MCTargetOptions;
+  class MCTargetStreamer;
   class TargetMachine;
   class TargetOptions;
   class raw_ostream;
   class formatted_raw_ostream;
 
   MCStreamer *createNullStreamer(MCContext &Ctx);
   MCStreamer *createAsmStreamer(MCContext &Ctx, formatted_raw_ostream &OS,
                                 bool isVerboseAsm, bool useDwarfDirectory,
typedef MCStreamer *(*AsmStreamerCtorTy)(MCContext &Ctx,
                                              formatted_raw_ostream &OS,
                                              bool isVerboseAsm,
                                              bool useDwarfDirectory,
                                              MCInstPrinter *InstPrint,
                                              MCCodeEmitter *CE,
                                              MCAsmBackend *TAB,
                                              bool ShowInst);
     typedef MCStreamer *(*NullStreamerCtorTy)(MCContext &Ctx);
+    typedef MCTargetStreamer *(*NullTargetStreamerCtorTy)(MCStreamer &S);
     typedef MCRelocationInfo *(*MCRelocationInfoCtorTy)(StringRef TT,
                                                         MCContext &Ctx);
     typedef MCSymbolizer *(*MCSymbolizerCtorTy)(
         StringRef TT, LLVMOpInfoCallback GetOpInfo,
         LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx,
         std::unique_ptr<MCRelocationInfo> &&RelInfo);
 
   private:
private:
     /// AsmStreamerCtorFn - Construction function for this target's
     /// AsmStreamer, if registered (default = llvm::createAsmStreamer).
     AsmStreamerCtorTy AsmStreamerCtorFn;
 
     /// Construction function for this target's NullStreamer, if registered
     /// (default = llvm::createNullStreamer).
     NullStreamerCtorTy NullStreamerCtorFn;
 
+    /// Construction function for this target's null TargetStreamer, if
+    /// registered (default = nullptr).
+    NullTargetStreamerCtorTy NullTargetStreamerCtorFn;
+
     /// 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:
     }
 
     MCStreamer *createNullStreamer(MCContext &Ctx) const {
       if (NullStreamerCtorFn)
         return NullStreamerCtorFn(Ctx);
       return llvm::createNullStreamer(Ctx);
     }
 
+    MCTargetStreamer *createNullTargetStreamer(MCStreamer &S) const {
+      if (NullTargetStreamerCtorFn)
+        return NullTargetStreamerCtorFn(S);
+      return nullptr;
+    }
+
     /// createMCRelocationInfo - Create a target specific MCRelocationInfo.
     ///
     /// \param TT The target triple.
     /// \param Ctx The target context.
     MCRelocationInfo *
       createMCRelocationInfo(StringRef TT, MCContext &Ctx) const {
       MCRelocationInfoCtorTy Fn = MCRelocationInfoCtorFn
                                       ? MCRelocationInfoCtorFn
struct TargetRegistry {
     static void RegisterAsmStreamer(Target &T, Target::AsmStreamerCtorTy Fn) {
       T.AsmStreamerCtorFn = Fn;
     }
 
     static void RegisterNullStreamer(Target &T, Target::NullStreamerCtorTy Fn) {
       T.NullStreamerCtorFn = Fn;
     }
 
+    static void
+    RegisterNullTargetStreamer(Target &T, Target::NullTargetStreamerCtorTy Fn) {
+      T.NullTargetStreamerCtorFn = Fn;
+    }
+
     /// RegisterMCRelocationInfo - Register an MCRelocationInfo
     /// 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.

llvm/trunk/lib/Object/IRObjectFile.cpp

IRObjectFile::IRObjectFile(MemoryBufferRef Object, std::unique_ptr<Module> Mod)
   std::unique_ptr<MCInstrInfo> MCII(T->createMCInstrInfo());
   if (!MCII)
     return;
 
   MCObjectFileInfo MOFI;
   MCContext MCCtx(MAI.get(), MRI.get(), &MOFI);
   MOFI.InitMCObjectFileInfo(Triple, Reloc::Default, CodeModel::Default, MCCtx);
   std::unique_ptr<RecordStreamer> Streamer(new RecordStreamer(MCCtx));
+  T->createNullTargetStreamer(*Streamer);
 
   std::unique_ptr<MemoryBuffer> Buffer(MemoryBuffer::getMemBuffer(InlineAsm));
   SourceMgr SrcMgr;
   SrcMgr.AddNewSourceBuffer(std::move(Buffer), SMLoc());
   std::unique_ptr<MCAsmParser> Parser(
       createMCAsmParser(SrcMgr, MCCtx, *Streamer, *MAI));
 
   MCTargetOptions MCOptions;

llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp

 }
 
 MCStreamer *createARMNullStreamer(MCContext &Ctx) {
   MCStreamer *S = llvm::createNullStreamer(Ctx);
   new ARMTargetStreamer(*S);
   return S;
 }
 
+MCTargetStreamer *createARMNullTargetStreamer(MCStreamer &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.

llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.h

 class MCContext;
 class MCInstrInfo;
 class MCInstPrinter;
 class MCObjectWriter;
 class MCRegisterInfo;
 class MCSubtargetInfo;
 class MCStreamer;
 class MCRelocationInfo;
+class MCTargetStreamer;
 class StringRef;
 class Target;
 class raw_ostream;
 
 extern Target TheARMLETarget, TheThumbLETarget;
 extern Target TheARMBETarget, TheThumbBETarget;
 
 namespace ARM_MC {
   std::string ParseARMTriple(StringRef TT, StringRef CPU);
 
   /// createARMMCSubtargetInfo - Create a ARM MCSubtargetInfo instance.
   /// This is exposed so Asm parser, etc. do not need to go through
   /// TargetRegistry.
   MCSubtargetInfo *createARMMCSubtargetInfo(StringRef TT, StringRef CPU,
                                             StringRef FS);
 }
 
 MCStreamer *createMCAsmStreamer(MCContext &Ctx, formatted_raw_ostream &OS,
                                 bool isVerboseAsm, bool useDwarfDirectory,
                                 MCInstPrinter *InstPrint, MCCodeEmitter *CE,
                                 MCAsmBackend *TAB, bool ShowInst);
 
 MCStreamer *createARMNullStreamer(MCContext &Ctx);
 
+MCTargetStreamer *createARMNullTargetStreamer(MCStreamer &S);
+
 MCCodeEmitter *createARMLEMCCodeEmitter(const MCInstrInfo &MCII,
                                         const MCRegisterInfo &MRI,
                                         const MCSubtargetInfo &STI,
                                         MCContext &Ctx);
 
 MCCodeEmitter *createARMBEMCCodeEmitter(const MCInstrInfo &MCII,
                                         const MCRegisterInfo &MRI,
                                         const MCSubtargetInfo &STI,

llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.cpp

extern "C" void LLVMInitializeARMTargetMC() {
   TargetRegistry::RegisterAsmStreamer(TheThumbBETarget, createMCAsmStreamer);
 
   // Register the null streamer.
   TargetRegistry::RegisterNullStreamer(TheARMLETarget, createARMNullStreamer);
   TargetRegistry::RegisterNullStreamer(TheARMBETarget, createARMNullStreamer);
   TargetRegistry::RegisterNullStreamer(TheThumbLETarget, createARMNullStreamer);
   TargetRegistry::RegisterNullStreamer(TheThumbBETarget, createARMNullStreamer);
 
+  // Register the null TargetStreamer.
+  TargetRegistry::RegisterNullTargetStreamer(TheARMLETarget,
+                                             createARMNullTargetStreamer);
+  TargetRegistry::RegisterNullTargetStreamer(TheARMBETarget,
+                                             createARMNullTargetStreamer);
+  TargetRegistry::RegisterNullTargetStreamer(TheThumbLETarget,
+                                             createARMNullTargetStreamer);
+  TargetRegistry::RegisterNullTargetStreamer(TheThumbBETarget,
+                                             createARMNullTargetStreamer);
+
   // Register the MCInstPrinter.
   TargetRegistry::RegisterMCInstPrinter(TheARMLETarget, createARMMCInstPrinter);
   TargetRegistry::RegisterMCInstPrinter(TheARMBETarget, createARMMCInstPrinter);
   TargetRegistry::RegisterMCInstPrinter(TheThumbLETarget,
                                         createARMMCInstPrinter);
   TargetRegistry::RegisterMCInstPrinter(TheThumbBETarget,
                                         createARMMCInstPrinter);
 

llvm/trunk/test/LTO/ARM/inline-asm.ll

+; Check that we don't crash on target-specific inline asm directives.
+;
+; RUN: llvm-as < %s > %t
+; RUN: llvm-lto -o /dev/null %t -mcpu armv4t
+
+target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
+target triple = "armv4t-unknown-linux"
+
+module asm ".fnstart"