1 //===- TargetSelect.h - Target Selection & 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 provides utilities to make sure that certain classes of targets are
10 // linked into the main application executable, and initialize them as
11 // appropriate.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_SUPPORT_TARGETSELECT_H
16 #define LLVM_SUPPORT_TARGETSELECT_H
17 
18 #include "llvm/Config/llvm-config.h"
19 
20 extern "C" {
21   // Declare all of the target-initialization functions that are available.
22 #define LLVM_TARGET(TargetName) void LLVMInitialize##TargetName##TargetInfo();
23 #include "llvm/Config/Targets.def"
24 
25 #define LLVM_TARGET(TargetName) void LLVMInitialize##TargetName##Target();
26 #include "llvm/Config/Targets.def"
27 
28   // Declare all of the target-MC-initialization functions that are available.
29 #define LLVM_TARGET(TargetName) void LLVMInitialize##TargetName##TargetMC();
30 #include "llvm/Config/Targets.def"
31 
32   // Declare all of the available assembly printer initialization functions.
33 #define LLVM_ASM_PRINTER(TargetName) void LLVMInitialize##TargetName##AsmPrinter();
34 #include "llvm/Config/AsmPrinters.def"
35 
36   // Declare all of the available assembly parser initialization functions.
37 #define LLVM_ASM_PARSER(TargetName) void LLVMInitialize##TargetName##AsmParser();
38 #include "llvm/Config/AsmParsers.def"
39 
40   // Declare all of the available disassembler initialization functions.
41 #define LLVM_DISASSEMBLER(TargetName) \
42   void LLVMInitialize##TargetName##Disassembler();
43 #include "llvm/Config/Disassemblers.def"
44 }
45 
46 namespace llvm {
47   /// InitializeAllTargetInfos - The main program should call this function if
48   /// it wants access to all available targets that LLVM is configured to
49   /// support, to make them available via the TargetRegistry.
50   ///
51   /// It is legal for a client to make multiple calls to this function.
InitializeAllTargetInfos()52   inline void InitializeAllTargetInfos() {
53 #define LLVM_TARGET(TargetName) LLVMInitialize##TargetName##TargetInfo();
54 #include "llvm/Config/Targets.def"
55   }
56 
57   /// InitializeAllTargets - The main program should call this function if it
58   /// wants access to all available target machines that LLVM is configured to
59   /// support, to make them available via the TargetRegistry.
60   ///
61   /// It is legal for a client to make multiple calls to this function.
InitializeAllTargets()62   inline void InitializeAllTargets() {
63     // FIXME: Remove this, clients should do it.
64     InitializeAllTargetInfos();
65 
66 #define LLVM_TARGET(TargetName) LLVMInitialize##TargetName##Target();
67 #include "llvm/Config/Targets.def"
68   }
69 
70   /// InitializeAllTargetMCs - The main program should call this function if it
71   /// wants access to all available target MC that LLVM is configured to
72   /// support, to make them available via the TargetRegistry.
73   ///
74   /// It is legal for a client to make multiple calls to this function.
InitializeAllTargetMCs()75   inline void InitializeAllTargetMCs() {
76 #define LLVM_TARGET(TargetName) LLVMInitialize##TargetName##TargetMC();
77 #include "llvm/Config/Targets.def"
78   }
79 
80   /// InitializeAllAsmPrinters - The main program should call this function if
81   /// it wants all asm printers that LLVM is configured to support, to make them
82   /// available via the TargetRegistry.
83   ///
84   /// It is legal for a client to make multiple calls to this function.
InitializeAllAsmPrinters()85   inline void InitializeAllAsmPrinters() {
86 #define LLVM_ASM_PRINTER(TargetName) LLVMInitialize##TargetName##AsmPrinter();
87 #include "llvm/Config/AsmPrinters.def"
88   }
89 
90   /// InitializeAllAsmParsers - The main program should call this function if it
91   /// wants all asm parsers that LLVM is configured to support, to make them
92   /// available via the TargetRegistry.
93   ///
94   /// It is legal for a client to make multiple calls to this function.
InitializeAllAsmParsers()95   inline void InitializeAllAsmParsers() {
96 #define LLVM_ASM_PARSER(TargetName) LLVMInitialize##TargetName##AsmParser();
97 #include "llvm/Config/AsmParsers.def"
98   }
99 
100   /// InitializeAllDisassemblers - The main program should call this function if
101   /// it wants all disassemblers that LLVM is configured to support, to make
102   /// them available via the TargetRegistry.
103   ///
104   /// It is legal for a client to make multiple calls to this function.
InitializeAllDisassemblers()105   inline void InitializeAllDisassemblers() {
106 #define LLVM_DISASSEMBLER(TargetName) LLVMInitialize##TargetName##Disassembler();
107 #include "llvm/Config/Disassemblers.def"
108   }
109 
110   /// InitializeNativeTarget - The main program should call this function to
111   /// initialize the native target corresponding to the host.  This is useful
112   /// for JIT applications to ensure that the target gets linked in correctly.
113   ///
114   /// It is legal for a client to make multiple calls to this function.
InitializeNativeTarget()115   inline bool InitializeNativeTarget() {
116   // If we have a native target, initialize it to ensure it is linked in.
117 #ifdef LLVM_NATIVE_TARGET
118     LLVM_NATIVE_TARGETINFO();
119     LLVM_NATIVE_TARGET();
120     LLVM_NATIVE_TARGETMC();
121     return false;
122 #else
123     return true;
124 #endif
125   }
126 
127   /// InitializeNativeTargetAsmPrinter - The main program should call
128   /// this function to initialize the native target asm printer.
InitializeNativeTargetAsmPrinter()129   inline bool InitializeNativeTargetAsmPrinter() {
130   // If we have a native target, initialize the corresponding asm printer.
131 #ifdef LLVM_NATIVE_ASMPRINTER
132     LLVM_NATIVE_ASMPRINTER();
133     return false;
134 #else
135     return true;
136 #endif
137   }
138 
139   /// InitializeNativeTargetAsmParser - The main program should call
140   /// this function to initialize the native target asm parser.
InitializeNativeTargetAsmParser()141   inline bool InitializeNativeTargetAsmParser() {
142   // If we have a native target, initialize the corresponding asm parser.
143 #ifdef LLVM_NATIVE_ASMPARSER
144     LLVM_NATIVE_ASMPARSER();
145     return false;
146 #else
147     return true;
148 #endif
149   }
150 
151   /// InitializeNativeTargetDisassembler - The main program should call
152   /// this function to initialize the native target disassembler.
InitializeNativeTargetDisassembler()153   inline bool InitializeNativeTargetDisassembler() {
154   // If we have a native target, initialize the corresponding disassembler.
155 #ifdef LLVM_NATIVE_DISASSEMBLER
156     LLVM_NATIVE_DISASSEMBLER();
157     return false;
158 #else
159     return true;
160 #endif
161   }
162 }
163 
164 #endif
165