/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Basic/Targets.cpp
Line | Count | Source (jump to first uncovered line) |
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/Le64.h" |
27 | | #include "Targets/M68k.h" |
28 | | #include "Targets/MSP430.h" |
29 | | #include "Targets/Mips.h" |
30 | | #include "Targets/NVPTX.h" |
31 | | #include "Targets/OSTargets.h" |
32 | | #include "Targets/PNaCl.h" |
33 | | #include "Targets/PPC.h" |
34 | | #include "Targets/RISCV.h" |
35 | | #include "Targets/SPIR.h" |
36 | | #include "Targets/Sparc.h" |
37 | | #include "Targets/SystemZ.h" |
38 | | #include "Targets/TCE.h" |
39 | | #include "Targets/VE.h" |
40 | | #include "Targets/WebAssembly.h" |
41 | | #include "Targets/X86.h" |
42 | | #include "Targets/XCore.h" |
43 | | #include "clang/Basic/Diagnostic.h" |
44 | | #include "llvm/ADT/StringExtras.h" |
45 | | #include "llvm/ADT/Triple.h" |
46 | | |
47 | | using namespace clang; |
48 | | |
49 | | namespace clang { |
50 | | namespace targets { |
51 | | //===----------------------------------------------------------------------===// |
52 | | // Common code shared among targets. |
53 | | //===----------------------------------------------------------------------===// |
54 | | |
55 | | /// DefineStd - Define a macro name and standard variants. For example if |
56 | | /// MacroName is "unix", then this will define "__unix", "__unix__", and "unix" |
57 | | /// when in GNU mode. |
58 | | void DefineStd(MacroBuilder &Builder, StringRef MacroName, |
59 | 30.8k | const LangOptions &Opts) { |
60 | 30.8k | assert(MacroName[0] != '_' && "Identifier should be in the user's namespace"); |
61 | | |
62 | | // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier |
63 | | // in the user's namespace. |
64 | 30.8k | if (Opts.GNUMode) |
65 | 15.6k | Builder.defineMacro(MacroName); |
66 | | |
67 | | // Define __unix. |
68 | 30.8k | Builder.defineMacro("__" + MacroName); |
69 | | |
70 | | // Define __unix__. |
71 | 30.8k | Builder.defineMacro("__" + MacroName + "__"); |
72 | 30.8k | } |
73 | | |
74 | 36.4k | void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName, bool Tuning) { |
75 | 36.4k | Builder.defineMacro("__" + CPUName); |
76 | 36.4k | Builder.defineMacro("__" + CPUName + "__"); |
77 | 36.4k | if (Tuning) |
78 | 36.2k | Builder.defineMacro("__tune_" + CPUName + "__"); |
79 | 36.4k | } |
80 | | |
81 | 186 | void addCygMingDefines(const LangOptions &Opts, MacroBuilder &Builder) { |
82 | | // Mingw and cygwin define __declspec(a) to __attribute__((a)). Clang |
83 | | // supports __declspec natively under -fms-extensions, but we define a no-op |
84 | | // __declspec macro anyway for pre-processor compatibility. |
85 | 186 | if (Opts.MicrosoftExt) |
86 | 41 | Builder.defineMacro("__declspec", "__declspec"); |
87 | 145 | else |
88 | 145 | Builder.defineMacro("__declspec(a)", "__attribute__((a))"); |
89 | | |
90 | 186 | if (!Opts.MicrosoftExt) { |
91 | | // Provide macros for all the calling convention keywords. Provide both |
92 | | // single and double underscore prefixed variants. These are available on |
93 | | // x64 as well as x86, even though they have no effect. |
94 | 145 | const char *CCs[] = {"cdecl", "stdcall", "fastcall", "thiscall", "pascal"}; |
95 | 725 | for (const char *CC : CCs) { |
96 | 725 | std::string GCCSpelling = "__attribute__((__"; |
97 | 725 | GCCSpelling += CC; |
98 | 725 | GCCSpelling += "__))"; |
99 | 725 | Builder.defineMacro(Twine("_") + CC, GCCSpelling); |
100 | 725 | Builder.defineMacro(Twine("__") + CC, GCCSpelling); |
101 | 725 | } |
102 | 145 | } |
103 | 186 | } |
104 | | |
105 | | //===----------------------------------------------------------------------===// |
106 | | // Driver code |
107 | | //===----------------------------------------------------------------------===// |
108 | | |
109 | | TargetInfo *AllocateTarget(const llvm::Triple &Triple, |
110 | 97.7k | const TargetOptions &Opts) { |
111 | 97.7k | llvm::Triple::OSType os = Triple.getOS(); |
112 | | |
113 | 97.7k | switch (Triple.getArch()) { |
114 | 239 | default: |
115 | 239 | return nullptr; |
116 | | |
117 | 4 | case llvm::Triple::arc: |
118 | 4 | return new ARCTargetInfo(Triple, Opts); |
119 | | |
120 | 18 | case llvm::Triple::xcore: |
121 | 18 | return new XCoreTargetInfo(Triple, Opts); |
122 | | |
123 | 33 | case llvm::Triple::hexagon: |
124 | 33 | if (os == llvm::Triple::Linux && |
125 | 33 | Triple.getEnvironment() == llvm::Triple::Musl4 ) |
126 | 2 | return new LinuxTargetInfo<HexagonTargetInfo>(Triple, Opts); |
127 | 31 | return new HexagonTargetInfo(Triple, Opts); |
128 | | |
129 | 8 | case llvm::Triple::lanai: |
130 | 8 | return new LanaiTargetInfo(Triple, Opts); |
131 | | |
132 | 16 | case llvm::Triple::aarch64_32: |
133 | 16 | if (Triple.isOSDarwin()) |
134 | 16 | return new DarwinAArch64TargetInfo(Triple, Opts); |
135 | | |
136 | 0 | return nullptr; |
137 | 2.90k | case llvm::Triple::aarch64: |
138 | 2.90k | if (Triple.isOSDarwin()) |
139 | 184 | return new DarwinAArch64TargetInfo(Triple, Opts); |
140 | | |
141 | 2.72k | switch (os) { |
142 | 2 | case llvm::Triple::CloudABI: |
143 | 2 | return new CloudABITargetInfo<AArch64leTargetInfo>(Triple, Opts); |
144 | 2 | case llvm::Triple::FreeBSD: |
145 | 2 | return new FreeBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts); |
146 | 26 | case llvm::Triple::Fuchsia: |
147 | 26 | return new FuchsiaTargetInfo<AArch64leTargetInfo>(Triple, Opts); |
148 | 2.35k | case llvm::Triple::Linux: |
149 | 2.35k | return new LinuxTargetInfo<AArch64leTargetInfo>(Triple, Opts); |
150 | 8 | case llvm::Triple::NetBSD: |
151 | 8 | return new NetBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts); |
152 | 4 | case llvm::Triple::OpenBSD: |
153 | 4 | return new OpenBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts); |
154 | 59 | case llvm::Triple::Win32: |
155 | 59 | switch (Triple.getEnvironment()) { |
156 | 3 | case llvm::Triple::GNU: |
157 | 3 | return new MinGWARM64TargetInfo(Triple, Opts); |
158 | 55 | case llvm::Triple::MSVC: |
159 | 56 | default: // Assume MSVC for unknown environments |
160 | 56 | return new MicrosoftARM64TargetInfo(Triple, Opts); |
161 | 59 | } |
162 | 272 | default: |
163 | 272 | return new AArch64leTargetInfo(Triple, Opts); |
164 | 2.72k | } |
165 | | |
166 | 33 | case llvm::Triple::aarch64_be: |
167 | 33 | switch (os) { |
168 | 0 | case llvm::Triple::FreeBSD: |
169 | 0 | return new FreeBSDTargetInfo<AArch64beTargetInfo>(Triple, Opts); |
170 | 0 | case llvm::Triple::Fuchsia: |
171 | 0 | return new FuchsiaTargetInfo<AArch64beTargetInfo>(Triple, Opts); |
172 | 10 | case llvm::Triple::Linux: |
173 | 10 | return new LinuxTargetInfo<AArch64beTargetInfo>(Triple, Opts); |
174 | 0 | case llvm::Triple::NetBSD: |
175 | 0 | return new NetBSDTargetInfo<AArch64beTargetInfo>(Triple, Opts); |
176 | 23 | default: |
177 | 23 | return new AArch64beTargetInfo(Triple, Opts); |
178 | 33 | } |
179 | | |
180 | 671 | case llvm::Triple::arm: |
181 | 1.28k | case llvm::Triple::thumb: |
182 | 1.28k | if (Triple.isOSBinFormatMachO()) |
183 | 214 | return new DarwinARMTargetInfo(Triple, Opts); |
184 | | |
185 | 1.07k | switch (os) { |
186 | 3 | case llvm::Triple::CloudABI: |
187 | 3 | return new CloudABITargetInfo<ARMleTargetInfo>(Triple, Opts); |
188 | 277 | case llvm::Triple::Linux: |
189 | 277 | return new LinuxTargetInfo<ARMleTargetInfo>(Triple, Opts); |
190 | 6 | case llvm::Triple::FreeBSD: |
191 | 6 | return new FreeBSDTargetInfo<ARMleTargetInfo>(Triple, Opts); |
192 | 7 | case llvm::Triple::NetBSD: |
193 | 7 | return new NetBSDTargetInfo<ARMleTargetInfo>(Triple, Opts); |
194 | 6 | case llvm::Triple::OpenBSD: |
195 | 6 | return new OpenBSDTargetInfo<ARMleTargetInfo>(Triple, Opts); |
196 | 2 | case llvm::Triple::RTEMS: |
197 | 2 | return new RTEMSTargetInfo<ARMleTargetInfo>(Triple, Opts); |
198 | 2 | case llvm::Triple::NaCl: |
199 | 2 | return new NaClTargetInfo<ARMleTargetInfo>(Triple, Opts); |
200 | 119 | case llvm::Triple::Win32: |
201 | 119 | switch (Triple.getEnvironment()) { |
202 | 1 | case llvm::Triple::Cygnus: |
203 | 1 | return new CygwinARMTargetInfo(Triple, Opts); |
204 | 4 | case llvm::Triple::GNU: |
205 | 4 | return new MinGWARMTargetInfo(Triple, Opts); |
206 | 10 | case llvm::Triple::Itanium: |
207 | 10 | return new ItaniumWindowsARMleTargetInfo(Triple, Opts); |
208 | 102 | case llvm::Triple::MSVC: |
209 | 104 | default: // Assume MSVC for unknown environments |
210 | 104 | return new MicrosoftARMleTargetInfo(Triple, Opts); |
211 | 119 | } |
212 | 651 | default: |
213 | 651 | return new ARMleTargetInfo(Triple, Opts); |
214 | 1.07k | } |
215 | | |
216 | 19 | case llvm::Triple::armeb: |
217 | 40 | case llvm::Triple::thumbeb: |
218 | 40 | if (Triple.isOSDarwin()) |
219 | 0 | return new DarwinARMTargetInfo(Triple, Opts); |
220 | | |
221 | 40 | switch (os) { |
222 | 12 | case llvm::Triple::Linux: |
223 | 12 | return new LinuxTargetInfo<ARMbeTargetInfo>(Triple, Opts); |
224 | 0 | case llvm::Triple::FreeBSD: |
225 | 0 | return new FreeBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts); |
226 | 0 | case llvm::Triple::NetBSD: |
227 | 0 | return new NetBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts); |
228 | 0 | case llvm::Triple::OpenBSD: |
229 | 0 | return new OpenBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts); |
230 | 0 | case llvm::Triple::RTEMS: |
231 | 0 | return new RTEMSTargetInfo<ARMbeTargetInfo>(Triple, Opts); |
232 | 0 | case llvm::Triple::NaCl: |
233 | 0 | return new NaClTargetInfo<ARMbeTargetInfo>(Triple, Opts); |
234 | 28 | default: |
235 | 28 | return new ARMbeTargetInfo(Triple, Opts); |
236 | 40 | } |
237 | | |
238 | 29 | case llvm::Triple::avr: |
239 | 29 | return new AVRTargetInfo(Triple, Opts); |
240 | 4 | case llvm::Triple::bpfeb: |
241 | 18 | case llvm::Triple::bpfel: |
242 | 18 | return new BPFTargetInfo(Triple, Opts); |
243 | | |
244 | 12 | case llvm::Triple::msp430: |
245 | 12 | return new MSP430TargetInfo(Triple, Opts); |
246 | | |
247 | 79 | case llvm::Triple::mips: |
248 | 79 | switch (os) { |
249 | 28 | case llvm::Triple::Linux: |
250 | 28 | return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts); |
251 | 0 | case llvm::Triple::RTEMS: |
252 | 0 | return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts); |
253 | 2 | case llvm::Triple::FreeBSD: |
254 | 2 | return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts); |
255 | 2 | case llvm::Triple::NetBSD: |
256 | 2 | return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts); |
257 | 47 | default: |
258 | 47 | return new MipsTargetInfo(Triple, Opts); |
259 | 79 | } |
260 | | |
261 | 40 | case llvm::Triple::mipsel: |
262 | 40 | switch (os) { |
263 | 34 | case llvm::Triple::Linux: |
264 | 34 | return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts); |
265 | 0 | case llvm::Triple::RTEMS: |
266 | 0 | return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts); |
267 | 0 | case llvm::Triple::FreeBSD: |
268 | 0 | return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts); |
269 | 0 | case llvm::Triple::NetBSD: |
270 | 0 | return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts); |
271 | 3 | case llvm::Triple::NaCl: |
272 | 3 | return new NaClTargetInfo<NaClMips32TargetInfo>(Triple, Opts); |
273 | 3 | default: |
274 | 3 | return new MipsTargetInfo(Triple, Opts); |
275 | 40 | } |
276 | | |
277 | 83 | case llvm::Triple::mips64: |
278 | 83 | switch (os) { |
279 | 53 | case llvm::Triple::Linux: |
280 | 53 | return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts); |
281 | 0 | case llvm::Triple::RTEMS: |
282 | 0 | return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts); |
283 | 2 | case llvm::Triple::FreeBSD: |
284 | 2 | return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts); |
285 | 1 | case llvm::Triple::NetBSD: |
286 | 1 | return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts); |
287 | 2 | case llvm::Triple::OpenBSD: |
288 | 2 | return new OpenBSDTargetInfo<MipsTargetInfo>(Triple, Opts); |
289 | 25 | default: |
290 | 25 | return new MipsTargetInfo(Triple, Opts); |
291 | 83 | } |
292 | | |
293 | 45 | case llvm::Triple::mips64el: |
294 | 45 | switch (os) { |
295 | 42 | case llvm::Triple::Linux: |
296 | 42 | return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts); |
297 | 0 | case llvm::Triple::RTEMS: |
298 | 0 | return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts); |
299 | 0 | case llvm::Triple::FreeBSD: |
300 | 0 | return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts); |
301 | 0 | case llvm::Triple::NetBSD: |
302 | 0 | return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts); |
303 | 1 | case llvm::Triple::OpenBSD: |
304 | 1 | return new OpenBSDTargetInfo<MipsTargetInfo>(Triple, Opts); |
305 | 2 | default: |
306 | 2 | return new MipsTargetInfo(Triple, Opts); |
307 | 45 | } |
308 | | |
309 | 6 | case llvm::Triple::m68k: |
310 | 6 | switch (os) { |
311 | 6 | case llvm::Triple::Linux: |
312 | 6 | return new LinuxTargetInfo<M68kTargetInfo>(Triple, Opts); |
313 | 0 | case llvm::Triple::NetBSD: |
314 | 0 | return new NetBSDTargetInfo<M68kTargetInfo>(Triple, Opts); |
315 | 0 | default: |
316 | 0 | return new M68kTargetInfo(Triple, Opts); |
317 | 6 | } |
318 | | |
319 | 0 | case llvm::Triple::le32: |
320 | 0 | switch (os) { |
321 | 0 | case llvm::Triple::NaCl: |
322 | 0 | return new NaClTargetInfo<PNaClTargetInfo>(Triple, Opts); |
323 | 0 | default: |
324 | 0 | return nullptr; |
325 | 0 | } |
326 | | |
327 | 0 | case llvm::Triple::le64: |
328 | 0 | return new Le64TargetInfo(Triple, Opts); |
329 | | |
330 | 231 | case llvm::Triple::ppc: |
331 | 231 | if (Triple.isOSDarwin()) |
332 | 6 | return new DarwinPPC32TargetInfo(Triple, Opts); |
333 | 225 | switch (os) { |
334 | 26 | case llvm::Triple::Linux: |
335 | 26 | return new LinuxTargetInfo<PPC32TargetInfo>(Triple, Opts); |
336 | 2 | case llvm::Triple::FreeBSD: |
337 | 2 | return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple, Opts); |
338 | 2 | case llvm::Triple::NetBSD: |
339 | 2 | return new NetBSDTargetInfo<PPC32TargetInfo>(Triple, Opts); |
340 | 4 | case llvm::Triple::OpenBSD: |
341 | 4 | return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple, Opts); |
342 | 0 | case llvm::Triple::RTEMS: |
343 | 0 | return new RTEMSTargetInfo<PPC32TargetInfo>(Triple, Opts); |
344 | 134 | case llvm::Triple::AIX: |
345 | 134 | return new AIXPPC32TargetInfo(Triple, Opts); |
346 | 57 | default: |
347 | 57 | return new PPC32TargetInfo(Triple, Opts); |
348 | 225 | } |
349 | | |
350 | 2 | case llvm::Triple::ppcle: |
351 | 2 | switch (os) { |
352 | 0 | case llvm::Triple::Linux: |
353 | 0 | return new LinuxTargetInfo<PPC32TargetInfo>(Triple, Opts); |
354 | 0 | case llvm::Triple::FreeBSD: |
355 | 0 | return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple, Opts); |
356 | 2 | default: |
357 | 2 | return new PPC32TargetInfo(Triple, Opts); |
358 | 2 | } |
359 | | |
360 | 261 | case llvm::Triple::ppc64: |
361 | 261 | if (Triple.isOSDarwin()) |
362 | 1 | return new DarwinPPC64TargetInfo(Triple, Opts); |
363 | 260 | switch (os) { |
364 | 78 | case llvm::Triple::Linux: |
365 | 78 | return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts); |
366 | 1 | case llvm::Triple::Lv2: |
367 | 1 | return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple, Opts); |
368 | 5 | case llvm::Triple::FreeBSD: |
369 | 5 | return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple, Opts); |
370 | 4 | case llvm::Triple::NetBSD: |
371 | 4 | return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts); |
372 | 2 | case llvm::Triple::OpenBSD: |
373 | 2 | return new OpenBSDTargetInfo<PPC64TargetInfo>(Triple, Opts); |
374 | 100 | case llvm::Triple::AIX: |
375 | 100 | return new AIXPPC64TargetInfo(Triple, Opts); |
376 | 70 | default: |
377 | 70 | return new PPC64TargetInfo(Triple, Opts); |
378 | 260 | } |
379 | | |
380 | 3.66k | case llvm::Triple::ppc64le: |
381 | 3.66k | switch (os) { |
382 | 216 | case llvm::Triple::Linux: |
383 | 216 | return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts); |
384 | 3 | case llvm::Triple::FreeBSD: |
385 | 3 | return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple, Opts); |
386 | 1 | case llvm::Triple::NetBSD: |
387 | 1 | return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts); |
388 | 1 | case llvm::Triple::OpenBSD: |
389 | 1 | return new OpenBSDTargetInfo<PPC64TargetInfo>(Triple, Opts); |
390 | 3.44k | default: |
391 | 3.44k | return new PPC64TargetInfo(Triple, Opts); |
392 | 3.66k | } |
393 | | |
394 | 139 | case llvm::Triple::nvptx: |
395 | 139 | return new NVPTXTargetInfo(Triple, Opts, /*TargetPointerWidth=*/32); |
396 | 173 | case llvm::Triple::nvptx64: |
397 | 173 | return new NVPTXTargetInfo(Triple, Opts, /*TargetPointerWidth=*/64); |
398 | | |
399 | 185 | case llvm::Triple::amdgcn: |
400 | 213 | case llvm::Triple::r600: |
401 | 213 | return new AMDGPUTargetInfo(Triple, Opts); |
402 | | |
403 | 104 | case llvm::Triple::riscv32: |
404 | | // TODO: add cases for NetBSD, RTEMS once tested. |
405 | 104 | switch (os) { |
406 | 0 | case llvm::Triple::FreeBSD: |
407 | 0 | return new FreeBSDTargetInfo<RISCV32TargetInfo>(Triple, Opts); |
408 | 42 | case llvm::Triple::Linux: |
409 | 42 | return new LinuxTargetInfo<RISCV32TargetInfo>(Triple, Opts); |
410 | 62 | default: |
411 | 62 | return new RISCV32TargetInfo(Triple, Opts); |
412 | 104 | } |
413 | | |
414 | 145 | case llvm::Triple::riscv64: |
415 | | // TODO: add cases for NetBSD, RTEMS once tested. |
416 | 145 | switch (os) { |
417 | 2 | case llvm::Triple::FreeBSD: |
418 | 2 | return new FreeBSDTargetInfo<RISCV64TargetInfo>(Triple, Opts); |
419 | 2 | case llvm::Triple::OpenBSD: |
420 | 2 | return new OpenBSDTargetInfo<RISCV64TargetInfo>(Triple, Opts); |
421 | 0 | case llvm::Triple::Fuchsia: |
422 | 0 | return new FuchsiaTargetInfo<RISCV64TargetInfo>(Triple, Opts); |
423 | 75 | case llvm::Triple::Linux: |
424 | 75 | return new LinuxTargetInfo<RISCV64TargetInfo>(Triple, Opts); |
425 | 66 | default: |
426 | 66 | return new RISCV64TargetInfo(Triple, Opts); |
427 | 145 | } |
428 | | |
429 | 31 | case llvm::Triple::sparc: |
430 | 31 | switch (os) { |
431 | 0 | case llvm::Triple::Linux: |
432 | 0 | return new LinuxTargetInfo<SparcV8TargetInfo>(Triple, Opts); |
433 | 2 | case llvm::Triple::Solaris: |
434 | 2 | return new SolarisTargetInfo<SparcV8TargetInfo>(Triple, Opts); |
435 | 2 | case llvm::Triple::NetBSD: |
436 | 2 | return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple, Opts); |
437 | 2 | case llvm::Triple::RTEMS: |
438 | 2 | return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple, Opts); |
439 | 25 | default: |
440 | 25 | return new SparcV8TargetInfo(Triple, Opts); |
441 | 31 | } |
442 | | |
443 | | // The 'sparcel' architecture copies all the above cases except for Solaris. |
444 | 0 | case llvm::Triple::sparcel: |
445 | 0 | switch (os) { |
446 | 0 | case llvm::Triple::Linux: |
447 | 0 | return new LinuxTargetInfo<SparcV8elTargetInfo>(Triple, Opts); |
448 | 0 | case llvm::Triple::NetBSD: |
449 | 0 | return new NetBSDTargetInfo<SparcV8elTargetInfo>(Triple, Opts); |
450 | 0 | case llvm::Triple::RTEMS: |
451 | 0 | return new RTEMSTargetInfo<SparcV8elTargetInfo>(Triple, Opts); |
452 | 0 | default: |
453 | 0 | return new SparcV8elTargetInfo(Triple, Opts); |
454 | 0 | } |
455 | | |
456 | 35 | case llvm::Triple::sparcv9: |
457 | 35 | switch (os) { |
458 | 5 | case llvm::Triple::Linux: |
459 | 5 | return new LinuxTargetInfo<SparcV9TargetInfo>(Triple, Opts); |
460 | 1 | case llvm::Triple::Solaris: |
461 | 1 | return new SolarisTargetInfo<SparcV9TargetInfo>(Triple, Opts); |
462 | 9 | case llvm::Triple::NetBSD: |
463 | 9 | return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts); |
464 | 11 | case llvm::Triple::OpenBSD: |
465 | 11 | return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts); |
466 | 0 | case llvm::Triple::FreeBSD: |
467 | 0 | return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts); |
468 | 9 | default: |
469 | 9 | return new SparcV9TargetInfo(Triple, Opts); |
470 | 35 | } |
471 | | |
472 | 92 | case llvm::Triple::systemz: |
473 | 92 | switch (os) { |
474 | 51 | case llvm::Triple::Linux: |
475 | 51 | return new LinuxTargetInfo<SystemZTargetInfo>(Triple, Opts); |
476 | 28 | case llvm::Triple::ZOS: |
477 | 28 | return new ZOSTargetInfo<SystemZTargetInfo>(Triple, Opts); |
478 | 13 | default: |
479 | 13 | return new SystemZTargetInfo(Triple, Opts); |
480 | 92 | } |
481 | | |
482 | 6 | case llvm::Triple::tce: |
483 | 6 | return new TCETargetInfo(Triple, Opts); |
484 | | |
485 | 1 | case llvm::Triple::tcele: |
486 | 1 | return new TCELETargetInfo(Triple, Opts); |
487 | | |
488 | 14.7k | case llvm::Triple::x86: |
489 | 14.7k | if (Triple.isOSDarwin()) |
490 | 421 | return new DarwinI386TargetInfo(Triple, Opts); |
491 | | |
492 | 14.3k | switch (os) { |
493 | 0 | case llvm::Triple::Ananas: |
494 | 0 | return new AnanasTargetInfo<X86_32TargetInfo>(Triple, Opts); |
495 | 0 | case llvm::Triple::CloudABI: |
496 | 0 | return new CloudABITargetInfo<X86_32TargetInfo>(Triple, Opts); |
497 | 451 | case llvm::Triple::Linux: { |
498 | 451 | switch (Triple.getEnvironment()) { |
499 | 447 | default: |
500 | 447 | return new LinuxTargetInfo<X86_32TargetInfo>(Triple, Opts); |
501 | 4 | case llvm::Triple::Android: |
502 | 4 | return new AndroidX86_32TargetInfo(Triple, Opts); |
503 | 451 | } |
504 | 451 | } |
505 | 1 | case llvm::Triple::DragonFly: |
506 | 1 | return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple, Opts); |
507 | 7 | case llvm::Triple::NetBSD: |
508 | 7 | return new NetBSDI386TargetInfo(Triple, Opts); |
509 | 5 | case llvm::Triple::OpenBSD: |
510 | 5 | return new OpenBSDI386TargetInfo(Triple, Opts); |
511 | 5 | case llvm::Triple::FreeBSD: |
512 | 5 | return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts); |
513 | 0 | case llvm::Triple::Fuchsia: |
514 | 0 | return new FuchsiaTargetInfo<X86_32TargetInfo>(Triple, Opts); |
515 | 1 | case llvm::Triple::KFreeBSD: |
516 | 1 | return new KFreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts); |
517 | 0 | case llvm::Triple::Minix: |
518 | 0 | return new MinixTargetInfo<X86_32TargetInfo>(Triple, Opts); |
519 | 6 | case llvm::Triple::Solaris: |
520 | 6 | return new SolarisTargetInfo<X86_32TargetInfo>(Triple, Opts); |
521 | 696 | case llvm::Triple::Win32: { |
522 | 696 | switch (Triple.getEnvironment()) { |
523 | 11 | case llvm::Triple::Cygnus: |
524 | 11 | return new CygwinX86_32TargetInfo(Triple, Opts); |
525 | 113 | case llvm::Triple::GNU: |
526 | 113 | return new MinGWX86_32TargetInfo(Triple, Opts); |
527 | 22 | case llvm::Triple::Itanium: |
528 | 572 | case llvm::Triple::MSVC: |
529 | 572 | default: // Assume MSVC for unknown environments |
530 | 572 | return new MicrosoftX86_32TargetInfo(Triple, Opts); |
531 | 696 | } |
532 | 696 | } |
533 | 3 | case llvm::Triple::Haiku: |
534 | 3 | return new HaikuX86_32TargetInfo(Triple, Opts); |
535 | 0 | case llvm::Triple::RTEMS: |
536 | 0 | return new RTEMSX86_32TargetInfo(Triple, Opts); |
537 | 2 | case llvm::Triple::NaCl: |
538 | 2 | return new NaClTargetInfo<X86_32TargetInfo>(Triple, Opts); |
539 | 6 | case llvm::Triple::ELFIAMCU: |
540 | 6 | return new MCUX86_32TargetInfo(Triple, Opts); |
541 | 0 | case llvm::Triple::Hurd: |
542 | 0 | return new HurdTargetInfo<X86_32TargetInfo>(Triple, Opts); |
543 | 13.1k | default: |
544 | 13.1k | return new X86_32TargetInfo(Triple, Opts); |
545 | 14.3k | } |
546 | | |
547 | 72.5k | case llvm::Triple::x86_64: |
548 | 72.5k | if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO()13.2k ) |
549 | 59.3k | return new DarwinX86_64TargetInfo(Triple, Opts); |
550 | | |
551 | 13.2k | switch (os) { |
552 | 0 | case llvm::Triple::Ananas: |
553 | 0 | return new AnanasTargetInfo<X86_64TargetInfo>(Triple, Opts); |
554 | 5 | case llvm::Triple::CloudABI: |
555 | 5 | return new CloudABITargetInfo<X86_64TargetInfo>(Triple, Opts); |
556 | 3.55k | case llvm::Triple::Linux: { |
557 | 3.55k | switch (Triple.getEnvironment()) { |
558 | 3.54k | default: |
559 | 3.54k | return new LinuxTargetInfo<X86_64TargetInfo>(Triple, Opts); |
560 | 6 | case llvm::Triple::Android: |
561 | 6 | return new AndroidX86_64TargetInfo(Triple, Opts); |
562 | 3.55k | } |
563 | 3.55k | } |
564 | 0 | case llvm::Triple::DragonFly: |
565 | 0 | return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple, Opts); |
566 | 10 | case llvm::Triple::NetBSD: |
567 | 10 | return new NetBSDTargetInfo<X86_64TargetInfo>(Triple, Opts); |
568 | 7 | case llvm::Triple::OpenBSD: |
569 | 7 | return new OpenBSDX86_64TargetInfo(Triple, Opts); |
570 | 41 | case llvm::Triple::FreeBSD: |
571 | 41 | return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts); |
572 | 8 | case llvm::Triple::Fuchsia: |
573 | 8 | return new FuchsiaTargetInfo<X86_64TargetInfo>(Triple, Opts); |
574 | 1 | case llvm::Triple::KFreeBSD: |
575 | 1 | return new KFreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts); |
576 | 2 | case llvm::Triple::Solaris: |
577 | 2 | return new SolarisTargetInfo<X86_64TargetInfo>(Triple, Opts); |
578 | 8.15k | case llvm::Triple::Win32: { |
579 | 8.15k | switch (Triple.getEnvironment()) { |
580 | 3 | case llvm::Triple::Cygnus: |
581 | 3 | return new CygwinX86_64TargetInfo(Triple, Opts); |
582 | 52 | case llvm::Triple::GNU: |
583 | 52 | return new MinGWX86_64TargetInfo(Triple, Opts); |
584 | 8.08k | case llvm::Triple::MSVC: |
585 | 8.09k | default: // Assume MSVC for unknown environments |
586 | 8.09k | return new MicrosoftX86_64TargetInfo(Triple, Opts); |
587 | 8.15k | } |
588 | 8.15k | } |
589 | 1 | case llvm::Triple::Haiku: |
590 | 1 | return new HaikuTargetInfo<X86_64TargetInfo>(Triple, Opts); |
591 | 8 | case llvm::Triple::NaCl: |
592 | 8 | return new NaClTargetInfo<X86_64TargetInfo>(Triple, Opts); |
593 | 46 | case llvm::Triple::PS4: |
594 | 46 | return new PS4OSTargetInfo<X86_64TargetInfo>(Triple, Opts); |
595 | 1.42k | default: |
596 | 1.42k | return new X86_64TargetInfo(Triple, Opts); |
597 | 13.2k | } |
598 | | |
599 | 261 | case llvm::Triple::spir: { |
600 | 261 | if (os != llvm::Triple::UnknownOS || |
601 | 261 | Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) |
602 | 0 | return nullptr; |
603 | 261 | return new SPIR32TargetInfo(Triple, Opts); |
604 | 261 | } |
605 | 50 | case llvm::Triple::spir64: { |
606 | 50 | if (os != llvm::Triple::UnknownOS || |
607 | 50 | Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) |
608 | 0 | return nullptr; |
609 | 50 | return new SPIR64TargetInfo(Triple, Opts); |
610 | 50 | } |
611 | 5 | case llvm::Triple::spirv32: { |
612 | 5 | if (os != llvm::Triple::UnknownOS || |
613 | 5 | Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) |
614 | 0 | return nullptr; |
615 | 5 | return new SPIRV32TargetInfo(Triple, Opts); |
616 | 5 | } |
617 | 7 | case llvm::Triple::spirv64: { |
618 | 7 | if (os != llvm::Triple::UnknownOS || |
619 | 7 | Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) |
620 | 0 | return nullptr; |
621 | 7 | return new SPIRV64TargetInfo(Triple, Opts); |
622 | 7 | } |
623 | 68 | case llvm::Triple::wasm32: |
624 | 68 | if (Triple.getSubArch() != llvm::Triple::NoSubArch || |
625 | 68 | Triple.getVendor() != llvm::Triple::UnknownVendor || |
626 | 68 | !Triple.isOSBinFormatWasm()) |
627 | 0 | return nullptr; |
628 | 68 | switch (os) { |
629 | 1 | case llvm::Triple::WASI: |
630 | 1 | return new WASITargetInfo<WebAssembly32TargetInfo>(Triple, Opts); |
631 | 4 | case llvm::Triple::Emscripten: |
632 | 4 | return new EmscriptenTargetInfo<WebAssembly32TargetInfo>(Triple, Opts); |
633 | 63 | case llvm::Triple::UnknownOS: |
634 | 63 | return new WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>(Triple, Opts); |
635 | 0 | default: |
636 | 0 | return nullptr; |
637 | 68 | } |
638 | 44 | case llvm::Triple::wasm64: |
639 | 44 | if (Triple.getSubArch() != llvm::Triple::NoSubArch || |
640 | 44 | Triple.getVendor() != llvm::Triple::UnknownVendor || |
641 | 44 | !Triple.isOSBinFormatWasm()) |
642 | 0 | return nullptr; |
643 | 44 | switch (os) { |
644 | 1 | case llvm::Triple::WASI: |
645 | 1 | return new WASITargetInfo<WebAssembly64TargetInfo>(Triple, Opts); |
646 | 1 | case llvm::Triple::Emscripten: |
647 | 1 | return new EmscriptenTargetInfo<WebAssembly64TargetInfo>(Triple, Opts); |
648 | 42 | case llvm::Triple::UnknownOS: |
649 | 42 | return new WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>(Triple, Opts); |
650 | 0 | default: |
651 | 0 | return nullptr; |
652 | 44 | } |
653 | | |
654 | 37 | case llvm::Triple::dxil: |
655 | 37 | return new DirectXTargetInfo(Triple,Opts); |
656 | 1 | case llvm::Triple::renderscript32: |
657 | 1 | return new LinuxTargetInfo<RenderScript32TargetInfo>(Triple, Opts); |
658 | 1 | case llvm::Triple::renderscript64: |
659 | 1 | return new LinuxTargetInfo<RenderScript64TargetInfo>(Triple, Opts); |
660 | | |
661 | 3 | case llvm::Triple::ve: |
662 | 3 | return new LinuxTargetInfo<VETargetInfo>(Triple, Opts); |
663 | | |
664 | 4 | case llvm::Triple::csky: |
665 | 4 | switch (os) { |
666 | 2 | case llvm::Triple::Linux: |
667 | 2 | return new LinuxTargetInfo<CSKYTargetInfo>(Triple, Opts); |
668 | 2 | default: |
669 | 2 | return new CSKYTargetInfo(Triple, Opts); |
670 | 4 | } |
671 | 97.7k | } |
672 | 97.7k | } |
673 | | } // namespace targets |
674 | | } // namespace clang |
675 | | |
676 | | using namespace clang::targets; |
677 | | /// CreateTargetInfo - Return the target info object for the specified target |
678 | | /// options. |
679 | | TargetInfo * |
680 | | TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags, |
681 | 97.4k | const std::shared_ptr<TargetOptions> &Opts) { |
682 | 97.4k | llvm::Triple Triple(Opts->Triple); |
683 | | |
684 | | // Construct the target |
685 | 97.4k | std::unique_ptr<TargetInfo> Target(AllocateTarget(Triple, *Opts)); |
686 | 97.4k | if (!Target) { |
687 | 6 | Diags.Report(diag::err_target_unknown_triple) << Triple.str(); |
688 | 6 | return nullptr; |
689 | 6 | } |
690 | 97.4k | Target->TargetOpts = Opts; |
691 | | |
692 | | // Set the target CPU if specified. |
693 | 97.4k | if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)38.1k ) { |
694 | 29 | Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU; |
695 | 29 | SmallVector<StringRef, 32> ValidList; |
696 | 29 | Target->fillValidCPUList(ValidList); |
697 | 29 | if (!ValidList.empty()) |
698 | 29 | Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", "); |
699 | 29 | return nullptr; |
700 | 29 | } |
701 | | |
702 | | // Check the TuneCPU name if specified. |
703 | 97.4k | if (!Opts->TuneCPU.empty() && |
704 | 97.4k | !Target->isValidTuneCPUName(Opts->TuneCPU)36.3k ) { |
705 | 8 | Diags.Report(diag::err_target_unknown_cpu) << Opts->TuneCPU; |
706 | 8 | SmallVector<StringRef, 32> ValidList; |
707 | 8 | Target->fillValidTuneCPUList(ValidList); |
708 | 8 | if (!ValidList.empty()) |
709 | 8 | Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", "); |
710 | 8 | return nullptr; |
711 | 8 | } |
712 | | |
713 | | // Set the target ABI if specified. |
714 | 97.4k | if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)1.15k ) { |
715 | 2 | Diags.Report(diag::err_target_unknown_abi) << Opts->ABI; |
716 | 2 | return nullptr; |
717 | 2 | } |
718 | | |
719 | | // Set the fp math unit. |
720 | 97.4k | if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)13 ) { |
721 | 1 | Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath; |
722 | 1 | return nullptr; |
723 | 1 | } |
724 | | |
725 | | // Compute the default target features, we need the target to handle this |
726 | | // because features may have dependencies on one another. |
727 | 97.4k | if (!Target->initFeatureMap(Opts->FeatureMap, Diags, Opts->CPU, |
728 | 97.4k | Opts->FeaturesAsWritten)) |
729 | 19 | return nullptr; |
730 | | |
731 | | // Add the features to the compile options. |
732 | 97.4k | Opts->Features.clear(); |
733 | 97.4k | for (const auto &F : Opts->FeatureMap) |
734 | 650k | Opts->Features.push_back((F.getValue() ? "+"568k : "-"81.6k ) + F.getKey().str()); |
735 | | // Sort here, so we handle the features in a predictable order. (This matters |
736 | | // when we're dealing with features that overlap.) |
737 | 97.4k | llvm::sort(Opts->Features); |
738 | | |
739 | 97.4k | if (!Target->handleTargetFeatures(Opts->Features, Diags)) |
740 | 5 | return nullptr; |
741 | | |
742 | 97.4k | Target->setSupportedOpenCLOpts(); |
743 | 97.4k | Target->setCommandLineOpenCLOpts(); |
744 | 97.4k | Target->setMaxAtomicWidth(); |
745 | | |
746 | 97.4k | if (!Opts->DarwinTargetVariantTriple.empty()) |
747 | 1 | Target->DarwinTargetVariantTriple = |
748 | 1 | llvm::Triple(Opts->DarwinTargetVariantTriple); |
749 | | |
750 | 97.4k | if (!Target->validateTarget(Diags)) |
751 | 3 | return nullptr; |
752 | | |
753 | 97.4k | Target->CheckFixedPointBits(); |
754 | | |
755 | 97.4k | return Target.release(); |
756 | 97.4k | } |
757 | | /// validateOpenCLTarget - Check that OpenCL target has valid |
758 | | /// options setting based on OpenCL version. |
759 | | bool TargetInfo::validateOpenCLTarget(const LangOptions &Opts, |
760 | 687 | DiagnosticsEngine &Diags) const { |
761 | 687 | const llvm::StringMap<bool> &OpenCLFeaturesMap = getSupportedOpenCLOpts(); |
762 | | |
763 | 28.8k | auto diagnoseNotSupportedCore = [&](llvm::StringRef Name, auto... OptArgs) { |
764 | 28.8k | if (OpenCLOptions::isOpenCLOptionCoreIn(Opts, OptArgs...) && |
765 | 28.8k | !hasFeatureEnabled(OpenCLFeaturesMap, Name)3.55k ) |
766 | 244 | Diags.Report(diag::warn_opencl_unsupported_core_feature) |
767 | 244 | << Name << Opts.OpenCLCPlusPlus |
768 | 244 | << Opts.getOpenCLVersionTuple().getAsString(); |
769 | 28.8k | }; Targets.cpp:auto clang::TargetInfo::validateOpenCLTarget(clang::LangOptions const&, clang::DiagnosticsEngine&) const::$_1::operator()<bool, int, clang::(anonymous namespace)::OpenCLVersionID, unsigned int>(llvm::StringRef, bool, int, clang::(anonymous namespace)::OpenCLVersionID, unsigned int) const Line | Count | Source | 763 | 3.43k | auto diagnoseNotSupportedCore = [&](llvm::StringRef Name, auto... OptArgs) { | 764 | 3.43k | if (OpenCLOptions::isOpenCLOptionCoreIn(Opts, OptArgs...) && | 765 | 3.43k | !hasFeatureEnabled(OpenCLFeaturesMap, Name)3.30k ) | 766 | 240 | Diags.Report(diag::warn_opencl_unsupported_core_feature) | 767 | 240 | << Name << Opts.OpenCLCPlusPlus | 768 | 240 | << Opts.getOpenCLVersionTuple().getAsString(); | 769 | 3.43k | }; |
Targets.cpp:auto clang::TargetInfo::validateOpenCLTarget(clang::LangOptions const&, clang::DiagnosticsEngine&) const::$_1::operator()<bool, int, unsigned int, clang::(anonymous namespace)::OpenCLVersionID>(llvm::StringRef, bool, int, unsigned int, clang::(anonymous namespace)::OpenCLVersionID) const Line | Count | Source | 763 | 8.24k | auto diagnoseNotSupportedCore = [&](llvm::StringRef Name, auto... OptArgs) { | 764 | 8.24k | if (OpenCLOptions::isOpenCLOptionCoreIn(Opts, OptArgs...) && | 765 | 8.24k | !hasFeatureEnabled(OpenCLFeaturesMap, Name)0 ) | 766 | 0 | Diags.Report(diag::warn_opencl_unsupported_core_feature) | 767 | 0 | << Name << Opts.OpenCLCPlusPlus | 768 | 0 | << Opts.getOpenCLVersionTuple().getAsString(); | 769 | 8.24k | }; |
Targets.cpp:auto clang::TargetInfo::validateOpenCLTarget(clang::LangOptions const&, clang::DiagnosticsEngine&) const::$_1::operator()<bool, int, unsigned int, unsigned int>(llvm::StringRef, bool, int, unsigned int, unsigned int) const Line | Count | Source | 763 | 16.4k | auto diagnoseNotSupportedCore = [&](llvm::StringRef Name, auto... OptArgs) { | 764 | 16.4k | if (OpenCLOptions::isOpenCLOptionCoreIn(Opts, OptArgs...) && | 765 | 16.4k | !hasFeatureEnabled(OpenCLFeaturesMap, Name)0 ) | 766 | 0 | Diags.Report(diag::warn_opencl_unsupported_core_feature) | 767 | 0 | << Name << Opts.OpenCLCPlusPlus | 768 | 0 | << Opts.getOpenCLVersionTuple().getAsString(); | 769 | 16.4k | }; |
Targets.cpp:auto clang::TargetInfo::validateOpenCLTarget(clang::LangOptions const&, clang::DiagnosticsEngine&) const::$_1::operator()<bool, int, clang::(anonymous namespace)::OpenCLVersionID, clang::(anonymous namespace)::OpenCLVersionID>(llvm::StringRef, bool, int, clang::(anonymous namespace)::OpenCLVersionID, clang::(anonymous namespace)::OpenCLVersionID) const Line | Count | Source | 763 | 687 | auto diagnoseNotSupportedCore = [&](llvm::StringRef Name, auto... OptArgs) { | 764 | 687 | if (OpenCLOptions::isOpenCLOptionCoreIn(Opts, OptArgs...) && | 765 | 687 | !hasFeatureEnabled(OpenCLFeaturesMap, Name)254 ) | 766 | 4 | Diags.Report(diag::warn_opencl_unsupported_core_feature) | 767 | 4 | << Name << Opts.OpenCLCPlusPlus | 768 | 4 | << Opts.getOpenCLVersionTuple().getAsString(); | 769 | 687 | }; |
|
770 | 687 | #define OPENCL_GENERIC_EXTENSION(Ext, ...) \ |
771 | 28.8k | diagnoseNotSupportedCore(#Ext, __VA_ARGS__); |
772 | 687 | #include "clang/Basic/OpenCLExtensions.def" |
773 | | |
774 | | // Validate that feature macros are set properly for OpenCL C 3.0. |
775 | | // In other cases assume that target is always valid. |
776 | 687 | if (Opts.getOpenCLCompatibleVersion() < 300) |
777 | 535 | return true; |
778 | | |
779 | 152 | return OpenCLOptions::diagnoseUnsupportedFeatureDependencies(*this, Diags) && |
780 | 152 | OpenCLOptions::diagnoseFeatureExtensionDifferences(*this, Diags)142 ; |
781 | 687 | } |