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