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