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