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

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