|
150
|
1 //===--- Targets.cpp - Implement target feature support -------------------===//
|
|
|
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 implements construction of a TargetInfo object from a
|
|
|
10 // target triple.
|
|
|
11 //
|
|
|
12 //===----------------------------------------------------------------------===//
|
|
|
13
|
|
|
14 #include "Targets.h"
|
|
|
15
|
|
|
16 #include "Targets/AArch64.h"
|
|
|
17 #include "Targets/AMDGPU.h"
|
|
|
18 #include "Targets/ARC.h"
|
|
|
19 #include "Targets/ARM.h"
|
|
|
20 #include "Targets/AVR.h"
|
|
|
21 #include "Targets/BPF.h"
|
|
|
22 #include "Targets/Hexagon.h"
|
|
|
23 #include "Targets/Lanai.h"
|
|
|
24 #include "Targets/Le64.h"
|
|
|
25 #include "Targets/MSP430.h"
|
|
|
26 #include "Targets/Mips.h"
|
|
|
27 #include "Targets/NVPTX.h"
|
|
|
28 #include "Targets/OSTargets.h"
|
|
|
29 #include "Targets/PNaCl.h"
|
|
|
30 #include "Targets/PPC.h"
|
|
|
31 #include "Targets/RISCV.h"
|
|
|
32 #include "Targets/SPIR.h"
|
|
|
33 #include "Targets/Sparc.h"
|
|
|
34 #include "Targets/SystemZ.h"
|
|
|
35 #include "Targets/TCE.h"
|
|
|
36 #include "Targets/WebAssembly.h"
|
|
|
37 #include "Targets/X86.h"
|
|
|
38 #include "Targets/XCore.h"
|
|
|
39 #include "clang/Basic/Diagnostic.h"
|
|
|
40 #include "llvm/ADT/StringExtras.h"
|
|
|
41 #include "llvm/ADT/Triple.h"
|
|
|
42
|
|
|
43 using namespace clang;
|
|
|
44
|
|
|
45 namespace clang {
|
|
|
46 namespace targets {
|
|
|
47 //===----------------------------------------------------------------------===//
|
|
|
48 // Common code shared among targets.
|
|
|
49 //===----------------------------------------------------------------------===//
|
|
|
50
|
|
|
51 /// DefineStd - Define a macro name and standard variants. For example if
|
|
|
52 /// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
|
|
|
53 /// when in GNU mode.
|
|
|
54 void DefineStd(MacroBuilder &Builder, StringRef MacroName,
|
|
|
55 const LangOptions &Opts) {
|
|
|
56 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
|
|
|
57
|
|
|
58 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
|
|
|
59 // in the user's namespace.
|
|
|
60 if (Opts.GNUMode)
|
|
|
61 Builder.defineMacro(MacroName);
|
|
|
62
|
|
|
63 // Define __unix.
|
|
|
64 Builder.defineMacro("__" + MacroName);
|
|
|
65
|
|
|
66 // Define __unix__.
|
|
|
67 Builder.defineMacro("__" + MacroName + "__");
|
|
|
68 }
|
|
|
69
|
|
|
70 void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName, bool Tuning) {
|
|
|
71 Builder.defineMacro("__" + CPUName);
|
|
|
72 Builder.defineMacro("__" + CPUName + "__");
|
|
|
73 if (Tuning)
|
|
|
74 Builder.defineMacro("__tune_" + CPUName + "__");
|
|
|
75 }
|
|
|
76
|
|
|
77 void addCygMingDefines(const LangOptions &Opts, MacroBuilder &Builder) {
|
|
|
78 // Mingw and cygwin define __declspec(a) to __attribute__((a)). Clang
|
|
|
79 // supports __declspec natively under -fms-extensions, but we define a no-op
|
|
|
80 // __declspec macro anyway for pre-processor compatibility.
|
|
|
81 if (Opts.MicrosoftExt)
|
|
|
82 Builder.defineMacro("__declspec", "__declspec");
|
|
|
83 else
|
|
|
84 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
|
|
|
85
|
|
|
86 if (!Opts.MicrosoftExt) {
|
|
|
87 // Provide macros for all the calling convention keywords. Provide both
|
|
|
88 // single and double underscore prefixed variants. These are available on
|
|
|
89 // x64 as well as x86, even though they have no effect.
|
|
|
90 const char *CCs[] = {"cdecl", "stdcall", "fastcall", "thiscall", "pascal"};
|
|
|
91 for (const char *CC : CCs) {
|
|
|
92 std::string GCCSpelling = "__attribute__((__";
|
|
|
93 GCCSpelling += CC;
|
|
|
94 GCCSpelling += "__))";
|
|
|
95 Builder.defineMacro(Twine("_") + CC, GCCSpelling);
|
|
|
96 Builder.defineMacro(Twine("__") + CC, GCCSpelling);
|
|
|
97 }
|
|
|
98 }
|
|
|
99 }
|
|
|
100
|
|
|
101 //===----------------------------------------------------------------------===//
|
|
|
102 // Driver code
|
|
|
103 //===----------------------------------------------------------------------===//
|
|
|
104
|
|
|
105 TargetInfo *AllocateTarget(const llvm::Triple &Triple,
|
|
|
106 const TargetOptions &Opts) {
|
|
|
107 llvm::Triple::OSType os = Triple.getOS();
|
|
|
108
|
|
|
109 switch (Triple.getArch()) {
|
|
|
110 default:
|
|
|
111 return nullptr;
|
|
|
112
|
|
|
113 case llvm::Triple::arc:
|
|
|
114 return new ARCTargetInfo(Triple, Opts);
|
|
|
115
|
|
|
116 case llvm::Triple::xcore:
|
|
|
117 return new XCoreTargetInfo(Triple, Opts);
|
|
|
118
|
|
|
119 case llvm::Triple::hexagon:
|
|
173
|
120 if (os == llvm::Triple::Linux &&
|
|
|
121 Triple.getEnvironment() == llvm::Triple::Musl)
|
|
|
122 return new LinuxTargetInfo<HexagonTargetInfo>(Triple, Opts);
|
|
150
|
123 return new HexagonTargetInfo(Triple, Opts);
|
|
|
124
|
|
|
125 case llvm::Triple::lanai:
|
|
|
126 return new LanaiTargetInfo(Triple, Opts);
|
|
|
127
|
|
|
128 case llvm::Triple::aarch64_32:
|
|
|
129 if (Triple.isOSDarwin())
|
|
|
130 return new DarwinAArch64TargetInfo(Triple, Opts);
|
|
|
131
|
|
|
132 return nullptr;
|
|
|
133 case llvm::Triple::aarch64:
|
|
|
134 if (Triple.isOSDarwin())
|
|
|
135 return new DarwinAArch64TargetInfo(Triple, Opts);
|
|
|
136
|
|
|
137 switch (os) {
|
|
|
138 case llvm::Triple::CloudABI:
|
|
|
139 return new CloudABITargetInfo<AArch64leTargetInfo>(Triple, Opts);
|
|
|
140 case llvm::Triple::FreeBSD:
|
|
|
141 return new FreeBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
|
|
|
142 case llvm::Triple::Fuchsia:
|
|
|
143 return new FuchsiaTargetInfo<AArch64leTargetInfo>(Triple, Opts);
|
|
|
144 case llvm::Triple::Linux:
|
|
|
145 return new LinuxTargetInfo<AArch64leTargetInfo>(Triple, Opts);
|
|
|
146 case llvm::Triple::NetBSD:
|
|
|
147 return new NetBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
|
|
|
148 case llvm::Triple::OpenBSD:
|
|
|
149 return new OpenBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
|
|
|
150 case llvm::Triple::Win32:
|
|
|
151 switch (Triple.getEnvironment()) {
|
|
|
152 case llvm::Triple::GNU:
|
|
|
153 return new MinGWARM64TargetInfo(Triple, Opts);
|
|
|
154 case llvm::Triple::MSVC:
|
|
|
155 default: // Assume MSVC for unknown environments
|
|
|
156 return new MicrosoftARM64TargetInfo(Triple, Opts);
|
|
|
157 }
|
|
|
158 default:
|
|
|
159 return new AArch64leTargetInfo(Triple, Opts);
|
|
|
160 }
|
|
|
161
|
|
|
162 case llvm::Triple::aarch64_be:
|
|
|
163 switch (os) {
|
|
|
164 case llvm::Triple::FreeBSD:
|
|
|
165 return new FreeBSDTargetInfo<AArch64beTargetInfo>(Triple, Opts);
|
|
|
166 case llvm::Triple::Fuchsia:
|
|
|
167 return new FuchsiaTargetInfo<AArch64beTargetInfo>(Triple, Opts);
|
|
|
168 case llvm::Triple::Linux:
|
|
|
169 return new LinuxTargetInfo<AArch64beTargetInfo>(Triple, Opts);
|
|
|
170 case llvm::Triple::NetBSD:
|
|
|
171 return new NetBSDTargetInfo<AArch64beTargetInfo>(Triple, Opts);
|
|
|
172 default:
|
|
|
173 return new AArch64beTargetInfo(Triple, Opts);
|
|
|
174 }
|
|
|
175
|
|
|
176 case llvm::Triple::arm:
|
|
|
177 case llvm::Triple::thumb:
|
|
|
178 if (Triple.isOSBinFormatMachO())
|
|
|
179 return new DarwinARMTargetInfo(Triple, Opts);
|
|
|
180
|
|
|
181 switch (os) {
|
|
|
182 case llvm::Triple::CloudABI:
|
|
|
183 return new CloudABITargetInfo<ARMleTargetInfo>(Triple, Opts);
|
|
|
184 case llvm::Triple::Linux:
|
|
|
185 return new LinuxTargetInfo<ARMleTargetInfo>(Triple, Opts);
|
|
|
186 case llvm::Triple::FreeBSD:
|
|
|
187 return new FreeBSDTargetInfo<ARMleTargetInfo>(Triple, Opts);
|
|
|
188 case llvm::Triple::NetBSD:
|
|
|
189 return new NetBSDTargetInfo<ARMleTargetInfo>(Triple, Opts);
|
|
|
190 case llvm::Triple::OpenBSD:
|
|
|
191 return new OpenBSDTargetInfo<ARMleTargetInfo>(Triple, Opts);
|
|
|
192 case llvm::Triple::RTEMS:
|
|
|
193 return new RTEMSTargetInfo<ARMleTargetInfo>(Triple, Opts);
|
|
|
194 case llvm::Triple::NaCl:
|
|
|
195 return new NaClTargetInfo<ARMleTargetInfo>(Triple, Opts);
|
|
|
196 case llvm::Triple::Win32:
|
|
|
197 switch (Triple.getEnvironment()) {
|
|
|
198 case llvm::Triple::Cygnus:
|
|
|
199 return new CygwinARMTargetInfo(Triple, Opts);
|
|
|
200 case llvm::Triple::GNU:
|
|
|
201 return new MinGWARMTargetInfo(Triple, Opts);
|
|
|
202 case llvm::Triple::Itanium:
|
|
|
203 return new ItaniumWindowsARMleTargetInfo(Triple, Opts);
|
|
|
204 case llvm::Triple::MSVC:
|
|
|
205 default: // Assume MSVC for unknown environments
|
|
|
206 return new MicrosoftARMleTargetInfo(Triple, Opts);
|
|
|
207 }
|
|
|
208 default:
|
|
|
209 return new ARMleTargetInfo(Triple, Opts);
|
|
|
210 }
|
|
|
211
|
|
|
212 case llvm::Triple::armeb:
|
|
|
213 case llvm::Triple::thumbeb:
|
|
|
214 if (Triple.isOSDarwin())
|
|
|
215 return new DarwinARMTargetInfo(Triple, Opts);
|
|
|
216
|
|
|
217 switch (os) {
|
|
|
218 case llvm::Triple::Linux:
|
|
|
219 return new LinuxTargetInfo<ARMbeTargetInfo>(Triple, Opts);
|
|
|
220 case llvm::Triple::FreeBSD:
|
|
|
221 return new FreeBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts);
|
|
|
222 case llvm::Triple::NetBSD:
|
|
|
223 return new NetBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts);
|
|
|
224 case llvm::Triple::OpenBSD:
|
|
|
225 return new OpenBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts);
|
|
|
226 case llvm::Triple::RTEMS:
|
|
|
227 return new RTEMSTargetInfo<ARMbeTargetInfo>(Triple, Opts);
|
|
|
228 case llvm::Triple::NaCl:
|
|
|
229 return new NaClTargetInfo<ARMbeTargetInfo>(Triple, Opts);
|
|
|
230 default:
|
|
|
231 return new ARMbeTargetInfo(Triple, Opts);
|
|
|
232 }
|
|
|
233
|
|
|
234 case llvm::Triple::avr:
|
|
|
235 return new AVRTargetInfo(Triple, Opts);
|
|
|
236 case llvm::Triple::bpfeb:
|
|
|
237 case llvm::Triple::bpfel:
|
|
|
238 return new BPFTargetInfo(Triple, Opts);
|
|
|
239
|
|
|
240 case llvm::Triple::msp430:
|
|
|
241 return new MSP430TargetInfo(Triple, Opts);
|
|
|
242
|
|
|
243 case llvm::Triple::mips:
|
|
|
244 switch (os) {
|
|
|
245 case llvm::Triple::Linux:
|
|
|
246 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
|
|
|
247 case llvm::Triple::RTEMS:
|
|
|
248 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
|
|
|
249 case llvm::Triple::FreeBSD:
|
|
|
250 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
|
|
|
251 case llvm::Triple::NetBSD:
|
|
|
252 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
|
|
|
253 default:
|
|
|
254 return new MipsTargetInfo(Triple, Opts);
|
|
|
255 }
|
|
|
256
|
|
|
257 case llvm::Triple::mipsel:
|
|
|
258 switch (os) {
|
|
|
259 case llvm::Triple::Linux:
|
|
|
260 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
|
|
|
261 case llvm::Triple::RTEMS:
|
|
|
262 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
|
|
|
263 case llvm::Triple::FreeBSD:
|
|
|
264 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
|
|
|
265 case llvm::Triple::NetBSD:
|
|
|
266 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
|
|
|
267 case llvm::Triple::NaCl:
|
|
|
268 return new NaClTargetInfo<NaClMips32TargetInfo>(Triple, Opts);
|
|
|
269 default:
|
|
|
270 return new MipsTargetInfo(Triple, Opts);
|
|
|
271 }
|
|
|
272
|
|
|
273 case llvm::Triple::mips64:
|
|
|
274 switch (os) {
|
|
|
275 case llvm::Triple::Linux:
|
|
|
276 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
|
|
|
277 case llvm::Triple::RTEMS:
|
|
|
278 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
|
|
|
279 case llvm::Triple::FreeBSD:
|
|
|
280 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
|
|
|
281 case llvm::Triple::NetBSD:
|
|
|
282 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
|
|
|
283 case llvm::Triple::OpenBSD:
|
|
|
284 return new OpenBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
|
|
|
285 default:
|
|
|
286 return new MipsTargetInfo(Triple, Opts);
|
|
|
287 }
|
|
|
288
|
|
|
289 case llvm::Triple::mips64el:
|
|
|
290 switch (os) {
|
|
|
291 case llvm::Triple::Linux:
|
|
|
292 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
|
|
|
293 case llvm::Triple::RTEMS:
|
|
|
294 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
|
|
|
295 case llvm::Triple::FreeBSD:
|
|
|
296 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
|
|
|
297 case llvm::Triple::NetBSD:
|
|
|
298 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
|
|
|
299 case llvm::Triple::OpenBSD:
|
|
|
300 return new OpenBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
|
|
|
301 default:
|
|
|
302 return new MipsTargetInfo(Triple, Opts);
|
|
|
303 }
|
|
|
304
|
|
|
305 case llvm::Triple::le32:
|
|
|
306 switch (os) {
|
|
|
307 case llvm::Triple::NaCl:
|
|
|
308 return new NaClTargetInfo<PNaClTargetInfo>(Triple, Opts);
|
|
|
309 default:
|
|
|
310 return nullptr;
|
|
|
311 }
|
|
|
312
|
|
|
313 case llvm::Triple::le64:
|
|
|
314 return new Le64TargetInfo(Triple, Opts);
|
|
|
315
|
|
|
316 case llvm::Triple::ppc:
|
|
|
317 if (Triple.isOSDarwin())
|
|
|
318 return new DarwinPPC32TargetInfo(Triple, Opts);
|
|
|
319 switch (os) {
|
|
|
320 case llvm::Triple::Linux:
|
|
|
321 return new LinuxTargetInfo<PPC32TargetInfo>(Triple, Opts);
|
|
|
322 case llvm::Triple::FreeBSD:
|
|
|
323 return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple, Opts);
|
|
|
324 case llvm::Triple::NetBSD:
|
|
|
325 return new NetBSDTargetInfo<PPC32TargetInfo>(Triple, Opts);
|
|
|
326 case llvm::Triple::OpenBSD:
|
|
|
327 return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple, Opts);
|
|
|
328 case llvm::Triple::RTEMS:
|
|
|
329 return new RTEMSTargetInfo<PPC32TargetInfo>(Triple, Opts);
|
|
|
330 case llvm::Triple::AIX:
|
|
|
331 return new AIXPPC32TargetInfo(Triple, Opts);
|
|
|
332 default:
|
|
|
333 return new PPC32TargetInfo(Triple, Opts);
|
|
|
334 }
|
|
|
335
|
|
|
336 case llvm::Triple::ppc64:
|
|
|
337 if (Triple.isOSDarwin())
|
|
|
338 return new DarwinPPC64TargetInfo(Triple, Opts);
|
|
|
339 switch (os) {
|
|
|
340 case llvm::Triple::Linux:
|
|
|
341 return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts);
|
|
|
342 case llvm::Triple::Lv2:
|
|
|
343 return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple, Opts);
|
|
|
344 case llvm::Triple::FreeBSD:
|
|
|
345 return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
|
|
|
346 case llvm::Triple::NetBSD:
|
|
|
347 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
|
|
|
348 case llvm::Triple::AIX:
|
|
|
349 return new AIXPPC64TargetInfo(Triple, Opts);
|
|
|
350 default:
|
|
|
351 return new PPC64TargetInfo(Triple, Opts);
|
|
|
352 }
|
|
|
353
|
|
|
354 case llvm::Triple::ppc64le:
|
|
|
355 switch (os) {
|
|
|
356 case llvm::Triple::Linux:
|
|
|
357 return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts);
|
|
|
358 case llvm::Triple::NetBSD:
|
|
|
359 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
|
|
|
360 default:
|
|
|
361 return new PPC64TargetInfo(Triple, Opts);
|
|
|
362 }
|
|
|
363
|
|
|
364 case llvm::Triple::nvptx:
|
|
|
365 return new NVPTXTargetInfo(Triple, Opts, /*TargetPointerWidth=*/32);
|
|
|
366 case llvm::Triple::nvptx64:
|
|
|
367 return new NVPTXTargetInfo(Triple, Opts, /*TargetPointerWidth=*/64);
|
|
|
368
|
|
|
369 case llvm::Triple::amdgcn:
|
|
|
370 case llvm::Triple::r600:
|
|
|
371 return new AMDGPUTargetInfo(Triple, Opts);
|
|
|
372
|
|
|
373 case llvm::Triple::riscv32:
|
|
|
374 // TODO: add cases for NetBSD, RTEMS once tested.
|
|
|
375 switch (os) {
|
|
|
376 case llvm::Triple::FreeBSD:
|
|
|
377 return new FreeBSDTargetInfo<RISCV32TargetInfo>(Triple, Opts);
|
|
|
378 case llvm::Triple::Linux:
|
|
|
379 return new LinuxTargetInfo<RISCV32TargetInfo>(Triple, Opts);
|
|
|
380 default:
|
|
|
381 return new RISCV32TargetInfo(Triple, Opts);
|
|
|
382 }
|
|
|
383
|
|
|
384 case llvm::Triple::riscv64:
|
|
|
385 // TODO: add cases for NetBSD, RTEMS once tested.
|
|
|
386 switch (os) {
|
|
|
387 case llvm::Triple::FreeBSD:
|
|
|
388 return new FreeBSDTargetInfo<RISCV64TargetInfo>(Triple, Opts);
|
|
|
389 case llvm::Triple::Fuchsia:
|
|
|
390 return new FuchsiaTargetInfo<RISCV64TargetInfo>(Triple, Opts);
|
|
|
391 case llvm::Triple::Linux:
|
|
|
392 return new LinuxTargetInfo<RISCV64TargetInfo>(Triple, Opts);
|
|
|
393 default:
|
|
|
394 return new RISCV64TargetInfo(Triple, Opts);
|
|
|
395 }
|
|
|
396
|
|
|
397 case llvm::Triple::sparc:
|
|
|
398 switch (os) {
|
|
|
399 case llvm::Triple::Linux:
|
|
|
400 return new LinuxTargetInfo<SparcV8TargetInfo>(Triple, Opts);
|
|
|
401 case llvm::Triple::Solaris:
|
|
|
402 return new SolarisTargetInfo<SparcV8TargetInfo>(Triple, Opts);
|
|
|
403 case llvm::Triple::NetBSD:
|
|
|
404 return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple, Opts);
|
|
|
405 case llvm::Triple::OpenBSD:
|
|
|
406 return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple, Opts);
|
|
|
407 case llvm::Triple::RTEMS:
|
|
|
408 return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple, Opts);
|
|
|
409 default:
|
|
|
410 return new SparcV8TargetInfo(Triple, Opts);
|
|
|
411 }
|
|
|
412
|
|
|
413 // The 'sparcel' architecture copies all the above cases except for Solaris.
|
|
|
414 case llvm::Triple::sparcel:
|
|
|
415 switch (os) {
|
|
|
416 case llvm::Triple::Linux:
|
|
|
417 return new LinuxTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
|
|
|
418 case llvm::Triple::NetBSD:
|
|
|
419 return new NetBSDTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
|
|
|
420 case llvm::Triple::OpenBSD:
|
|
|
421 return new OpenBSDTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
|
|
|
422 case llvm::Triple::RTEMS:
|
|
|
423 return new RTEMSTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
|
|
|
424 default:
|
|
|
425 return new SparcV8elTargetInfo(Triple, Opts);
|
|
|
426 }
|
|
|
427
|
|
|
428 case llvm::Triple::sparcv9:
|
|
|
429 switch (os) {
|
|
|
430 case llvm::Triple::Linux:
|
|
|
431 return new LinuxTargetInfo<SparcV9TargetInfo>(Triple, Opts);
|
|
|
432 case llvm::Triple::Solaris:
|
|
|
433 return new SolarisTargetInfo<SparcV9TargetInfo>(Triple, Opts);
|
|
|
434 case llvm::Triple::NetBSD:
|
|
|
435 return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts);
|
|
|
436 case llvm::Triple::OpenBSD:
|
|
|
437 return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts);
|
|
|
438 case llvm::Triple::FreeBSD:
|
|
|
439 return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts);
|
|
|
440 default:
|
|
|
441 return new SparcV9TargetInfo(Triple, Opts);
|
|
|
442 }
|
|
|
443
|
|
|
444 case llvm::Triple::systemz:
|
|
|
445 switch (os) {
|
|
|
446 case llvm::Triple::Linux:
|
|
|
447 return new LinuxTargetInfo<SystemZTargetInfo>(Triple, Opts);
|
|
|
448 default:
|
|
|
449 return new SystemZTargetInfo(Triple, Opts);
|
|
|
450 }
|
|
|
451
|
|
|
452 case llvm::Triple::tce:
|
|
|
453 return new TCETargetInfo(Triple, Opts);
|
|
|
454
|
|
|
455 case llvm::Triple::tcele:
|
|
|
456 return new TCELETargetInfo(Triple, Opts);
|
|
|
457
|
|
|
458 case llvm::Triple::x86:
|
|
|
459 if (Triple.isOSDarwin())
|
|
|
460 return new DarwinI386TargetInfo(Triple, Opts);
|
|
|
461
|
|
|
462 switch (os) {
|
|
|
463 case llvm::Triple::Ananas:
|
|
|
464 return new AnanasTargetInfo<X86_32TargetInfo>(Triple, Opts);
|
|
|
465 case llvm::Triple::CloudABI:
|
|
|
466 return new CloudABITargetInfo<X86_32TargetInfo>(Triple, Opts);
|
|
|
467 case llvm::Triple::Linux: {
|
|
|
468 switch (Triple.getEnvironment()) {
|
|
|
469 default:
|
|
|
470 return new LinuxTargetInfo<X86_32TargetInfo>(Triple, Opts);
|
|
|
471 case llvm::Triple::Android:
|
|
|
472 return new AndroidX86_32TargetInfo(Triple, Opts);
|
|
|
473 }
|
|
|
474 }
|
|
|
475 case llvm::Triple::DragonFly:
|
|
|
476 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple, Opts);
|
|
|
477 case llvm::Triple::NetBSD:
|
|
|
478 return new NetBSDI386TargetInfo(Triple, Opts);
|
|
|
479 case llvm::Triple::OpenBSD:
|
|
|
480 return new OpenBSDI386TargetInfo(Triple, Opts);
|
|
|
481 case llvm::Triple::FreeBSD:
|
|
|
482 return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts);
|
|
173
|
483 case llvm::Triple::Fuchsia:
|
|
|
484 return new FuchsiaTargetInfo<X86_32TargetInfo>(Triple, Opts);
|
|
150
|
485 case llvm::Triple::KFreeBSD:
|
|
|
486 return new KFreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts);
|
|
|
487 case llvm::Triple::Minix:
|
|
|
488 return new MinixTargetInfo<X86_32TargetInfo>(Triple, Opts);
|
|
|
489 case llvm::Triple::Solaris:
|
|
|
490 return new SolarisTargetInfo<X86_32TargetInfo>(Triple, Opts);
|
|
|
491 case llvm::Triple::Win32: {
|
|
|
492 switch (Triple.getEnvironment()) {
|
|
|
493 case llvm::Triple::Cygnus:
|
|
|
494 return new CygwinX86_32TargetInfo(Triple, Opts);
|
|
|
495 case llvm::Triple::GNU:
|
|
|
496 return new MinGWX86_32TargetInfo(Triple, Opts);
|
|
|
497 case llvm::Triple::Itanium:
|
|
|
498 case llvm::Triple::MSVC:
|
|
|
499 default: // Assume MSVC for unknown environments
|
|
|
500 return new MicrosoftX86_32TargetInfo(Triple, Opts);
|
|
|
501 }
|
|
|
502 }
|
|
|
503 case llvm::Triple::Haiku:
|
|
|
504 return new HaikuX86_32TargetInfo(Triple, Opts);
|
|
|
505 case llvm::Triple::RTEMS:
|
|
|
506 return new RTEMSX86_32TargetInfo(Triple, Opts);
|
|
|
507 case llvm::Triple::NaCl:
|
|
|
508 return new NaClTargetInfo<X86_32TargetInfo>(Triple, Opts);
|
|
|
509 case llvm::Triple::ELFIAMCU:
|
|
|
510 return new MCUX86_32TargetInfo(Triple, Opts);
|
|
|
511 case llvm::Triple::Hurd:
|
|
|
512 return new HurdTargetInfo<X86_32TargetInfo>(Triple, Opts);
|
|
|
513 default:
|
|
|
514 return new X86_32TargetInfo(Triple, Opts);
|
|
|
515 }
|
|
|
516
|
|
|
517 case llvm::Triple::x86_64:
|
|
|
518 if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())
|
|
|
519 return new DarwinX86_64TargetInfo(Triple, Opts);
|
|
|
520
|
|
|
521 switch (os) {
|
|
|
522 case llvm::Triple::Ananas:
|
|
|
523 return new AnanasTargetInfo<X86_64TargetInfo>(Triple, Opts);
|
|
|
524 case llvm::Triple::CloudABI:
|
|
|
525 return new CloudABITargetInfo<X86_64TargetInfo>(Triple, Opts);
|
|
|
526 case llvm::Triple::Linux: {
|
|
|
527 switch (Triple.getEnvironment()) {
|
|
|
528 default:
|
|
|
529 return new LinuxTargetInfo<X86_64TargetInfo>(Triple, Opts);
|
|
|
530 case llvm::Triple::Android:
|
|
|
531 return new AndroidX86_64TargetInfo(Triple, Opts);
|
|
|
532 }
|
|
|
533 }
|
|
|
534 case llvm::Triple::DragonFly:
|
|
|
535 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
|
|
|
536 case llvm::Triple::NetBSD:
|
|
|
537 return new NetBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
|
|
|
538 case llvm::Triple::OpenBSD:
|
|
|
539 return new OpenBSDX86_64TargetInfo(Triple, Opts);
|
|
|
540 case llvm::Triple::FreeBSD:
|
|
|
541 return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
|
|
|
542 case llvm::Triple::Fuchsia:
|
|
|
543 return new FuchsiaTargetInfo<X86_64TargetInfo>(Triple, Opts);
|
|
|
544 case llvm::Triple::KFreeBSD:
|
|
|
545 return new KFreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
|
|
|
546 case llvm::Triple::Solaris:
|
|
|
547 return new SolarisTargetInfo<X86_64TargetInfo>(Triple, Opts);
|
|
|
548 case llvm::Triple::Win32: {
|
|
|
549 switch (Triple.getEnvironment()) {
|
|
|
550 case llvm::Triple::Cygnus:
|
|
|
551 return new CygwinX86_64TargetInfo(Triple, Opts);
|
|
|
552 case llvm::Triple::GNU:
|
|
|
553 return new MinGWX86_64TargetInfo(Triple, Opts);
|
|
|
554 case llvm::Triple::MSVC:
|
|
|
555 default: // Assume MSVC for unknown environments
|
|
|
556 return new MicrosoftX86_64TargetInfo(Triple, Opts);
|
|
|
557 }
|
|
|
558 }
|
|
|
559 case llvm::Triple::Haiku:
|
|
|
560 return new HaikuTargetInfo<X86_64TargetInfo>(Triple, Opts);
|
|
|
561 case llvm::Triple::NaCl:
|
|
|
562 return new NaClTargetInfo<X86_64TargetInfo>(Triple, Opts);
|
|
|
563 case llvm::Triple::PS4:
|
|
|
564 return new PS4OSTargetInfo<X86_64TargetInfo>(Triple, Opts);
|
|
|
565 default:
|
|
|
566 return new X86_64TargetInfo(Triple, Opts);
|
|
|
567 }
|
|
|
568
|
|
|
569 case llvm::Triple::spir: {
|
|
|
570 if (Triple.getOS() != llvm::Triple::UnknownOS ||
|
|
|
571 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
|
|
|
572 return nullptr;
|
|
|
573 return new SPIR32TargetInfo(Triple, Opts);
|
|
|
574 }
|
|
|
575 case llvm::Triple::spir64: {
|
|
|
576 if (Triple.getOS() != llvm::Triple::UnknownOS ||
|
|
|
577 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
|
|
|
578 return nullptr;
|
|
|
579 return new SPIR64TargetInfo(Triple, Opts);
|
|
|
580 }
|
|
|
581 case llvm::Triple::wasm32:
|
|
|
582 if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
|
|
|
583 Triple.getVendor() != llvm::Triple::UnknownVendor ||
|
|
|
584 !Triple.isOSBinFormatWasm())
|
|
|
585 return nullptr;
|
|
|
586 switch (Triple.getOS()) {
|
|
|
587 case llvm::Triple::WASI:
|
|
|
588 return new WASITargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
|
|
|
589 case llvm::Triple::Emscripten:
|
|
|
590 return new EmscriptenTargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
|
|
|
591 case llvm::Triple::UnknownOS:
|
|
|
592 return new WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
|
|
|
593 default:
|
|
|
594 return nullptr;
|
|
|
595 }
|
|
|
596 case llvm::Triple::wasm64:
|
|
|
597 if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
|
|
|
598 Triple.getVendor() != llvm::Triple::UnknownVendor ||
|
|
|
599 !Triple.isOSBinFormatWasm())
|
|
|
600 return nullptr;
|
|
|
601 switch (Triple.getOS()) {
|
|
|
602 case llvm::Triple::WASI:
|
|
|
603 return new WASITargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
|
|
|
604 case llvm::Triple::Emscripten:
|
|
|
605 return new EmscriptenTargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
|
|
|
606 case llvm::Triple::UnknownOS:
|
|
|
607 return new WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
|
|
|
608 default:
|
|
|
609 return nullptr;
|
|
|
610 }
|
|
|
611
|
|
|
612 case llvm::Triple::renderscript32:
|
|
|
613 return new LinuxTargetInfo<RenderScript32TargetInfo>(Triple, Opts);
|
|
|
614 case llvm::Triple::renderscript64:
|
|
|
615 return new LinuxTargetInfo<RenderScript64TargetInfo>(Triple, Opts);
|
|
|
616 }
|
|
|
617 }
|
|
|
618 } // namespace targets
|
|
|
619 } // namespace clang
|
|
|
620
|
|
|
621 using namespace clang::targets;
|
|
|
622 /// CreateTargetInfo - Return the target info object for the specified target
|
|
|
623 /// options.
|
|
|
624 TargetInfo *
|
|
|
625 TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
|
|
|
626 const std::shared_ptr<TargetOptions> &Opts) {
|
|
|
627 llvm::Triple Triple(Opts->Triple);
|
|
|
628
|
|
|
629 // Construct the target
|
|
|
630 std::unique_ptr<TargetInfo> Target(AllocateTarget(Triple, *Opts));
|
|
|
631 if (!Target) {
|
|
|
632 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
|
|
|
633 return nullptr;
|
|
|
634 }
|
|
|
635 Target->TargetOpts = Opts;
|
|
|
636
|
|
|
637 // Set the target CPU if specified.
|
|
|
638 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
|
|
|
639 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
|
|
|
640 SmallVector<StringRef, 32> ValidList;
|
|
|
641 Target->fillValidCPUList(ValidList);
|
|
|
642 if (!ValidList.empty())
|
|
|
643 Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", ");
|
|
|
644 return nullptr;
|
|
|
645 }
|
|
|
646
|
|
|
647 // Set the target ABI if specified.
|
|
|
648 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
|
|
|
649 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
|
|
|
650 return nullptr;
|
|
|
651 }
|
|
|
652
|
|
|
653 // Set the fp math unit.
|
|
|
654 if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
|
|
|
655 Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath;
|
|
|
656 return nullptr;
|
|
|
657 }
|
|
|
658
|
|
|
659 // Compute the default target features, we need the target to handle this
|
|
|
660 // because features may have dependencies on one another.
|
|
|
661 llvm::StringMap<bool> Features;
|
|
|
662 if (!Target->initFeatureMap(Features, Diags, Opts->CPU,
|
|
|
663 Opts->FeaturesAsWritten))
|
|
|
664 return nullptr;
|
|
|
665
|
|
|
666 // Add the features to the compile options.
|
|
|
667 Opts->Features.clear();
|
|
|
668 for (const auto &F : Features)
|
|
|
669 Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str());
|
|
|
670 // Sort here, so we handle the features in a predictable order. (This matters
|
|
|
671 // when we're dealing with features that overlap.)
|
|
|
672 llvm::sort(Opts->Features);
|
|
|
673
|
|
|
674 if (!Target->handleTargetFeatures(Opts->Features, Diags))
|
|
|
675 return nullptr;
|
|
|
676
|
|
|
677 Target->setSupportedOpenCLOpts();
|
|
|
678 Target->setOpenCLExtensionOpts();
|
|
|
679 Target->setMaxAtomicWidth();
|
|
|
680
|
|
|
681 if (!Target->validateTarget(Diags))
|
|
|
682 return nullptr;
|
|
|
683
|
|
|
684 Target->CheckFixedPointBits();
|
|
|
685
|
|
|
686 return Target.release();
|
|
|
687 }
|
