LLVM  10.0.0svn
TargetRegistry.h
Go to the documentation of this file.
1 //===- Support/TargetRegistry.h - Target Registration -----------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file exposes the TargetRegistry interface, which tools can use to access
10 // the appropriate target specific classes (TargetMachine, AsmPrinter, etc.)
11 // which have been registered.
12 //
13 // Target specific class implementations should register themselves using the
14 // appropriate TargetRegistry interfaces.
15 //
16 //===----------------------------------------------------------------------===//
17 
18 #ifndef LLVM_SUPPORT_TARGETREGISTRY_H
19 #define LLVM_SUPPORT_TARGETREGISTRY_H
20 
22 #include "llvm/ADT/Optional.h"
23 #include "llvm/ADT/StringRef.h"
24 #include "llvm/ADT/Triple.h"
26 #include "llvm/Support/CodeGen.h"
29 #include <algorithm>
30 #include <cassert>
31 #include <cstddef>
32 #include <iterator>
33 #include <memory>
34 #include <string>
35 
36 namespace llvm {
37 
38 class AsmPrinter;
39 class MCAsmBackend;
40 class MCAsmInfo;
41 class MCAsmParser;
42 class MCCodeEmitter;
43 class MCContext;
44 class MCDisassembler;
45 class MCInstPrinter;
46 class MCInstrAnalysis;
47 class MCInstrInfo;
48 class MCObjectWriter;
49 class MCRegisterInfo;
50 class MCRelocationInfo;
51 class MCStreamer;
52 class MCSubtargetInfo;
53 class MCSymbolizer;
54 class MCTargetAsmParser;
55 class MCTargetOptions;
56 class MCTargetStreamer;
57 class raw_ostream;
58 class raw_pwrite_stream;
59 class TargetMachine;
60 class TargetOptions;
61 
62 MCStreamer *createNullStreamer(MCContext &Ctx);
63 // Takes ownership of \p TAB and \p CE.
64 
65 /// Create a machine code streamer which will print out assembly for the native
66 /// target, suitable for compiling with a native assembler.
67 ///
68 /// \param InstPrint - If given, the instruction printer to use. If not given
69 /// the MCInst representation will be printed. This method takes ownership of
70 /// InstPrint.
71 ///
72 /// \param CE - If given, a code emitter to use to show the instruction
73 /// encoding inline with the assembly. This method takes ownership of \p CE.
74 ///
75 /// \param TAB - If given, a target asm backend to use to show the fixup
76 /// information in conjunction with encoding information. This method takes
77 /// ownership of \p TAB.
78 ///
79 /// \param ShowInst - Whether to show the MCInst representation inline with
80 /// the assembly.
81 MCStreamer *
82 createAsmStreamer(MCContext &Ctx, std::unique_ptr<formatted_raw_ostream> OS,
83  bool isVerboseAsm, bool useDwarfDirectory,
84  MCInstPrinter *InstPrint, std::unique_ptr<MCCodeEmitter> &&CE,
85  std::unique_ptr<MCAsmBackend> &&TAB, bool ShowInst);
86 
87 MCStreamer *createELFStreamer(MCContext &Ctx,
88  std::unique_ptr<MCAsmBackend> &&TAB,
89  std::unique_ptr<MCObjectWriter> &&OW,
90  std::unique_ptr<MCCodeEmitter> &&CE,
91  bool RelaxAll);
92 MCStreamer *createMachOStreamer(MCContext &Ctx,
93  std::unique_ptr<MCAsmBackend> &&TAB,
94  std::unique_ptr<MCObjectWriter> &&OW,
95  std::unique_ptr<MCCodeEmitter> &&CE,
96  bool RelaxAll, bool DWARFMustBeAtTheEnd,
97  bool LabelSections = false);
98 MCStreamer *createWasmStreamer(MCContext &Ctx,
99  std::unique_ptr<MCAsmBackend> &&TAB,
100  std::unique_ptr<MCObjectWriter> &&OW,
101  std::unique_ptr<MCCodeEmitter> &&CE,
102  bool RelaxAll);
103 MCStreamer *createXCOFFStreamer(MCContext &Ctx,
104  std::unique_ptr<MCAsmBackend> &&TAB,
105  std::unique_ptr<MCObjectWriter> &&OW,
106  std::unique_ptr<MCCodeEmitter> &&CE,
107  bool RelaxAll);
108 
109 MCRelocationInfo *createMCRelocationInfo(const Triple &TT, MCContext &Ctx);
110 
111 MCSymbolizer *createMCSymbolizer(const Triple &TT, LLVMOpInfoCallback GetOpInfo,
112  LLVMSymbolLookupCallback SymbolLookUp,
113  void *DisInfo, MCContext *Ctx,
114  std::unique_ptr<MCRelocationInfo> &&RelInfo);
115 
116 /// Target - Wrapper for Target specific information.
117 ///
118 /// For registration purposes, this is a POD type so that targets can be
119 /// registered without the use of static constructors.
120 ///
121 /// Targets should implement a single global instance of this class (which
122 /// will be zero initialized), and pass that instance to the TargetRegistry as
123 /// part of their initialization.
124 class Target {
125 public:
126  friend struct TargetRegistry;
127 
129 
130  using MCAsmInfoCtorFnTy = MCAsmInfo *(*)(const MCRegisterInfo &MRI,
131  const Triple &TT);
135  using MCSubtargetInfoCtorFnTy = MCSubtargetInfo *(*)(const Triple &TT,
136  StringRef CPU,
137  StringRef Features);
139  *(*)(const Target &T, const Triple &TT, StringRef CPU, StringRef Features,
140  const TargetOptions &Options, Optional<Reloc::Model> RM,
142  // If it weren't for layering issues (this header is in llvm/Support, but
143  // depends on MC?) this should take the Streamer by value rather than rvalue
144  // reference.
145  using AsmPrinterCtorTy = AsmPrinter *(*)(
146  TargetMachine &TM, std::unique_ptr<MCStreamer> &&Streamer);
147  using MCAsmBackendCtorTy = MCAsmBackend *(*)(const Target &T,
148  const MCSubtargetInfo &STI,
149  const MCRegisterInfo &MRI,
150  const MCTargetOptions &Options);
152  const MCSubtargetInfo &STI, MCAsmParser &P, const MCInstrInfo &MII,
153  const MCTargetOptions &Options);
154  using MCDisassemblerCtorTy = MCDisassembler *(*)(const Target &T,
155  const MCSubtargetInfo &STI,
156  MCContext &Ctx);
157  using MCInstPrinterCtorTy = MCInstPrinter *(*)(const Triple &T,
158  unsigned SyntaxVariant,
159  const MCAsmInfo &MAI,
160  const MCInstrInfo &MII,
162  using MCCodeEmitterCtorTy = MCCodeEmitter *(*)(const MCInstrInfo &II,
163  const MCRegisterInfo &MRI,
164  MCContext &Ctx);
165  using ELFStreamerCtorTy =
166  MCStreamer *(*)(const Triple &T, MCContext &Ctx,
167  std::unique_ptr<MCAsmBackend> &&TAB,
168  std::unique_ptr<MCObjectWriter> &&OW,
169  std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll);
170  using MachOStreamerCtorTy =
171  MCStreamer *(*)(MCContext &Ctx, std::unique_ptr<MCAsmBackend> &&TAB,
172  std::unique_ptr<MCObjectWriter> &&OW,
173  std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll,
174  bool DWARFMustBeAtTheEnd);
175  using COFFStreamerCtorTy =
176  MCStreamer *(*)(MCContext &Ctx, std::unique_ptr<MCAsmBackend> &&TAB,
177  std::unique_ptr<MCObjectWriter> &&OW,
178  std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll,
179  bool IncrementalLinkerCompatible);
180  using WasmStreamerCtorTy =
181  MCStreamer *(*)(const Triple &T, MCContext &Ctx,
182  std::unique_ptr<MCAsmBackend> &&TAB,
183  std::unique_ptr<MCObjectWriter> &&OW,
184  std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll);
187  MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint,
188  bool IsVerboseAsm);
190  MCStreamer &S, const MCSubtargetInfo &STI);
191  using MCRelocationInfoCtorTy = MCRelocationInfo *(*)(const Triple &TT,
192  MCContext &Ctx);
193  using MCSymbolizerCtorTy = MCSymbolizer *(*)(
194  const Triple &TT, LLVMOpInfoCallback GetOpInfo,
195  LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx,
196  std::unique_ptr<MCRelocationInfo> &&RelInfo);
197 
198 private:
199  /// Next - The next registered target in the linked list, maintained by the
200  /// TargetRegistry.
201  Target *Next;
202 
203  /// The target function for checking if an architecture is supported.
204  ArchMatchFnTy ArchMatchFn;
205 
206  /// Name - The target name.
207  const char *Name;
208 
209  /// ShortDesc - A short description of the target.
210  const char *ShortDesc;
211 
212  /// BackendName - The name of the backend implementation. This must match the
213  /// name of the 'def X : Target ...' in TableGen.
214  const char *BackendName;
215 
216  /// HasJIT - Whether this target supports the JIT.
217  bool HasJIT;
218 
219  /// MCAsmInfoCtorFn - Constructor function for this target's MCAsmInfo, if
220  /// registered.
221  MCAsmInfoCtorFnTy MCAsmInfoCtorFn;
222 
223  /// MCInstrInfoCtorFn - Constructor function for this target's MCInstrInfo,
224  /// if registered.
225  MCInstrInfoCtorFnTy MCInstrInfoCtorFn;
226 
227  /// MCInstrAnalysisCtorFn - Constructor function for this target's
228  /// MCInstrAnalysis, if registered.
229  MCInstrAnalysisCtorFnTy MCInstrAnalysisCtorFn;
230 
231  /// MCRegInfoCtorFn - Constructor function for this target's MCRegisterInfo,
232  /// if registered.
233  MCRegInfoCtorFnTy MCRegInfoCtorFn;
234 
235  /// MCSubtargetInfoCtorFn - Constructor function for this target's
236  /// MCSubtargetInfo, if registered.
237  MCSubtargetInfoCtorFnTy MCSubtargetInfoCtorFn;
238 
239  /// TargetMachineCtorFn - Construction function for this target's
240  /// TargetMachine, if registered.
241  TargetMachineCtorTy TargetMachineCtorFn;
242 
243  /// MCAsmBackendCtorFn - Construction function for this target's
244  /// MCAsmBackend, if registered.
245  MCAsmBackendCtorTy MCAsmBackendCtorFn;
246 
247  /// MCAsmParserCtorFn - Construction function for this target's
248  /// MCTargetAsmParser, if registered.
249  MCAsmParserCtorTy MCAsmParserCtorFn;
250 
251  /// AsmPrinterCtorFn - Construction function for this target's AsmPrinter,
252  /// if registered.
253  AsmPrinterCtorTy AsmPrinterCtorFn;
254 
255  /// MCDisassemblerCtorFn - Construction function for this target's
256  /// MCDisassembler, if registered.
257  MCDisassemblerCtorTy MCDisassemblerCtorFn;
258 
259  /// MCInstPrinterCtorFn - Construction function for this target's
260  /// MCInstPrinter, if registered.
261  MCInstPrinterCtorTy MCInstPrinterCtorFn;
262 
263  /// MCCodeEmitterCtorFn - Construction function for this target's
264  /// CodeEmitter, if registered.
265  MCCodeEmitterCtorTy MCCodeEmitterCtorFn;
266 
267  // Construction functions for the various object formats, if registered.
268  COFFStreamerCtorTy COFFStreamerCtorFn = nullptr;
269  MachOStreamerCtorTy MachOStreamerCtorFn = nullptr;
270  ELFStreamerCtorTy ELFStreamerCtorFn = nullptr;
271  WasmStreamerCtorTy WasmStreamerCtorFn = nullptr;
272 
273  /// Construction function for this target's null TargetStreamer, if
274  /// registered (default = nullptr).
275  NullTargetStreamerCtorTy NullTargetStreamerCtorFn = nullptr;
276 
277  /// Construction function for this target's asm TargetStreamer, if
278  /// registered (default = nullptr).
279  AsmTargetStreamerCtorTy AsmTargetStreamerCtorFn = nullptr;
280 
281  /// Construction function for this target's obj TargetStreamer, if
282  /// registered (default = nullptr).
283  ObjectTargetStreamerCtorTy ObjectTargetStreamerCtorFn = nullptr;
284 
285  /// MCRelocationInfoCtorFn - Construction function for this target's
286  /// MCRelocationInfo, if registered (default = llvm::createMCRelocationInfo)
287  MCRelocationInfoCtorTy MCRelocationInfoCtorFn = nullptr;
288 
289  /// MCSymbolizerCtorFn - Construction function for this target's
290  /// MCSymbolizer, if registered (default = llvm::createMCSymbolizer)
291  MCSymbolizerCtorTy MCSymbolizerCtorFn = nullptr;
292 
293 public:
294  Target() = default;
295 
296  /// @name Target Information
297  /// @{
298 
299  // getNext - Return the next registered target.
300  const Target *getNext() const { return Next; }
301 
302  /// getName - Get the target name.
303  const char *getName() const { return Name; }
304 
305  /// getShortDescription - Get a short description of the target.
306  const char *getShortDescription() const { return ShortDesc; }
307 
308  /// getBackendName - Get the backend name.
309  const char *getBackendName() const { return BackendName; }
310 
311  /// @}
312  /// @name Feature Predicates
313  /// @{
314 
315  /// hasJIT - Check if this targets supports the just-in-time compilation.
316  bool hasJIT() const { return HasJIT; }
317 
318  /// hasTargetMachine - Check if this target supports code generation.
319  bool hasTargetMachine() const { return TargetMachineCtorFn != nullptr; }
320 
321  /// hasMCAsmBackend - Check if this target supports .o generation.
322  bool hasMCAsmBackend() const { return MCAsmBackendCtorFn != nullptr; }
323 
324  /// hasMCAsmParser - Check if this target supports assembly parsing.
325  bool hasMCAsmParser() const { return MCAsmParserCtorFn != nullptr; }
326 
327  /// @}
328  /// @name Feature Constructors
329  /// @{
330 
331  /// createMCAsmInfo - Create a MCAsmInfo implementation for the specified
332  /// target triple.
333  ///
334  /// \param TheTriple This argument is used to determine the target machine
335  /// feature set; it should always be provided. Generally this should be
336  /// either the target triple from the module, or the target triple of the
337  /// host if that does not exist.
339  StringRef TheTriple) const {
340  if (!MCAsmInfoCtorFn)
341  return nullptr;
342  return MCAsmInfoCtorFn(MRI, Triple(TheTriple));
343  }
344 
345  /// createMCInstrInfo - Create a MCInstrInfo implementation.
346  ///
348  if (!MCInstrInfoCtorFn)
349  return nullptr;
350  return MCInstrInfoCtorFn();
351  }
352 
353  /// createMCInstrAnalysis - Create a MCInstrAnalysis implementation.
354  ///
356  if (!MCInstrAnalysisCtorFn)
357  return nullptr;
358  return MCInstrAnalysisCtorFn(Info);
359  }
360 
361  /// createMCRegInfo - Create a MCRegisterInfo implementation.
362  ///
364  if (!MCRegInfoCtorFn)
365  return nullptr;
366  return MCRegInfoCtorFn(Triple(TT));
367  }
368 
369  /// createMCSubtargetInfo - Create a MCSubtargetInfo implementation.
370  ///
371  /// \param TheTriple This argument is used to determine the target machine
372  /// feature set; it should always be provided. Generally this should be
373  /// either the target triple from the module, or the target triple of the
374  /// host if that does not exist.
375  /// \param CPU This specifies the name of the target CPU.
376  /// \param Features This specifies the string representation of the
377  /// additional target features.
379  StringRef Features) const {
380  if (!MCSubtargetInfoCtorFn)
381  return nullptr;
382  return MCSubtargetInfoCtorFn(Triple(TheTriple), CPU, Features);
383  }
384 
385  /// createTargetMachine - Create a target specific machine implementation
386  /// for the specified \p Triple.
387  ///
388  /// \param TT This argument is used to determine the target machine
389  /// feature set; it should always be provided. Generally this should be
390  /// either the target triple from the module, or the target triple of the
391  /// host if that does not exist.
393  StringRef Features,
394  const TargetOptions &Options,
398  bool JIT = false) const {
399  if (!TargetMachineCtorFn)
400  return nullptr;
401  return TargetMachineCtorFn(*this, Triple(TT), CPU, Features, Options, RM,
402  CM, OL, JIT);
403  }
404 
405  /// createMCAsmBackend - Create a target specific assembly parser.
407  const MCRegisterInfo &MRI,
408  const MCTargetOptions &Options) const {
409  if (!MCAsmBackendCtorFn)
410  return nullptr;
411  return MCAsmBackendCtorFn(*this, STI, MRI, Options);
412  }
413 
414  /// createMCAsmParser - Create a target specific assembly parser.
415  ///
416  /// \param Parser The target independent parser implementation to use for
417  /// parsing and lexing.
419  MCAsmParser &Parser,
420  const MCInstrInfo &MII,
421  const MCTargetOptions &Options) const {
422  if (!MCAsmParserCtorFn)
423  return nullptr;
424  return MCAsmParserCtorFn(STI, Parser, MII, Options);
425  }
426 
427  /// createAsmPrinter - Create a target specific assembly printer pass. This
428  /// takes ownership of the MCStreamer object.
430  std::unique_ptr<MCStreamer> &&Streamer) const {
431  if (!AsmPrinterCtorFn)
432  return nullptr;
433  return AsmPrinterCtorFn(TM, std::move(Streamer));
434  }
435 
437  MCContext &Ctx) const {
438  if (!MCDisassemblerCtorFn)
439  return nullptr;
440  return MCDisassemblerCtorFn(*this, STI, Ctx);
441  }
442 
443  MCInstPrinter *createMCInstPrinter(const Triple &T, unsigned SyntaxVariant,
444  const MCAsmInfo &MAI,
445  const MCInstrInfo &MII,
446  const MCRegisterInfo &MRI) const {
447  if (!MCInstPrinterCtorFn)
448  return nullptr;
449  return MCInstPrinterCtorFn(T, SyntaxVariant, MAI, MII, MRI);
450  }
451 
452  /// createMCCodeEmitter - Create a target specific code emitter.
454  const MCRegisterInfo &MRI,
455  MCContext &Ctx) const {
456  if (!MCCodeEmitterCtorFn)
457  return nullptr;
458  return MCCodeEmitterCtorFn(II, MRI, Ctx);
459  }
460 
461  /// Create a target specific MCStreamer.
462  ///
463  /// \param T The target triple.
464  /// \param Ctx The target context.
465  /// \param TAB The target assembler backend object. Takes ownership.
466  /// \param OW The stream object.
467  /// \param Emitter The target independent assembler object.Takes ownership.
468  /// \param RelaxAll Relax all fixups?
470  std::unique_ptr<MCAsmBackend> &&TAB,
471  std::unique_ptr<MCObjectWriter> &&OW,
472  std::unique_ptr<MCCodeEmitter> &&Emitter,
473  const MCSubtargetInfo &STI, bool RelaxAll,
474  bool IncrementalLinkerCompatible,
475  bool DWARFMustBeAtTheEnd) const {
476  MCStreamer *S;
477  switch (T.getObjectFormat()) {
479  llvm_unreachable("Unknown object format");
480  case Triple::COFF:
481  assert(T.isOSWindows() && "only Windows COFF is supported");
482  S = COFFStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),
483  std::move(Emitter), RelaxAll,
484  IncrementalLinkerCompatible);
485  break;
486  case Triple::MachO:
487  if (MachOStreamerCtorFn)
488  S = MachOStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),
489  std::move(Emitter), RelaxAll,
490  DWARFMustBeAtTheEnd);
491  else
492  S = createMachOStreamer(Ctx, std::move(TAB), std::move(OW),
493  std::move(Emitter), RelaxAll,
494  DWARFMustBeAtTheEnd);
495  break;
496  case Triple::ELF:
497  if (ELFStreamerCtorFn)
498  S = ELFStreamerCtorFn(T, Ctx, std::move(TAB), std::move(OW),
499  std::move(Emitter), RelaxAll);
500  else
501  S = createELFStreamer(Ctx, std::move(TAB), std::move(OW),
502  std::move(Emitter), RelaxAll);
503  break;
504  case Triple::Wasm:
505  if (WasmStreamerCtorFn)
506  S = WasmStreamerCtorFn(T, Ctx, std::move(TAB), std::move(OW),
507  std::move(Emitter), RelaxAll);
508  else
509  S = createWasmStreamer(Ctx, std::move(TAB), std::move(OW),
510  std::move(Emitter), RelaxAll);
511  break;
512  case Triple::XCOFF:
513  S = createXCOFFStreamer(Ctx, std::move(TAB), std::move(OW),
514  std::move(Emitter), RelaxAll);
515  break;
516  }
517  if (ObjectTargetStreamerCtorFn)
518  ObjectTargetStreamerCtorFn(*S, STI);
519  return S;
520  }
521 
523  std::unique_ptr<formatted_raw_ostream> OS,
524  bool IsVerboseAsm, bool UseDwarfDirectory,
525  MCInstPrinter *InstPrint,
526  std::unique_ptr<MCCodeEmitter> &&CE,
527  std::unique_ptr<MCAsmBackend> &&TAB,
528  bool ShowInst) const {
529  formatted_raw_ostream &OSRef = *OS;
531  Ctx, std::move(OS), IsVerboseAsm, UseDwarfDirectory, InstPrint,
532  std::move(CE), std::move(TAB), ShowInst);
533  createAsmTargetStreamer(*S, OSRef, InstPrint, IsVerboseAsm);
534  return S;
535  }
536 
539  MCInstPrinter *InstPrint,
540  bool IsVerboseAsm) const {
541  if (AsmTargetStreamerCtorFn)
542  return AsmTargetStreamerCtorFn(S, OS, InstPrint, IsVerboseAsm);
543  return nullptr;
544  }
545 
549  return S;
550  }
551 
553  if (NullTargetStreamerCtorFn)
554  return NullTargetStreamerCtorFn(S);
555  return nullptr;
556  }
557 
558  /// createMCRelocationInfo - Create a target specific MCRelocationInfo.
559  ///
560  /// \param TT The target triple.
561  /// \param Ctx The target context.
563  MCRelocationInfoCtorTy Fn = MCRelocationInfoCtorFn
564  ? MCRelocationInfoCtorFn
566  return Fn(Triple(TT), Ctx);
567  }
568 
569  /// createMCSymbolizer - Create a target specific MCSymbolizer.
570  ///
571  /// \param TT The target triple.
572  /// \param GetOpInfo The function to get the symbolic information for
573  /// operands.
574  /// \param SymbolLookUp The function to lookup a symbol name.
575  /// \param DisInfo The pointer to the block of symbolic information for above
576  /// call
577  /// back.
578  /// \param Ctx The target context.
579  /// \param RelInfo The relocation information for this target. Takes
580  /// ownership.
581  MCSymbolizer *
583  LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo,
584  MCContext *Ctx,
585  std::unique_ptr<MCRelocationInfo> &&RelInfo) const {
586  MCSymbolizerCtorTy Fn =
587  MCSymbolizerCtorFn ? MCSymbolizerCtorFn : llvm::createMCSymbolizer;
588  return Fn(Triple(TT), GetOpInfo, SymbolLookUp, DisInfo, Ctx,
589  std::move(RelInfo));
590  }
591 
592  /// @}
593 };
594 
595 /// TargetRegistry - Generic interface to target specific features.
597  // FIXME: Make this a namespace, probably just move all the Register*
598  // functions into Target (currently they all just set members on the Target
599  // anyway, and Target friends this class so those functions can...
600  // function).
601  TargetRegistry() = delete;
602 
603  class iterator
604  : public std::iterator<std::forward_iterator_tag, Target, ptrdiff_t> {
605  friend struct TargetRegistry;
606 
607  const Target *Current = nullptr;
608 
609  explicit iterator(Target *T) : Current(T) {}
610 
611  public:
612  iterator() = default;
613 
614  bool operator==(const iterator &x) const { return Current == x.Current; }
615  bool operator!=(const iterator &x) const { return !operator==(x); }
616 
617  // Iterator traversal: forward iteration only
618  iterator &operator++() { // Preincrement
619  assert(Current && "Cannot increment end iterator!");
620  Current = Current->getNext();
621  return *this;
622  }
623  iterator operator++(int) { // Postincrement
624  iterator tmp = *this;
625  ++*this;
626  return tmp;
627  }
628 
629  const Target &operator*() const {
630  assert(Current && "Cannot dereference end iterator!");
631  return *Current;
632  }
633 
634  const Target *operator->() const { return &operator*(); }
635  };
636 
637  /// printRegisteredTargetsForVersion - Print the registered targets
638  /// appropriately for inclusion in a tool's version output.
639  static void printRegisteredTargetsForVersion(raw_ostream &OS);
640 
641  /// @name Registry Access
642  /// @{
643 
644  static iterator_range<iterator> targets();
645 
646  /// lookupTarget - Lookup a target based on a target triple.
647  ///
648  /// \param Triple - The triple to use for finding a target.
649  /// \param Error - On failure, an error string describing why no target was
650  /// found.
651  static const Target *lookupTarget(const std::string &Triple,
652  std::string &Error);
653 
654  /// lookupTarget - Lookup a target based on an architecture name
655  /// and a target triple. If the architecture name is non-empty,
656  /// then the lookup is done by architecture. Otherwise, the target
657  /// triple is used.
658  ///
659  /// \param ArchName - The architecture to use for finding a target.
660  /// \param TheTriple - The triple to use for finding a target. The
661  /// triple is updated with canonical architecture name if a lookup
662  /// by architecture is done.
663  /// \param Error - On failure, an error string describing why no target was
664  /// found.
665  static const Target *lookupTarget(const std::string &ArchName,
666  Triple &TheTriple, std::string &Error);
667 
668  /// @}
669  /// @name Target Registration
670  /// @{
671 
672  /// RegisterTarget - Register the given target. Attempts to register a
673  /// target which has already been registered will be ignored.
674  ///
675  /// Clients are responsible for ensuring that registration doesn't occur
676  /// while another thread is attempting to access the registry. Typically
677  /// this is done by initializing all targets at program startup.
678  ///
679  /// @param T - The target being registered.
680  /// @param Name - The target name. This should be a static string.
681  /// @param ShortDesc - A short target description. This should be a static
682  /// string.
683  /// @param BackendName - The name of the backend. This should be a static
684  /// string that is the same for all targets that share a backend
685  /// implementation and must match the name used in the 'def X : Target ...' in
686  /// TableGen.
687  /// @param ArchMatchFn - The arch match checking function for this target.
688  /// @param HasJIT - Whether the target supports JIT code
689  /// generation.
690  static void RegisterTarget(Target &T, const char *Name, const char *ShortDesc,
691  const char *BackendName,
692  Target::ArchMatchFnTy ArchMatchFn,
693  bool HasJIT = false);
694 
695  /// RegisterMCAsmInfo - Register a MCAsmInfo implementation for the
696  /// given target.
697  ///
698  /// Clients are responsible for ensuring that registration doesn't occur
699  /// while another thread is attempting to access the registry. Typically
700  /// this is done by initializing all targets at program startup.
701  ///
702  /// @param T - The target being registered.
703  /// @param Fn - A function to construct a MCAsmInfo for the target.
705  T.MCAsmInfoCtorFn = Fn;
706  }
707 
708  /// RegisterMCInstrInfo - Register a MCInstrInfo implementation for the
709  /// given target.
710  ///
711  /// Clients are responsible for ensuring that registration doesn't occur
712  /// while another thread is attempting to access the registry. Typically
713  /// this is done by initializing all targets at program startup.
714  ///
715  /// @param T - The target being registered.
716  /// @param Fn - A function to construct a MCInstrInfo for the target.
718  T.MCInstrInfoCtorFn = Fn;
719  }
720 
721  /// RegisterMCInstrAnalysis - Register a MCInstrAnalysis implementation for
722  /// the given target.
725  T.MCInstrAnalysisCtorFn = Fn;
726  }
727 
728  /// RegisterMCRegInfo - Register a MCRegisterInfo implementation for the
729  /// given target.
730  ///
731  /// Clients are responsible for ensuring that registration doesn't occur
732  /// while another thread is attempting to access the registry. Typically
733  /// this is done by initializing all targets at program startup.
734  ///
735  /// @param T - The target being registered.
736  /// @param Fn - A function to construct a MCRegisterInfo for the target.
738  T.MCRegInfoCtorFn = Fn;
739  }
740 
741  /// RegisterMCSubtargetInfo - Register a MCSubtargetInfo implementation for
742  /// the given target.
743  ///
744  /// Clients are responsible for ensuring that registration doesn't occur
745  /// while another thread is attempting to access the registry. Typically
746  /// this is done by initializing all targets at program startup.
747  ///
748  /// @param T - The target being registered.
749  /// @param Fn - A function to construct a MCSubtargetInfo for the target.
752  T.MCSubtargetInfoCtorFn = Fn;
753  }
754 
755  /// RegisterTargetMachine - Register a TargetMachine implementation for the
756  /// given target.
757  ///
758  /// Clients are responsible for ensuring that registration doesn't occur
759  /// while another thread is attempting to access the registry. Typically
760  /// this is done by initializing all targets at program startup.
761  ///
762  /// @param T - The target being registered.
763  /// @param Fn - A function to construct a TargetMachine for the target.
765  T.TargetMachineCtorFn = Fn;
766  }
767 
768  /// RegisterMCAsmBackend - Register a MCAsmBackend implementation for the
769  /// given target.
770  ///
771  /// Clients are responsible for ensuring that registration doesn't occur
772  /// while another thread is attempting to access the registry. Typically
773  /// this is done by initializing all targets at program startup.
774  ///
775  /// @param T - The target being registered.
776  /// @param Fn - A function to construct an AsmBackend for the target.
778  T.MCAsmBackendCtorFn = Fn;
779  }
780 
781  /// RegisterMCAsmParser - Register a MCTargetAsmParser implementation for
782  /// the given target.
783  ///
784  /// Clients are responsible for ensuring that registration doesn't occur
785  /// while another thread is attempting to access the registry. Typically
786  /// this is done by initializing all targets at program startup.
787  ///
788  /// @param T - The target being registered.
789  /// @param Fn - A function to construct an MCTargetAsmParser for the target.
791  T.MCAsmParserCtorFn = Fn;
792  }
793 
794  /// RegisterAsmPrinter - Register an AsmPrinter implementation for the given
795  /// 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 AsmPrinter for the target.
804  T.AsmPrinterCtorFn = Fn;
805  }
806 
807  /// RegisterMCDisassembler - Register a MCDisassembler implementation for
808  /// the given target.
809  ///
810  /// Clients are responsible for ensuring that registration doesn't occur
811  /// while another thread is attempting to access the registry. Typically
812  /// this is done by initializing all targets at program startup.
813  ///
814  /// @param T - The target being registered.
815  /// @param Fn - A function to construct an MCDisassembler for the target.
818  T.MCDisassemblerCtorFn = Fn;
819  }
820 
821  /// RegisterMCInstPrinter - Register a MCInstPrinter implementation for the
822  /// given target.
823  ///
824  /// Clients are responsible for ensuring that registration doesn't occur
825  /// while another thread is attempting to access the registry. Typically
826  /// this is done by initializing all targets at program startup.
827  ///
828  /// @param T - The target being registered.
829  /// @param Fn - A function to construct an MCInstPrinter for the target.
831  T.MCInstPrinterCtorFn = Fn;
832  }
833 
834  /// RegisterMCCodeEmitter - Register a MCCodeEmitter implementation for the
835  /// given target.
836  ///
837  /// Clients are responsible for ensuring that registration doesn't occur
838  /// while another thread is attempting to access the registry. Typically
839  /// this is done by initializing all targets at program startup.
840  ///
841  /// @param T - The target being registered.
842  /// @param Fn - A function to construct an MCCodeEmitter for the target.
844  T.MCCodeEmitterCtorFn = Fn;
845  }
846 
848  T.COFFStreamerCtorFn = Fn;
849  }
850 
852  T.MachOStreamerCtorFn = Fn;
853  }
854 
856  T.ELFStreamerCtorFn = Fn;
857  }
858 
860  T.WasmStreamerCtorFn = Fn;
861  }
862 
865  T.NullTargetStreamerCtorFn = Fn;
866  }
867 
870  T.AsmTargetStreamerCtorFn = Fn;
871  }
872 
873  static void
876  T.ObjectTargetStreamerCtorFn = Fn;
877  }
878 
879  /// RegisterMCRelocationInfo - Register an MCRelocationInfo
880  /// implementation for the given target.
881  ///
882  /// Clients are responsible for ensuring that registration doesn't occur
883  /// while another thread is attempting to access the registry. Typically
884  /// this is done by initializing all targets at program startup.
885  ///
886  /// @param T - The target being registered.
887  /// @param Fn - A function to construct an MCRelocationInfo for the target.
890  T.MCRelocationInfoCtorFn = Fn;
891  }
892 
893  /// RegisterMCSymbolizer - Register an MCSymbolizer
894  /// implementation for the given target.
895  ///
896  /// Clients are responsible for ensuring that registration doesn't occur
897  /// while another thread is attempting to access the registry. Typically
898  /// this is done by initializing all targets at program startup.
899  ///
900  /// @param T - The target being registered.
901  /// @param Fn - A function to construct an MCSymbolizer for the target.
903  T.MCSymbolizerCtorFn = Fn;
904  }
905 
906  /// @}
907 };
908 
909 //===--------------------------------------------------------------------===//
910 
911 /// RegisterTarget - Helper template for registering a target, for use in the
912 /// target's initialization function. Usage:
913 ///
914 ///
915 /// Target &getTheFooTarget() { // The global target instance.
916 /// static Target TheFooTarget;
917 /// return TheFooTarget;
918 /// }
919 /// extern "C" void LLVMInitializeFooTargetInfo() {
920 /// RegisterTarget<Triple::foo> X(getTheFooTarget(), "foo", "Foo
921 /// description", "Foo" /* Backend Name */);
922 /// }
923 template <Triple::ArchType TargetArchType = Triple::UnknownArch,
924  bool HasJIT = false>
926  RegisterTarget(Target &T, const char *Name, const char *Desc,
927  const char *BackendName) {
928  TargetRegistry::RegisterTarget(T, Name, Desc, BackendName, &getArchMatch,
929  HasJIT);
930  }
931 
932  static bool getArchMatch(Triple::ArchType Arch) {
933  return Arch == TargetArchType;
934  }
935 };
936 
937 /// RegisterMCAsmInfo - Helper template for registering a target assembly info
938 /// implementation. This invokes the static "Create" method on the class to
939 /// actually do the construction. Usage:
940 ///
941 /// extern "C" void LLVMInitializeFooTarget() {
942 /// extern Target TheFooTarget;
943 /// RegisterMCAsmInfo<FooMCAsmInfo> X(TheFooTarget);
944 /// }
945 template <class MCAsmInfoImpl> struct RegisterMCAsmInfo {
948  }
949 
950 private:
951  static MCAsmInfo *Allocator(const MCRegisterInfo & /*MRI*/,
952  const Triple &TT) {
953  return new MCAsmInfoImpl(TT);
954  }
955 };
956 
957 /// RegisterMCAsmInfoFn - Helper template for registering a target assembly info
958 /// implementation. This invokes the specified function to do the
959 /// construction. Usage:
960 ///
961 /// extern "C" void LLVMInitializeFooTarget() {
962 /// extern Target TheFooTarget;
963 /// RegisterMCAsmInfoFn X(TheFooTarget, TheFunction);
964 /// }
968  }
969 };
970 
971 /// RegisterMCInstrInfo - Helper template for registering a target instruction
972 /// info implementation. This invokes the static "Create" method on the class
973 /// to actually do the construction. Usage:
974 ///
975 /// extern "C" void LLVMInitializeFooTarget() {
976 /// extern Target TheFooTarget;
977 /// RegisterMCInstrInfo<FooMCInstrInfo> X(TheFooTarget);
978 /// }
979 template <class MCInstrInfoImpl> struct RegisterMCInstrInfo {
982  }
983 
984 private:
985  static MCInstrInfo *Allocator() { return new MCInstrInfoImpl(); }
986 };
987 
988 /// RegisterMCInstrInfoFn - Helper template for registering a target
989 /// instruction info implementation. This invokes the specified function to
990 /// do the construction. Usage:
991 ///
992 /// extern "C" void LLVMInitializeFooTarget() {
993 /// extern Target TheFooTarget;
994 /// RegisterMCInstrInfoFn X(TheFooTarget, TheFunction);
995 /// }
999  }
1000 };
1001 
1002 /// RegisterMCInstrAnalysis - Helper template for registering a target
1003 /// instruction analyzer implementation. This invokes the static "Create"
1004 /// method on the class to actually do the construction. Usage:
1005 ///
1006 /// extern "C" void LLVMInitializeFooTarget() {
1007 /// extern Target TheFooTarget;
1008 /// RegisterMCInstrAnalysis<FooMCInstrAnalysis> X(TheFooTarget);
1009 /// }
1010 template <class MCInstrAnalysisImpl> struct RegisterMCInstrAnalysis {
1013  }
1014 
1015 private:
1016  static MCInstrAnalysis *Allocator(const MCInstrInfo *Info) {
1017  return new MCInstrAnalysisImpl(Info);
1018  }
1019 };
1020 
1021 /// RegisterMCInstrAnalysisFn - Helper template for registering a target
1022 /// instruction analyzer implementation. This invokes the specified function
1023 /// to do the construction. Usage:
1024 ///
1025 /// extern "C" void LLVMInitializeFooTarget() {
1026 /// extern Target TheFooTarget;
1027 /// RegisterMCInstrAnalysisFn X(TheFooTarget, TheFunction);
1028 /// }
1032  }
1033 };
1034 
1035 /// RegisterMCRegInfo - Helper template for registering a target register info
1036 /// implementation. This invokes the static "Create" method on the class to
1037 /// actually do the construction. Usage:
1038 ///
1039 /// extern "C" void LLVMInitializeFooTarget() {
1040 /// extern Target TheFooTarget;
1041 /// RegisterMCRegInfo<FooMCRegInfo> X(TheFooTarget);
1042 /// }
1043 template <class MCRegisterInfoImpl> struct RegisterMCRegInfo {
1046  }
1047 
1048 private:
1049  static MCRegisterInfo *Allocator(const Triple & /*TT*/) {
1050  return new MCRegisterInfoImpl();
1051  }
1052 };
1053 
1054 /// RegisterMCRegInfoFn - Helper template for registering a target register
1055 /// info implementation. This invokes the specified function to do the
1056 /// construction. Usage:
1057 ///
1058 /// extern "C" void LLVMInitializeFooTarget() {
1059 /// extern Target TheFooTarget;
1060 /// RegisterMCRegInfoFn X(TheFooTarget, TheFunction);
1061 /// }
1065  }
1066 };
1067 
1068 /// RegisterMCSubtargetInfo - Helper template for registering a target
1069 /// subtarget info implementation. This invokes the static "Create" method
1070 /// on the class to actually do the construction. Usage:
1071 ///
1072 /// extern "C" void LLVMInitializeFooTarget() {
1073 /// extern Target TheFooTarget;
1074 /// RegisterMCSubtargetInfo<FooMCSubtargetInfo> X(TheFooTarget);
1075 /// }
1076 template <class MCSubtargetInfoImpl> struct RegisterMCSubtargetInfo {
1079  }
1080 
1081 private:
1082  static MCSubtargetInfo *Allocator(const Triple & /*TT*/, StringRef /*CPU*/,
1083  StringRef /*FS*/) {
1084  return new MCSubtargetInfoImpl();
1085  }
1086 };
1087 
1088 /// RegisterMCSubtargetInfoFn - Helper template for registering a target
1089 /// subtarget info implementation. This invokes the specified function to
1090 /// do the construction. Usage:
1091 ///
1092 /// extern "C" void LLVMInitializeFooTarget() {
1093 /// extern Target TheFooTarget;
1094 /// RegisterMCSubtargetInfoFn X(TheFooTarget, TheFunction);
1095 /// }
1099  }
1100 };
1101 
1102 /// RegisterTargetMachine - Helper template for registering a target machine
1103 /// implementation, for use in the target machine initialization
1104 /// function. Usage:
1105 ///
1106 /// extern "C" void LLVMInitializeFooTarget() {
1107 /// extern Target TheFooTarget;
1108 /// RegisterTargetMachine<FooTargetMachine> X(TheFooTarget);
1109 /// }
1110 template <class TargetMachineImpl> struct RegisterTargetMachine {
1113  }
1114 
1115 private:
1116  static TargetMachine *
1117  Allocator(const Target &T, const Triple &TT, StringRef CPU, StringRef FS,
1118  const TargetOptions &Options, Optional<Reloc::Model> RM,
1119  Optional<CodeModel::Model> CM, CodeGenOpt::Level OL, bool JIT) {
1120  return new TargetMachineImpl(T, TT, CPU, FS, Options, RM, CM, OL, JIT);
1121  }
1122 };
1123 
1124 /// RegisterMCAsmBackend - Helper template for registering a target specific
1125 /// assembler backend. Usage:
1126 ///
1127 /// extern "C" void LLVMInitializeFooMCAsmBackend() {
1128 /// extern Target TheFooTarget;
1129 /// RegisterMCAsmBackend<FooAsmLexer> X(TheFooTarget);
1130 /// }
1131 template <class MCAsmBackendImpl> struct RegisterMCAsmBackend {
1134  }
1135 
1136 private:
1137  static MCAsmBackend *Allocator(const Target &T, const MCSubtargetInfo &STI,
1138  const MCRegisterInfo &MRI,
1139  const MCTargetOptions &Options) {
1140  return new MCAsmBackendImpl(T, STI, MRI);
1141  }
1142 };
1143 
1144 /// RegisterMCAsmParser - Helper template for registering a target specific
1145 /// assembly parser, for use in the target machine initialization
1146 /// function. Usage:
1147 ///
1148 /// extern "C" void LLVMInitializeFooMCAsmParser() {
1149 /// extern Target TheFooTarget;
1150 /// RegisterMCAsmParser<FooAsmParser> X(TheFooTarget);
1151 /// }
1152 template <class MCAsmParserImpl> struct RegisterMCAsmParser {
1155  }
1156 
1157 private:
1158  static MCTargetAsmParser *Allocator(const MCSubtargetInfo &STI,
1159  MCAsmParser &P, const MCInstrInfo &MII,
1160  const MCTargetOptions &Options) {
1161  return new MCAsmParserImpl(STI, P, MII, Options);
1162  }
1163 };
1164 
1165 /// RegisterAsmPrinter - Helper template for registering a target specific
1166 /// assembly printer, for use in the target machine initialization
1167 /// function. Usage:
1168 ///
1169 /// extern "C" void LLVMInitializeFooAsmPrinter() {
1170 /// extern Target TheFooTarget;
1171 /// RegisterAsmPrinter<FooAsmPrinter> X(TheFooTarget);
1172 /// }
1173 template <class AsmPrinterImpl> struct RegisterAsmPrinter {
1176  }
1177 
1178 private:
1179  static AsmPrinter *Allocator(TargetMachine &TM,
1180  std::unique_ptr<MCStreamer> &&Streamer) {
1181  return new AsmPrinterImpl(TM, std::move(Streamer));
1182  }
1183 };
1184 
1185 /// RegisterMCCodeEmitter - Helper template for registering a target specific
1186 /// machine code emitter, for use in the target initialization
1187 /// function. Usage:
1188 ///
1189 /// extern "C" void LLVMInitializeFooMCCodeEmitter() {
1190 /// extern Target TheFooTarget;
1191 /// RegisterMCCodeEmitter<FooCodeEmitter> X(TheFooTarget);
1192 /// }
1193 template <class MCCodeEmitterImpl> struct RegisterMCCodeEmitter {
1196  }
1197 
1198 private:
1199  static MCCodeEmitter *Allocator(const MCInstrInfo & /*II*/,
1200  const MCRegisterInfo & /*MRI*/,
1201  MCContext & /*Ctx*/) {
1202  return new MCCodeEmitterImpl();
1203  }
1204 };
1205 
1206 } // end namespace llvm
1207 
1208 #endif // LLVM_SUPPORT_TARGETREGISTRY_H
const Target * operator->() const
RegisterMCSubtargetInfoFn(Target &T, Target::MCSubtargetInfoCtorFnTy Fn)
MCTargetStreamer *(*)(MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint, bool IsVerboseAsm) AsmTargetStreamerCtorTy
MCStreamer * createMCObjectStreamer(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, const MCSubtargetInfo &STI, bool RelaxAll, bool IncrementalLinkerCompatible, bool DWARFMustBeAtTheEnd) const
Create a target specific MCStreamer.
Target()=default
RegisterMCInstrInfoFn - Helper template for registering a target instruction info implementation...
This class represents lattice values for constants.
Definition: AllocatorList.h:23
RegisterMCAsmInfoFn(Target &T, Target::MCAsmInfoCtorFnTy Fn)
Generic assembler parser interface, for use by target specific assembly parsers.
Definition: MCAsmParser.h:109
TargetMachine * createTargetMachine(StringRef TT, StringRef CPU, StringRef Features, const TargetOptions &Options, Optional< Reloc::Model > RM, Optional< CodeModel::Model > CM=None, CodeGenOpt::Level OL=CodeGenOpt::Default, bool JIT=false) const
createTargetMachine - Create a target specific machine implementation for the specified Triple...
bool hasTargetMachine() const
hasTargetMachine - Check if this target supports code generation.
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
RegisterMCSubtargetInfo - Helper template for registering a target subtarget info implementation...
formatted_raw_ostream - A raw_ostream that wraps another one and keeps track of line and column posit...
static void RegisterMCInstrAnalysis(Target &T, Target::MCInstrAnalysisCtorFnTy Fn)
RegisterMCInstrAnalysis - Register a MCInstrAnalysis implementation for the given target...
MCTargetAsmParser - Generic interface to target specific assembly parsers.
Superclass for all disassemblers.
This provides a very simple, boring adaptor for a begin and end iterator into a range type...
MCCodeEmitter *(*)(const MCInstrInfo &II, const MCRegisterInfo &MRI, MCContext &Ctx) MCCodeEmitterCtorTy
MCSymbolizer *(*)(const Triple &TT, LLVMOpInfoCallback GetOpInfo, LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx, std::unique_ptr< MCRelocationInfo > &&RelInfo) MCSymbolizerCtorTy
Target specific streamer interface.
Definition: MCStreamer.h:85
MCAsmBackend * createMCAsmBackend(const MCSubtargetInfo &STI, const MCRegisterInfo &MRI, const MCTargetOptions &Options) const
createMCAsmBackend - Create a target specific assembly parser.
RegisterMCCodeEmitter(Target &T)
MCInstrInfo * createMCInstrInfo() const
createMCInstrInfo - Create a MCInstrInfo implementation.
MCSubtargetInfo *(*)(const Triple &TT, StringRef CPU, StringRef Features) MCSubtargetInfoCtorFnTy
MCStreamer * createNullStreamer(MCContext &Ctx)
Create a dummy machine code streamer, which does nothing.
RegisterMCInstrAnalysis(Target &T)
MCTargetStreamer *(*)(MCStreamer &S) NullTargetStreamerCtorTy
MCDisassembler * createMCDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx) const
static void RegisterMCDisassembler(Target &T, Target::MCDisassemblerCtorTy Fn)
RegisterMCDisassembler - Register a MCDisassembler implementation for the given target.
TargetRegistry - Generic interface to target specific features.
static void RegisterMCInstPrinter(Target &T, Target::MCInstPrinterCtorTy Fn)
RegisterMCInstPrinter - Register a MCInstPrinter implementation for the given target.
MCSymbolizer * createMCSymbolizer(const Triple &TT, LLVMOpInfoCallback GetOpInfo, LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx, std::unique_ptr< MCRelocationInfo > &&RelInfo)
static void RegisterAsmTargetStreamer(Target &T, Target::AsmTargetStreamerCtorTy Fn)
RegisterMCInstrAnalysisFn - Helper template for registering a target instruction analyzer implementat...
static void RegisterWasmStreamer(Target &T, Target::WasmStreamerCtorTy Fn)
const char * getShortDescription() const
getShortDescription - Get a short description of the target.
const char * getName() const
getName - Get the target name.
RegisterMCAsmBackend(Target &T)
RegisterTargetMachine(Target &T)
MCInstPrinter * createMCInstPrinter(const Triple &T, unsigned SyntaxVariant, const MCAsmInfo &MAI, const MCInstrInfo &MII, const MCRegisterInfo &MRI) const
MCStreamer * createXCOFFStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE, bool RelaxAll)
bool hasMCAsmParser() const
hasMCAsmParser - Check if this target supports assembly parsing.
RegisterMCRegInfoFn - Helper template for registering a target register info implementation.
static void RegisterCOFFStreamer(Target &T, Target::COFFStreamerCtorTy Fn)
int(* LLVMOpInfoCallback)(void *DisInfo, uint64_t PC, uint64_t Offset, uint64_t Size, int TagType, void *TagBuf)
The type for the operand information call back function.
MCAsmBackend *(*)(const Target &T, const MCSubtargetInfo &STI, const MCRegisterInfo &MRI, const MCTargetOptions &Options) MCAsmBackendCtorTy
APInt operator*(APInt a, uint64_t RHS)
Definition: APInt.h:2099
MCInstrAnalysis *(*)(const MCInstrInfo *Info) MCInstrAnalysisCtorFnTy
Context object for machine code objects.
Definition: MCContext.h:65
MCStreamer * createNullStreamer(MCContext &Ctx) const
MCRegisterInfo *(*)(const Triple &TT) MCRegInfoCtorFnTy
RegisterTargetMachine - Helper template for registering a target machine implementation, for use in the target machine initialization function.
RegisterMCAsmParser - Helper template for registering a target specific assembly parser, for use in the target machine initialization function.
static void RegisterTargetMachine(Target &T, Target::TargetMachineCtorTy Fn)
RegisterTargetMachine - Register a TargetMachine implementation for the given target.
MCStreamer * createAsmStreamer(MCContext &Ctx, std::unique_ptr< formatted_raw_ostream > OS, bool isVerboseAsm, bool useDwarfDirectory, MCInstPrinter *InstPrint, MCCodeEmitter *CE, MCAsmBackend *TAB, bool ShowInst)
Create a machine code streamer which will print out assembly for the native target, suitable for compiling with a native assembler.
RegisterAsmPrinter - Helper template for registering a target specific assembly printer, for use in the target machine initialization function.
RegisterMCInstrAnalysis - Helper template for registering a target instruction analyzer implementatio...
const Target & operator*() const
MCCodeEmitter * createMCCodeEmitter(const MCInstrInfo &II, const MCRegisterInfo &MRI, MCContext &Ctx) const
createMCCodeEmitter - Create a target specific code emitter.
AsmPrinter *(*)(TargetMachine &TM, std::unique_ptr< MCStreamer > &&Streamer) AsmPrinterCtorTy
Analysis containing CSE Info
Definition: CSEInfo.cpp:20
MCRelocationInfo * createMCRelocationInfo(const Triple &TT, MCContext &Ctx)
MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...
This class is intended to be used as a base class for asm properties and features specific to the tar...
Definition: MCAsmInfo.h:56
bool isOSWindows() const
Tests whether the OS is Windows.
Definition: Triple.h:538
const Target * getNext() const
static void RegisterMCAsmBackend(Target &T, Target::MCAsmBackendCtorTy Fn)
RegisterMCAsmBackend - Register a MCAsmBackend implementation for the given target.
#define P(N)
RegisterMCSubtargetInfoFn - Helper template for registering a target subtarget info implementation...
Streaming machine code generation interface.
Definition: MCStreamer.h:190
MCTargetAsmParser *(*)(const MCSubtargetInfo &STI, MCAsmParser &P, const MCInstrInfo &MII, const MCTargetOptions &Options) MCAsmParserCtorTy
unsigned const MachineRegisterInfo * MRI
RegisterAsmPrinter(Target &T)
AsmPrinter * createAsmPrinter(TargetMachine &TM, std::unique_ptr< MCStreamer > &&Streamer) const
createAsmPrinter - Create a target specific assembly printer pass.
static void RegisterMCAsmParser(Target &T, Target::MCAsmParserCtorTy Fn)
RegisterMCAsmParser - Register a MCTargetAsmParser implementation for the given target.
Symbolize and annotate disassembled instructions.
Definition: MCSymbolizer.h:38
MCDisassembler *(*)(const Target &T, const MCSubtargetInfo &STI, MCContext &Ctx) MCDisassemblerCtorTy
static void RegisterMachOStreamer(Target &T, Target::MachOStreamerCtorTy Fn)
MCStreamer * createELFStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE, bool RelaxAll)
MCCodeEmitter - Generic instruction encoding interface.
Definition: MCCodeEmitter.h:21
Interface to description of machine instruction set.
Definition: MCInstrInfo.h:23
RegisterMCRegInfo(Target &T)
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:78
bool(*)(Triple::ArchType Arch) ArchMatchFnTy
static void RegisterTarget(Target &T, const char *Name, const char *ShortDesc, const char *BackendName, Target::ArchMatchFnTy ArchMatchFn, bool HasJIT=false)
RegisterTarget - Register the given target.
Create MCExprs from relocations found in an object file.
MCRegisterInfo * createMCRegInfo(StringRef TT) const
createMCRegInfo - Create a MCRegisterInfo implementation.
static void RegisterMCAsmInfo(Target &T, Target::MCAsmInfoCtorFnTy Fn)
RegisterMCAsmInfo - Register a MCAsmInfo implementation for the given target.
MCTargetAsmParser * createMCAsmParser(const MCSubtargetInfo &STI, MCAsmParser &Parser, const MCInstrInfo &MII, const MCTargetOptions &Options) const
createMCAsmParser - Create a target specific assembly parser.
static void RegisterMCSubtargetInfo(Target &T, Target::MCSubtargetInfoCtorFnTy Fn)
RegisterMCSubtargetInfo - Register a MCSubtargetInfo implementation for the given target...
static void RegisterObjectTargetStreamer(Target &T, Target::ObjectTargetStreamerCtorTy Fn)
friend struct TargetRegistry
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:43
MCTargetStreamer * createAsmTargetStreamer(MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint, bool IsVerboseAsm) const
RegisterMCAsmBackend - Helper template for registering a target specific assembler backend...
Basic Register Allocator
MCInstrAnalysis * createMCInstrAnalysis(const MCInstrInfo *Info) const
createMCInstrAnalysis - Create a MCInstrAnalysis implementation.
RegisterTarget(Target &T, const char *Name, const char *Desc, const char *BackendName)
static void RegisterMCCodeEmitter(Target &T, Target::MCCodeEmitterCtorTy Fn)
RegisterMCCodeEmitter - Register a MCCodeEmitter implementation for the given target.
bool hasMCAsmBackend() const
hasMCAsmBackend - Check if this target supports .o generation.
MCTargetStreamer *(*)(MCStreamer &S, const MCSubtargetInfo &STI) ObjectTargetStreamerCtorTy
RegisterMCSubtargetInfo(Target &T)
RegisterMCAsmInfo(Target &T)
MCAsmInfo * createMCAsmInfo(const MCRegisterInfo &MRI, StringRef TheTriple) const
createMCAsmInfo - Create a MCAsmInfo implementation for the specified target triple.
A range adaptor for a pair of iterators.
static void RegisterMCRegInfo(Target &T, Target::MCRegInfoCtorFnTy Fn)
RegisterMCRegInfo - Register a MCRegisterInfo implementation for the given target.
Target - Wrapper for Target specific information.
RegisterMCInstrInfo(Target &T)
RegisterMCInstrAnalysisFn(Target &T, Target::MCInstrAnalysisCtorFnTy Fn)
MCAsmInfo *(*)(const MCRegisterInfo &MRI, const Triple &TT) MCAsmInfoCtorFnTy
MCSubtargetInfo * createMCSubtargetInfo(StringRef TheTriple, StringRef CPU, StringRef Features) const
createMCSubtargetInfo - Create a MCSubtargetInfo implementation.
RegisterMCAsmParser(Target &T)
This is an instance of a target assembly language printer that converts an MCInst to valid target ass...
Definition: MCInstPrinter.h:39
ObjectFormatType getObjectFormat() const
getFormat - Get the object format for this triple.
Definition: Triple.h:326
MCRelocationInfo *(*)(const Triple &TT, MCContext &Ctx) MCRelocationInfoCtorTy
static void RegisterMCInstrInfo(Target &T, Target::MCInstrInfoCtorFnTy Fn)
RegisterMCInstrInfo - Register a MCInstrInfo implementation for the given target. ...
Generic base class for all target subtargets.
TargetMachine *(*)(const Target &T, const Triple &TT, StringRef CPU, StringRef Features, const TargetOptions &Options, Optional< Reloc::Model > RM, Optional< CodeModel::Model > CM, CodeGenOpt::Level OL, bool JIT) TargetMachineCtorTy
MCSymbolizer * createMCSymbolizer(StringRef TT, LLVMOpInfoCallback GetOpInfo, LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx, std::unique_ptr< MCRelocationInfo > &&RelInfo) const
createMCSymbolizer - Create a target specific MCSymbolizer.
static bool getArchMatch(Triple::ArchType Arch)
const char * getBackendName() const
getBackendName - Get the backend name.
static void RegisterELFStreamer(Target &T, Target::ELFStreamerCtorTy Fn)
MCStreamer * createAsmStreamer(MCContext &Ctx, std::unique_ptr< formatted_raw_ostream > OS, bool IsVerboseAsm, bool UseDwarfDirectory, MCInstPrinter *InstPrint, std::unique_ptr< MCCodeEmitter > &&CE, std::unique_ptr< MCAsmBackend > &&TAB, bool ShowInst) const
bool operator!=(const iterator &x) const
MCStreamer *(*)(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool RelaxAll, bool DWARFMustBeAtTheEnd) MachOStreamerCtorTy
static void RegisterMCSymbolizer(Target &T, Target::MCSymbolizerCtorTy Fn)
RegisterMCSymbolizer - Register an MCSymbolizer implementation for the given target.
RegisterMCInstrInfoFn(Target &T, Target::MCInstrInfoCtorFnTy Fn)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
RegisterMCRegInfo - Helper template for registering a target register info implementation.
MCRelocationInfo * createMCRelocationInfo(StringRef TT, MCContext &Ctx) const
createMCRelocationInfo - Create a target specific MCRelocationInfo.
RegisterMCAsmInfoFn - Helper template for registering a target assembly info implementation.
static void RegisterNullTargetStreamer(Target &T, Target::NullTargetStreamerCtorTy Fn)
Generic interface to target specific assembler backends.
Definition: MCAsmBackend.h:41
RegisterMCAsmInfo - Helper template for registering a target assembly info implementation.
bool hasJIT() const
hasJIT - Check if this targets supports the just-in-time compilation.
MCStreamer *(*)(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool RelaxAll) ELFStreamerCtorTy
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
MCTargetStreamer * createNullTargetStreamer(MCStreamer &S) const
static void RegisterMCRelocationInfo(Target &T, Target::MCRelocationInfoCtorTy Fn)
RegisterMCRelocationInfo - Register an MCRelocationInfo implementation for the given target...
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
MCInstPrinter *(*)(const Triple &T, unsigned SyntaxVariant, const MCAsmInfo &MAI, const MCInstrInfo &MII, const MCRegisterInfo &MRI) MCInstPrinterCtorTy
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:65
static void RegisterAsmPrinter(Target &T, Target::AsmPrinterCtorTy Fn)
RegisterAsmPrinter - Register an AsmPrinter implementation for the given target.
MCStreamer * createWasmStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE, bool RelaxAll)
MCInstrInfo *(*)() MCInstrInfoCtorFnTy
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
MCStreamer *(*)(const Triple &T, MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool RelaxAll) WasmStreamerCtorTy
bool operator==(uint64_t V1, const APInt &V2)
Definition: APInt.h:1975
MCStreamer * createMachOStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE, bool RelaxAll, bool DWARFMustBeAtTheEnd, bool LabelSections=false)
const char *(* LLVMSymbolLookupCallback)(void *DisInfo, uint64_t ReferenceValue, uint64_t *ReferenceType, uint64_t ReferencePC, const char **ReferenceName)
The type for the symbol lookup function.
bool operator==(const iterator &x) const
RegisterMCCodeEmitter - Helper template for registering a target specific machine code emitter...
RegisterMCRegInfoFn(Target &T, Target::MCRegInfoCtorFnTy Fn)
MCStreamer *(*)(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&Emitter, bool RelaxAll, bool IncrementalLinkerCompatible) COFFStreamerCtorTy
RegisterMCInstrInfo - Helper template for registering a target instruction info implementation.