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::Managarm:
168 return std::make_unique<ManagarmTargetInfo<AArch64leTargetInfo>>(args: Triple,
169 args: Opts);
170 case llvm::Triple::NetBSD:
171 return std::make_unique<NetBSDTargetInfo<AArch64leTargetInfo>>(args: Triple,
172 args: Opts);
173 case llvm::Triple::OpenBSD:
174 return std::make_unique<OpenBSDTargetInfo<AArch64leTargetInfo>>(args: Triple,
175 args: Opts);
176 case llvm::Triple::Win32:
177 switch (Triple.getEnvironment()) {
178 case llvm::Triple::GNU:
179 return std::make_unique<MinGWARM64TargetInfo>(args: Triple, args: Opts);
180 case llvm::Triple::MSVC:
181 default: // Assume MSVC for unknown environments
182 return std::make_unique<MicrosoftARM64TargetInfo>(args: Triple, args: Opts);
183 }
184 default:
185 return std::make_unique<AArch64leTargetInfo>(args: Triple, args: Opts);
186 }
187
188 case llvm::Triple::aarch64_be:
189 switch (os) {
190 case llvm::Triple::FreeBSD:
191 return std::make_unique<FreeBSDTargetInfo<AArch64beTargetInfo>>(args: Triple,
192 args: Opts);
193 case llvm::Triple::Fuchsia:
194 return std::make_unique<FuchsiaTargetInfo<AArch64beTargetInfo>>(args: Triple,
195 args: Opts);
196 case llvm::Triple::Linux:
197 return std::make_unique<LinuxTargetInfo<AArch64beTargetInfo>>(args: Triple,
198 args: Opts);
199 case llvm::Triple::NetBSD:
200 return std::make_unique<NetBSDTargetInfo<AArch64beTargetInfo>>(args: Triple,
201 args: Opts);
202 default:
203 return std::make_unique<AArch64beTargetInfo>(args: Triple, args: Opts);
204 }
205
206 case llvm::Triple::arm:
207 case llvm::Triple::thumb:
208 if (Triple.isOSBinFormatMachO())
209 return std::make_unique<DarwinARMTargetInfo>(args: Triple, args: Opts);
210
211 switch (os) {
212 case llvm::Triple::Linux:
213 switch (Triple.getEnvironment()) {
214 default:
215 return std::make_unique<LinuxTargetInfo<ARMleTargetInfo>>(args: Triple, args: Opts);
216 case llvm::Triple::OpenHOS:
217 return std::make_unique<OHOSTargetInfo<ARMleTargetInfo>>(args: Triple, args: Opts);
218 }
219 case llvm::Triple::LiteOS:
220 return std::make_unique<OHOSTargetInfo<ARMleTargetInfo>>(args: Triple, args: Opts);
221 case llvm::Triple::FreeBSD:
222 return std::make_unique<FreeBSDTargetInfo<ARMleTargetInfo>>(args: Triple, args: Opts);
223 case llvm::Triple::NetBSD:
224 return std::make_unique<NetBSDTargetInfo<ARMleTargetInfo>>(args: Triple, args: Opts);
225 case llvm::Triple::OpenBSD:
226 return std::make_unique<OpenBSDTargetInfo<ARMleTargetInfo>>(args: Triple, args: Opts);
227 case llvm::Triple::RTEMS:
228 return std::make_unique<RTEMSTargetInfo<ARMleTargetInfo>>(args: Triple, args: Opts);
229 case llvm::Triple::Haiku:
230 return std::make_unique<HaikuTargetInfo<ARMleTargetInfo>>(args: Triple, args: Opts);
231 case llvm::Triple::NaCl:
232 return std::make_unique<NaClTargetInfo<ARMleTargetInfo>>(args: Triple, args: Opts);
233 case llvm::Triple::Win32:
234 switch (Triple.getEnvironment()) {
235 case llvm::Triple::Cygnus:
236 return std::make_unique<CygwinARMTargetInfo>(args: Triple, args: Opts);
237 case llvm::Triple::GNU:
238 return std::make_unique<MinGWARMTargetInfo>(args: Triple, args: Opts);
239 case llvm::Triple::Itanium:
240 return std::make_unique<ItaniumWindowsARMleTargetInfo>(args: Triple, args: Opts);
241 case llvm::Triple::MSVC:
242 default: // Assume MSVC for unknown environments
243 return std::make_unique<MicrosoftARMleTargetInfo>(args: Triple, args: Opts);
244 }
245 default:
246 return std::make_unique<ARMleTargetInfo>(args: Triple, args: Opts);
247 }
248
249 case llvm::Triple::armeb:
250 case llvm::Triple::thumbeb:
251 if (Triple.isOSDarwin())
252 return std::make_unique<DarwinARMTargetInfo>(args: Triple, args: Opts);
253 else if (Triple.isAppleMachO())
254 return std::make_unique<AppleMachOARMTargetInfo>(args: Triple, args: Opts);
255
256 switch (os) {
257 case llvm::Triple::Linux:
258 return std::make_unique<LinuxTargetInfo<ARMbeTargetInfo>>(args: Triple, args: Opts);
259 case llvm::Triple::NetBSD:
260 return std::make_unique<NetBSDTargetInfo<ARMbeTargetInfo>>(args: Triple, args: Opts);
261 case llvm::Triple::RTEMS:
262 return std::make_unique<RTEMSTargetInfo<ARMbeTargetInfo>>(args: Triple, args: Opts);
263 case llvm::Triple::NaCl:
264 return std::make_unique<NaClTargetInfo<ARMbeTargetInfo>>(args: Triple, args: Opts);
265 default:
266 return std::make_unique<ARMbeTargetInfo>(args: Triple, args: Opts);
267 }
268
269 case llvm::Triple::avr:
270 return std::make_unique<AVRTargetInfo>(args: Triple, args: Opts);
271 case llvm::Triple::bpfeb:
272 case llvm::Triple::bpfel:
273 return std::make_unique<BPFTargetInfo>(args: Triple, args: Opts);
274
275 case llvm::Triple::msp430:
276 return std::make_unique<MSP430TargetInfo>(args: Triple, args: Opts);
277
278 case llvm::Triple::mips:
279 switch (os) {
280 case llvm::Triple::Linux:
281 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
282 case llvm::Triple::RTEMS:
283 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
284 case llvm::Triple::FreeBSD:
285 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
286 case llvm::Triple::NetBSD:
287 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
288 default:
289 return std::make_unique<MipsTargetInfo>(args: Triple, args: Opts);
290 }
291
292 case llvm::Triple::mipsel:
293 switch (os) {
294 case llvm::Triple::Linux:
295 switch (Triple.getEnvironment()) {
296 default:
297 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
298 case llvm::Triple::OpenHOS:
299 return std::make_unique<OHOSTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
300 }
301 case llvm::Triple::RTEMS:
302 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
303 case llvm::Triple::FreeBSD:
304 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
305 case llvm::Triple::NetBSD:
306 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
307 case llvm::Triple::NaCl:
308 return std::make_unique<NaClTargetInfo<NaClMips32TargetInfo>>(args: Triple,
309 args: Opts);
310 case llvm::Triple::Win32:
311 switch (Triple.getEnvironment()) {
312 case llvm::Triple::GNU:
313 return std::make_unique<MinGWMipsTargetInfo>(args: Triple, args: Opts);
314 case llvm::Triple::MSVC:
315 default: // Assume MSVC for unknown environments
316 return std::make_unique<MicrosoftMipsTargetInfo>(args: Triple, args: Opts);
317 }
318 default:
319 return std::make_unique<MipsTargetInfo>(args: Triple, args: Opts);
320 }
321
322 case llvm::Triple::mips64:
323 switch (os) {
324 case llvm::Triple::Linux:
325 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
326 case llvm::Triple::RTEMS:
327 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
328 case llvm::Triple::FreeBSD:
329 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
330 case llvm::Triple::NetBSD:
331 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
332 case llvm::Triple::OpenBSD:
333 return std::make_unique<OpenBSDTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
334 default:
335 return std::make_unique<MipsTargetInfo>(args: Triple, args: Opts);
336 }
337
338 case llvm::Triple::mips64el:
339 switch (os) {
340 case llvm::Triple::Linux:
341 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
342 case llvm::Triple::RTEMS:
343 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
344 case llvm::Triple::FreeBSD:
345 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
346 case llvm::Triple::NetBSD:
347 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
348 case llvm::Triple::OpenBSD:
349 return std::make_unique<OpenBSDTargetInfo<MipsTargetInfo>>(args: Triple, args: Opts);
350 default:
351 return std::make_unique<MipsTargetInfo>(args: Triple, args: Opts);
352 }
353
354 case llvm::Triple::m68k:
355 switch (os) {
356 case llvm::Triple::Linux:
357 return std::make_unique<LinuxTargetInfo<M68kTargetInfo>>(args: Triple, args: Opts);
358 case llvm::Triple::NetBSD:
359 return std::make_unique<NetBSDTargetInfo<M68kTargetInfo>>(args: Triple, args: Opts);
360 default:
361 return std::make_unique<M68kTargetInfo>(args: Triple, args: Opts);
362 }
363
364 case llvm::Triple::ppc:
365 switch (os) {
366 case llvm::Triple::Linux:
367 return std::make_unique<LinuxTargetInfo<PPC32TargetInfo>>(args: Triple, args: Opts);
368 case llvm::Triple::FreeBSD:
369 return std::make_unique<FreeBSDTargetInfo<PPC32TargetInfo>>(args: Triple, args: Opts);
370 case llvm::Triple::NetBSD:
371 return std::make_unique<NetBSDTargetInfo<PPC32TargetInfo>>(args: Triple, args: Opts);
372 case llvm::Triple::OpenBSD:
373 return std::make_unique<OpenBSDTargetInfo<PPC32TargetInfo>>(args: Triple, args: Opts);
374 case llvm::Triple::RTEMS:
375 return std::make_unique<RTEMSTargetInfo<PPC32TargetInfo>>(args: Triple, args: Opts);
376 case llvm::Triple::AIX:
377 return std::make_unique<AIXPPC32TargetInfo>(args: Triple, args: Opts);
378 default:
379 return std::make_unique<PPC32TargetInfo>(args: Triple, args: Opts);
380 }
381
382 case llvm::Triple::ppcle:
383 switch (os) {
384 case llvm::Triple::Linux:
385 return std::make_unique<LinuxTargetInfo<PPC32TargetInfo>>(args: Triple, args: Opts);
386 case llvm::Triple::FreeBSD:
387 return std::make_unique<FreeBSDTargetInfo<PPC32TargetInfo>>(args: Triple, args: Opts);
388 default:
389 return std::make_unique<PPC32TargetInfo>(args: Triple, args: Opts);
390 }
391
392 case llvm::Triple::ppc64:
393 switch (os) {
394 case llvm::Triple::Linux:
395 return std::make_unique<LinuxTargetInfo<PPC64TargetInfo>>(args: Triple, args: Opts);
396 case llvm::Triple::Lv2:
397 return std::make_unique<PS3PPUTargetInfo<PPC64TargetInfo>>(args: Triple, args: Opts);
398 case llvm::Triple::FreeBSD:
399 return std::make_unique<FreeBSDTargetInfo<PPC64TargetInfo>>(args: Triple, args: Opts);
400 case llvm::Triple::NetBSD:
401 return std::make_unique<NetBSDTargetInfo<PPC64TargetInfo>>(args: Triple, args: Opts);
402 case llvm::Triple::OpenBSD:
403 return std::make_unique<OpenBSDTargetInfo<PPC64TargetInfo>>(args: Triple, args: Opts);
404 case llvm::Triple::AIX:
405 return std::make_unique<AIXPPC64TargetInfo>(args: Triple, args: Opts);
406 default:
407 return std::make_unique<PPC64TargetInfo>(args: Triple, args: Opts);
408 }
409
410 case llvm::Triple::ppc64le:
411 switch (os) {
412 case llvm::Triple::Linux:
413 return std::make_unique<LinuxTargetInfo<PPC64TargetInfo>>(args: Triple, args: Opts);
414 case llvm::Triple::FreeBSD:
415 return std::make_unique<FreeBSDTargetInfo<PPC64TargetInfo>>(args: Triple, args: Opts);
416 case llvm::Triple::NetBSD:
417 return std::make_unique<NetBSDTargetInfo<PPC64TargetInfo>>(args: Triple, args: Opts);
418 case llvm::Triple::OpenBSD:
419 return std::make_unique<OpenBSDTargetInfo<PPC64TargetInfo>>(args: Triple, args: Opts);
420 default:
421 return std::make_unique<PPC64TargetInfo>(args: Triple, args: Opts);
422 }
423
424 case llvm::Triple::nvptx:
425 return std::make_unique<NVPTXTargetInfo>(args: Triple, args: Opts,
426 /*TargetPointerWidth=*/args: 32);
427 case llvm::Triple::nvptx64:
428 return std::make_unique<NVPTXTargetInfo>(args: Triple, args: Opts,
429 /*TargetPointerWidth=*/args: 64);
430
431 case llvm::Triple::amdgcn:
432 case llvm::Triple::r600:
433 return std::make_unique<AMDGPUTargetInfo>(args: Triple, args: Opts);
434
435 case llvm::Triple::riscv32:
436 switch (os) {
437 case llvm::Triple::NetBSD:
438 return std::make_unique<NetBSDTargetInfo<RISCV32TargetInfo>>(args: Triple,
439 args: Opts);
440 case llvm::Triple::Linux:
441 return std::make_unique<LinuxTargetInfo<RISCV32TargetInfo>>(args: Triple, args: Opts);
442 default:
443 return std::make_unique<RISCV32TargetInfo>(args: Triple, args: Opts);
444 }
445
446 case llvm::Triple::riscv64:
447 switch (os) {
448 case llvm::Triple::FreeBSD:
449 return std::make_unique<FreeBSDTargetInfo<RISCV64TargetInfo>>(args: Triple,
450 args: Opts);
451 case llvm::Triple::NetBSD:
452 return std::make_unique<NetBSDTargetInfo<RISCV64TargetInfo>>(args: Triple,
453 args: Opts);
454 case llvm::Triple::OpenBSD:
455 return std::make_unique<OpenBSDTargetInfo<RISCV64TargetInfo>>(args: Triple,
456 args: Opts);
457 case llvm::Triple::Fuchsia:
458 return std::make_unique<FuchsiaTargetInfo<RISCV64TargetInfo>>(args: Triple,
459 args: Opts);
460 case llvm::Triple::Haiku:
461 return std::make_unique<HaikuTargetInfo<RISCV64TargetInfo>>(args: Triple,
462 args: Opts);
463 case llvm::Triple::Linux:
464 switch (Triple.getEnvironment()) {
465 default:
466 return std::make_unique<LinuxTargetInfo<RISCV64TargetInfo>>(args: Triple,
467 args: Opts);
468 case llvm::Triple::OpenHOS:
469 return std::make_unique<OHOSTargetInfo<RISCV64TargetInfo>>(args: Triple,
470 args: Opts);
471 }
472 case llvm::Triple::Managarm:
473 return std::make_unique<ManagarmTargetInfo<RISCV64TargetInfo>>(args: Triple,
474 args: Opts);
475 default:
476 return std::make_unique<RISCV64TargetInfo>(args: Triple, args: Opts);
477 }
478
479 case llvm::Triple::sparc:
480 switch (os) {
481 case llvm::Triple::Linux:
482 return std::make_unique<LinuxTargetInfo<SparcV8TargetInfo>>(args: Triple, args: Opts);
483 case llvm::Triple::Solaris:
484 return std::make_unique<SolarisTargetInfo<SparcV8TargetInfo>>(args: Triple,
485 args: Opts);
486 case llvm::Triple::NetBSD:
487 return std::make_unique<NetBSDTargetInfo<SparcV8TargetInfo>>(args: Triple,
488 args: Opts);
489 case llvm::Triple::RTEMS:
490 return std::make_unique<RTEMSTargetInfo<SparcV8TargetInfo>>(args: Triple, args: Opts);
491 default:
492 return std::make_unique<SparcV8TargetInfo>(args: Triple, args: Opts);
493 }
494
495 case llvm::Triple::sparcel:
496 switch (os) {
497 case llvm::Triple::Linux:
498 return std::make_unique<LinuxTargetInfo<SparcV8elTargetInfo>>(args: Triple,
499 args: Opts);
500 case llvm::Triple::RTEMS:
501 return std::make_unique<RTEMSTargetInfo<SparcV8elTargetInfo>>(args: Triple,
502 args: Opts);
503 default:
504 return std::make_unique<SparcV8elTargetInfo>(args: Triple, args: Opts);
505 }
506
507 case llvm::Triple::sparcv9:
508 switch (os) {
509 case llvm::Triple::Linux:
510 return std::make_unique<LinuxTargetInfo<SparcV9TargetInfo>>(args: Triple, args: Opts);
511 case llvm::Triple::Solaris:
512 return std::make_unique<SolarisTargetInfo<SparcV9TargetInfo>>(args: Triple,
513 args: Opts);
514 case llvm::Triple::NetBSD:
515 return std::make_unique<NetBSDTargetInfo<SparcV9TargetInfo>>(args: Triple,
516 args: Opts);
517 case llvm::Triple::OpenBSD:
518 return std::make_unique<OpenBSDTargetInfo<SparcV9TargetInfo>>(args: Triple,
519 args: Opts);
520 case llvm::Triple::FreeBSD:
521 return std::make_unique<FreeBSDTargetInfo<SparcV9TargetInfo>>(args: Triple,
522 args: Opts);
523 default:
524 return std::make_unique<SparcV9TargetInfo>(args: Triple, args: Opts);
525 }
526
527 case llvm::Triple::systemz:
528 switch (os) {
529 case llvm::Triple::Linux:
530 return std::make_unique<LinuxTargetInfo<SystemZTargetInfo>>(args: Triple, args: Opts);
531 case llvm::Triple::ZOS:
532 return std::make_unique<ZOSTargetInfo<SystemZTargetInfo>>(args: Triple, args: Opts);
533 default:
534 return std::make_unique<SystemZTargetInfo>(args: Triple, args: Opts);
535 }
536
537 case llvm::Triple::tce:
538 return std::make_unique<TCETargetInfo>(args: Triple, args: Opts);
539
540 case llvm::Triple::tcele:
541 return std::make_unique<TCELETargetInfo>(args: Triple, args: Opts);
542
543 case llvm::Triple::x86:
544 if (Triple.isOSDarwin())
545 return std::make_unique<DarwinI386TargetInfo>(args: Triple, args: Opts);
546 else if (Triple.isAppleMachO())
547 return std::make_unique<AppleMachOI386TargetInfo>(args: Triple, args: Opts);
548
549 switch (os) {
550 case llvm::Triple::Linux: {
551 switch (Triple.getEnvironment()) {
552 default:
553 return std::make_unique<LinuxTargetInfo<X86_32TargetInfo>>(args: Triple,
554 args: Opts);
555 case llvm::Triple::Android:
556 return std::make_unique<AndroidX86_32TargetInfo>(args: Triple, args: Opts);
557 }
558 }
559 case llvm::Triple::DragonFly:
560 return std::make_unique<DragonFlyBSDTargetInfo<X86_32TargetInfo>>(args: Triple,
561 args: Opts);
562 case llvm::Triple::NetBSD:
563 return std::make_unique<NetBSDI386TargetInfo>(args: Triple, args: Opts);
564 case llvm::Triple::OpenBSD:
565 return std::make_unique<OpenBSDI386TargetInfo>(args: Triple, args: Opts);
566 case llvm::Triple::FreeBSD:
567 return std::make_unique<FreeBSDTargetInfo<X86_32TargetInfo>>(args: Triple,
568 args: Opts);
569 case llvm::Triple::Fuchsia:
570 return std::make_unique<FuchsiaTargetInfo<X86_32TargetInfo>>(args: Triple,
571 args: Opts);
572 case llvm::Triple::KFreeBSD:
573 return std::make_unique<KFreeBSDTargetInfo<X86_32TargetInfo>>(args: Triple,
574 args: Opts);
575 case llvm::Triple::Solaris:
576 return std::make_unique<SolarisTargetInfo<X86_32TargetInfo>>(args: Triple,
577 args: Opts);
578 case llvm::Triple::Win32: {
579 switch (Triple.getEnvironment()) {
580 case llvm::Triple::Cygnus:
581 return std::make_unique<CygwinX86_32TargetInfo>(args: Triple, args: Opts);
582 case llvm::Triple::GNU:
583 return std::make_unique<MinGWX86_32TargetInfo>(args: Triple, args: Opts);
584 case llvm::Triple::Itanium:
585 case llvm::Triple::MSVC:
586 default: // Assume MSVC for unknown environments
587 return std::make_unique<MicrosoftX86_32TargetInfo>(args: Triple, args: Opts);
588 }
589 }
590 case llvm::Triple::Haiku:
591 return std::make_unique<HaikuX86_32TargetInfo>(args: Triple, args: Opts);
592 case llvm::Triple::RTEMS:
593 return std::make_unique<RTEMSX86_32TargetInfo>(args: Triple, args: Opts);
594 case llvm::Triple::NaCl:
595 return std::make_unique<NaClTargetInfo<X86_32TargetInfo>>(args: Triple, args: Opts);
596 case llvm::Triple::ELFIAMCU:
597 return std::make_unique<MCUX86_32TargetInfo>(args: Triple, args: Opts);
598 case llvm::Triple::Hurd:
599 return std::make_unique<HurdTargetInfo<X86_32TargetInfo>>(args: Triple, args: Opts);
600 default:
601 return std::make_unique<X86_32TargetInfo>(args: Triple, args: Opts);
602 }
603
604 case llvm::Triple::x86_64:
605 if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())
606 return std::make_unique<DarwinX86_64TargetInfo>(args: Triple, args: Opts);
607
608 switch (os) {
609 case llvm::Triple::Linux: {
610 switch (Triple.getEnvironment()) {
611 default:
612 return std::make_unique<LinuxTargetInfo<X86_64TargetInfo>>(args: Triple,
613 args: Opts);
614 case llvm::Triple::Android:
615 return std::make_unique<AndroidX86_64TargetInfo>(args: Triple, args: Opts);
616 case llvm::Triple::OpenHOS:
617 return std::make_unique<OHOSX86_64TargetInfo>(args: Triple, args: Opts);
618 }
619 }
620 case llvm::Triple::DragonFly:
621 return std::make_unique<DragonFlyBSDTargetInfo<X86_64TargetInfo>>(args: Triple,
622 args: Opts);
623 case llvm::Triple::NetBSD:
624 return std::make_unique<NetBSDTargetInfo<X86_64TargetInfo>>(args: Triple, args: Opts);
625 case llvm::Triple::OpenBSD:
626 return std::make_unique<OpenBSDX86_64TargetInfo>(args: Triple, args: Opts);
627 case llvm::Triple::FreeBSD:
628 return std::make_unique<FreeBSDTargetInfo<X86_64TargetInfo>>(args: Triple,
629 args: Opts);
630 case llvm::Triple::Fuchsia:
631 return std::make_unique<FuchsiaTargetInfo<X86_64TargetInfo>>(args: Triple,
632 args: Opts);
633 case llvm::Triple::KFreeBSD:
634 return std::make_unique<KFreeBSDTargetInfo<X86_64TargetInfo>>(args: Triple,
635 args: Opts);
636 case llvm::Triple::Solaris:
637 return std::make_unique<SolarisTargetInfo<X86_64TargetInfo>>(args: Triple,
638 args: Opts);
639 case llvm::Triple::UEFI:
640 return std::make_unique<UEFIX86_64TargetInfo>(args: Triple, args: Opts);
641
642 case llvm::Triple::Win32: {
643 switch (Triple.getEnvironment()) {
644 case llvm::Triple::Cygnus:
645 return std::make_unique<CygwinX86_64TargetInfo>(args: Triple, args: Opts);
646 case llvm::Triple::GNU:
647 return std::make_unique<MinGWX86_64TargetInfo>(args: Triple, args: Opts);
648 case llvm::Triple::MSVC:
649 default: // Assume MSVC for unknown environments
650 return std::make_unique<MicrosoftX86_64TargetInfo>(args: Triple, args: Opts);
651 }
652 }
653 case llvm::Triple::Haiku:
654 return std::make_unique<HaikuTargetInfo<X86_64TargetInfo>>(args: Triple, args: Opts);
655 case llvm::Triple::NaCl:
656 return std::make_unique<NaClTargetInfo<X86_64TargetInfo>>(args: Triple, args: Opts);
657 case llvm::Triple::PS4:
658 return std::make_unique<PS4OSTargetInfo<X86_64TargetInfo>>(args: Triple, args: Opts);
659 case llvm::Triple::PS5:
660 return std::make_unique<PS5OSTargetInfo<X86_64TargetInfo>>(args: Triple, args: Opts);
661 case llvm::Triple::Hurd:
662 return std::make_unique<HurdTargetInfo<X86_64TargetInfo>>(args: Triple, args: Opts);
663 case llvm::Triple::Managarm:
664 return std::make_unique<ManagarmTargetInfo<X86_64TargetInfo>>(args: Triple,
665 args: Opts);
666 default:
667 return std::make_unique<X86_64TargetInfo>(args: Triple, args: Opts);
668 }
669
670 case llvm::Triple::spir: {
671 if (os != llvm::Triple::UnknownOS ||
672 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
673 return nullptr;
674 return std::make_unique<SPIR32TargetInfo>(args: Triple, args: Opts);
675 }
676 case llvm::Triple::spir64: {
677 if (os != llvm::Triple::UnknownOS ||
678 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
679 return nullptr;
680 return std::make_unique<SPIR64TargetInfo>(args: Triple, args: Opts);
681 }
682 case llvm::Triple::spirv: {
683 return std::make_unique<SPIRVTargetInfo>(args: Triple, args: Opts);
684 }
685 case llvm::Triple::spirv32: {
686 if (os != llvm::Triple::UnknownOS ||
687 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
688 return nullptr;
689 return std::make_unique<SPIRV32TargetInfo>(args: Triple, args: Opts);
690 }
691 case llvm::Triple::spirv64: {
692 if (os != llvm::Triple::UnknownOS ||
693 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) {
694 if (os == llvm::Triple::OSType::AMDHSA)
695 return std::make_unique<SPIRV64AMDGCNTargetInfo>(args: Triple, args: Opts);
696 return nullptr;
697 }
698 return std::make_unique<SPIRV64TargetInfo>(args: Triple, args: Opts);
699 }
700 case llvm::Triple::wasm32:
701 if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
702 Triple.getVendor() != llvm::Triple::UnknownVendor ||
703 !Triple.isOSBinFormatWasm())
704 return nullptr;
705 switch (os) {
706 case llvm::Triple::WASI:
707 return std::make_unique<WASITargetInfo<WebAssembly32TargetInfo>>(args: Triple,
708 args: Opts);
709 case llvm::Triple::Emscripten:
710 return std::make_unique<EmscriptenTargetInfo<WebAssembly32TargetInfo>>(
711 args: Triple, args: Opts);
712 case llvm::Triple::UnknownOS:
713 return std::make_unique<WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>>(
714 args: Triple, args: Opts);
715 default:
716 return nullptr;
717 }
718 case llvm::Triple::wasm64:
719 if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
720 Triple.getVendor() != llvm::Triple::UnknownVendor ||
721 !Triple.isOSBinFormatWasm())
722 return nullptr;
723 switch (os) {
724 case llvm::Triple::WASI:
725 return std::make_unique<WASITargetInfo<WebAssembly64TargetInfo>>(args: Triple,
726 args: Opts);
727 case llvm::Triple::Emscripten:
728 return std::make_unique<EmscriptenTargetInfo<WebAssembly64TargetInfo>>(
729 args: Triple, args: Opts);
730 case llvm::Triple::UnknownOS:
731 return std::make_unique<WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>>(
732 args: Triple, args: Opts);
733 default:
734 return nullptr;
735 }
736
737 case llvm::Triple::dxil:
738 return std::make_unique<DirectXTargetInfo>(args: Triple, args: Opts);
739
740 case llvm::Triple::ve:
741 return std::make_unique<LinuxTargetInfo<VETargetInfo>>(args: Triple, args: Opts);
742
743 case llvm::Triple::csky:
744 switch (os) {
745 case llvm::Triple::Linux:
746 return std::make_unique<LinuxTargetInfo<CSKYTargetInfo>>(args: Triple, args: Opts);
747 default:
748 return std::make_unique<CSKYTargetInfo>(args: Triple, args: Opts);
749 }
750 case llvm::Triple::loongarch32:
751 switch (os) {
752 case llvm::Triple::Linux:
753 return std::make_unique<LinuxTargetInfo<LoongArch32TargetInfo>>(args: Triple,
754 args: Opts);
755 default:
756 return std::make_unique<LoongArch32TargetInfo>(args: Triple, args: Opts);
757 }
758 case llvm::Triple::loongarch64:
759 switch (os) {
760 case llvm::Triple::Linux:
761 switch (Triple.getEnvironment()) {
762 default:
763 return std::make_unique<LinuxTargetInfo<LoongArch64TargetInfo>>(args: Triple,
764 args: Opts);
765 case llvm::Triple::OpenHOS:
766 return std::make_unique<OHOSTargetInfo<LoongArch64TargetInfo>>(args: Triple,
767 args: Opts);
768 }
769 case llvm::Triple::FreeBSD:
770 return std::make_unique<FreeBSDTargetInfo<LoongArch64TargetInfo>>(args: Triple,
771 args: Opts);
772 default:
773 return std::make_unique<LoongArch64TargetInfo>(args: Triple, args: Opts);
774 }
775
776 case llvm::Triple::xtensa:
777 return std::make_unique<XtensaTargetInfo>(args: Triple, args: Opts);
778 }
779}
780} // namespace targets
781} // namespace clang
782
783using namespace clang::targets;
784/// CreateTargetInfo - Return the target info object for the specified target
785/// options.
786TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
787 TargetOptions &OptsRef) {
788 TargetOptions *Opts = &OptsRef;
789
790 llvm::Triple Triple(llvm::Triple::normalize(Str: Opts->Triple));
791
792 // Construct the target
793 std::unique_ptr<TargetInfo> Target = AllocateTarget(Triple, Opts: *Opts);
794 if (!Target) {
795 Diags.Report(DiagID: diag::err_target_unknown_triple) << Triple.str();
796 return nullptr;
797 }
798 Target->TargetOpts = Opts;
799
800 // Set the target CPU if specified.
801 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
802 Diags.Report(DiagID: diag::err_target_unknown_cpu) << Opts->CPU;
803 SmallVector<StringRef, 32> ValidList;
804 Target->fillValidCPUList(Values&: ValidList);
805 if (!ValidList.empty())
806 Diags.Report(DiagID: diag::note_valid_options) << llvm::join(R&: ValidList, Separator: ", ");
807 return nullptr;
808 }
809
810 // Check the TuneCPU name if specified.
811 if (!Opts->TuneCPU.empty() &&
812 !Target->isValidTuneCPUName(Name: Opts->TuneCPU)) {
813 Diags.Report(DiagID: diag::err_target_unknown_cpu) << Opts->TuneCPU;
814 SmallVector<StringRef, 32> ValidList;
815 Target->fillValidTuneCPUList(Values&: ValidList);
816 if (!ValidList.empty())
817 Diags.Report(DiagID: diag::note_valid_options) << llvm::join(R&: ValidList, Separator: ", ");
818 return nullptr;
819 }
820
821 // Set the target ABI if specified.
822 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
823 Diags.Report(DiagID: diag::err_target_unknown_abi) << Opts->ABI;
824 return nullptr;
825 }
826
827 // Set the fp math unit.
828 if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
829 Diags.Report(DiagID: diag::err_target_unknown_fpmath) << Opts->FPMath;
830 return nullptr;
831 }
832
833 // Compute the default target features, we need the target to handle this
834 // because features may have dependencies on one another.
835 llvm::erase_if(C&: Opts->FeaturesAsWritten, P: [&](StringRef Name) {
836 if (Target->isReadOnlyFeature(Feature: Name.substr(Start: 1))) {
837 Diags.Report(DiagID: diag::warn_fe_backend_readonly_feature_flag) << Name;
838 return true;
839 }
840 return false;
841 });
842 if (!Target->initFeatureMap(Features&: Opts->FeatureMap, Diags, CPU: Opts->CPU,
843 FeatureVec: Opts->FeaturesAsWritten))
844 return nullptr;
845
846 // Add the features to the compile options.
847 Opts->Features.clear();
848 for (const auto &F : Opts->FeatureMap)
849 Opts->Features.push_back(x: (F.getValue() ? "+" : "-") + F.getKey().str());
850 // Sort here, so we handle the features in a predictable order. (This matters
851 // when we're dealing with features that overlap.)
852 llvm::sort(C&: Opts->Features);
853
854 if (!Target->handleTargetFeatures(Features&: Opts->Features, Diags))
855 return nullptr;
856
857 Target->setSupportedOpenCLOpts();
858 Target->setCommandLineOpenCLOpts();
859 Target->setMaxAtomicWidth();
860
861 if (!Opts->DarwinTargetVariantTriple.empty())
862 Target->DarwinTargetVariantTriple =
863 llvm::Triple(Opts->DarwinTargetVariantTriple);
864
865 if (!Target->validateTarget(Diags))
866 return nullptr;
867
868 Target->CheckFixedPointBits();
869
870 return Target.release();
871}
872/// validateOpenCLTarget - Check that OpenCL target has valid
873/// options setting based on OpenCL version.
874bool TargetInfo::validateOpenCLTarget(const LangOptions &Opts,
875 DiagnosticsEngine &Diags) const {
876 const llvm::StringMap<bool> &OpenCLFeaturesMap = getSupportedOpenCLOpts();
877
878 auto diagnoseNotSupportedCore = [&](llvm::StringRef Name, auto... OptArgs) {
879 if (OpenCLOptions::isOpenCLOptionCoreIn(Opts, OptArgs...) &&
880 !hasFeatureEnabled(Features: OpenCLFeaturesMap, Name))
881 Diags.Report(DiagID: diag::warn_opencl_unsupported_core_feature)
882 << Name << Opts.OpenCLCPlusPlus
883 << Opts.getOpenCLVersionTuple().getAsString();
884 };
885#define OPENCL_GENERIC_EXTENSION(Ext, ...) \
886 diagnoseNotSupportedCore(#Ext, __VA_ARGS__);
887#include "clang/Basic/OpenCLExtensions.def"
888
889 // Validate that feature macros are set properly for OpenCL C 3.0.
890 // In other cases assume that target is always valid.
891 if (Opts.getOpenCLCompatibleVersion() < 300)
892 return true;
893
894 return OpenCLOptions::diagnoseUnsupportedFeatureDependencies(TI: *this, Diags) &&
895 OpenCLOptions::diagnoseFeatureExtensionDifferences(TI: *this, Diags);
896}
897