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 return !llvm::is_contained(Range: kStaticLangageTypes, Element: Id);
128}
129
130bool types::appendSuffixForType(ID Id) {
131 return Id == TY_PCH || Id == TY_dSYM || Id == TY_CUDA_FATBIN ||
132 Id == TY_HIP_FATBIN;
133}
134
135bool types::canLipoType(ID Id) {
136 return (Id == TY_Nothing ||
137 Id == TY_Image ||
138 Id == TY_Object ||
139 Id == TY_LTO_BC);
140}
141
142bool types::isAcceptedByClang(ID Id) {
143 switch (Id) {
144 default:
145 return false;
146
147 case TY_Asm:
148 case TY_C: case TY_PP_C:
149 case TY_CL: case TY_PP_CL: case TY_CLCXX: case TY_PP_CLCXX:
150 case TY_CUDA: case TY_PP_CUDA:
151 case TY_CUDA_DEVICE:
152 case TY_HIP:
153 case TY_PP_HIP:
154 case TY_HIP_DEVICE:
155 case TY_ObjC: case TY_PP_ObjC: case TY_PP_ObjC_Alias:
156 case TY_CXX: case TY_PP_CXX:
157 case TY_ObjCXX: case TY_PP_ObjCXX: case TY_PP_ObjCXX_Alias:
158 case TY_CHeader: case TY_PP_CHeader:
159 case TY_CLHeader:
160 case TY_ObjCHeader: case TY_PP_ObjCHeader:
161 case TY_CXXHeader: case TY_PP_CXXHeader:
162 case TY_CXXSHeader:
163 case TY_CXXUHeader:
164 case TY_CXXHUHeader:
165 case TY_PP_CXXHeaderUnit:
166 case TY_ObjCXXHeader: case TY_PP_ObjCXXHeader:
167 case TY_CXXModule:
168 case TY_PP_CXXModule:
169 case TY_CXXStdModule:
170 case TY_PP_CXXStdModule:
171 case TY_AST: case TY_ModuleFile: case TY_PCH:
172 case TY_LLVM_IR: case TY_LLVM_BC:
173 case TY_API_INFO:
174 return true;
175 }
176}
177
178bool types::isAcceptedByFlang(ID Id) {
179 switch (Id) {
180 default:
181 return false;
182
183 case TY_Fortran:
184 case TY_PP_Fortran:
185 return true;
186 case TY_LLVM_IR:
187 case TY_LLVM_BC:
188 return true;
189 case TY_PP_CUDA:
190 case TY_CUDA:
191 return true;
192 }
193}
194
195bool types::isDerivedFromC(ID Id) {
196 switch (Id) {
197 default:
198 return false;
199
200 case TY_PP_C:
201 case TY_C:
202 case TY_CL:
203 case TY_PP_CL:
204 case TY_CLCXX:
205 case TY_PP_CLCXX:
206 case TY_PP_CUDA:
207 case TY_CUDA:
208 case TY_CUDA_DEVICE:
209 case TY_PP_HIP:
210 case TY_HIP:
211 case TY_HIP_DEVICE:
212 case TY_PP_ObjC:
213 case TY_PP_ObjC_Alias:
214 case TY_ObjC:
215 case TY_PP_CXX:
216 case TY_CXX:
217 case TY_PP_ObjCXX:
218 case TY_PP_ObjCXX_Alias:
219 case TY_ObjCXX:
220 case TY_PP_CHeader:
221 case TY_CHeader:
222 case TY_CLHeader:
223 case TY_PP_ObjCHeader:
224 case TY_ObjCHeader:
225 case TY_PP_CXXHeader:
226 case TY_CXXHeader:
227 case TY_PP_ObjCXXHeader:
228 case TY_ObjCXXHeader:
229 case TY_CXXModule:
230 case TY_PP_CXXModule:
231 case TY_CXXStdModule:
232 case TY_PP_CXXStdModule:
233 return true;
234 }
235}
236
237bool types::isObjC(ID Id) {
238 switch (Id) {
239 default:
240 return false;
241
242 case TY_ObjC: case TY_PP_ObjC: case TY_PP_ObjC_Alias:
243 case TY_ObjCXX: case TY_PP_ObjCXX:
244 case TY_ObjCHeader: case TY_PP_ObjCHeader:
245 case TY_ObjCXXHeader: case TY_PP_ObjCXXHeader: case TY_PP_ObjCXX_Alias:
246 return true;
247 }
248}
249
250bool types::isOpenCL(ID Id) {
251 switch (Id) {
252 default:
253 return false;
254 case TY_PP_CL:
255 case TY_PP_CLCXX:
256 case TY_CL:
257 case TY_CLCXX:
258 return true;
259 }
260}
261
262bool types::isCXX(ID Id) {
263 switch (Id) {
264 default:
265 return false;
266
267 case TY_CXX: case TY_PP_CXX:
268 case TY_ObjCXX: case TY_PP_ObjCXX: case TY_PP_ObjCXX_Alias:
269 case TY_CXXHeader: case TY_PP_CXXHeader:
270 case TY_CXXSHeader:
271 case TY_CXXUHeader:
272 case TY_CXXHUHeader:
273 case TY_PP_CXXHeaderUnit:
274 case TY_ObjCXXHeader: case TY_PP_ObjCXXHeader:
275 case TY_CXXModule:
276 case TY_PP_CXXModule:
277 case TY_CXXStdModule:
278 case TY_PP_CXXStdModule:
279 case TY_ModuleFile:
280 case TY_PP_CLCXX:
281 case TY_CUDA: case TY_PP_CUDA: case TY_CUDA_DEVICE:
282 case TY_HIP:
283 case TY_PP_HIP:
284 case TY_HIP_DEVICE:
285 return true;
286 }
287}
288
289bool types::isLLVMIR(ID Id) {
290 switch (Id) {
291 default:
292 return false;
293
294 case TY_LLVM_IR:
295 case TY_LLVM_BC:
296 case TY_LTO_IR:
297 case TY_LTO_BC:
298 return true;
299 }
300}
301
302bool types::isCuda(ID Id) {
303 switch (Id) {
304 default:
305 return false;
306
307 case TY_CUDA:
308 case TY_PP_CUDA:
309 case TY_CUDA_DEVICE:
310 return true;
311 }
312}
313
314bool types::isHIP(ID Id) {
315 switch (Id) {
316 default:
317 return false;
318
319 case TY_HIP:
320 case TY_PP_HIP:
321 case TY_HIP_DEVICE:
322 return true;
323 }
324}
325
326bool types::isHLSL(ID Id) { return Id == TY_HLSL; }
327
328bool types::isSrcFile(ID Id) {
329 return Id != TY_Object && getPreprocessedType(Id) != TY_INVALID;
330}
331
332types::ID types::lookupTypeForExtension(llvm::StringRef Ext) {
333 return llvm::StringSwitch<types::ID>(Ext)
334 .Case(S: "c", Value: TY_C)
335 .Case(S: "C", Value: TY_CXX)
336 .Case(S: "F", Value: TY_Fortran)
337 .Case(S: "f", Value: TY_PP_Fortran)
338 .Case(S: "h", Value: TY_CHeader)
339 .Case(S: "H", Value: TY_CXXHeader)
340 .Case(S: "i", Value: TY_PP_C)
341 .Case(S: "m", Value: TY_ObjC)
342 .Case(S: "M", Value: TY_ObjCXX)
343 .Case(S: "o", Value: TY_Object)
344 .Case(S: "S", Value: TY_Asm)
345 .Case(S: "s", Value: TY_PP_Asm)
346 .Case(S: "bc", Value: TY_LLVM_BC)
347 .Case(S: "cc", Value: TY_CXX)
348 .Case(S: "CC", Value: TY_CXX)
349 .Case(S: "cl", Value: TY_CL)
350 .Case(S: "cli", Value: TY_PP_CL)
351 .Case(S: "clcpp", Value: TY_CLCXX)
352 .Case(S: "clii", Value: TY_PP_CLCXX)
353 .Case(S: "cp", Value: TY_CXX)
354 .Case(S: "cu", Value: TY_CUDA)
355 .Case(S: "hh", Value: TY_CXXHeader)
356 .Case(S: "ii", Value: TY_PP_CXX)
357 .Case(S: "ll", Value: TY_LLVM_IR)
358 .Case(S: "mi", Value: TY_PP_ObjC)
359 .Case(S: "mm", Value: TY_ObjCXX)
360 .Case(S: "adb", Value: TY_Ada)
361 .Case(S: "ads", Value: TY_Ada)
362 .Case(S: "asm", Value: TY_PP_Asm)
363 .Case(S: "ast", Value: TY_AST)
364 .Case(S: "ccm", Value: TY_CXXModule)
365 .Case(S: "cpp", Value: TY_CXX)
366 .Case(S: "CPP", Value: TY_CXX)
367 .Case(S: "c++", Value: TY_CXX)
368 .Case(S: "C++", Value: TY_CXX)
369 .Case(S: "cui", Value: TY_PP_CUDA)
370 .Case(S: "cxx", Value: TY_CXX)
371 .Case(S: "CXX", Value: TY_CXX)
372 .Case(S: "F03", Value: TY_Fortran)
373 .Case(S: "f03", Value: TY_PP_Fortran)
374 .Case(S: "F08", Value: TY_Fortran)
375 .Case(S: "f08", Value: TY_PP_Fortran)
376 .Case(S: "F90", Value: TY_Fortran)
377 .Case(S: "f90", Value: TY_PP_Fortran)
378 .Case(S: "F95", Value: TY_Fortran)
379 .Case(S: "f95", Value: TY_PP_Fortran)
380 .Case(S: "for", Value: TY_PP_Fortran)
381 .Case(S: "FOR", Value: TY_PP_Fortran)
382 .Case(S: "fpp", Value: TY_Fortran)
383 .Case(S: "FPP", Value: TY_Fortran)
384 .Case(S: "gch", Value: TY_PCH)
385 .Case(S: "hip", Value: TY_HIP)
386 .Case(S: "hipi", Value: TY_PP_HIP)
387 .Case(S: "hpp", Value: TY_CXXHeader)
388 .Case(S: "hxx", Value: TY_CXXHeader)
389 .Case(S: "iim", Value: TY_PP_CXXModule)
390 .Case(S: "iih", Value: TY_PP_CXXHeaderUnit)
391 .Case(S: "lib", Value: TY_Object)
392 .Case(S: "mii", Value: TY_PP_ObjCXX)
393 .Case(S: "obj", Value: TY_Object)
394 .Case(S: "ifs", Value: TY_IFS)
395 .Case(S: "pch", Value: TY_PCH)
396 .Case(S: "pcm", Value: TY_ModuleFile)
397 .Case(S: "c++m", Value: TY_CXXModule)
398 .Case(S: "cppm", Value: TY_CXXModule)
399 .Case(S: "cxxm", Value: TY_CXXModule)
400 .Case(S: "hlsl", Value: TY_HLSL)
401 .Default(Value: TY_INVALID);
402}
403
404types::ID types::lookupTypeForTypeSpecifier(const char *Name) {
405 for (unsigned i=0; i<numTypes; ++i) {
406 types::ID Id = (types::ID) (i + 1);
407 if (canTypeBeUserSpecified(Id) &&
408 strcmp(s1: Name, s2: getInfo(id: Id).Name) == 0)
409 return Id;
410 }
411 // Accept "cu" as an alias for "cuda" for NVCC compatibility
412 if (strcmp(s1: Name, s2: "cu") == 0) {
413 return types::TY_CUDA;
414 }
415 return TY_INVALID;
416}
417
418llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases>
419types::getCompilationPhases(ID Id, phases::ID LastPhase) {
420 llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> P;
421 const auto &Info = getInfo(id: Id);
422 for (int I = 0; I <= LastPhase; ++I)
423 if (Info.Phases.contains(Id: static_cast<phases::ID>(I)))
424 P.push_back(Elt: static_cast<phases::ID>(I));
425 assert(P.size() <= phases::MaxNumberOfPhases && "Too many phases in list");
426 return P;
427}
428
429llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases>
430types::getCompilationPhases(const clang::driver::Driver &Driver,
431 llvm::opt::DerivedArgList &DAL, ID Id) {
432 return types::getCompilationPhases(Id, LastPhase: Driver.getFinalPhase(DAL));
433}
434
435ID types::lookupCXXTypeForCType(ID Id) {
436 switch (Id) {
437 default:
438 return Id;
439
440 case types::TY_C:
441 return types::TY_CXX;
442 case types::TY_PP_C:
443 return types::TY_PP_CXX;
444 case types::TY_CHeader:
445 return types::TY_CXXHeader;
446 case types::TY_PP_CHeader:
447 return types::TY_PP_CXXHeader;
448 }
449}
450
451ID types::lookupHeaderTypeForSourceType(ID Id) {
452 switch (Id) {
453 default:
454 return Id;
455
456 // FIXME: Handle preprocessed input types.
457 case types::TY_C:
458 return types::TY_CHeader;
459 case types::TY_CXX:
460 case types::TY_CXXModule:
461 case types::TY_CXXStdModule:
462 return types::TY_CXXHeader;
463 case types::TY_ObjC:
464 return types::TY_ObjCHeader;
465 case types::TY_ObjCXX:
466 return types::TY_ObjCXXHeader;
467 case types::TY_CL:
468 case types::TY_CLCXX:
469 return types::TY_CLHeader;
470 }
471}
472