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