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/CSKY.h"
23#include "Targets/DirectX.h"
24#include "Targets/Hexagon.h"
25#include "Targets/Lanai.h"
26#include "Targets/LoongArch.h"
27#include "Targets/M68k.h"
28#include "Targets/MSP430.h"
29#include "Targets/Mips.h"
30#include "Targets/NVPTX.h"
31#include "Targets/OSTargets.h"
32#include "Targets/PNaCl.h"
33#include "Targets/PPC.h"
34#include "Targets/RISCV.h"
35#include "Targets/SPIR.h"
36#include "Targets/Sparc.h"
37#include "Targets/SystemZ.h"
38#include "Targets/TCE.h"
39#include "Targets/VE.h"
40#include "Targets/WebAssembly.h"
41#include "Targets/X86.h"
42#include "Targets/XCore.h"
43#include "Targets/Xtensa.h"
44#include "clang/Basic/Diagnostic.h"
45#include "clang/Basic/DiagnosticFrontend.h"
46#include "llvm/ADT/StringExtras.h"
47#include "llvm/TargetParser/Triple.h"
48
49using namespace clang;
50
51namespace clang {
52namespace targets {
53//===----------------------------------------------------------------------===//
54// Common code shared among targets.
55//===----------------------------------------------------------------------===//
56
57/// DefineStd - Define a macro name and standard variants. For example if
58/// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
59/// when in GNU mode.
60void DefineStd(MacroBuilder &Builder, StringRef MacroName,
61 const LangOptions &Opts) {
62 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
63
64 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
65 // in the user's namespace.
66 if (Opts.GNUMode)
67 Builder.defineMacro(Name: MacroName);
68
69 // Define __unix.
70 Builder.defineMacro(Name: "__" + MacroName);
71
72 // Define __unix__.
73 Builder.defineMacro(Name: "__" + MacroName + "__");
74}
75
76void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName, bool Tuning) {
77 Builder.defineMacro(Name: "__" + CPUName);
78 Builder.defineMacro(Name: "__" + CPUName + "__");
79 if (Tuning)
80 Builder.defineMacro(Name: "__tune_" + CPUName + "__");
81}
82
83void addCygMingDefines(const LangOptions &Opts, MacroBuilder &Builder) {
84 // Mingw and cygwin define __declspec(a) to __attribute__((a)). Clang
85 // supports __declspec natively under -fdeclspec (also enabled with
86 // -fms-extensions), but we define a no-op __declspec macro anyway for
87 // pre-processor compatibility.
88 if (Opts.DeclSpecKeyword)
89 Builder.defineMacro(Name: "__declspec", Value: "__declspec");
90 else
91 Builder.defineMacro(Name: "__declspec(a)", Value: "__attribute__((a))");
92
93 if (!Opts.MicrosoftExt) {
94 // Provide macros for all the calling convention keywords. Provide both
95 // single and double underscore prefixed variants. These are available on
96 // x64 as well as x86, even though they have no effect.
97 const char *CCs[] = {"cdecl", "stdcall", "fastcall", "thiscall", "pascal"};
98 for (const char *CC : CCs) {
99 std::string GCCSpelling = "__attribute__((__";
100 GCCSpelling += CC;
101 GCCSpelling += "__))";
102 Builder.defineMacro(Name: Twine("_") + CC, Value: GCCSpelling);
103 Builder.defineMacro(Name: Twine("__") + CC, Value: GCCSpelling);
104 }
105 }
106}
107
108//===----------------------------------------------------------------------===//
109// Driver code
110//===----------------------------------------------------------------------===//
111
112std::unique_ptr<TargetInfo> AllocateTarget(const llvm::Triple &Triple,
113 const TargetOptions &Opts) {
114 llvm::Triple::OSType os = Triple.getOS();
115
116 switch (Triple.getArch()) {
117 default:
118 return nullptr;
119
120 case llvm::Triple::arc:
121 return std::make_unique<ARCTargetInfo>(args: Triple, args: Opts);
122
123 case llvm::Triple::xcore:
124 return std::make_unique<XCoreTargetInfo>(args: Triple, args: Opts);
125
126 case llvm::Triple::hexagon:
127 if (os == llvm::Triple::Linux &&
128 Triple.getEnvironment() == llvm::Triple::Musl)
129 return std::make_unique<LinuxTargetInfo<HexagonTargetInfo>>(args: Triple, args: Opts);
130 return std::make_unique<HexagonTargetInfo>(args: Triple, args: Opts);
131
132 case llvm::Triple::lanai:
133 return std::make_unique<LanaiTargetInfo>(args: Triple, args: Opts);
134
135 case llvm::Triple::aarch64_32:
136 if (Triple.isOSDarwin())
137 return std::make_unique<DarwinAArch64TargetInfo>(args: Triple, args: Opts);
138 else if (Triple.isAppleMachO())
139 return std::make_unique<AppleMachOAArch64TargetInfo>(args: Triple, args: Opts);
140
141 return nullptr;
142 case llvm::Triple::aarch64:
143 if (Triple.isOSDarwin())
144 return std::make_unique<DarwinAArch64TargetInfo>(args: Triple, args: Opts);
145 else if (Triple.isAppleMachO())
146 return std::make_unique<AppleMachOAArch64TargetInfo>(args: Triple, args: Opts);
147
148 switch (os) {
149 case llvm::Triple::FreeBSD:
150 return std::make_unique<FreeBSDTargetInfo<AArch64leTargetInfo>>(args: Triple,
151 args: Opts);
152 case llvm::Triple::Fuchsia:
153 return std::make_unique<FuchsiaTargetInfo<AArch64leTargetInfo>>(args: Triple,
154 args: Opts);
155 case llvm::Triple::Haiku:
156 return std::make_unique<HaikuTargetInfo<AArch64leTargetInfo>>(args: Triple,
157 args: Opts);
158 case llvm::Triple::Linux:
159 switch (Triple.getEnvironment()) {
160 default:
161 return std::make_unique<LinuxTargetInfo<AArch64leTargetInfo>>(args: Triple,
162 args: Opts);
163 case llvm::Triple::OpenHOS:
164 return std::make_unique<OHOSTargetInfo<AArch64leTargetInfo>>(args: Triple,
165 args: Opts);
166 }
167 case llvm::Triple::NetBSD:
168 return std::make_unique<NetBSDTargetInfo<AArch64leTargetInfo>>(args: Triple,
169 args: Opts);
170 case llvm::Triple::OpenBSD:
171 return std::make_unique<OpenBSDTargetInfo<AArch64leTargetInfo>>(args: Triple,
172 args: Opts);
173 case llvm::Triple::Win32:
174 switch (Triple.getEnvironment()) {
175 case llvm::Triple::GNU:
176 return std::make_unique<MinGWARM64TargetInfo>(args: Triple, args: Opts);
177 case llvm::Triple::MSVC:
178 default: // Assume MSVC for unknown environments
179 return std::make_unique<MicrosoftARM64TargetInfo>(args: Triple, args: Opts);
180 }
181 default:
182 return std::make_unique<AArch64leTargetInfo>(args: Triple, args: Opts);
183 }
184
185 case llvm::Triple::aarch64_be:
186 switch (os) {
187 case llvm::Triple::FreeBSD:
188 return std::make_unique<FreeBSDTargetInfo<AArch64beTargetInfo>>(args: Triple,
189 args: Opts);
190 case llvm::Triple::Fuchsia:
191 return std::make_unique<FuchsiaTargetInfo<AArch64beTargetInfo>>(args: Triple,
192 args: Opts);
193 case llvm::Triple::Linux:
194 return std::make_unique<LinuxTargetInfo<AArch64beTargetInfo>>(args: Triple,
195 args: Opts);
196 case llvm::Triple::NetBSD:
197 return std::make_unique<NetBSDTargetInfo<AArch64beTargetInfo>>(args: Triple,
198 args: Opts);
199 default:
200 return std::make_unique<AArch64beTargetInfo>(args: Triple, args: Opts);
201 }
202
203 case llvm::Triple::arm:
204 case llvm::Triple::thumb:
205 if (Triple.isOSBinFormatMachO())
206 return std::make_unique<DarwinARMTargetInfo>(args: Triple, args: Opts);
207
208 switch (os) {
209 case llvm::Triple::Linux:
210 switch (Triple.getEnvironment()) {
211 default:
212 return std::make_unique<LinuxTargetInfo<ARMleTargetInfo>>(args: Triple, args: Opts);
213 case llvm::Triple::OpenHOS:
214 return std::make_unique<OHOSTargetInfo<ARMleTargetInfo>>(args: Triple, args: Opts);
215 }
216 case llvm::Triple::LiteOS:
217 return std::make_unique<OHOSTargetInfo<ARMleTargetInfo>>(args: Triple, args: Opts);
218 case llvm::Triple::FreeBSD:
219 return std::make_unique<FreeBSDTargetInfo<ARMleTargetInfo>>(args: Triple, args: Opts);
220 case llvm::Triple::NetBSD:
221 return std::make_unique<NetBSDTargetInfo<ARMleTargetInfo>>(args: Triple, args: Opts);
222 case llvm::Triple::OpenBSD:
223 return std::make_unique<OpenBSDTargetInfo<ARMleTargetInfo>>(args: Triple, args: Opts);
224 case llvm::Triple::RTEMS:
225 return std::make_unique<RTEMSTargetInfo<ARMleTargetInfo>>(args: Triple, args: Opts);
226 case llvm::Triple::Haiku:
227 return std::make_unique<HaikuTargetInfo<ARMleTargetInfo>>(args: Triple, args: Opts);
228 case llvm::Triple::NaCl:
229 return std::make_unique<NaClTargetInfo<ARMleTargetInfo>>(args: Triple, args: Opts);
230 case llvm::Triple::Win32:
231 switch (Triple.getEnvironment()) {
232 case llvm::Triple::Cygnus:
233 return std::make_unique<CygwinARMTargetInfo>(args: Triple, args: Opts);
234 case llvm::Triple::GNU:
235 return std::make_unique<MinGWARMTargetInfo>(args: Triple, args: Opts);
236 case llvm::Triple::Itanium:
237 return std::make_unique<ItaniumWindowsARMleTargetInfo>(args: Triple, args: Opts);
238 case llvm::Triple::MSVC:
239 default: // Assume MSVC for unknown environments
240 return std::make_unique<MicrosoftARMleTargetInfo>(args: Triple, args: Opts);
241 }
242 default:
243 return std::make_unique<ARMleTargetInfo>(args: Triple, args: Opts);
244 }
245
246 case llvm::Triple::armeb:
247 case llvm::Triple::thumbeb:
248 if (Triple.isOSDarwin())
249 return std::make_unique<DarwinARMTargetInfo>(args: Triple, args: Opts);
250 else if (Triple.isAppleMachO())
251 return std::make_unique<AppleMachOARMTargetInfo>(args: Triple, args: Opts);
252
253 switch (os) {
254 case llvm::Triple::Linux:
255 return std::make_unique<LinuxTargetInfo<ARMbeTargetInfo>>(args: Triple, args: Opts);
256 case llvm::Triple::NetBSD:
257 return std::make_unique<NetBSDTargetInfo<ARMbeTargetInfo>>(args: Triple, args: Opts);
258 case llvm::Triple::RTEMS:
259 return std::make_unique<RTEMSTargetInfo<ARMbeTargetInfo>>(args: Triple, args: Opts);
260 case llvm::Triple::NaCl:
261 return std::make_unique<NaClTargetInfo<ARMbeTargetInfo>>(args: Triple, args: Opts);
262 default:
263 return std::make_unique<ARMbeTargetInfo>(args: Triple, args: Opts);
264 }
265
266 case llvm::Triple::avr:
267 return std::make_unique<AVRTargetInfo>(args: Triple, args: Opts);
268 case llvm::Triple::bpfeb:
269 case llvm::Triple::bpfel:
270 return std::make_unique<BPFTargetInfo>(args: Triple, args: Opts);
271
272 case llvm::Triple::msp430:
273 return std::make_unique<MSP430TargetInfo>(args: Triple, args: Opts);
274
275 case llvm::Triple::mips:
276 switch (os) {
277 case llvm::Triple::Linux:
278 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
279 case llvm::Triple::RTEMS:
280 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
281 case llvm::Triple::FreeBSD:
282 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
283 case llvm::Triple::NetBSD:
284 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
285 default:
286 return std::make_unique<MipsTargetInfo>(args: Triple, args: Opts);
287 }
288
289 case llvm::Triple::mipsel:
290 switch (os) {
291 case llvm::Triple::Linux:
292 switch (Triple.getEnvironment()) {
293 default:
294 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
295 case llvm::Triple::OpenHOS:
296 return std::make_unique<OHOSTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
297 }
298 case llvm::Triple::RTEMS:
299 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
300 case llvm::Triple::FreeBSD:
301 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
302 case llvm::Triple::NetBSD:
303 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
304 case llvm::Triple::NaCl:
305 return std::make_unique<NaClTargetInfo<NaClMips32TargetInfo>>(args: Triple,
306 args: Opts);
307 case llvm::Triple::Win32:
308 switch (Triple.getEnvironment()) {
309 case llvm::Triple::GNU:
310 return std::make_unique<MinGWMipsTargetInfo>(args: Triple, args: Opts);
311 case llvm::Triple::MSVC:
312 default: // Assume MSVC for unknown environments
313 return std::make_unique<MicrosoftMipsTargetInfo>(args: Triple, args: Opts);
314 }
315 default:
316 return std::make_unique<MipsTargetInfo>(args: Triple, args: Opts);
317 }
318
319 case llvm::Triple::mips64:
320 switch (os) {
321 case llvm::Triple::Linux:
322 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
323 case llvm::Triple::RTEMS:
324 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
325 case llvm::Triple::FreeBSD:
326 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
327 case llvm::Triple::NetBSD:
328 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
329 case llvm::Triple::OpenBSD:
330 return std::make_unique<OpenBSDTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
331 default:
332 return std::make_unique<MipsTargetInfo>(args: Triple, args: Opts);
333 }
334
335 case llvm::Triple::mips64el:
336 switch (os) {
337 case llvm::Triple::Linux:
338 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
339 case llvm::Triple::RTEMS:
340 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
341 case llvm::Triple::FreeBSD:
342 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
343 case llvm::Triple::NetBSD:
344 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
345 case llvm::Triple::OpenBSD:
346 return std::make_unique<OpenBSDTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
347 default:
348 return std::make_unique<MipsTargetInfo>(args: Triple, args: Opts);
349 }
350
351 case llvm::Triple::m68k:
352 switch (os) {
353 case llvm::Triple::Linux:
354 return std::make_unique<LinuxTargetInfo<M68kTargetInfo>>(args: Triple, args: Opts);
355 case llvm::Triple::NetBSD:
356 return std::make_unique<NetBSDTargetInfo<M68kTargetInfo>>(args: Triple, args: Opts);
357 default:
358 return std::make_unique<M68kTargetInfo>(args: Triple, args: Opts);
359 }
360
361 case llvm::Triple::ppc:
362 switch (os) {
363 case llvm::Triple::Linux:
364 return std::make_unique<LinuxTargetInfo<PPC32TargetInfo>>(args: Triple, args: Opts);
365 case llvm::Triple::FreeBSD:
366 return std::make_unique<FreeBSDTargetInfo<PPC32TargetInfo>>(args: Triple, args: Opts);
367 case llvm::Triple::NetBSD:
368 return std::make_unique<NetBSDTargetInfo<PPC32TargetInfo>>(args: Triple, args: Opts);
369 case llvm::Triple::OpenBSD:
370 return std::make_unique<OpenBSDTargetInfo<PPC32TargetInfo>>(args: Triple, args: Opts);
371 case llvm::Triple::RTEMS:
372 return std::make_unique<RTEMSTargetInfo<PPC32TargetInfo>>(args: Triple, args: Opts);
373 case llvm::Triple::AIX:
374 return std::make_unique<AIXPPC32TargetInfo>(args: Triple, args: Opts);
375 default:
376 return std::make_unique<PPC32TargetInfo>(args: Triple, args: Opts);
377 }
378
379 case llvm::Triple::ppcle:
380 switch (os) {
381 case llvm::Triple::Linux:
382 return std::make_unique<LinuxTargetInfo<PPC32TargetInfo>>(args: Triple, args: Opts);
383 case llvm::Triple::FreeBSD:
384 return std::make_unique<FreeBSDTargetInfo<PPC32TargetInfo>>(args: Triple, args: Opts);
385 default:
386 return std::make_unique<PPC32TargetInfo>(args: Triple, args: Opts);
387 }
388
389 case llvm::Triple::ppc64:
390 switch (os) {
391 case llvm::Triple::Linux:
392 return std::make_unique<LinuxTargetInfo<PPC64TargetInfo>>(args: Triple, args: Opts);
393 case llvm::Triple::Lv2:
394 return std::make_unique<PS3PPUTargetInfo<PPC64TargetInfo>>(args: Triple, args: Opts);
395 case llvm::Triple::FreeBSD:
396 return std::make_unique<FreeBSDTargetInfo<PPC64TargetInfo>>(args: Triple, args: Opts);
397 case llvm::Triple::NetBSD:
398 return std::make_unique<NetBSDTargetInfo<PPC64TargetInfo>>(args: Triple, args: Opts);
399 case llvm::Triple::OpenBSD:
400 return std::make_unique<OpenBSDTargetInfo<PPC64TargetInfo>>(args: Triple, args: Opts);
401 case llvm::Triple::AIX:
402 return std::make_unique<AIXPPC64TargetInfo>(args: Triple, args: Opts);
403 default:
404 return std::make_unique<PPC64TargetInfo>(args: Triple, args: Opts);
405 }
406
407 case llvm::Triple::ppc64le:
408 switch (os) {
409 case llvm::Triple::Linux:
410 return std::make_unique<LinuxTargetInfo<PPC64TargetInfo>>(args: Triple, args: Opts);
411 case llvm::Triple::FreeBSD:
412 return std::make_unique<FreeBSDTargetInfo<PPC64TargetInfo>>(args: Triple, args: Opts);
413 case llvm::Triple::NetBSD:
414 return std::make_unique<NetBSDTargetInfo<PPC64TargetInfo>>(args: Triple, args: Opts);
415 case llvm::Triple::OpenBSD:
416 return std::make_unique<OpenBSDTargetInfo<PPC64TargetInfo>>(args: Triple, args: Opts);
417 default:
418 return std::make_unique<PPC64TargetInfo>(args: Triple, args: Opts);
419 }
420
421 case llvm::Triple::nvptx:
422 return std::make_unique<NVPTXTargetInfo>(args: Triple, args: Opts,
423 /*TargetPointerWidth=*/args: 32);
424 case llvm::Triple::nvptx64:
425 return std::make_unique<NVPTXTargetInfo>(args: Triple, args: Opts,
426 /*TargetPointerWidth=*/args: 64);
427
428 case llvm::Triple::amdgcn:
429 case llvm::Triple::r600:
430 return std::make_unique<AMDGPUTargetInfo>(args: Triple, args: Opts);
431
432 case llvm::Triple::riscv32:
433 switch (os) {
434 case llvm::Triple::NetBSD:
435 return std::make_unique<NetBSDTargetInfo<RISCV32TargetInfo>>(args: Triple,
436 args: Opts);
437 case llvm::Triple::Linux:
438 return std::make_unique<LinuxTargetInfo<RISCV32TargetInfo>>(args: Triple, args: Opts);
439 default:
440 return std::make_unique<RISCV32TargetInfo>(args: Triple, args: Opts);
441 }
442
443 case llvm::Triple::riscv64:
444 switch (os) {
445 case llvm::Triple::FreeBSD:
446 return std::make_unique<FreeBSDTargetInfo<RISCV64TargetInfo>>(args: Triple,
447 args: Opts);
448 case llvm::Triple::NetBSD:
449 return std::make_unique<NetBSDTargetInfo<RISCV64TargetInfo>>(args: Triple,
450 args: Opts);
451 case llvm::Triple::OpenBSD:
452 return std::make_unique<OpenBSDTargetInfo<RISCV64TargetInfo>>(args: Triple,
453 args: Opts);
454 case llvm::Triple::Fuchsia:
455 return std::make_unique<FuchsiaTargetInfo<RISCV64TargetInfo>>(args: Triple,
456 args: Opts);
457 case llvm::Triple::Haiku:
458 return std::make_unique<HaikuTargetInfo<RISCV64TargetInfo>>(args: Triple,
459 args: Opts);
460 case llvm::Triple::Linux:
461 switch (Triple.getEnvironment()) {
462 default:
463 return std::make_unique<LinuxTargetInfo<RISCV64TargetInfo>>(args: Triple,
464 args: Opts);
465 case llvm::Triple::OpenHOS:
466 return std::make_unique<OHOSTargetInfo<RISCV64TargetInfo>>(args: Triple,
467 args: Opts);
468 }
469 default:
470 return std::make_unique<RISCV64TargetInfo>(args: Triple, args: Opts);
471 }
472
473 case llvm::Triple::sparc:
474 switch (os) {
475 case llvm::Triple::Linux:
476 return std::make_unique<LinuxTargetInfo<SparcV8TargetInfo>>(args: Triple, args: Opts);
477 case llvm::Triple::Solaris:
478 return std::make_unique<SolarisTargetInfo<SparcV8TargetInfo>>(args: Triple,
479 args: Opts);
480 case llvm::Triple::NetBSD:
481 return std::make_unique<NetBSDTargetInfo<SparcV8TargetInfo>>(args: Triple,
482 args: Opts);
483 case llvm::Triple::RTEMS:
484 return std::make_unique<RTEMSTargetInfo<SparcV8TargetInfo>>(args: Triple, args: Opts);
485 default:
486 return std::make_unique<SparcV8TargetInfo>(args: Triple, args: Opts);
487 }
488
489 case llvm::Triple::sparcel:
490 switch (os) {
491 case llvm::Triple::Linux:
492 return std::make_unique<LinuxTargetInfo<SparcV8elTargetInfo>>(args: Triple,
493 args: Opts);
494 case llvm::Triple::RTEMS:
495 return std::make_unique<RTEMSTargetInfo<SparcV8elTargetInfo>>(args: Triple,
496 args: Opts);
497 default:
498 return std::make_unique<SparcV8elTargetInfo>(args: Triple, args: Opts);
499 }
500
501 case llvm::Triple::sparcv9:
502 switch (os) {
503 case llvm::Triple::Linux:
504 return std::make_unique<LinuxTargetInfo<SparcV9TargetInfo>>(args: Triple, args: Opts);
505 case llvm::Triple::Solaris:
506 return std::make_unique<SolarisTargetInfo<SparcV9TargetInfo>>(args: Triple,
507 args: Opts);
508 case llvm::Triple::NetBSD:
509 return std::make_unique<NetBSDTargetInfo<SparcV9TargetInfo>>(args: Triple,
510 args: Opts);
511 case llvm::Triple::OpenBSD:
512 return std::make_unique<OpenBSDTargetInfo<SparcV9TargetInfo>>(args: Triple,
513 args: Opts);
514 case llvm::Triple::FreeBSD:
515 return std::make_unique<FreeBSDTargetInfo<SparcV9TargetInfo>>(args: Triple,
516 args: Opts);
517 default:
518 return std::make_unique<SparcV9TargetInfo>(args: Triple, args: Opts);
519 }
520
521 case llvm::Triple::systemz:
522 switch (os) {
523 case llvm::Triple::Linux:
524 return std::make_unique<LinuxTargetInfo<SystemZTargetInfo>>(args: Triple, args: Opts);
525 case llvm::Triple::ZOS:
526 return std::make_unique<ZOSTargetInfo<SystemZTargetInfo>>(args: Triple, args: Opts);
527 default:
528 return std::make_unique<SystemZTargetInfo>(args: Triple, args: Opts);
529 }
530
531 case llvm::Triple::tce:
532 return std::make_unique<TCETargetInfo>(args: Triple, args: Opts);
533
534 case llvm::Triple::tcele:
535 return std::make_unique<TCELETargetInfo>(args: Triple, args: Opts);
536
537 case llvm::Triple::x86:
538 if (Triple.isOSDarwin())
539 return std::make_unique<DarwinI386TargetInfo>(args: Triple, args: Opts);
540 else if (Triple.isAppleMachO())
541 return std::make_unique<AppleMachOI386TargetInfo>(args: Triple, args: Opts);
542
543 switch (os) {
544 case llvm::Triple::Linux: {
545 switch (Triple.getEnvironment()) {
546 default:
547 return std::make_unique<LinuxTargetInfo<X86_32TargetInfo>>(args: Triple,
548 args: Opts);
549 case llvm::Triple::Android:
550 return std::make_unique<AndroidX86_32TargetInfo>(args: Triple, args: Opts);
551 }
552 }
553 case llvm::Triple::DragonFly:
554 return std::make_unique<DragonFlyBSDTargetInfo<X86_32TargetInfo>>(args: Triple,
555 args: Opts);
556 case llvm::Triple::NetBSD:
557 return std::make_unique<NetBSDI386TargetInfo>(args: Triple, args: Opts);
558 case llvm::Triple::OpenBSD:
559 return std::make_unique<OpenBSDI386TargetInfo>(args: Triple, args: Opts);
560 case llvm::Triple::FreeBSD:
561 return std::make_unique<FreeBSDTargetInfo<X86_32TargetInfo>>(args: Triple,
562 args: Opts);
563 case llvm::Triple::Fuchsia:
564 return std::make_unique<FuchsiaTargetInfo<X86_32TargetInfo>>(args: Triple,
565 args: Opts);
566 case llvm::Triple::KFreeBSD:
567 return std::make_unique<KFreeBSDTargetInfo<X86_32TargetInfo>>(args: Triple,
568 args: Opts);
569 case llvm::Triple::Solaris:
570 return std::make_unique<SolarisTargetInfo<X86_32TargetInfo>>(args: Triple,
571 args: Opts);
572 case llvm::Triple::Win32: {
573 switch (Triple.getEnvironment()) {
574 case llvm::Triple::Cygnus:
575 return std::make_unique<CygwinX86_32TargetInfo>(args: Triple, args: Opts);
576 case llvm::Triple::GNU:
577 return std::make_unique<MinGWX86_32TargetInfo>(args: Triple, args: Opts);
578 case llvm::Triple::Itanium:
579 case llvm::Triple::MSVC:
580 default: // Assume MSVC for unknown environments
581 return std::make_unique<MicrosoftX86_32TargetInfo>(args: Triple, args: Opts);
582 }
583 }
584 case llvm::Triple::Haiku:
585 return std::make_unique<HaikuX86_32TargetInfo>(args: Triple, args: Opts);
586 case llvm::Triple::RTEMS:
587 return std::make_unique<RTEMSX86_32TargetInfo>(args: Triple, args: Opts);
588 case llvm::Triple::NaCl:
589 return std::make_unique<NaClTargetInfo<X86_32TargetInfo>>(args: Triple, args: Opts);
590 case llvm::Triple::ELFIAMCU:
591 return std::make_unique<MCUX86_32TargetInfo>(args: Triple, args: Opts);
592 case llvm::Triple::Hurd:
593 return std::make_unique<HurdTargetInfo<X86_32TargetInfo>>(args: Triple, args: Opts);
594 default:
595 return std::make_unique<X86_32TargetInfo>(args: Triple, args: Opts);
596 }
597
598 case llvm::Triple::x86_64:
599 if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())
600 return std::make_unique<DarwinX86_64TargetInfo>(args: Triple, args: Opts);
601
602 switch (os) {
603 case llvm::Triple::Linux: {
604 switch (Triple.getEnvironment()) {
605 default:
606 return std::make_unique<LinuxTargetInfo<X86_64TargetInfo>>(args: Triple,
607 args: Opts);
608 case llvm::Triple::Android:
609 return std::make_unique<AndroidX86_64TargetInfo>(args: Triple, args: Opts);
610 case llvm::Triple::OpenHOS:
611 return std::make_unique<OHOSX86_64TargetInfo>(args: Triple, args: Opts);
612 }
613 }
614 case llvm::Triple::DragonFly:
615 return std::make_unique<DragonFlyBSDTargetInfo<X86_64TargetInfo>>(args: Triple,
616 args: Opts);
617 case llvm::Triple::NetBSD:
618 return std::make_unique<NetBSDTargetInfo<X86_64TargetInfo>>(args: Triple, args: Opts);
619 case llvm::Triple::OpenBSD:
620 return std::make_unique<OpenBSDX86_64TargetInfo>(args: Triple, args: Opts);
621 case llvm::Triple::FreeBSD:
622 return std::make_unique<FreeBSDTargetInfo<X86_64TargetInfo>>(args: Triple,
623 args: Opts);
624 case llvm::Triple::Fuchsia:
625 return std::make_unique<FuchsiaTargetInfo<X86_64TargetInfo>>(args: Triple,
626 args: Opts);
627 case llvm::Triple::KFreeBSD:
628 return std::make_unique<KFreeBSDTargetInfo<X86_64TargetInfo>>(args: Triple,
629 args: Opts);
630 case llvm::Triple::Solaris:
631 return std::make_unique<SolarisTargetInfo<X86_64TargetInfo>>(args: Triple,
632 args: Opts);
633 case llvm::Triple::UEFI:
634 return std::make_unique<UEFIX86_64TargetInfo>(args: Triple, args: Opts);
635
636 case llvm::Triple::Win32: {
637 switch (Triple.getEnvironment()) {
638 case llvm::Triple::Cygnus:
639 return std::make_unique<CygwinX86_64TargetInfo>(args: Triple, args: Opts);
640 case llvm::Triple::GNU:
641 return std::make_unique<MinGWX86_64TargetInfo>(args: Triple, args: Opts);
642 case llvm::Triple::MSVC:
643 default: // Assume MSVC for unknown environments
644 return std::make_unique<MicrosoftX86_64TargetInfo>(args: Triple, args: Opts);
645 }
646 }
647 case llvm::Triple::Haiku:
648 return std::make_unique<HaikuTargetInfo<X86_64TargetInfo>>(args: Triple, args: Opts);
649 case llvm::Triple::NaCl:
650 return std::make_unique<NaClTargetInfo<X86_64TargetInfo>>(args: Triple, args: Opts);
651 case llvm::Triple::PS4:
652 return std::make_unique<PS4OSTargetInfo<X86_64TargetInfo>>(args: Triple, args: Opts);
653 case llvm::Triple::PS5:
654 return std::make_unique<PS5OSTargetInfo<X86_64TargetInfo>>(args: Triple, args: Opts);
655 case llvm::Triple::Hurd:
656 return std::make_unique<HurdTargetInfo<X86_64TargetInfo>>(args: Triple, args: Opts);
657 default:
658 return std::make_unique<X86_64TargetInfo>(args: Triple, args: Opts);
659 }
660
661 case llvm::Triple::spir: {
662 if (os != llvm::Triple::UnknownOS ||
663 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
664 return nullptr;
665 return std::make_unique<SPIR32TargetInfo>(args: Triple, args: Opts);
666 }
667 case llvm::Triple::spir64: {
668 if (os != llvm::Triple::UnknownOS ||
669 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
670 return nullptr;
671 return std::make_unique<SPIR64TargetInfo>(args: Triple, args: Opts);
672 }
673 case llvm::Triple::spirv: {
674 return std::make_unique<SPIRVTargetInfo>(args: Triple, args: Opts);
675 }
676 case llvm::Triple::spirv32: {
677 if (os != llvm::Triple::UnknownOS ||
678 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
679 return nullptr;
680 return std::make_unique<SPIRV32TargetInfo>(args: Triple, args: Opts);
681 }
682 case llvm::Triple::spirv64: {
683 if (os != llvm::Triple::UnknownOS ||
684 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) {
685 if (os == llvm::Triple::OSType::AMDHSA)
686 return std::make_unique<SPIRV64AMDGCNTargetInfo>(args: Triple, args: Opts);
687 return nullptr;
688 }
689 return std::make_unique<SPIRV64TargetInfo>(args: Triple, args: Opts);
690 }
691 case llvm::Triple::wasm32:
692 if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
693 Triple.getVendor() != llvm::Triple::UnknownVendor ||
694 !Triple.isOSBinFormatWasm())
695 return nullptr;
696 switch (os) {
697 case llvm::Triple::WASI:
698 return std::make_unique<WASITargetInfo<WebAssembly32TargetInfo>>(args: Triple,
699 args: Opts);
700 case llvm::Triple::Emscripten:
701 return std::make_unique<EmscriptenTargetInfo<WebAssembly32TargetInfo>>(
702 args: Triple, args: Opts);
703 case llvm::Triple::UnknownOS:
704 return std::make_unique<WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>>(
705 args: Triple, args: Opts);
706 default:
707 return nullptr;
708 }
709 case llvm::Triple::wasm64:
710 if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
711 Triple.getVendor() != llvm::Triple::UnknownVendor ||
712 !Triple.isOSBinFormatWasm())
713 return nullptr;
714 switch (os) {
715 case llvm::Triple::WASI:
716 return std::make_unique<WASITargetInfo<WebAssembly64TargetInfo>>(args: Triple,
717 args: Opts);
718 case llvm::Triple::Emscripten:
719 return std::make_unique<EmscriptenTargetInfo<WebAssembly64TargetInfo>>(
720 args: Triple, args: Opts);
721 case llvm::Triple::UnknownOS:
722 return std::make_unique<WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>>(
723 args: Triple, args: Opts);
724 default:
725 return nullptr;
726 }
727
728 case llvm::Triple::dxil:
729 return std::make_unique<DirectXTargetInfo>(args: Triple, args: Opts);
730
731 case llvm::Triple::ve:
732 return std::make_unique<LinuxTargetInfo<VETargetInfo>>(args: Triple, args: Opts);
733
734 case llvm::Triple::csky:
735 switch (os) {
736 case llvm::Triple::Linux:
737 return std::make_unique<LinuxTargetInfo<CSKYTargetInfo>>(args: Triple, args: Opts);
738 default:
739 return std::make_unique<CSKYTargetInfo>(args: Triple, args: Opts);
740 }
741 case llvm::Triple::loongarch32:
742 switch (os) {
743 case llvm::Triple::Linux:
744 return std::make_unique<LinuxTargetInfo<LoongArch32TargetInfo>>(args: Triple,
745 args: Opts);
746 default:
747 return std::make_unique<LoongArch32TargetInfo>(args: Triple, args: Opts);
748 }
749 case llvm::Triple::loongarch64:
750 switch (os) {
751 case llvm::Triple::Linux:
752 switch (Triple.getEnvironment()) {
753 default:
754 return std::make_unique<LinuxTargetInfo<LoongArch64TargetInfo>>(args: Triple,
755 args: Opts);
756 case llvm::Triple::OpenHOS:
757 return std::make_unique<OHOSTargetInfo<LoongArch64TargetInfo>>(args: Triple,
758 args: Opts);
759 }
760 case llvm::Triple::FreeBSD:
761 return std::make_unique<FreeBSDTargetInfo<LoongArch64TargetInfo>>(args: Triple,
762 args: Opts);
763 default:
764 return std::make_unique<LoongArch64TargetInfo>(args: Triple, args: Opts);
765 }
766
767 case llvm::Triple::xtensa:
768 return std::make_unique<XtensaTargetInfo>(args: Triple, args: Opts);
769 }
770}
771} // namespace targets
772} // namespace clang
773
774using namespace clang::targets;
775/// CreateTargetInfo - Return the target info object for the specified target
776/// options.
777TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
778 TargetOptions &OptsRef) {
779 TargetOptions *Opts = &OptsRef;
780
781 llvm::Triple Triple(llvm::Triple::normalize(Str: Opts->Triple));
782
783 // Construct the target
784 std::unique_ptr<TargetInfo> Target = AllocateTarget(Triple, Opts: *Opts);
785 if (!Target) {
786 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
787 return nullptr;
788 }
789 Target->TargetOpts = Opts;
790
791 // Set the target CPU if specified.
792 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
793 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
794 SmallVector<StringRef, 32> ValidList;
795 Target->fillValidCPUList(Values&: ValidList);
796 if (!ValidList.empty())
797 Diags.Report(diag::note_valid_options) << llvm::join(R&: ValidList, Separator: ", ");
798 return nullptr;
799 }
800
801 // Check the TuneCPU name if specified.
802 if (!Opts->TuneCPU.empty() &&
803 !Target->isValidTuneCPUName(Name: Opts->TuneCPU)) {
804 Diags.Report(diag::err_target_unknown_cpu) << Opts->TuneCPU;
805 SmallVector<StringRef, 32> ValidList;
806 Target->fillValidTuneCPUList(Values&: ValidList);
807 if (!ValidList.empty())
808 Diags.Report(diag::note_valid_options) << llvm::join(R&: ValidList, Separator: ", ");
809 return nullptr;
810 }
811
812 // Set the target ABI if specified.
813 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
814 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
815 return nullptr;
816 }
817
818 // Set the fp math unit.
819 if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
820 Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath;
821 return nullptr;
822 }
823
824 // Compute the default target features, we need the target to handle this
825 // because features may have dependencies on one another.
826 llvm::erase_if(C&: Opts->FeaturesAsWritten, P: [&](StringRef Name) {
827 if (Target->isReadOnlyFeature(Feature: Name.substr(Start: 1))) {
828 Diags.Report(diag::warn_fe_backend_readonly_feature_flag) << Name;
829 return true;
830 }
831 return false;
832 });
833 if (!Target->initFeatureMap(Features&: Opts->FeatureMap, Diags, CPU: Opts->CPU,
834 FeatureVec: Opts->FeaturesAsWritten))
835 return nullptr;
836
837 // Add the features to the compile options.
838 Opts->Features.clear();
839 for (const auto &F : Opts->FeatureMap)
840 Opts->Features.push_back(x: (F.getValue() ? "+" : "-") + F.getKey().str());
841 // Sort here, so we handle the features in a predictable order. (This matters
842 // when we're dealing with features that overlap.)
843 llvm::sort(C&: Opts->Features);
844
845 if (!Target->handleTargetFeatures(Features&: Opts->Features, Diags))
846 return nullptr;
847
848 Target->setSupportedOpenCLOpts();
849 Target->setCommandLineOpenCLOpts();
850 Target->setMaxAtomicWidth();
851
852 if (!Opts->DarwinTargetVariantTriple.empty())
853 Target->DarwinTargetVariantTriple =
854 llvm::Triple(Opts->DarwinTargetVariantTriple);
855
856 if (!Target->validateTarget(Diags))
857 return nullptr;
858
859 Target->CheckFixedPointBits();
860
861 return Target.release();
862}
863/// validateOpenCLTarget - Check that OpenCL target has valid
864/// options setting based on OpenCL version.
865bool TargetInfo::validateOpenCLTarget(const LangOptions &Opts,
866 DiagnosticsEngine &Diags) const {
867 const llvm::StringMap<bool> &OpenCLFeaturesMap = getSupportedOpenCLOpts();
868
869 auto diagnoseNotSupportedCore = [&](llvm::StringRef Name, auto... OptArgs) {
870 if (OpenCLOptions::isOpenCLOptionCoreIn(Opts, OptArgs...) &&
871 !hasFeatureEnabled(Features: OpenCLFeaturesMap, Name))
872 Diags.Report(diag::warn_opencl_unsupported_core_feature)
873 << Name << Opts.OpenCLCPlusPlus
874 << Opts.getOpenCLVersionTuple().getAsString();
875 };
876#define OPENCL_GENERIC_EXTENSION(Ext, ...) \
877 diagnoseNotSupportedCore(#Ext, __VA_ARGS__);
878#include "clang/Basic/OpenCLExtensions.def"
879
880 // Validate that feature macros are set properly for OpenCL C 3.0.
881 // In other cases assume that target is always valid.
882 if (Opts.getOpenCLCompatibleVersion() < 300)
883 return true;
884
885 return OpenCLOptions::diagnoseUnsupportedFeatureDependencies(TI: *this, Diags) &&
886 OpenCLOptions::diagnoseFeatureExtensionDifferences(TI: *this, Diags);
887}
888

source code of clang/lib/Basic/Targets.cpp