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