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