contrib/llvm/include/llvm/Support/TargetRegistry.h

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