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