1//===--- TargetRegistry.cpp - Target registration -------------------------===//
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#include "llvm/MC/TargetRegistry.h"
10#include "llvm/ADT/STLExtras.h"
11#include "llvm/ADT/StringRef.h"
12#include "llvm/MC/MCAsmBackend.h"
13#include "llvm/MC/MCCodeEmitter.h"
14#include "llvm/MC/MCContext.h"
15#include "llvm/MC/MCInstPrinter.h"
16#include "llvm/MC/MCLFI.h"
17#include "llvm/MC/MCObjectStreamer.h"
18#include "llvm/MC/MCObjectWriter.h"
19#include "llvm/Support/Regex.h"
20#include "llvm/Support/raw_ostream.h"
21#include <cassert>
22#include <vector>
23using namespace llvm;
24
25// Clients are responsible for avoid race conditions in registration.
26static Target *FirstTarget = nullptr;
27
28bool Target::isValidFeatureListFormat(StringRef Features) {
29 if (Features.empty())
30 return true;
31
32 static const llvm::Regex pattern("^([+-][^,]+)(,[+-][^,]+)*,?$");
33 return pattern.match(String: Features);
34}
35
36MCStreamer *Target::createMCObjectStreamer(
37 const Triple &T, MCContext &Ctx, std::unique_ptr<MCAsmBackend> TAB,
38 std::unique_ptr<MCObjectWriter> OW, std::unique_ptr<MCCodeEmitter> Emitter,
39 const MCSubtargetInfo &STI) const {
40 MCStreamer *S = nullptr;
41 switch (T.getObjectFormat()) {
42 case Triple::UnknownObjectFormat:
43 llvm_unreachable("Unknown object format");
44 case Triple::COFF:
45 assert(T.isOSWindowsOrUEFI() && "only Windows and UEFI COFF are supported");
46 S = COFFStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),
47 std::move(Emitter));
48 break;
49 case Triple::MachO:
50 if (MachOStreamerCtorFn)
51 S = MachOStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),
52 std::move(Emitter));
53 else
54 S = createMachOStreamer(Ctx, TAB: std::move(TAB), OW: std::move(OW),
55 CE: std::move(Emitter), DWARFMustBeAtTheEnd: false);
56 break;
57 case Triple::ELF:
58 if (ELFStreamerCtorFn)
59 S = ELFStreamerCtorFn(T, Ctx, std::move(TAB), std::move(OW),
60 std::move(Emitter));
61 else
62 S = createELFStreamer(Ctx, TAB: std::move(TAB), OW: std::move(OW),
63 CE: std::move(Emitter));
64 break;
65 case Triple::Wasm:
66 S = createWasmStreamer(Ctx, TAB: std::move(TAB), OW: std::move(OW),
67 CE: std::move(Emitter));
68 break;
69 case Triple::GOFF:
70 S = createGOFFStreamer(Ctx, TAB: std::move(TAB), OW: std::move(OW),
71 CE: std::move(Emitter));
72 break;
73 case Triple::XCOFF:
74 S = XCOFFStreamerCtorFn(T, Ctx, std::move(TAB), std::move(OW),
75 std::move(Emitter));
76 break;
77 case Triple::SPIRV:
78 S = createSPIRVStreamer(Ctx, TAB: std::move(TAB), OW: std::move(OW),
79 CE: std::move(Emitter));
80 break;
81 case Triple::DXContainer:
82 S = createDXContainerStreamer(Ctx, TAB: std::move(TAB), OW: std::move(OW),
83 CE: std::move(Emitter));
84 break;
85 }
86 if (ObjectTargetStreamerCtorFn)
87 ObjectTargetStreamerCtorFn(*S, STI);
88 if (T.isLFI())
89 initializeLFIMCStreamer(Streamer&: *S, Ctx, TheTriple: T);
90 return S;
91}
92
93MCStreamer *Target::createAsmStreamer(MCContext &Ctx,
94 std::unique_ptr<formatted_raw_ostream> OS,
95 std::unique_ptr<MCInstPrinter> IP,
96 std::unique_ptr<MCCodeEmitter> CE,
97 std::unique_ptr<MCAsmBackend> TAB) const {
98 MCInstPrinter *Printer = IP.get();
99 formatted_raw_ostream &OSRef = *OS;
100 MCStreamer *S;
101 if (AsmStreamerCtorFn)
102 S = AsmStreamerCtorFn(Ctx, std::move(OS), std::move(IP), std::move(CE),
103 std::move(TAB));
104 else
105 S = llvm::createAsmStreamer(Ctx, OS: std::move(OS), InstPrint: std::move(IP),
106 CE: std::move(CE), TAB: std::move(TAB));
107
108 createAsmTargetStreamer(S&: *S, OS&: OSRef, InstPrint: Printer);
109 return S;
110}
111
112iterator_range<TargetRegistry::iterator> TargetRegistry::targets() {
113 return make_range(x: iterator(FirstTarget), y: iterator());
114}
115
116const Target *TargetRegistry::lookupTarget(StringRef ArchName,
117 Triple &TheTriple,
118 std::string &Error) {
119 // Allocate target machine. First, check whether the user has explicitly
120 // specified an architecture to compile for. If so we have to look it up by
121 // name, because it might be a backend that has no mapping to a target triple.
122 const Target *TheTarget = nullptr;
123 if (!ArchName.empty()) {
124 auto I = find_if(Range: targets(),
125 P: [&](const Target &T) { return ArchName == T.getName(); });
126
127 if (I == targets().end()) {
128 Error = ("invalid target '" + ArchName + "'.").str();
129 return nullptr;
130 }
131
132 TheTarget = &*I;
133
134 // Adjust the triple to match (if known), otherwise stick with the
135 // given triple.
136 Triple::ArchType Type = Triple::getArchTypeForLLVMName(Str: ArchName);
137 if (Type != Triple::UnknownArch)
138 TheTriple.setArch(Kind: Type);
139 } else {
140 // Get the target specific parser.
141 std::string TempError;
142 TheTarget = TargetRegistry::lookupTarget(TheTriple, Error&: TempError);
143 if (!TheTarget) {
144 Error = "unable to get target for '" + TheTriple.getTriple() +
145 "', see --version and --triple.";
146 return nullptr;
147 }
148 }
149
150 return TheTarget;
151}
152
153const Target *TargetRegistry::lookupTarget(const Triple &TT,
154 std::string &Error) {
155 // Provide special warning when no targets are initialized.
156 if (targets().begin() == targets().end()) {
157 Error = "Unable to find target for this triple (no targets are registered)";
158 return nullptr;
159 }
160 Triple::ArchType Arch = TT.getArch();
161 auto ArchMatch = [&](const Target &T) { return T.ArchMatchFn(Arch); };
162 auto I = find_if(Range: targets(), P: ArchMatch);
163
164 if (I == targets().end()) {
165 Error =
166 "No available targets are compatible with triple \"" + TT.str() + "\"";
167 return nullptr;
168 }
169
170 auto J = std::find_if(first: std::next(x: I), last: targets().end(), pred: ArchMatch);
171 if (J != targets().end()) {
172 Error = std::string("Cannot choose between targets \"") + I->Name +
173 "\" and \"" + J->Name + "\"";
174 return nullptr;
175 }
176
177 return &*I;
178}
179
180void TargetRegistry::RegisterTarget(Target &T, const char *Name,
181 const char *ShortDesc,
182 const char *BackendName,
183 Target::ArchMatchFnTy ArchMatchFn,
184 bool HasJIT) {
185 assert(Name && ShortDesc && ArchMatchFn &&
186 "Missing required target information!");
187
188 // Check if this target has already been initialized, we allow this as a
189 // convenience to some clients.
190 if (T.Name)
191 return;
192
193 // Add to the list of targets.
194 T.Next = FirstTarget;
195 FirstTarget = &T;
196
197 T.Name = Name;
198 T.ShortDesc = ShortDesc;
199 T.BackendName = BackendName;
200 T.ArchMatchFn = ArchMatchFn;
201 T.HasJIT = HasJIT;
202}
203
204static int TargetArraySortFn(const std::pair<StringRef, const Target *> *LHS,
205 const std::pair<StringRef, const Target *> *RHS) {
206 return LHS->first.compare(RHS: RHS->first);
207}
208
209void TargetRegistry::printRegisteredTargetsForVersion(raw_ostream &OS) {
210 std::vector<std::pair<StringRef, const Target*> > Targets;
211 size_t Width = 0;
212 for (const auto &T : TargetRegistry::targets()) {
213 Targets.push_back(x: std::make_pair(x: T.getName(), y: &T));
214 Width = std::max(a: Width, b: Targets.back().first.size());
215 }
216 array_pod_sort(Start: Targets.begin(), End: Targets.end(), Compare: TargetArraySortFn);
217
218 OS << "\n";
219 OS << " Registered Targets:\n";
220 for (const auto &Target : Targets) {
221 OS << " " << Target.first;
222 OS.indent(NumSpaces: Width - Target.first.size())
223 << " - " << Target.second->getShortDescription() << '\n';
224 }
225 if (Targets.empty())
226 OS << " (none)\n";
227}
228