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