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