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