LCOV - code coverage report
Current view: top level - include/llvm/Support - TargetRegistry.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 99 104 95.2 %
Date: 2018-07-13 00:08:38 Functions: 164 167 98.2 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- Support/TargetRegistry.h - Target Registration -----------*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This file exposes the TargetRegistry interface, which tools can use to access
      11             : // the appropriate target specific classes (TargetMachine, AsmPrinter, etc.)
      12             : // which have been registered.
      13             : //
      14             : // Target specific class implementations should register themselves using the
      15             : // appropriate TargetRegistry interfaces.
      16             : //
      17             : //===----------------------------------------------------------------------===//
      18             : 
      19             : #ifndef LLVM_SUPPORT_TARGETREGISTRY_H
      20             : #define LLVM_SUPPORT_TARGETREGISTRY_H
      21             : 
      22             : #include "llvm-c/DisassemblerTypes.h"
      23             : #include "llvm/ADT/Optional.h"
      24             : #include "llvm/ADT/StringRef.h"
      25             : #include "llvm/ADT/Triple.h"
      26             : #include "llvm/ADT/iterator_range.h"
      27             : #include "llvm/Support/CodeGen.h"
      28             : #include "llvm/Support/ErrorHandling.h"
      29             : #include "llvm/Support/FormattedStream.h"
      30             : #include <algorithm>
      31             : #include <cassert>
      32             : #include <cstddef>
      33             : #include <iterator>
      34             : #include <memory>
      35             : #include <string>
      36             : 
      37             : namespace llvm {
      38             : 
      39             : class AsmPrinter;
      40             : class MCAsmBackend;
      41             : class MCAsmInfo;
      42             : class MCAsmParser;
      43             : class MCCodeEmitter;
      44             : class MCContext;
      45             : class MCDisassembler;
      46             : class MCInstPrinter;
      47             : class MCInstrAnalysis;
      48             : class MCInstrInfo;
      49             : class MCObjectWriter;
      50             : class MCRegisterInfo;
      51             : class MCRelocationInfo;
      52             : class MCStreamer;
      53             : class MCSubtargetInfo;
      54             : class MCSymbolizer;
      55             : class MCTargetAsmParser;
      56             : class MCTargetOptions;
      57             : class MCTargetStreamer;
      58             : class raw_ostream;
      59             : class raw_pwrite_stream;
      60             : class TargetMachine;
      61             : class TargetOptions;
      62             : 
      63             : MCStreamer *createNullStreamer(MCContext &Ctx);
      64             : // Takes ownership of \p TAB and \p CE.
      65             : 
      66             : /// Create a machine code streamer which will print out assembly for the native
      67             : /// target, suitable for compiling with a native assembler.
      68             : ///
      69             : /// \param InstPrint - If given, the instruction printer to use. If not given
      70             : /// the MCInst representation will be printed.  This method takes ownership of
      71             : /// InstPrint.
      72             : ///
      73             : /// \param CE - If given, a code emitter to use to show the instruction
      74             : /// encoding inline with the assembly. This method takes ownership of \p CE.
      75             : ///
      76             : /// \param TAB - If given, a target asm backend to use to show the fixup
      77             : /// information in conjunction with encoding information. This method takes
      78             : /// ownership of \p TAB.
      79             : ///
      80             : /// \param ShowInst - Whether to show the MCInst representation inline with
      81             : /// the assembly.
      82             : MCStreamer *
      83             : createAsmStreamer(MCContext &Ctx, std::unique_ptr<formatted_raw_ostream> OS,
      84             :                   bool isVerboseAsm, bool useDwarfDirectory,
      85             :                   MCInstPrinter *InstPrint, std::unique_ptr<MCCodeEmitter> &&CE,
      86             :                   std::unique_ptr<MCAsmBackend> &&TAB, bool ShowInst);
      87             : 
      88             : MCStreamer *createELFStreamer(MCContext &Ctx,
      89             :                               std::unique_ptr<MCAsmBackend> &&TAB,
      90             :                               std::unique_ptr<MCObjectWriter> &&OW,
      91             :                               std::unique_ptr<MCCodeEmitter> &&CE,
      92             :                               bool RelaxAll);
      93             : MCStreamer *createMachOStreamer(MCContext &Ctx,
      94             :                                 std::unique_ptr<MCAsmBackend> &&TAB,
      95             :                                 std::unique_ptr<MCObjectWriter> &&OW,
      96             :                                 std::unique_ptr<MCCodeEmitter> &&CE,
      97             :                                 bool RelaxAll, bool DWARFMustBeAtTheEnd,
      98             :                                 bool LabelSections = false);
      99             : MCStreamer *createWasmStreamer(MCContext &Ctx,
     100             :                                std::unique_ptr<MCAsmBackend> &&TAB,
     101             :                                std::unique_ptr<MCObjectWriter> &&OW,
     102             :                                std::unique_ptr<MCCodeEmitter> &&CE,
     103             :                                bool RelaxAll);
     104             : 
     105             : MCRelocationInfo *createMCRelocationInfo(const Triple &TT, MCContext &Ctx);
     106             : 
     107             : MCSymbolizer *createMCSymbolizer(const Triple &TT, LLVMOpInfoCallback GetOpInfo,
     108             :                                  LLVMSymbolLookupCallback SymbolLookUp,
     109             :                                  void *DisInfo, MCContext *Ctx,
     110             :                                  std::unique_ptr<MCRelocationInfo> &&RelInfo);
     111             : 
     112             : /// Target - Wrapper for Target specific information.
     113             : ///
     114             : /// For registration purposes, this is a POD type so that targets can be
     115             : /// registered without the use of static constructors.
     116             : ///
     117             : /// Targets should implement a single global instance of this class (which
     118             : /// will be zero initialized), and pass that instance to the TargetRegistry as
     119             : /// part of their initialization.
     120             : class Target {
     121             : public:
     122             :   friend struct TargetRegistry;
     123             : 
     124             :   using ArchMatchFnTy = bool (*)(Triple::ArchType Arch);
     125             : 
     126             :   using MCAsmInfoCtorFnTy = MCAsmInfo *(*)(const MCRegisterInfo &MRI,
     127             :                                            const Triple &TT);
     128             :   using MCInstrInfoCtorFnTy = MCInstrInfo *(*)();
     129             :   using MCInstrAnalysisCtorFnTy = MCInstrAnalysis *(*)(const MCInstrInfo *Info);
     130             :   using MCRegInfoCtorFnTy = MCRegisterInfo *(*)(const Triple &TT);
     131             :   using MCSubtargetInfoCtorFnTy = MCSubtargetInfo *(*)(const Triple &TT,
     132             :                                                        StringRef CPU,
     133             :                                                        StringRef Features);
     134             :   using TargetMachineCtorTy = TargetMachine
     135             :       *(*)(const Target &T, const Triple &TT, StringRef CPU, StringRef Features,
     136             :            const TargetOptions &Options, Optional<Reloc::Model> RM,
     137             :            Optional<CodeModel::Model> CM, CodeGenOpt::Level OL, bool JIT);
     138             :   // If it weren't for layering issues (this header is in llvm/Support, but
     139             :   // depends on MC?) this should take the Streamer by value rather than rvalue
     140             :   // reference.
     141             :   using AsmPrinterCtorTy = AsmPrinter *(*)(
     142             :       TargetMachine &TM, std::unique_ptr<MCStreamer> &&Streamer);
     143             :   using MCAsmBackendCtorTy = MCAsmBackend *(*)(const Target &T,
     144             :                                                const MCSubtargetInfo &STI,
     145             :                                                const MCRegisterInfo &MRI,
     146             :                                                const MCTargetOptions &Options);
     147             :   using MCAsmParserCtorTy = MCTargetAsmParser *(*)(
     148             :       const MCSubtargetInfo &STI, MCAsmParser &P, const MCInstrInfo &MII,
     149             :       const MCTargetOptions &Options);
     150             :   using MCDisassemblerCtorTy = MCDisassembler *(*)(const Target &T,
     151             :                                                    const MCSubtargetInfo &STI,
     152             :                                                    MCContext &Ctx);
     153             :   using MCInstPrinterCtorTy = MCInstPrinter *(*)(const Triple &T,
     154             :                                                  unsigned SyntaxVariant,
     155             :                                                  const MCAsmInfo &MAI,
     156             :                                                  const MCInstrInfo &MII,
     157             :                                                  const MCRegisterInfo &MRI);
     158             :   using MCCodeEmitterCtorTy = MCCodeEmitter *(*)(const MCInstrInfo &II,
     159             :                                                  const MCRegisterInfo &MRI,
     160             :                                                  MCContext &Ctx);
     161             :   using ELFStreamerCtorTy =
     162             :       MCStreamer *(*)(const Triple &T, MCContext &Ctx,
     163             :                       std::unique_ptr<MCAsmBackend> &&TAB,
     164             :                       std::unique_ptr<MCObjectWriter> &&OW,
     165             :                       std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll);
     166             :   using MachOStreamerCtorTy =
     167             :       MCStreamer *(*)(MCContext &Ctx, std::unique_ptr<MCAsmBackend> &&TAB,
     168             :                       std::unique_ptr<MCObjectWriter> &&OW,
     169             :                       std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll,
     170             :                       bool DWARFMustBeAtTheEnd);
     171             :   using COFFStreamerCtorTy =
     172             :       MCStreamer *(*)(MCContext &Ctx, std::unique_ptr<MCAsmBackend> &&TAB,
     173             :                       std::unique_ptr<MCObjectWriter> &&OW,
     174             :                       std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll,
     175             :                       bool IncrementalLinkerCompatible);
     176             :   using WasmStreamerCtorTy =
     177             :       MCStreamer *(*)(const Triple &T, MCContext &Ctx,
     178             :                       std::unique_ptr<MCAsmBackend> &&TAB,
     179             :                       std::unique_ptr<MCObjectWriter> &&OW,
     180             :                       std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll);
     181             :   using NullTargetStreamerCtorTy = MCTargetStreamer *(*)(MCStreamer &S);
     182             :   using AsmTargetStreamerCtorTy = MCTargetStreamer *(*)(
     183             :       MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint,
     184             :       bool IsVerboseAsm);
     185             :   using ObjectTargetStreamerCtorTy = MCTargetStreamer *(*)(
     186             :       MCStreamer &S, const MCSubtargetInfo &STI);
     187             :   using MCRelocationInfoCtorTy = MCRelocationInfo *(*)(const Triple &TT,
     188             :                                                        MCContext &Ctx);
     189             :   using MCSymbolizerCtorTy = MCSymbolizer *(*)(
     190             :       const Triple &TT, LLVMOpInfoCallback GetOpInfo,
     191             :       LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx,
     192             :       std::unique_ptr<MCRelocationInfo> &&RelInfo);
     193             : 
     194             : private:
     195             :   /// Next - The next registered target in the linked list, maintained by the
     196             :   /// TargetRegistry.
     197             :   Target *Next;
     198             : 
     199             :   /// The target function for checking if an architecture is supported.
     200             :   ArchMatchFnTy ArchMatchFn;
     201             : 
     202             :   /// Name - The target name.
     203             :   const char *Name;
     204             : 
     205             :   /// ShortDesc - A short description of the target.
     206             :   const char *ShortDesc;
     207             : 
     208             :   /// BackendName - The name of the backend implementation. This must match the
     209             :   /// name of the 'def X : Target ...' in TableGen.
     210             :   const char *BackendName;
     211             : 
     212             :   /// HasJIT - Whether this target supports the JIT.
     213             :   bool HasJIT;
     214             : 
     215             :   /// MCAsmInfoCtorFn - Constructor function for this target's MCAsmInfo, if
     216             :   /// registered.
     217             :   MCAsmInfoCtorFnTy MCAsmInfoCtorFn;
     218             : 
     219             :   /// MCInstrInfoCtorFn - Constructor function for this target's MCInstrInfo,
     220             :   /// if registered.
     221             :   MCInstrInfoCtorFnTy MCInstrInfoCtorFn;
     222             : 
     223             :   /// MCInstrAnalysisCtorFn - Constructor function for this target's
     224             :   /// MCInstrAnalysis, if registered.
     225             :   MCInstrAnalysisCtorFnTy MCInstrAnalysisCtorFn;
     226             : 
     227             :   /// MCRegInfoCtorFn - Constructor function for this target's MCRegisterInfo,
     228             :   /// if registered.
     229             :   MCRegInfoCtorFnTy MCRegInfoCtorFn;
     230             : 
     231             :   /// MCSubtargetInfoCtorFn - Constructor function for this target's
     232             :   /// MCSubtargetInfo, if registered.
     233             :   MCSubtargetInfoCtorFnTy MCSubtargetInfoCtorFn;
     234             : 
     235             :   /// TargetMachineCtorFn - Construction function for this target's
     236             :   /// TargetMachine, if registered.
     237             :   TargetMachineCtorTy TargetMachineCtorFn;
     238             : 
     239             :   /// MCAsmBackendCtorFn - Construction function for this target's
     240             :   /// MCAsmBackend, if registered.
     241             :   MCAsmBackendCtorTy MCAsmBackendCtorFn;
     242             : 
     243             :   /// MCAsmParserCtorFn - Construction function for this target's
     244             :   /// MCTargetAsmParser, if registered.
     245             :   MCAsmParserCtorTy MCAsmParserCtorFn;
     246             : 
     247             :   /// AsmPrinterCtorFn - Construction function for this target's AsmPrinter,
     248             :   /// if registered.
     249             :   AsmPrinterCtorTy AsmPrinterCtorFn;
     250             : 
     251             :   /// MCDisassemblerCtorFn - Construction function for this target's
     252             :   /// MCDisassembler, if registered.
     253             :   MCDisassemblerCtorTy MCDisassemblerCtorFn;
     254             : 
     255             :   /// MCInstPrinterCtorFn - Construction function for this target's
     256             :   /// MCInstPrinter, if registered.
     257             :   MCInstPrinterCtorTy MCInstPrinterCtorFn;
     258             : 
     259             :   /// MCCodeEmitterCtorFn - Construction function for this target's
     260             :   /// CodeEmitter, if registered.
     261             :   MCCodeEmitterCtorTy MCCodeEmitterCtorFn;
     262             : 
     263             :   // Construction functions for the various object formats, if registered.
     264             :   COFFStreamerCtorTy COFFStreamerCtorFn = nullptr;
     265             :   MachOStreamerCtorTy MachOStreamerCtorFn = nullptr;
     266             :   ELFStreamerCtorTy ELFStreamerCtorFn = nullptr;
     267             :   WasmStreamerCtorTy WasmStreamerCtorFn = nullptr;
     268             : 
     269             :   /// Construction function for this target's null TargetStreamer, if
     270             :   /// registered (default = nullptr).
     271             :   NullTargetStreamerCtorTy NullTargetStreamerCtorFn = nullptr;
     272             : 
     273             :   /// Construction function for this target's asm TargetStreamer, if
     274             :   /// registered (default = nullptr).
     275             :   AsmTargetStreamerCtorTy AsmTargetStreamerCtorFn = nullptr;
     276             : 
     277             :   /// Construction function for this target's obj TargetStreamer, if
     278             :   /// registered (default = nullptr).
     279             :   ObjectTargetStreamerCtorTy ObjectTargetStreamerCtorFn = nullptr;
     280             : 
     281             :   /// MCRelocationInfoCtorFn - Construction function for this target's
     282             :   /// MCRelocationInfo, if registered (default = llvm::createMCRelocationInfo)
     283             :   MCRelocationInfoCtorTy MCRelocationInfoCtorFn = nullptr;
     284             : 
     285             :   /// MCSymbolizerCtorFn - Construction function for this target's
     286             :   /// MCSymbolizer, if registered (default = llvm::createMCSymbolizer)
     287             :   MCSymbolizerCtorTy MCSymbolizerCtorFn = nullptr;
     288             : 
     289             : public:
     290     2888742 :   Target() = default;
     291             : 
     292             :   /// @name Target Information
     293             :   /// @{
     294             : 
     295             :   // getNext - Return the next registered target.
     296             :   const Target *getNext() const { return Next; }
     297             : 
     298             :   /// getName - Get the target name.
     299             :   const char *getName() const { return Name; }
     300             : 
     301             :   /// getShortDescription - Get a short description of the target.
     302             :   const char *getShortDescription() const { return ShortDesc; }
     303             : 
     304             :   /// getBackendName - Get the backend name.
     305             :   const char *getBackendName() const { return BackendName; }
     306             : 
     307             :   /// @}
     308             :   /// @name Feature Predicates
     309             :   /// @{
     310             : 
     311             :   /// hasJIT - Check if this targets supports the just-in-time compilation.
     312             :   bool hasJIT() const { return HasJIT; }
     313             : 
     314             :   /// hasTargetMachine - Check if this target supports code generation.
     315           0 :   bool hasTargetMachine() const { return TargetMachineCtorFn != nullptr; }
     316             : 
     317             :   /// hasMCAsmBackend - Check if this target supports .o generation.
     318           0 :   bool hasMCAsmBackend() const { return MCAsmBackendCtorFn != nullptr; }
     319             : 
     320             :   /// hasMCAsmParser - Check if this target supports assembly parsing.
     321             :   bool hasMCAsmParser() const { return MCAsmParserCtorFn != nullptr; }
     322             : 
     323             :   /// @}
     324             :   /// @name Feature Constructors
     325             :   /// @{
     326             : 
     327             :   /// createMCAsmInfo - Create a MCAsmInfo implementation for the specified
     328             :   /// target triple.
     329             :   ///
     330             :   /// \param TheTriple This argument is used to determine the target machine
     331             :   /// feature set; it should always be provided. Generally this should be
     332             :   /// either the target triple from the module, or the target triple of the
     333             :   /// host if that does not exist.
     334       45345 :   MCAsmInfo *createMCAsmInfo(const MCRegisterInfo &MRI,
     335             :                              StringRef TheTriple) const {
     336       45345 :     if (!MCAsmInfoCtorFn)
     337             :       return nullptr;
     338       90690 :     return MCAsmInfoCtorFn(MRI, Triple(TheTriple));
     339             :   }
     340             : 
     341             :   /// createMCInstrInfo - Create a MCInstrInfo implementation.
     342             :   ///
     343             :   MCInstrInfo *createMCInstrInfo() const {
     344       56625 :     if (!MCInstrInfoCtorFn)
     345             :       return nullptr;
     346       56625 :     return MCInstrInfoCtorFn();
     347             :   }
     348             : 
     349             :   /// createMCInstrAnalysis - Create a MCInstrAnalysis implementation.
     350             :   ///
     351             :   MCInstrAnalysis *createMCInstrAnalysis(const MCInstrInfo *Info) const {
     352        1625 :     if (!MCInstrAnalysisCtorFn)
     353             :       return nullptr;
     354        1569 :     return MCInstrAnalysisCtorFn(Info);
     355             :   }
     356             : 
     357             :   /// createMCRegInfo - Create a MCRegisterInfo implementation.
     358             :   ///
     359       46030 :   MCRegisterInfo *createMCRegInfo(StringRef TT) const {
     360       46030 :     if (!MCRegInfoCtorFn)
     361             :       return nullptr;
     362       92060 :     return MCRegInfoCtorFn(Triple(TT));
     363             :   }
     364             : 
     365             :   /// createMCSubtargetInfo - Create a MCSubtargetInfo implementation.
     366             :   ///
     367             :   /// \param TheTriple This argument is used to determine the target machine
     368             :   /// feature set; it should always be provided. Generally this should be
     369             :   /// either the target triple from the module, or the target triple of the
     370             :   /// host if that does not exist.
     371             :   /// \param CPU This specifies the name of the target CPU.
     372             :   /// \param Features This specifies the string representation of the
     373             :   /// additional target features.
     374       45011 :   MCSubtargetInfo *createMCSubtargetInfo(StringRef TheTriple, StringRef CPU,
     375             :                                          StringRef Features) const {
     376       45011 :     if (!MCSubtargetInfoCtorFn)
     377             :       return nullptr;
     378       90022 :     return MCSubtargetInfoCtorFn(Triple(TheTriple), CPU, Features);
     379             :   }
     380             : 
     381             :   /// createTargetMachine - Create a target specific machine implementation
     382             :   /// for the specified \p Triple.
     383             :   ///
     384             :   /// \param TT This argument is used to determine the target machine
     385             :   /// feature set; it should always be provided. Generally this should be
     386             :   /// either the target triple from the module, or the target triple of the
     387             :   /// host if that does not exist.
     388       35218 :   TargetMachine *createTargetMachine(StringRef TT, StringRef CPU,
     389             :                                      StringRef Features,
     390             :                                      const TargetOptions &Options,
     391             :                                      Optional<Reloc::Model> RM,
     392             :                                      Optional<CodeModel::Model> CM = None,
     393             :                                      CodeGenOpt::Level OL = CodeGenOpt::Default,
     394             :                                      bool JIT = false) const {
     395       35218 :     if (!TargetMachineCtorFn)
     396             :       return nullptr;
     397      105641 :     return TargetMachineCtorFn(*this, Triple(TT), CPU, Features, Options, RM,
     398       35218 :                                CM, OL, JIT);
     399             :   }
     400             : 
     401             :   /// createMCAsmBackend - Create a target specific assembly parser.
     402             :   MCAsmBackend *createMCAsmBackend(const MCSubtargetInfo &STI,
     403             :                                    const MCRegisterInfo &MRI,
     404             :                                    const MCTargetOptions &Options) const {
     405       29434 :     if (!MCAsmBackendCtorFn)
     406             :       return nullptr;
     407       29060 :     return MCAsmBackendCtorFn(*this, STI, MRI, Options);
     408             :   }
     409             : 
     410             :   /// createMCAsmParser - Create a target specific assembly parser.
     411             :   ///
     412             :   /// \param Parser The target independent parser implementation to use for
     413             :   /// parsing and lexing.
     414             :   MCTargetAsmParser *createMCAsmParser(const MCSubtargetInfo &STI,
     415             :                                        MCAsmParser &Parser,
     416             :                                        const MCInstrInfo &MII,
     417             :                                        const MCTargetOptions &Options) const {
     418       17442 :     if (!MCAsmParserCtorFn)
     419             :       return nullptr;
     420       17442 :     return MCAsmParserCtorFn(STI, Parser, MII, Options);
     421             :   }
     422             : 
     423             :   /// createAsmPrinter - Create a target specific assembly printer pass.  This
     424             :   /// takes ownership of the MCStreamer object.
     425             :   AsmPrinter *createAsmPrinter(TargetMachine &TM,
     426             :                                std::unique_ptr<MCStreamer> &&Streamer) const {
     427       22203 :     if (!AsmPrinterCtorFn)
     428             :       return nullptr;
     429       22203 :     return AsmPrinterCtorFn(TM, std::move(Streamer));
     430             :   }
     431             : 
     432             :   MCDisassembler *createMCDisassembler(const MCSubtargetInfo &STI,
     433             :                                        MCContext &Ctx) const {
     434        2097 :     if (!MCDisassemblerCtorFn)
     435             :       return nullptr;
     436        2097 :     return MCDisassemblerCtorFn(*this, STI, Ctx);
     437             :   }
     438             : 
     439             :   MCInstPrinter *createMCInstPrinter(const Triple &T, unsigned SyntaxVariant,
     440             :                                      const MCAsmInfo &MAI,
     441             :                                      const MCInstrInfo &MII,
     442             :                                      const MCRegisterInfo &MRI) const {
     443       23955 :     if (!MCInstPrinterCtorFn)
     444             :       return nullptr;
     445       23955 :     return MCInstPrinterCtorFn(T, SyntaxVariant, MAI, MII, MRI);
     446             :   }
     447             : 
     448             :   /// createMCCodeEmitter - Create a target specific code emitter.
     449             :   MCCodeEmitter *createMCCodeEmitter(const MCInstrInfo &II,
     450             :                                      const MCRegisterInfo &MRI,
     451             :                                      MCContext &Ctx) const {
     452      144977 :     if (!MCCodeEmitterCtorFn)
     453             :       return nullptr;
     454      144977 :     return MCCodeEmitterCtorFn(II, MRI, Ctx);
     455             :   }
     456             : 
     457             :   /// Create a target specific MCStreamer.
     458             :   ///
     459             :   /// \param T The target triple.
     460             :   /// \param Ctx The target context.
     461             :   /// \param TAB The target assembler backend object. Takes ownership.
     462             :   /// \param OW The stream object.
     463             :   /// \param Emitter The target independent assembler object.Takes ownership.
     464             :   /// \param RelaxAll Relax all fixups?
     465        7563 :   MCStreamer *createMCObjectStreamer(const Triple &T, MCContext &Ctx,
     466             :                                      std::unique_ptr<MCAsmBackend> &&TAB,
     467             :                                      std::unique_ptr<MCObjectWriter> &&OW,
     468             :                                      std::unique_ptr<MCCodeEmitter> &&Emitter,
     469             :                                      const MCSubtargetInfo &STI, bool RelaxAll,
     470             :                                      bool IncrementalLinkerCompatible,
     471             :                                      bool DWARFMustBeAtTheEnd) const {
     472             :     MCStreamer *S;
     473        7563 :     switch (T.getObjectFormat()) {
     474           0 :     default:
     475           0 :       llvm_unreachable("Unknown object format");
     476         386 :     case Triple::COFF:
     477             :       assert(T.isOSWindows() && "only Windows COFF is supported");
     478         386 :       S = COFFStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),
     479             :                              std::move(Emitter), RelaxAll,
     480             :                              IncrementalLinkerCompatible);
     481         386 :       break;
     482         653 :     case Triple::MachO:
     483         653 :       if (MachOStreamerCtorFn)
     484         147 :         S = MachOStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),
     485             :                                 std::move(Emitter), RelaxAll,
     486             :                                 DWARFMustBeAtTheEnd);
     487             :       else
     488         506 :         S = createMachOStreamer(Ctx, std::move(TAB), std::move(OW),
     489             :                                 std::move(Emitter), RelaxAll,
     490             :                                 DWARFMustBeAtTheEnd);
     491             :       break;
     492        6385 :     case Triple::ELF:
     493        6385 :       if (ELFStreamerCtorFn)
     494        1821 :         S = ELFStreamerCtorFn(T, Ctx, std::move(TAB), std::move(OW),
     495             :                               std::move(Emitter), RelaxAll);
     496             :       else
     497        4564 :         S = createELFStreamer(Ctx, std::move(TAB), std::move(OW),
     498             :                               std::move(Emitter), RelaxAll);
     499             :       break;
     500         139 :     case Triple::Wasm:
     501         139 :       if (WasmStreamerCtorFn)
     502           0 :         S = WasmStreamerCtorFn(T, Ctx, std::move(TAB), std::move(OW),
     503             :                                std::move(Emitter), RelaxAll);
     504             :       else
     505         139 :         S = createWasmStreamer(Ctx, std::move(TAB), std::move(OW),
     506             :                                std::move(Emitter), RelaxAll);
     507             :       break;
     508             :     }
     509        7563 :     if (ObjectTargetStreamerCtorFn)
     510        7535 :       ObjectTargetStreamerCtorFn(*S, STI);
     511        7563 :     return S;
     512             :   }
     513             : 
     514       21871 :   MCStreamer *createAsmStreamer(MCContext &Ctx,
     515             :                                 std::unique_ptr<formatted_raw_ostream> OS,
     516             :                                 bool IsVerboseAsm, bool UseDwarfDirectory,
     517             :                                 MCInstPrinter *InstPrint,
     518             :                                 std::unique_ptr<MCCodeEmitter> &&CE,
     519             :                                 std::unique_ptr<MCAsmBackend> &&TAB,
     520             :                                 bool ShowInst) const {
     521             :     formatted_raw_ostream &OSRef = *OS;
     522       43742 :     MCStreamer *S = llvm::createAsmStreamer(
     523             :         Ctx, std::move(OS), IsVerboseAsm, UseDwarfDirectory, InstPrint,
     524       21871 :         std::move(CE), std::move(TAB), ShowInst);
     525             :     createAsmTargetStreamer(*S, OSRef, InstPrint, IsVerboseAsm);
     526       21871 :     return S;
     527             :   }
     528             : 
     529             :   MCTargetStreamer *createAsmTargetStreamer(MCStreamer &S,
     530             :                                             formatted_raw_ostream &OS,
     531             :                                             MCInstPrinter *InstPrint,
     532             :                                             bool IsVerboseAsm) const {
     533       21871 :     if (AsmTargetStreamerCtorFn)
     534       20558 :       return AsmTargetStreamerCtorFn(S, OS, InstPrint, IsVerboseAsm);
     535             :     return nullptr;
     536             :   }
     537             : 
     538             :   MCStreamer *createNullStreamer(MCContext &Ctx) const {
     539          16 :     MCStreamer *S = llvm::createNullStreamer(Ctx);
     540          16 :     createNullTargetStreamer(*S);
     541             :     return S;
     542             :   }
     543             : 
     544             :   MCTargetStreamer *createNullTargetStreamer(MCStreamer &S) const {
     545         114 :     if (NullTargetStreamerCtorFn)
     546           5 :       return NullTargetStreamerCtorFn(S);
     547             :     return nullptr;
     548             :   }
     549             : 
     550             :   /// createMCRelocationInfo - Create a target specific MCRelocationInfo.
     551             :   ///
     552             :   /// \param TT The target triple.
     553             :   /// \param Ctx The target context.
     554         225 :   MCRelocationInfo *createMCRelocationInfo(StringRef TT, MCContext &Ctx) const {
     555         225 :     MCRelocationInfoCtorTy Fn = MCRelocationInfoCtorFn
     556         225 :                                     ? MCRelocationInfoCtorFn
     557             :                                     : llvm::createMCRelocationInfo;
     558         450 :     return Fn(Triple(TT), Ctx);
     559             :   }
     560             : 
     561             :   /// createMCSymbolizer - Create a target specific MCSymbolizer.
     562             :   ///
     563             :   /// \param TT The target triple.
     564             :   /// \param GetOpInfo The function to get the symbolic information for
     565             :   /// operands.
     566             :   /// \param SymbolLookUp The function to lookup a symbol name.
     567             :   /// \param DisInfo The pointer to the block of symbolic information for above
     568             :   /// call
     569             :   /// back.
     570             :   /// \param Ctx The target context.
     571             :   /// \param RelInfo The relocation information for this target. Takes
     572             :   /// ownership.
     573             :   MCSymbolizer *
     574         225 :   createMCSymbolizer(StringRef TT, LLVMOpInfoCallback GetOpInfo,
     575             :                      LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo,
     576             :                      MCContext *Ctx,
     577             :                      std::unique_ptr<MCRelocationInfo> &&RelInfo) const {
     578             :     MCSymbolizerCtorTy Fn =
     579         225 :         MCSymbolizerCtorFn ? MCSymbolizerCtorFn : llvm::createMCSymbolizer;
     580         450 :     return Fn(Triple(TT), GetOpInfo, SymbolLookUp, DisInfo, Ctx,
     581         450 :               std::move(RelInfo));
     582             :   }
     583             : 
     584             :   /// @}
     585             : };
     586             : 
     587             : /// TargetRegistry - Generic interface to target specific features.
     588             : struct TargetRegistry {
     589             :   // FIXME: Make this a namespace, probably just move all the Register*
     590             :   // functions into Target (currently they all just set members on the Target
     591             :   // anyway, and Target friends this class so those functions can...
     592             :   // function).
     593             :   TargetRegistry() = delete;
     594             : 
     595             :   class iterator
     596             :       : public std::iterator<std::forward_iterator_tag, Target, ptrdiff_t> {
     597             :     friend struct TargetRegistry;
     598             : 
     599             :     const Target *Current = nullptr;
     600             : 
     601             :     explicit iterator(Target *T) : Current(T) {}
     602             : 
     603             :   public:
     604             :     iterator() = default;
     605             : 
     606             :     bool operator==(const iterator &x) const { return Current == x.Current; }
     607             :     bool operator!=(const iterator &x) const { return !operator==(x); }
     608             : 
     609             :     // Iterator traversal: forward iteration only
     610             :     iterator &operator++() { // Preincrement
     611             :       assert(Current && "Cannot increment end iterator!");
     612     1470019 :       Current = Current->getNext();
     613             :       return *this;
     614             :     }
     615             :     iterator operator++(int) { // Postincrement
     616             :       iterator tmp = *this;
     617             :       ++*this;
     618             :       return tmp;
     619             :     }
     620             : 
     621             :     const Target &operator*() const {
     622             :       assert(Current && "Cannot dereference end iterator!");
     623             :       return *Current;
     624             :     }
     625             : 
     626             :     const Target *operator->() const { return &operator*(); }
     627             :   };
     628             : 
     629             :   /// printRegisteredTargetsForVersion - Print the registered targets
     630             :   /// appropriately for inclusion in a tool's version output.
     631             :   static void printRegisteredTargetsForVersion(raw_ostream &OS);
     632             : 
     633             :   /// @name Registry Access
     634             :   /// @{
     635             : 
     636             :   static iterator_range<iterator> targets();
     637             : 
     638             :   /// lookupTarget - Lookup a target based on a target triple.
     639             :   ///
     640             :   /// \param Triple - The triple to use for finding a target.
     641             :   /// \param Error - On failure, an error string describing why no target was
     642             :   /// found.
     643             :   static const Target *lookupTarget(const std::string &Triple,
     644             :                                     std::string &Error);
     645             : 
     646             :   /// lookupTarget - Lookup a target based on an architecture name
     647             :   /// and a target triple.  If the architecture name is non-empty,
     648             :   /// then the lookup is done by architecture.  Otherwise, the target
     649             :   /// triple is used.
     650             :   ///
     651             :   /// \param ArchName - The architecture to use for finding a target.
     652             :   /// \param TheTriple - The triple to use for finding a target.  The
     653             :   /// triple is updated with canonical architecture name if a lookup
     654             :   /// by architecture is done.
     655             :   /// \param Error - On failure, an error string describing why no target was
     656             :   /// found.
     657             :   static const Target *lookupTarget(const std::string &ArchName,
     658             :                                     Triple &TheTriple, std::string &Error);
     659             : 
     660             :   /// @}
     661             :   /// @name Target Registration
     662             :   /// @{
     663             : 
     664             :   /// RegisterTarget - Register the given target. Attempts to register a
     665             :   /// target which has already been registered will be ignored.
     666             :   ///
     667             :   /// Clients are responsible for ensuring that registration doesn't occur
     668             :   /// while another thread is attempting to access the registry. Typically
     669             :   /// this is done by initializing all targets at program startup.
     670             :   ///
     671             :   /// @param T - The target being registered.
     672             :   /// @param Name - The target name. This should be a static string.
     673             :   /// @param ShortDesc - A short target description. This should be a static
     674             :   /// string.
     675             :   /// @param BackendName - The name of the backend. This should be a static
     676             :   /// string that is the same for all targets that share a backend
     677             :   /// implementation and must match the name used in the 'def X : Target ...' in
     678             :   /// TableGen.
     679             :   /// @param ArchMatchFn - The arch match checking function for this target.
     680             :   /// @param HasJIT - Whether the target supports JIT code
     681             :   /// generation.
     682             :   static void RegisterTarget(Target &T, const char *Name, const char *ShortDesc,
     683             :                              const char *BackendName,
     684             :                              Target::ArchMatchFnTy ArchMatchFn,
     685             :                              bool HasJIT = false);
     686             : 
     687             :   /// RegisterMCAsmInfo - Register a MCAsmInfo implementation for the
     688             :   /// given target.
     689             :   ///
     690             :   /// Clients are responsible for ensuring that registration doesn't occur
     691             :   /// while another thread is attempting to access the registry. Typically
     692             :   /// this is done by initializing all targets at program startup.
     693             :   ///
     694             :   /// @param T - The target being registered.
     695             :   /// @param Fn - A function to construct a MCAsmInfo for the target.
     696             :   static void RegisterMCAsmInfo(Target &T, Target::MCAsmInfoCtorFnTy Fn) {
     697     2587978 :     T.MCAsmInfoCtorFn = Fn;
     698             :   }
     699             : 
     700             :   /// RegisterMCInstrInfo - Register a MCInstrInfo implementation for the
     701             :   /// given target.
     702             :   ///
     703             :   /// Clients are responsible for ensuring that registration doesn't occur
     704             :   /// while another thread is attempting to access the registry. Typically
     705             :   /// this is done by initializing all targets at program startup.
     706             :   ///
     707             :   /// @param T - The target being registered.
     708             :   /// @param Fn - A function to construct a MCInstrInfo for the target.
     709             :   static void RegisterMCInstrInfo(Target &T, Target::MCInstrInfoCtorFnTy Fn) {
     710     2587978 :     T.MCInstrInfoCtorFn = Fn;
     711             :   }
     712             : 
     713             :   /// RegisterMCInstrAnalysis - Register a MCInstrAnalysis implementation for
     714             :   /// the given target.
     715             :   static void RegisterMCInstrAnalysis(Target &T,
     716             :                                       Target::MCInstrAnalysisCtorFnTy Fn) {
     717     1370356 :     T.MCInstrAnalysisCtorFn = Fn;
     718             :   }
     719             : 
     720             :   /// RegisterMCRegInfo - Register a MCRegisterInfo implementation for the
     721             :   /// given target.
     722             :   ///
     723             :   /// Clients are responsible for ensuring that registration doesn't occur
     724             :   /// while another thread is attempting to access the registry. Typically
     725             :   /// this is done by initializing all targets at program startup.
     726             :   ///
     727             :   /// @param T - The target being registered.
     728             :   /// @param Fn - A function to construct a MCRegisterInfo for the target.
     729             :   static void RegisterMCRegInfo(Target &T, Target::MCRegInfoCtorFnTy Fn) {
     730     2587978 :     T.MCRegInfoCtorFn = Fn;
     731             :   }
     732             : 
     733             :   /// RegisterMCSubtargetInfo - Register a MCSubtargetInfo implementation for
     734             :   /// the given target.
     735             :   ///
     736             :   /// Clients are responsible for ensuring that registration doesn't occur
     737             :   /// while another thread is attempting to access the registry. Typically
     738             :   /// this is done by initializing all targets at program startup.
     739             :   ///
     740             :   /// @param T - The target being registered.
     741             :   /// @param Fn - A function to construct a MCSubtargetInfo for the target.
     742             :   static void RegisterMCSubtargetInfo(Target &T,
     743             :                                       Target::MCSubtargetInfoCtorFnTy Fn) {
     744     2587978 :     T.MCSubtargetInfoCtorFn = Fn;
     745             :   }
     746             : 
     747             :   /// RegisterTargetMachine - Register a TargetMachine implementation for the
     748             :   /// given target.
     749             :   ///
     750             :   /// Clients are responsible for ensuring that registration doesn't occur
     751             :   /// while another thread is attempting to access the registry. Typically
     752             :   /// this is done by initializing all targets at program startup.
     753             :   ///
     754             :   /// @param T - The target being registered.
     755             :   /// @param Fn - A function to construct a TargetMachine for the target.
     756             :   static void RegisterTargetMachine(Target &T, Target::TargetMachineCtorTy Fn) {
     757     3333598 :     T.TargetMachineCtorFn = Fn;
     758             :   }
     759             : 
     760             :   /// RegisterMCAsmBackend - Register a MCAsmBackend implementation for the
     761             :   /// given target.
     762             :   ///
     763             :   /// Clients are responsible for ensuring that registration doesn't occur
     764             :   /// while another thread is attempting to access the registry. Typically
     765             :   /// this is done by initializing all targets at program startup.
     766             :   ///
     767             :   /// @param T - The target being registered.
     768             :   /// @param Fn - A function to construct an AsmBackend for the target.
     769             :   static void RegisterMCAsmBackend(Target &T, Target::MCAsmBackendCtorTy Fn) {
     770     2283574 :     T.MCAsmBackendCtorFn = Fn;
     771             :   }
     772             : 
     773             :   /// RegisterMCAsmParser - Register a MCTargetAsmParser implementation for
     774             :   /// the given target.
     775             :   ///
     776             :   /// Clients are responsible for ensuring that registration doesn't occur
     777             :   /// while another thread is attempting to access the registry. Typically
     778             :   /// this is done by initializing all targets at program startup.
     779             :   ///
     780             :   /// @param T - The target being registered.
     781             :   /// @param Fn - A function to construct an MCTargetAsmParser for the target.
     782             :   static void RegisterMCAsmParser(Target &T, Target::MCAsmParserCtorTy Fn) {
     783     2123238 :     T.MCAsmParserCtorFn = Fn;
     784             :   }
     785             : 
     786             :   /// RegisterAsmPrinter - Register an AsmPrinter implementation for the given
     787             :   /// target.
     788             :   ///
     789             :   /// Clients are responsible for ensuring that registration doesn't occur
     790             :   /// while another thread is attempting to access the registry. Typically
     791             :   /// this is done by initializing all targets at program startup.
     792             :   ///
     793             :   /// @param T - The target being registered.
     794             :   /// @param Fn - A function to construct an AsmPrinter for the target.
     795             :   static void RegisterAsmPrinter(Target &T, Target::AsmPrinterCtorTy Fn) {
     796     2119206 :     T.AsmPrinterCtorFn = Fn;
     797             :   }
     798             : 
     799             :   /// RegisterMCDisassembler - Register a MCDisassembler implementation for
     800             :   /// the given target.
     801             :   ///
     802             :   /// Clients are responsible for ensuring that registration doesn't occur
     803             :   /// while another thread is attempting to access the registry. Typically
     804             :   /// this is done by initializing all targets at program startup.
     805             :   ///
     806             :   /// @param T - The target being registered.
     807             :   /// @param Fn - A function to construct an MCDisassembler for the target.
     808             :   static void RegisterMCDisassembler(Target &T,
     809             :                                      Target::MCDisassemblerCtorTy Fn) {
     810      415020 :     T.MCDisassemblerCtorFn = Fn;
     811             :   }
     812             : 
     813             :   /// RegisterMCInstPrinter - Register a MCInstPrinter implementation for the
     814             :   /// given target.
     815             :   ///
     816             :   /// Clients are responsible for ensuring that registration doesn't occur
     817             :   /// while another thread is attempting to access the registry. Typically
     818             :   /// this is done by initializing all targets at program startup.
     819             :   ///
     820             :   /// @param T - The target being registered.
     821             :   /// @param Fn - A function to construct an MCInstPrinter for the target.
     822             :   static void RegisterMCInstPrinter(Target &T, Target::MCInstPrinterCtorTy Fn) {
     823     2587978 :     T.MCInstPrinterCtorFn = Fn;
     824             :   }
     825             : 
     826             :   /// RegisterMCCodeEmitter - Register a MCCodeEmitter implementation for the
     827             :   /// given target.
     828             :   ///
     829             :   /// Clients are responsible for ensuring that registration doesn't occur
     830             :   /// while another thread is attempting to access the registry. Typically
     831             :   /// this is done by initializing all targets at program startup.
     832             :   ///
     833             :   /// @param T - The target being registered.
     834             :   /// @param Fn - A function to construct an MCCodeEmitter for the target.
     835             :   static void RegisterMCCodeEmitter(Target &T, Target::MCCodeEmitterCtorTy Fn) {
     836     2283574 :     T.MCCodeEmitterCtorFn = Fn;
     837             :   }
     838             : 
     839             :   static void RegisterCOFFStreamer(Target &T, Target::COFFStreamerCtorTy Fn) {
     840      685447 :     T.COFFStreamerCtorFn = Fn;
     841             :   }
     842             : 
     843             :   static void RegisterMachOStreamer(Target &T, Target::MachOStreamerCtorTy Fn) {
     844      532719 :     T.MachOStreamerCtorFn = Fn;
     845             :   }
     846             : 
     847             :   static void RegisterELFStreamer(Target &T, Target::ELFStreamerCtorTy Fn) {
     848     1445931 :     T.ELFStreamerCtorFn = Fn;
     849             :   }
     850             : 
     851             :   static void RegisterWasmStreamer(Target &T, Target::WasmStreamerCtorTy Fn) {
     852             :     T.WasmStreamerCtorFn = Fn;
     853             :   }
     854             : 
     855             :   static void RegisterNullTargetStreamer(Target &T,
     856             :                                          Target::NullTargetStreamerCtorTy Fn) {
     857      608808 :     T.NullTargetStreamerCtorFn = Fn;
     858             :   }
     859             : 
     860             :   static void RegisterAsmTargetStreamer(Target &T,
     861             :                                         Target::AsmTargetStreamerCtorTy Fn) {
     862     2055271 :     T.AsmTargetStreamerCtorFn = Fn;
     863             :   }
     864             : 
     865             :   static void
     866             :   RegisterObjectTargetStreamer(Target &T,
     867             :                                Target::ObjectTargetStreamerCtorTy Fn) {
     868     1903069 :     T.ObjectTargetStreamerCtorFn = Fn;
     869             :   }
     870             : 
     871             :   /// RegisterMCRelocationInfo - Register an MCRelocationInfo
     872             :   /// implementation for the given target.
     873             :   ///
     874             :   /// Clients are responsible for ensuring that registration doesn't occur
     875             :   /// while another thread is attempting to access the registry. Typically
     876             :   /// this is done by initializing all targets at program startup.
     877             :   ///
     878             :   /// @param T - The target being registered.
     879             :   /// @param Fn - A function to construct an MCRelocationInfo for the target.
     880             :   static void RegisterMCRelocationInfo(Target &T,
     881             :                                        Target::MCRelocationInfoCtorTy Fn) {
     882      533233 :     T.MCRelocationInfoCtorFn = Fn;
     883             :   }
     884             : 
     885             :   /// RegisterMCSymbolizer - Register an MCSymbolizer
     886             :   /// implementation for the given target.
     887             :   ///
     888             :   /// Clients are responsible for ensuring that registration doesn't occur
     889             :   /// while another thread is attempting to access the registry. Typically
     890             :   /// this is done by initializing all targets at program startup.
     891             :   ///
     892             :   /// @param T - The target being registered.
     893             :   /// @param Fn - A function to construct an MCSymbolizer for the target.
     894             :   static void RegisterMCSymbolizer(Target &T, Target::MCSymbolizerCtorTy Fn) {
     895       55336 :     T.MCSymbolizerCtorFn = Fn;
     896             :   }
     897             : 
     898             :   /// @}
     899             : };
     900             : 
     901             : //===--------------------------------------------------------------------===//
     902             : 
     903             : /// RegisterTarget - Helper template for registering a target, for use in the
     904             : /// target's initialization function. Usage:
     905             : ///
     906             : ///
     907             : /// Target &getTheFooTarget() { // The global target instance.
     908             : ///   static Target TheFooTarget;
     909             : ///   return TheFooTarget;
     910             : /// }
     911             : /// extern "C" void LLVMInitializeFooTargetInfo() {
     912             : ///   RegisterTarget<Triple::foo> X(getTheFooTarget(), "foo", "Foo
     913             : ///   description", "Foo" /* Backend Name */);
     914             : /// }
     915             : template <Triple::ArchType TargetArchType = Triple::UnknownArch,
     916             :           bool HasJIT = false>
     917             : struct RegisterTarget {
     918             :   RegisterTarget(Target &T, const char *Name, const char *Desc,
     919             :                  const char *BackendName) {
     920     3600092 :     TargetRegistry::RegisterTarget(T, Name, Desc, BackendName, &getArchMatch,
     921             :                                    HasJIT);
     922             :   }
     923             : 
     924     1267072 :   static bool getArchMatch(Triple::ArchType Arch) {
     925     1267072 :     return Arch == TargetArchType;
     926             :   }
     927             : };
     928             : 
     929             : /// RegisterMCAsmInfo - Helper template for registering a target assembly info
     930             : /// implementation.  This invokes the static "Create" method on the class to
     931             : /// actually do the construction.  Usage:
     932             : ///
     933             : /// extern "C" void LLVMInitializeFooTarget() {
     934             : ///   extern Target TheFooTarget;
     935             : ///   RegisterMCAsmInfo<FooMCAsmInfo> X(TheFooTarget);
     936             : /// }
     937             : template <class MCAsmInfoImpl> struct RegisterMCAsmInfo {
     938             :   RegisterMCAsmInfo(Target &T) {
     939             :     TargetRegistry::RegisterMCAsmInfo(T, &Allocator);
     940             :   }
     941             : 
     942             : private:
     943        3834 :   static MCAsmInfo *Allocator(const MCRegisterInfo & /*MRI*/,
     944             :                               const Triple &TT) {
     945        3834 :     return new MCAsmInfoImpl(TT);
     946             :   }
     947             : };
     948             : 
     949             : /// RegisterMCAsmInfoFn - Helper template for registering a target assembly info
     950             : /// implementation.  This invokes the specified function to do the
     951             : /// construction.  Usage:
     952             : ///
     953             : /// extern "C" void LLVMInitializeFooTarget() {
     954             : ///   extern Target TheFooTarget;
     955             : ///   RegisterMCAsmInfoFn X(TheFooTarget, TheFunction);
     956             : /// }
     957             : struct RegisterMCAsmInfoFn {
     958             :   RegisterMCAsmInfoFn(Target &T, Target::MCAsmInfoCtorFnTy Fn) {
     959             :     TargetRegistry::RegisterMCAsmInfo(T, Fn);
     960             :   }
     961             : };
     962             : 
     963             : /// RegisterMCInstrInfo - Helper template for registering a target instruction
     964             : /// info implementation.  This invokes the static "Create" method on the class
     965             : /// to actually do the construction.  Usage:
     966             : ///
     967             : /// extern "C" void LLVMInitializeFooTarget() {
     968             : ///   extern Target TheFooTarget;
     969             : ///   RegisterMCInstrInfo<FooMCInstrInfo> X(TheFooTarget);
     970             : /// }
     971             : template <class MCInstrInfoImpl> struct RegisterMCInstrInfo {
     972             :   RegisterMCInstrInfo(Target &T) {
     973             :     TargetRegistry::RegisterMCInstrInfo(T, &Allocator);
     974             :   }
     975             : 
     976             : private:
     977             :   static MCInstrInfo *Allocator() { return new MCInstrInfoImpl(); }
     978             : };
     979             : 
     980             : /// RegisterMCInstrInfoFn - Helper template for registering a target
     981             : /// instruction info implementation.  This invokes the specified function to
     982             : /// do the construction.  Usage:
     983             : ///
     984             : /// extern "C" void LLVMInitializeFooTarget() {
     985             : ///   extern Target TheFooTarget;
     986             : ///   RegisterMCInstrInfoFn X(TheFooTarget, TheFunction);
     987             : /// }
     988             : struct RegisterMCInstrInfoFn {
     989             :   RegisterMCInstrInfoFn(Target &T, Target::MCInstrInfoCtorFnTy Fn) {
     990             :     TargetRegistry::RegisterMCInstrInfo(T, Fn);
     991             :   }
     992             : };
     993             : 
     994             : /// RegisterMCInstrAnalysis - Helper template for registering a target
     995             : /// instruction analyzer implementation.  This invokes the static "Create"
     996             : /// method on the class to actually do the construction.  Usage:
     997             : ///
     998             : /// extern "C" void LLVMInitializeFooTarget() {
     999             : ///   extern Target TheFooTarget;
    1000             : ///   RegisterMCInstrAnalysis<FooMCInstrAnalysis> X(TheFooTarget);
    1001             : /// }
    1002             : template <class MCInstrAnalysisImpl> struct RegisterMCInstrAnalysis {
    1003             :   RegisterMCInstrAnalysis(Target &T) {
    1004             :     TargetRegistry::RegisterMCInstrAnalysis(T, &Allocator);
    1005             :   }
    1006             : 
    1007             : private:
    1008             :   static MCInstrAnalysis *Allocator(const MCInstrInfo *Info) {
    1009             :     return new MCInstrAnalysisImpl(Info);
    1010             :   }
    1011             : };
    1012             : 
    1013             : /// RegisterMCInstrAnalysisFn - Helper template for registering a target
    1014             : /// instruction analyzer implementation.  This invokes the specified function
    1015             : /// to do the construction.  Usage:
    1016             : ///
    1017             : /// extern "C" void LLVMInitializeFooTarget() {
    1018             : ///   extern Target TheFooTarget;
    1019             : ///   RegisterMCInstrAnalysisFn X(TheFooTarget, TheFunction);
    1020             : /// }
    1021             : struct RegisterMCInstrAnalysisFn {
    1022             :   RegisterMCInstrAnalysisFn(Target &T, Target::MCInstrAnalysisCtorFnTy Fn) {
    1023             :     TargetRegistry::RegisterMCInstrAnalysis(T, Fn);
    1024             :   }
    1025             : };
    1026             : 
    1027             : /// RegisterMCRegInfo - Helper template for registering a target register info
    1028             : /// implementation.  This invokes the static "Create" method on the class to
    1029             : /// actually do the construction.  Usage:
    1030             : ///
    1031             : /// extern "C" void LLVMInitializeFooTarget() {
    1032             : ///   extern Target TheFooTarget;
    1033             : ///   RegisterMCRegInfo<FooMCRegInfo> X(TheFooTarget);
    1034             : /// }
    1035             : template <class MCRegisterInfoImpl> struct RegisterMCRegInfo {
    1036             :   RegisterMCRegInfo(Target &T) {
    1037             :     TargetRegistry::RegisterMCRegInfo(T, &Allocator);
    1038             :   }
    1039             : 
    1040             : private:
    1041             :   static MCRegisterInfo *Allocator(const Triple & /*TT*/) {
    1042             :     return new MCRegisterInfoImpl();
    1043             :   }
    1044             : };
    1045             : 
    1046             : /// RegisterMCRegInfoFn - Helper template for registering a target register
    1047             : /// info implementation.  This invokes the specified function to do the
    1048             : /// construction.  Usage:
    1049             : ///
    1050             : /// extern "C" void LLVMInitializeFooTarget() {
    1051             : ///   extern Target TheFooTarget;
    1052             : ///   RegisterMCRegInfoFn X(TheFooTarget, TheFunction);
    1053             : /// }
    1054             : struct RegisterMCRegInfoFn {
    1055             :   RegisterMCRegInfoFn(Target &T, Target::MCRegInfoCtorFnTy Fn) {
    1056             :     TargetRegistry::RegisterMCRegInfo(T, Fn);
    1057             :   }
    1058             : };
    1059             : 
    1060             : /// RegisterMCSubtargetInfo - Helper template for registering a target
    1061             : /// subtarget info implementation.  This invokes the static "Create" method
    1062             : /// on the class to actually do the construction.  Usage:
    1063             : ///
    1064             : /// extern "C" void LLVMInitializeFooTarget() {
    1065             : ///   extern Target TheFooTarget;
    1066             : ///   RegisterMCSubtargetInfo<FooMCSubtargetInfo> X(TheFooTarget);
    1067             : /// }
    1068             : template <class MCSubtargetInfoImpl> struct RegisterMCSubtargetInfo {
    1069             :   RegisterMCSubtargetInfo(Target &T) {
    1070             :     TargetRegistry::RegisterMCSubtargetInfo(T, &Allocator);
    1071             :   }
    1072             : 
    1073             : private:
    1074             :   static MCSubtargetInfo *Allocator(const Triple & /*TT*/, StringRef /*CPU*/,
    1075             :                                     StringRef /*FS*/) {
    1076             :     return new MCSubtargetInfoImpl();
    1077             :   }
    1078             : };
    1079             : 
    1080             : /// RegisterMCSubtargetInfoFn - Helper template for registering a target
    1081             : /// subtarget info implementation.  This invokes the specified function to
    1082             : /// do the construction.  Usage:
    1083             : ///
    1084             : /// extern "C" void LLVMInitializeFooTarget() {
    1085             : ///   extern Target TheFooTarget;
    1086             : ///   RegisterMCSubtargetInfoFn X(TheFooTarget, TheFunction);
    1087             : /// }
    1088             : struct RegisterMCSubtargetInfoFn {
    1089             :   RegisterMCSubtargetInfoFn(Target &T, Target::MCSubtargetInfoCtorFnTy Fn) {
    1090             :     TargetRegistry::RegisterMCSubtargetInfo(T, Fn);
    1091             :   }
    1092             : };
    1093             : 
    1094             : /// RegisterTargetMachine - Helper template for registering a target machine
    1095             : /// implementation, for use in the target machine initialization
    1096             : /// function. Usage:
    1097             : ///
    1098             : /// extern "C" void LLVMInitializeFooTarget() {
    1099             : ///   extern Target TheFooTarget;
    1100             : ///   RegisterTargetMachine<FooTargetMachine> X(TheFooTarget);
    1101             : /// }
    1102             : template <class TargetMachineImpl> struct RegisterTargetMachine {
    1103             :   RegisterTargetMachine(Target &T) {
    1104             :     TargetRegistry::RegisterTargetMachine(T, &Allocator);
    1105             :   }
    1106             : 
    1107             : private:
    1108             :   static TargetMachine *
    1109       35218 :   Allocator(const Target &T, const Triple &TT, StringRef CPU, StringRef FS,
    1110             :             const TargetOptions &Options, Optional<Reloc::Model> RM,
    1111             :             Optional<CodeModel::Model> CM, CodeGenOpt::Level OL, bool JIT) {
    1112       73015 :     return new TargetMachineImpl(T, TT, CPU, FS, Options, RM, CM, OL, JIT);
    1113             :   }
    1114             : };
    1115             : 
    1116             : /// RegisterMCAsmBackend - Helper template for registering a target specific
    1117             : /// assembler backend. Usage:
    1118             : ///
    1119             : /// extern "C" void LLVMInitializeFooMCAsmBackend() {
    1120             : ///   extern Target TheFooTarget;
    1121             : ///   RegisterMCAsmBackend<FooAsmLexer> X(TheFooTarget);
    1122             : /// }
    1123             : template <class MCAsmBackendImpl> struct RegisterMCAsmBackend {
    1124             :   RegisterMCAsmBackend(Target &T) {
    1125             :     TargetRegistry::RegisterMCAsmBackend(T, &Allocator);
    1126             :   }
    1127             : 
    1128             : private:
    1129             :   static MCAsmBackend *Allocator(const Target &T, const MCSubtargetInfo &STI,
    1130             :                                  const MCRegisterInfo &MRI,
    1131             :                                  const MCTargetOptions &Options) {
    1132             :     return new MCAsmBackendImpl(T, STI, MRI);
    1133             :   }
    1134             : };
    1135             : 
    1136             : /// RegisterMCAsmParser - Helper template for registering a target specific
    1137             : /// assembly parser, for use in the target machine initialization
    1138             : /// function. Usage:
    1139             : ///
    1140             : /// extern "C" void LLVMInitializeFooMCAsmParser() {
    1141             : ///   extern Target TheFooTarget;
    1142             : ///   RegisterMCAsmParser<FooAsmParser> X(TheFooTarget);
    1143             : /// }
    1144             : template <class MCAsmParserImpl> struct RegisterMCAsmParser {
    1145             :   RegisterMCAsmParser(Target &T) {
    1146             :     TargetRegistry::RegisterMCAsmParser(T, &Allocator);
    1147             :   }
    1148             : 
    1149             : private:
    1150       17442 :   static MCTargetAsmParser *Allocator(const MCSubtargetInfo &STI,
    1151             :                                       MCAsmParser &P, const MCInstrInfo &MII,
    1152             :                                       const MCTargetOptions &Options) {
    1153       17445 :     return new MCAsmParserImpl(STI, P, MII, Options);
    1154             :   }
    1155             : };
    1156             : 
    1157             : /// RegisterAsmPrinter - Helper template for registering a target specific
    1158             : /// assembly printer, for use in the target machine initialization
    1159             : /// function. Usage:
    1160             : ///
    1161             : /// extern "C" void LLVMInitializeFooAsmPrinter() {
    1162             : ///   extern Target TheFooTarget;
    1163             : ///   RegisterAsmPrinter<FooAsmPrinter> X(TheFooTarget);
    1164             : /// }
    1165             : template <class AsmPrinterImpl> struct RegisterAsmPrinter {
    1166             :   RegisterAsmPrinter(Target &T) {
    1167             :     TargetRegistry::RegisterAsmPrinter(T, &Allocator);
    1168             :   }
    1169             : 
    1170             : private:
    1171       18601 :   static AsmPrinter *Allocator(TargetMachine &TM,
    1172             :                                std::unique_ptr<MCStreamer> &&Streamer) {
    1173       37202 :     return new AsmPrinterImpl(TM, std::move(Streamer));
    1174             :   }
    1175             : };
    1176             : 
    1177             : /// RegisterMCCodeEmitter - Helper template for registering a target specific
    1178             : /// machine code emitter, for use in the target initialization
    1179             : /// function. Usage:
    1180             : ///
    1181             : /// extern "C" void LLVMInitializeFooMCCodeEmitter() {
    1182             : ///   extern Target TheFooTarget;
    1183             : ///   RegisterMCCodeEmitter<FooCodeEmitter> X(TheFooTarget);
    1184             : /// }
    1185             : template <class MCCodeEmitterImpl> struct RegisterMCCodeEmitter {
    1186             :   RegisterMCCodeEmitter(Target &T) {
    1187             :     TargetRegistry::RegisterMCCodeEmitter(T, &Allocator);
    1188             :   }
    1189             : 
    1190             : private:
    1191             :   static MCCodeEmitter *Allocator(const MCInstrInfo & /*II*/,
    1192             :                                   const MCRegisterInfo & /*MRI*/,
    1193             :                                   MCContext & /*Ctx*/) {
    1194             :     return new MCCodeEmitterImpl();
    1195             :   }
    1196             : };
    1197             : 
    1198             : } // end namespace llvm
    1199             : 
    1200             : #endif // LLVM_SUPPORT_TARGETREGISTRY_H

Generated by: LCOV version 1.13