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