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