clang 20.0.0git
Types.cpp
Go to the documentation of this file.
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).Name;
51}
52
53types::ID types::getPreprocessedType(ID Id) {
54 ID PPT = getInfo(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;
63}
64
65static bool isPreprocessedHeaderUnitType(ID Id) {
66 return Id == TY_CXXSHeader || Id == TY_CXXUHeader || Id == TY_CXXHUHeader ||
67 Id == TY_PP_CXXHeaderUnit;
68}
69
70types::ID types::getPrecompiledType(ID Id) {
71 if (isPreprocessedModuleType(Id))
72 return TY_ModuleFile;
73 if (isPreprocessedHeaderUnitType(Id))
74 return TY_HeaderUnit;
75 if (onlyPrecompileType(Id))
76 return TY_PCH;
77 return TY_INVALID;
78}
79
80const char *types::getTypeTempSuffix(ID Id, bool CLStyle) {
81 if (CLStyle) {
82 switch (Id) {
83 case TY_Object:
84 case TY_LTO_BC:
85 return "obj";
86 case TY_Image:
87 return "exe";
88 case TY_PP_Asm:
89 return "asm";
90 default:
91 break;
92 }
93 }
94 return getInfo(Id).TempSuffix;
95}
96
97bool types::onlyPrecompileType(ID Id) {
98 return getInfo(Id).Phases.contains(phases::Precompile) &&
99 !isPreprocessedModuleType(Id);
100}
101
102bool types::canTypeBeUserSpecified(ID Id) {
103 static const clang::driver::types::ID kStaticLangageTypes[] = {
104 TY_CUDA_DEVICE, TY_HIP_DEVICE, TY_PP_CHeader,
105 TY_PP_ObjCHeader, TY_PP_CXXHeader, TY_PP_ObjCXXHeader,
106 TY_PP_CXXModule, TY_LTO_IR, TY_LTO_BC,
107 TY_Plist, TY_RewrittenObjC, TY_RewrittenLegacyObjC,
108 TY_Remap, TY_PCH, TY_Object,
109 TY_Image, TY_dSYM, TY_Dependencies,
110 TY_CUDA_FATBIN, TY_HIP_FATBIN};
111 return !llvm::is_contained(kStaticLangageTypes, Id);
112}
113
114bool types::appendSuffixForType(ID Id) {
115 return Id == TY_PCH || Id == TY_dSYM || Id == TY_CUDA_FATBIN ||
116 Id == TY_HIP_FATBIN;
117}
118
119bool types::canLipoType(ID Id) {
120 return (Id == TY_Nothing ||
121 Id == TY_Image ||
122 Id == TY_Object ||
123 Id == TY_LTO_BC);
124}
125
126bool types::isAcceptedByClang(ID Id) {
127 switch (Id) {
128 default:
129 return false;
130
131 case TY_Asm:
132 case TY_C: case TY_PP_C:
133 case TY_CL: case TY_PP_CL: case TY_CLCXX: case TY_PP_CLCXX:
134 case TY_CUDA: case TY_PP_CUDA:
135 case TY_CUDA_DEVICE:
136 case TY_HIP:
137 case TY_PP_HIP:
138 case TY_HIP_DEVICE:
139 case TY_ObjC: case TY_PP_ObjC: case TY_PP_ObjC_Alias:
140 case TY_CXX: case TY_PP_CXX:
141 case TY_ObjCXX: case TY_PP_ObjCXX: case TY_PP_ObjCXX_Alias:
142 case TY_CHeader: case TY_PP_CHeader:
143 case TY_CLHeader:
144 case TY_ObjCHeader: case TY_PP_ObjCHeader:
145 case TY_CXXHeader: case TY_PP_CXXHeader:
146 case TY_CXXSHeader:
147 case TY_CXXUHeader:
148 case TY_CXXHUHeader:
149 case TY_PP_CXXHeaderUnit:
150 case TY_ObjCXXHeader: case TY_PP_ObjCXXHeader:
151 case TY_CXXModule: case TY_PP_CXXModule:
152 case TY_AST: case TY_ModuleFile: case TY_PCH:
153 case TY_LLVM_IR: case TY_LLVM_BC:
154 case TY_API_INFO:
155 return true;
156 }
157}
158
159bool types::isAcceptedByFlang(ID Id) {
160 switch (Id) {
161 default:
162 return false;
163
164 case TY_Fortran:
165 case TY_PP_Fortran:
166 return true;
167 case TY_LLVM_IR:
168 case TY_LLVM_BC:
169 return true;
170 case TY_PP_CUDA:
171 case TY_CUDA:
172 return true;
173 }
174}
175
176bool types::isDerivedFromC(ID Id) {
177 switch (Id) {
178 default:
179 return false;
180
181 case TY_PP_C:
182 case TY_C:
183 case TY_CL:
184 case TY_PP_CL:
185 case TY_CLCXX:
186 case TY_PP_CLCXX:
187 case TY_PP_CUDA:
188 case TY_CUDA:
189 case TY_CUDA_DEVICE:
190 case TY_PP_HIP:
191 case TY_HIP:
192 case TY_HIP_DEVICE:
193 case TY_PP_ObjC:
194 case TY_PP_ObjC_Alias:
195 case TY_ObjC:
196 case TY_PP_CXX:
197 case TY_CXX:
198 case TY_PP_ObjCXX:
199 case TY_PP_ObjCXX_Alias:
200 case TY_ObjCXX:
201 case TY_PP_CHeader:
202 case TY_CHeader:
203 case TY_CLHeader:
204 case TY_PP_ObjCHeader:
205 case TY_ObjCHeader:
206 case TY_PP_CXXHeader:
207 case TY_CXXHeader:
208 case TY_PP_ObjCXXHeader:
209 case TY_ObjCXXHeader:
210 case TY_CXXModule:
211 case TY_PP_CXXModule:
212 return true;
213 }
214}
215
216bool types::isObjC(ID Id) {
217 switch (Id) {
218 default:
219 return false;
220
221 case TY_ObjC: case TY_PP_ObjC: case TY_PP_ObjC_Alias:
222 case TY_ObjCXX: case TY_PP_ObjCXX:
223 case TY_ObjCHeader: case TY_PP_ObjCHeader:
224 case TY_ObjCXXHeader: case TY_PP_ObjCXXHeader: case TY_PP_ObjCXX_Alias:
225 return true;
226 }
227}
228
229bool types::isOpenCL(ID Id) { return Id == TY_CL || Id == TY_CLCXX; }
230
231bool types::isCXX(ID Id) {
232 switch (Id) {
233 default:
234 return false;
235
236 case TY_CXX: case TY_PP_CXX:
237 case TY_ObjCXX: case TY_PP_ObjCXX: case TY_PP_ObjCXX_Alias:
238 case TY_CXXHeader: case TY_PP_CXXHeader:
239 case TY_CXXSHeader:
240 case TY_CXXUHeader:
241 case TY_CXXHUHeader:
242 case TY_PP_CXXHeaderUnit:
243 case TY_ObjCXXHeader: case TY_PP_ObjCXXHeader:
244 case TY_CXXModule:
245 case TY_PP_CXXModule:
246 case TY_ModuleFile:
247 case TY_PP_CLCXX:
248 case TY_CUDA: case TY_PP_CUDA: case TY_CUDA_DEVICE:
249 case TY_HIP:
250 case TY_PP_HIP:
251 case TY_HIP_DEVICE:
252 return true;
253 }
254}
255
256bool types::isLLVMIR(ID Id) {
257 switch (Id) {
258 default:
259 return false;
260
261 case TY_LLVM_IR:
262 case TY_LLVM_BC:
263 case TY_LTO_IR:
264 case TY_LTO_BC:
265 return true;
266 }
267}
268
269bool types::isCuda(ID Id) {
270 switch (Id) {
271 default:
272 return false;
273
274 case TY_CUDA:
275 case TY_PP_CUDA:
276 case TY_CUDA_DEVICE:
277 return true;
278 }
279}
280
281bool types::isHIP(ID Id) {
282 switch (Id) {
283 default:
284 return false;
285
286 case TY_HIP:
287 case TY_PP_HIP:
288 case TY_HIP_DEVICE:
289 return true;
290 }
291}
292
293bool types::isHLSL(ID Id) { return Id == TY_HLSL; }
294
295bool types::isSrcFile(ID Id) {
296 return Id != TY_Object && getPreprocessedType(Id) != TY_INVALID;
297}
298
299types::ID types::lookupTypeForExtension(llvm::StringRef Ext) {
300 return llvm::StringSwitch<types::ID>(Ext)
301 .Case("c", TY_C)
302 .Case("C", TY_CXX)
303 .Case("F", TY_Fortran)
304 .Case("f", TY_PP_Fortran)
305 .Case("h", TY_CHeader)
306 .Case("H", TY_CXXHeader)
307 .Case("i", TY_PP_C)
308 .Case("m", TY_ObjC)
309 .Case("M", TY_ObjCXX)
310 .Case("o", TY_Object)
311 .Case("S", TY_Asm)
312 .Case("s", TY_PP_Asm)
313 .Case("bc", TY_LLVM_BC)
314 .Case("cc", TY_CXX)
315 .Case("CC", TY_CXX)
316 .Case("cl", TY_CL)
317 .Case("cli", TY_PP_CL)
318 .Case("clcpp", TY_CLCXX)
319 .Case("clii", TY_PP_CLCXX)
320 .Case("cp", TY_CXX)
321 .Case("cu", TY_CUDA)
322 .Case("hh", TY_CXXHeader)
323 .Case("ii", TY_PP_CXX)
324 .Case("ll", TY_LLVM_IR)
325 .Case("mi", TY_PP_ObjC)
326 .Case("mm", TY_ObjCXX)
327 .Case("adb", TY_Ada)
328 .Case("ads", TY_Ada)
329 .Case("asm", TY_PP_Asm)
330 .Case("ast", TY_AST)
331 .Case("ccm", TY_CXXModule)
332 .Case("cpp", TY_CXX)
333 .Case("CPP", TY_CXX)
334 .Case("c++", TY_CXX)
335 .Case("C++", TY_CXX)
336 .Case("cui", TY_PP_CUDA)
337 .Case("cxx", TY_CXX)
338 .Case("CXX", TY_CXX)
339 .Case("F03", TY_Fortran)
340 .Case("f03", TY_PP_Fortran)
341 .Case("F08", TY_Fortran)
342 .Case("f08", TY_PP_Fortran)
343 .Case("F90", TY_Fortran)
344 .Case("f90", TY_PP_Fortran)
345 .Case("F95", TY_Fortran)
346 .Case("f95", TY_PP_Fortran)
347 .Case("for", TY_PP_Fortran)
348 .Case("FOR", TY_PP_Fortran)
349 .Case("fpp", TY_Fortran)
350 .Case("FPP", TY_Fortran)
351 .Case("gch", TY_PCH)
352 .Case("hip", TY_HIP)
353 .Case("hipi", TY_PP_HIP)
354 .Case("hpp", TY_CXXHeader)
355 .Case("hxx", TY_CXXHeader)
356 .Case("iim", TY_PP_CXXModule)
357 .Case("iih", TY_PP_CXXHeaderUnit)
358 .Case("lib", TY_Object)
359 .Case("mii", TY_PP_ObjCXX)
360 .Case("obj", TY_Object)
361 .Case("ifs", TY_IFS)
362 .Case("pch", TY_PCH)
363 .Case("pcm", TY_ModuleFile)
364 .Case("c++m", TY_CXXModule)
365 .Case("cppm", TY_CXXModule)
366 .Case("cxxm", TY_CXXModule)
367 .Case("hlsl", TY_HLSL)
368 .Default(TY_INVALID);
369}
370
371