1//===--- Types.cpp - Driver input & temporary type information ------------===//
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#include "clang/Driver/Types.h"
10#include "clang/Driver/Driver.h"
11#include "llvm/ADT/STLExtras.h"
12#include "llvm/ADT/SmallVector.h"
13#include "llvm/ADT/StringSwitch.h"
14#include <cassert>
15#include <cstring>
16
17using namespace clang::driver;
18using namespace clang::driver::types;
19
20struct TypeInfo {
21 const char *Name;
22 const char *TempSuffix;
23 ID PreprocessedType;
24 class PhasesBitSet {
25 unsigned Bits = 0;
26
27 public:
28 constexpr PhasesBitSet(std::initializer_list<phases::ID> Phases) {
29 for (auto Id : Phases)
30 Bits |= 1 << Id;
31 }
32 bool contains(phases::ID Id) const { return Bits & (1 << Id); }
33 } Phases;
34};
35
36static constexpr TypeInfo TypeInfos[] = {
37#define TYPE(NAME, ID, PP_TYPE, TEMP_SUFFIX, ...) \
38 { NAME, TEMP_SUFFIX, TY_##PP_TYPE, { __VA_ARGS__ }, },
39#include "clang/Driver/Types.def"
40#undef TYPE
41};
42static const unsigned numTypes = std::size(TypeInfos);
43
44static const TypeInfo &getInfo(unsigned id) {
45 assert(id > 0 && id - 1 < numTypes && "Invalid Type ID.");
46 return TypeInfos[id - 1];
47}
48
49const char *types::getTypeName(ID Id) {
50 return getInfo(id: Id).Name;
51}
52
53types::ID types::getPreprocessedType(ID Id) {
54 ID PPT = getInfo(id: Id).PreprocessedType;
55 assert((getInfo(Id).Phases.contains(phases::Preprocess) !=
56 (PPT == TY_INVALID)) &&
57 "Unexpected Preprocess Type.");
58 return PPT;
59}
60
61static bool isPreprocessedModuleType(ID Id) {
62 return Id == TY_CXXModule || Id == TY_PP_CXXModule || Id == TY_CXXStdModule ||
63 Id == TY_PP_CXXStdModule;
64}
65
66static bool isPreprocessedHeaderUnitType(ID Id) {
67 return Id == TY_CXXSHeader || Id == TY_CXXUHeader || Id == TY_CXXHUHeader ||
68 Id == TY_PP_CXXHeaderUnit;
69}
70
71types::ID types::getPrecompiledType(ID Id) {
72 if (isPreprocessedModuleType(Id))
73 return TY_ModuleFile;
74 if (isPreprocessedHeaderUnitType(Id))
75 return TY_HeaderUnit;
76 if (onlyPrecompileType(Id))
77 return TY_PCH;
78 return TY_INVALID;
79}
80
81const char *types::getTypeTempSuffix(ID Id, bool CLStyle) {
82 if (CLStyle) {
83 switch (Id) {
84 case TY_Object:
85 case TY_LTO_BC:
86 return "obj";
87 case TY_Image:
88 return "exe";
89 case TY_PP_Asm:
90 return "asm";
91 default:
92 break;
93 }
94 }
95 return getInfo(id: Id).TempSuffix;
96}
97
98bool types::onlyPrecompileType(ID Id) {
99 return getInfo(id: Id).Phases.contains(Id: phases::Precompile) &&
100 !isPreprocessedModuleType(Id);
101}
102
103bool types::canTypeBeUserSpecified(ID Id) {
104 static const clang::driver::types::ID kStaticLangageTypes[] = {
105 TY_CUDA_DEVICE,
106 TY_HIP_DEVICE,
107 TY_PP_CHeader,
108 TY_PP_ObjCHeader,
109 TY_PP_CXXHeader,
110 TY_PP_ObjCXXHeader,
111 TY_PP_CXXModule,
112 TY_CXXStdModule,
113 TY_PP_CXXStdModule,
114 TY_LTO_IR,
115 TY_LTO_BC,
116 TY_Plist,
117 TY_RewrittenObjC,
118 TY_RewrittenLegacyObjC,
119 TY_Remap,
120 TY_PCH,
121 TY_Object,
122 TY_Image,
123 TY_dSYM,
124 TY_Dependencies,
125 TY_CUDA_FATBIN,
126 TY_HIP_FATBIN,
127 TY_SYCL_FATBIN};
128 return !llvm::is_contained(Range: kStaticLangageTypes, Element: Id);
129}
130
131bool types::appendSuffixForType(ID Id) {
132 return Id == TY_PCH || Id == TY_dSYM || Id == TY_CUDA_FATBIN ||
133 Id == TY_HIP_FATBIN || Id == TY_SYCL_FATBIN;
134}
135
136bool types::canLipoType(ID Id) {
137 return (Id == TY_Nothing ||
138 Id == TY_Image ||
139 Id == TY_Object ||
140 Id == TY_LTO_BC);
141}
142
143bool types::isAcceptedByClang(ID Id) {
144 switch (Id) {
145 default:
146 return false;
147
148 case TY_Asm:
149 case TY_C: case TY_PP_C:
150 case TY_CL: case TY_PP_CL: case TY_CLCXX: case TY_PP_CLCXX:
151 case TY_CUDA: case TY_PP_CUDA:
152 case TY_CUDA_DEVICE:
153 case TY_HIP:
154 case TY_PP_HIP:
155 case TY_HIP_DEVICE:
156 case TY_ObjC: case TY_PP_ObjC: case TY_PP_ObjC_Alias:
157 case TY_CXX: case TY_PP_CXX:
158 case TY_ObjCXX: case TY_PP_ObjCXX: case TY_PP_ObjCXX_Alias:
159 case TY_CHeader: case TY_PP_CHeader:
160 case TY_CLHeader:
161 case TY_ObjCHeader: case TY_PP_ObjCHeader:
162 case TY_CXXHeader: case TY_PP_CXXHeader:
163 case TY_CXXSHeader:
164 case TY_CXXUHeader:
165 case TY_CXXHUHeader:
166 case TY_PP_CXXHeaderUnit:
167 case TY_ObjCXXHeader: case TY_PP_ObjCXXHeader:
168 case TY_CXXModule:
169 case TY_PP_CXXModule:
170 case TY_CXXStdModule:
171 case TY_PP_CXXStdModule:
172 case TY_AST: case TY_ModuleFile: case TY_PCH:
173 case TY_LLVM_IR: case TY_LLVM_BC:
174 case TY_CIR:
175 case TY_CIRBC:
176 case TY_API_INFO:
177 return true;
178 }
179}
180
181bool types::isAcceptedByFlang(ID Id) {
182 switch (Id) {
183 default:
184 return false;
185
186 case TY_Fortran:
187 case TY_PP_Fortran:
188 return true;
189 case TY_LLVM_IR:
190 case TY_LLVM_BC:
191 return true;
192 case TY_PP_CUDA:
193 case TY_CUDA:
194 return true;
195 }
196}
197
198bool types::isDerivedFromC(ID Id) {
199 switch (Id) {
200 default:
201 return false;
202
203 case TY_PP_C:
204 case TY_C:
205 case TY_CL:
206 case TY_PP_CL:
207 case TY_CLCXX:
208 case TY_PP_CLCXX:
209 case TY_PP_CUDA:
210 case TY_CUDA:
211 case TY_CUDA_DEVICE:
212 case TY_PP_HIP:
213 case TY_HIP:
214 case TY_HIP_DEVICE:
215 case TY_PP_ObjC:
216 case TY_PP_ObjC_Alias:
217 case TY_ObjC:
218 case TY_PP_CXX:
219 case TY_CXX:
220 case TY_PP_ObjCXX:
221 case TY_PP_ObjCXX_Alias:
222 case TY_ObjCXX:
223 case TY_PP_CHeader:
224 case TY_CHeader:
225 case TY_CLHeader:
226 case TY_PP_ObjCHeader:
227 case TY_ObjCHeader:
228 case TY_PP_CXXHeader:
229 case TY_CXXHeader:
230 case TY_PP_ObjCXXHeader:
231 case TY_ObjCXXHeader:
232 case TY_CXXModule:
233 case TY_PP_CXXModule:
234 case TY_CXXStdModule:
235 case TY_PP_CXXStdModule:
236 return true;
237 }
238}
239
240bool types::isObjC(ID Id) {
241 switch (Id) {
242 default:
243 return false;
244
245 case TY_ObjC: case TY_PP_ObjC: case TY_PP_ObjC_Alias:
246 case TY_ObjCXX: case TY_PP_ObjCXX:
247 case TY_ObjCHeader: case TY_PP_ObjCHeader:
248 case TY_ObjCXXHeader: case TY_PP_ObjCXXHeader: case TY_PP_ObjCXX_Alias:
249 return true;
250 }
251}
252
253bool types::isOpenCL(ID Id) {
254 switch (Id) {
255 default:
256 return false;
257 case TY_PP_CL:
258 case TY_PP_CLCXX:
259 case TY_CL:
260 case TY_CLCXX:
261 return true;
262 }
263}
264
265bool types::isCXX(ID Id) {
266 switch (Id) {
267 default:
268 return false;
269
270 case TY_CXX: case TY_PP_CXX:
271 case TY_ObjCXX: case TY_PP_ObjCXX: case TY_PP_ObjCXX_Alias:
272 case TY_CXXHeader: case TY_PP_CXXHeader:
273 case TY_CXXSHeader:
274 case TY_CXXUHeader:
275 case TY_CXXHUHeader:
276 case TY_PP_CXXHeaderUnit:
277 case TY_ObjCXXHeader: case TY_PP_ObjCXXHeader:
278 case TY_CXXModule:
279 case TY_PP_CXXModule:
280 case TY_CXXStdModule:
281 case TY_PP_CXXStdModule:
282 case TY_ModuleFile:
283 case TY_PP_CLCXX:
284 case TY_CUDA: case TY_PP_CUDA: case TY_CUDA_DEVICE:
285 case TY_HIP:
286 case TY_PP_HIP:
287 case TY_HIP_DEVICE:
288 return true;
289 }
290}
291
292bool types::isLLVMIR(ID Id) {
293 switch (Id) {
294 default:
295 return false;
296
297 case TY_LLVM_IR:
298 case TY_LLVM_BC:
299 case TY_LTO_IR:
300 case TY_LTO_BC:
301 return true;
302 }
303}
304
305bool types::isCuda(ID Id) {
306 switch (Id) {
307 default:
308 return false;
309
310 case TY_CUDA:
311 case TY_PP_CUDA:
312 case TY_CUDA_DEVICE:
313 return true;
314 }
315}
316
317bool types::isHIP(ID Id) {
318 switch (Id) {
319 default:
320 return false;
321
322 case TY_HIP:
323 case TY_PP_HIP:
324 case TY_HIP_DEVICE:
325 return true;
326 }
327}
328
329bool types::isHLSL(ID Id) { return Id == TY_HLSL; }
330
331bool types::isSrcFile(ID Id) {
332 return Id != TY_Object && getPreprocessedType(Id) != TY_INVALID;
333}
334
335types::ID types::lookupTypeForExtension(llvm::StringRef Ext) {
336 return llvm::StringSwitch<types::ID>(Ext)
337 .Case(S: "c", Value: TY_C)
338 .Case(S: "C", Value: TY_CXX)
339 .Case(S: "F", Value: TY_Fortran)
340 .Case(S: "f", Value: TY_PP_Fortran)
341 .Case(S: "h", Value: TY_CHeader)
342 .Case(S: "H", Value: TY_CXXHeader)
343 .Case(S: "i", Value: TY_PP_C)
344 .Case(S: "m", Value: TY_ObjC)
345 .Case(S: "M", Value: TY_ObjCXX)
346 .Case(S: "o", Value: TY_Object)
347 .Case(S: "S", Value: TY_Asm)
348 .Case(S: "s", Value: TY_PP_Asm)
349 .Case(S: "bc", Value: TY_LLVM_BC)
350 .Case(S: "cc", Value: TY_CXX)
351 .Case(S: "CC", Value: TY_CXX)
352 .Case(S: "cl", Value: TY_CL)
353 .Case(S: "cli", Value: TY_PP_CL)
354 .Case(S: "clcpp", Value: TY_CLCXX)
355 .Case(S: "clii", Value: TY_PP_CLCXX)
356 .Case(S: "cp", Value: TY_CXX)
357 .Case(S: "cu", Value: TY_CUDA)
358 .Case(S: "hh", Value: TY_CXXHeader)
359 .Case(S: "ii", Value: TY_PP_CXX)
360 .Case(S: "ll", Value: TY_LLVM_IR)
361 .Case(S: "mi", Value: TY_PP_ObjC)
362 .Case(S: "mm", Value: TY_ObjCXX)
363 .Case(S: "adb", Value: TY_Ada)
364 .Case(S: "ads", Value: TY_Ada)
365 .Case(S: "asm", Value: TY_PP_Asm)
366 .Case(S: "ast", Value: TY_AST)
367 .Case(S: "ccm", Value: TY_CXXModule)
368 .Case(S: "cpp", Value: TY_CXX)
369 .Case(S: "CPP", Value: TY_CXX)
370 .Case(S: "c++", Value: TY_CXX)
371 .Case(S: "C++", Value: TY_CXX)
372 .Case(S: "cir", Value: TY_CIR)
373 .Case(S: "cirbc", Value: TY_CIRBC)
374 .Case(S: "cui", Value: TY_PP_CUDA)
375 .Case(S: "cxx", Value: TY_CXX)
376 .Case(S: "CXX", Value: TY_CXX)
377 .Case(S: "F03", Value: TY_Fortran)
378 .Case(S: "f03", Value: TY_PP_Fortran)
379 .Case(S: "F08", Value: TY_Fortran)
380 .Case(S: "f08", Value: TY_PP_Fortran)
381 .Case(S: "F90", Value: TY_Fortran)
382 .Case(S: "f90", Value: TY_PP_Fortran)
383 .Case(S: "F95", Value: TY_Fortran)
384 .Case(S: "f95", Value: TY_PP_Fortran)
385 .Case(S: "for", Value: TY_PP_Fortran)
386 .Case(S: "FOR", Value: TY_PP_Fortran)
387 .Case(S: "fpp", Value: TY_Fortran)
388 .Case(S: "FPP", Value: TY_Fortran)
389 .Case(S: "gch", Value: TY_PCH)
390 .Case(S: "hip", Value: TY_HIP)
391 .Case(S: "hipi", Value: TY_PP_HIP)
392 .Case(S: "hpp", Value: TY_CXXHeader)
393 .Case(S: "hxx", Value: TY_CXXHeader)
394 .Case(S: "iim", Value: TY_PP_CXXModule)
395 .Case(S: "iih", Value: TY_PP_CXXHeaderUnit)
396 .Case(S: "lib", Value: TY_Object)
397 .Case(S: "mii", Value: TY_PP_ObjCXX)
398 .Case(S: "obj", Value: TY_Object)
399 .Case(S: "ifs", Value: TY_IFS)
400 .Case(S: "pch", Value: TY_PCH)
401 .Case(S: "pcm", Value: TY_ModuleFile)
402 .Case(S: "c++m", Value: TY_CXXModule)
403 .Case(S: "cppm", Value: TY_CXXModule)
404 .Case(S: "cxxm", Value: TY_CXXModule)
405 .Case(S: "hlsl", Value: TY_HLSL)
406 .Default(Value: TY_INVALID);
407}
408
409types::ID types::lookupTypeForTypeSpecifier(const char *Name) {
410 for (unsigned i=0; i<numTypes; ++i) {
411 types::ID Id = (types::ID) (i + 1);
412 if (canTypeBeUserSpecified(Id) &&
413 strcmp(s1: Name, s2: getInfo(id: Id).Name) == 0)
414 return Id;
415 }
416 // Accept "cu" as an alias for "cuda" for NVCC compatibility
417 if (strcmp(s1: Name, s2: "cu") == 0) {
418 return types::TY_CUDA;
419 }
420 return TY_INVALID;
421}
422
423llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases>
424types::getCompilationPhases(ID Id, phases::ID LastPhase) {
425 llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> P;
426 const auto &Info = getInfo(id: Id);
427 for (int I = 0; I <= LastPhase; ++I)
428 if (Info.Phases.contains(Id: static_cast<phases::ID>(I)))
429 P.push_back(Elt: static_cast<phases::ID>(I));
430 assert(P.size() <= phases::MaxNumberOfPhases && "Too many phases in list");
431 return P;
432}
433
434llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases>
435types::getCompilationPhases(const clang::driver::Driver &Driver,
436 llvm::opt::DerivedArgList &DAL, ID Id) {
437 return types::getCompilationPhases(Id, LastPhase: Driver.getFinalPhase(DAL));
438}
439
440ID types::lookupCXXTypeForCType(ID Id) {
441 switch (Id) {
442 default:
443 return Id;
444
445 case types::TY_C:
446 return types::TY_CXX;
447 case types::TY_PP_C:
448 return types::TY_PP_CXX;
449 case types::TY_CHeader:
450 return types::TY_CXXHeader;
451 case types::TY_PP_CHeader:
452 return types::TY_PP_CXXHeader;
453 }
454}
455
456ID types::lookupHeaderTypeForSourceType(ID Id) {
457 switch (Id) {
458 default:
459 return Id;
460
461 // FIXME: Handle preprocessed input types.
462 case types::TY_C:
463 return types::TY_CHeader;
464 case types::TY_CXX:
465 case types::TY_CXXModule:
466 case types::TY_CXXStdModule:
467 return types::TY_CXXHeader;
468 case types::TY_ObjC:
469 return types::TY_ObjCHeader;
470 case types::TY_ObjCXX:
471 return types::TY_ObjCXXHeader;
472 case types::TY_CL:
473 case types::TY_CLCXX:
474 return types::TY_CLHeader;
475 }
476}
477