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