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