clang 17.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
10#include "clang/Driver/Driver.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
20using namespace clang::driver;
21using namespace clang::driver::types;
22
23struct TypeInfo {
24 const char *Name;
25 const char *TempSuffix;
28 unsigned Bits = 0;
29
30 public:
31 constexpr PhasesBitSet(std::initializer_list<phases::ID> Phases) {
32 for (auto Id : Phases)
33 Bits |= 1 << Id;
34 }
35 bool contains(phases::ID Id) const { return Bits & (1 << Id); }
37};
38
39static 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};
45static const unsigned numTypes = std::size(TypeInfos);
46
47static const TypeInfo &getInfo(unsigned id) {
48 assert(id > 0 && id - 1 < numTypes && "Invalid Type ID.");
49 return TypeInfos[id - 1];
50}
51
52const char *types::getTypeName(ID Id) {
53 return getInfo(Id).Name;
54}
55
58 assert((getInfo(Id).Phases.contains(phases::Preprocess) !=
59 (PPT == TY_INVALID)) &&
60 "Unexpected Preprocess Type.");
61 return PPT;
62}
63
65 return Id == TY_CXXModule || Id == TY_PP_CXXModule;
66}
67
69 return Id == TY_CXXSHeader || Id == TY_CXXUHeader || Id == TY_CXXHUHeader ||
70 Id == TY_PP_CXXHeaderUnit;
71}
72
75 return TY_ModuleFile;
77 return TY_HeaderUnit;
79 return TY_PCH;
80 return TY_INVALID;
81}
82
83const char *types::getTypeTempSuffix(ID Id, bool CLMode) {
84 if (CLMode) {
85 switch (Id) {
86 case TY_Object:
87 case TY_LTO_BC:
88 return "obj";
89 case TY_Image:
90 return "exe";
91 case TY_PP_Asm:
92 return "asm";
93 default:
94 break;
95 }
96 }
97 return getInfo(Id).TempSuffix;
98}
99
103}
104
106 static const clang::driver::types::ID kStaticLangageTypes[] = {
107 TY_CUDA_DEVICE, TY_HIP_DEVICE, TY_PP_CHeader,
108 TY_PP_ObjCHeader, TY_PP_CXXHeader, TY_PP_ObjCXXHeader,
109 TY_PP_CXXModule, TY_LTO_IR, TY_LTO_BC,
110 TY_Plist, TY_RewrittenObjC, TY_RewrittenLegacyObjC,
111 TY_Remap, TY_PCH, TY_Object,
112 TY_Image, TY_dSYM, TY_Dependencies,
113 TY_CUDA_FATBIN, TY_HIP_FATBIN};
114 return !llvm::is_contained(kStaticLangageTypes, Id);
115}
116
118 return Id == TY_PCH || Id == TY_dSYM || Id == TY_CUDA_FATBIN ||
119 Id == TY_HIP_FATBIN;
120}
121
123 return (Id == TY_Nothing ||
124 Id == TY_Image ||
125 Id == TY_Object ||
126 Id == TY_LTO_BC);
127}
128
130 switch (Id) {
131 default:
132 return false;
133
134 case TY_Asm:
135 case TY_C: case TY_PP_C:
136 case TY_CL: case TY_CLCXX:
137 case TY_CUDA: case TY_PP_CUDA:
138 case TY_CUDA_DEVICE:
139 case TY_HIP:
140 case TY_PP_HIP:
141 case TY_HIP_DEVICE:
142 case TY_ObjC: case TY_PP_ObjC: case TY_PP_ObjC_Alias:
143 case TY_CXX: case TY_PP_CXX:
144 case TY_ObjCXX: case TY_PP_ObjCXX: case TY_PP_ObjCXX_Alias:
145 case TY_CHeader: case TY_PP_CHeader:
146 case TY_CLHeader:
147 case TY_ObjCHeader: case TY_PP_ObjCHeader:
148 case TY_CXXHeader: case TY_PP_CXXHeader:
149 case TY_CXXSHeader:
150 case TY_CXXUHeader:
151 case TY_CXXHUHeader:
152 case TY_PP_CXXHeaderUnit:
153 case TY_ObjCXXHeader: case TY_PP_ObjCXXHeader:
154 case TY_CXXModule: case TY_PP_CXXModule:
155 case TY_AST: case TY_ModuleFile: case TY_PCH:
156 case TY_LLVM_IR: case TY_LLVM_BC:
157 case TY_API_INFO:
158 return true;
159 }
160}
161
163 switch (Id) {
164 default:
165 return false;
166
167 case TY_Fortran:
168 case TY_PP_Fortran:
169 return true;
170 case TY_LLVM_IR:
171 case TY_LLVM_BC:
172 return true;
173 }
174}
175
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_CLCXX:
185 case TY_PP_CUDA:
186 case TY_CUDA:
187 case TY_CUDA_DEVICE:
188 case TY_PP_HIP:
189 case TY_HIP:
190 case TY_HIP_DEVICE:
191 case TY_PP_ObjC:
192 case TY_PP_ObjC_Alias:
193 case TY_ObjC:
194 case TY_PP_CXX:
195 case TY_CXX:
196 case TY_PP_ObjCXX:
197 case TY_PP_ObjCXX_Alias:
198 case TY_ObjCXX:
199 case TY_RenderScript:
200 case TY_PP_CHeader:
201 case TY_CHeader:
202 case TY_CLHeader:
203 case TY_PP_ObjCHeader:
204 case TY_ObjCHeader:
205 case TY_PP_CXXHeader:
206 case TY_CXXHeader:
207 case TY_PP_ObjCXXHeader:
208 case TY_ObjCXXHeader:
209 case TY_CXXModule:
210 case TY_PP_CXXModule:
211 return true;
212 }
213}
214
216 switch (Id) {
217 default:
218 return false;
219
220 case TY_ObjC: case TY_PP_ObjC: case TY_PP_ObjC_Alias:
221 case TY_ObjCXX: case TY_PP_ObjCXX:
222 case TY_ObjCHeader: case TY_PP_ObjCHeader:
223 case TY_ObjCXXHeader: case TY_PP_ObjCXXHeader: case TY_PP_ObjCXX_Alias:
224 return true;
225 }
226}
227
228bool types::isOpenCL(ID Id) { return Id == TY_CL || Id == TY_CLCXX; }
229
231 switch (Id) {
232 default:
233 return false;
234
235 case TY_CXX: case TY_PP_CXX:
236 case TY_ObjCXX: case TY_PP_ObjCXX: case TY_PP_ObjCXX_Alias:
237 case TY_CXXHeader: case TY_PP_CXXHeader:
238 case TY_CXXSHeader:
239 case TY_CXXUHeader:
240 case TY_CXXHUHeader:
241 case TY_PP_CXXHeaderUnit:
242 case TY_ObjCXXHeader: case TY_PP_ObjCXXHeader:
243 case TY_CXXModule: case TY_PP_CXXModule:
244 case TY_CUDA: case TY_PP_CUDA: case TY_CUDA_DEVICE:
245 case TY_HIP:
246 case TY_PP_HIP:
247 case TY_HIP_DEVICE:
248 return true;
249 }
250}
251
253 switch (Id) {
254 default:
255 return false;
256
257 case TY_LLVM_IR:
258 case TY_LLVM_BC:
259 case TY_LTO_IR:
260 case TY_LTO_BC:
261 return true;
262 }
263}
264
266 switch (Id) {
267 default:
268 return false;
269
270 case TY_CUDA:
271 case TY_PP_CUDA:
272 case TY_CUDA_DEVICE:
273 return true;
274 }
275}
276
278 switch (Id) {
279 default:
280 return false;
281
282 case TY_HIP:
283 case TY_PP_HIP:
284 case TY_HIP_DEVICE:
285 return true;
286 }
287}
288
289bool types::isHLSL(ID Id) { return Id == TY_HLSL; }
290
292 return Id != TY_Object && getPreprocessedType(Id) != TY_INVALID;
293}
294
296 return llvm::StringSwitch<types::ID>(Ext)
297 .Case("c", TY_C)
298 .Case("C", TY_CXX)
299 .Case("F", TY_Fortran)
300 .Case("f", TY_PP_Fortran)
301 .Case("h", TY_CHeader)
302 .Case("H", TY_CXXHeader)
303 .Case("i", TY_PP_C)
304 .Case("m", TY_ObjC)
305 .Case("M", TY_ObjCXX)
306 .Case("o", TY_Object)
307 .Case("S", TY_Asm)
308 .Case("s", TY_PP_Asm)
309 .Case("bc", TY_LLVM_BC)
310 .Case("cc", TY_CXX)
311 .Case("CC", TY_CXX)
312 .Case("cl", TY_CL)
313 .Case("clcpp", TY_CLCXX)
314 .Case("cp", TY_CXX)
315 .Case("cu", TY_CUDA)
316 .Case("hh", TY_CXXHeader)
317 .Case("ii", TY_PP_CXX)
318 .Case("ll", TY_LLVM_IR)
319 .Case("mi", TY_PP_ObjC)
320 .Case("mm", TY_ObjCXX)
321 .Case("rs", TY_RenderScript)
322 .Case("adb", TY_Ada)
323 .Case("ads", TY_Ada)
324 .Case("asm", TY_PP_Asm)
325 .Case("ast", TY_AST)
326 .Case("ccm", TY_CXXModule)
327 .Case("cpp", TY_CXX)
328 .Case("CPP", TY_CXX)
329 .Case("c++", TY_CXX)
330 .Case("C++", TY_CXX)
331 .Case("cui", TY_PP_CUDA)
332 .Case("cxx", TY_CXX)
333 .Case("CXX", TY_CXX)
334 .Case("F03", TY_Fortran)
335 .Case("f03", TY_PP_Fortran)
336 .Case("F08", TY_Fortran)
337 .Case("f08", TY_PP_Fortran)
338 .Case("F90", TY_Fortran)
339 .Case("f90", TY_PP_Fortran)
340 .Case("F95", TY_Fortran)
341 .Case("f95", TY_PP_Fortran)
342 .Case("for", TY_PP_Fortran)
343 .Case("FOR", TY_PP_Fortran)
344 .Case("fpp", TY_Fortran)
345 .Case("FPP", TY_Fortran)
346 .Case("gch", TY_PCH)
347 .Case("hip", TY_HIP)
348 .Case("hipi", TY_PP_HIP)
349 .Case("hpp", TY_CXXHeader)
350 .Case("hxx", TY_CXXHeader)
351 .Case("iim", TY_PP_CXXModule)
352 .Case("iih", TY_PP_CXXHeaderUnit)
353 .Case("lib", TY_Object)
354 .Case("mii", TY_PP_ObjCXX)
355 .Case("obj", TY_Object)
356 .Case("ifs", TY_IFS)
357 .Case("pch", TY_PCH)
358 .Case("pcm", TY_ModuleFile)
359 .Case("c++m", TY_CXXModule)
360 .Case("cppm", TY_CXXModule)
361 .Case("cxxm", TY_CXXModule)
362 .Case("hlsl", TY_HLSL)
363 .Default(TY_INVALID);
364}
365
367 for (unsigned i=0; i<numTypes; ++i) {
368 types::ID Id = (types::ID) (i + 1);
370 strcmp(Name, getInfo(Id).Name) == 0)
371 return Id;
372 }
373 // Accept "cu" as an alias for "cuda" for NVCC compatibility
374 if (strcmp(Name, "cu") == 0) {
375 return types::TY_CUDA;
376 }
377 return TY_INVALID;
378}
379
383 const auto &Info = getInfo(Id);
384 for (int I = 0; I <= LastPhase; ++I)
385 if (Info.Phases.contains(static_cast<phases::ID>(I)))
386 P.push_back(static_cast<phases::ID>(I));
387 assert(P.size() <= phases::MaxNumberOfPhases && "Too many phases in list");
388 return P;
389}
390
393 llvm::opt::DerivedArgList &DAL, ID Id) {
395}
396
398 switch (Id) {
399 default:
400 return Id;
401
402 case types::TY_C:
403 return types::TY_CXX;
404 case types::TY_PP_C:
405 return types::TY_PP_CXX;
406 case types::TY_CHeader:
407 return types::TY_CXXHeader;
408 case types::TY_PP_CHeader:
409 return types::TY_PP_CXXHeader;
410 }
411}
412
414 switch (Id) {
415 default:
416 return Id;
417
418 // FIXME: Handle preprocessed input types.
419 case types::TY_C:
420 return types::TY_CHeader;
421 case types::TY_CXX:
422 case types::TY_CXXModule:
423 return types::TY_CXXHeader;
424 case types::TY_ObjC:
425 return types::TY_ObjCHeader;
426 case types::TY_ObjCXX:
427 return types::TY_ObjCXXHeader;
428 case types::TY_CL:
429 case types::TY_CLCXX:
430 return types::TY_CLHeader;
431 }
432}
int Id
Definition: ASTDiff.cpp:190
StringRef P
static constexpr TypeInfo TypeInfos[]
Definition: Types.cpp:39
static const TypeInfo & getInfo(unsigned id)
Definition: Types.cpp:47
static bool isPreprocessedHeaderUnitType(ID Id)
Definition: Types.cpp:68
static const unsigned numTypes
Definition: Types.cpp:45
static bool isPreprocessedModuleType(ID Id)
Definition: Types.cpp:64
constexpr PhasesBitSet(std::initializer_list< phases::ID > Phases)
Definition: Types.cpp:31
bool contains(phases::ID Id) const
Definition: Types.cpp:35
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:77
phases::ID getFinalPhase(const llvm::opt::DerivedArgList &DAL, llvm::opt::Arg **FinalPhaseArg=nullptr) const
Definition: Driver.cpp:357
ID
ID - Ordered values for successive stages in the compilation process which interact with user options...
Definition: Phases.h:17
ID lookupTypeForTypeSpecifier(const char *Name)
lookupTypeForTypSpecifier - Lookup the type to use for a user specified type name.
Definition: Types.cpp:366
bool isHLSL(ID Id)
isHLSL - Is this an HLSL input.
Definition: Types.cpp:289
const char * getTypeTempSuffix(ID Id, bool CLMode=false)
getTypeTempSuffix - Return the suffix to use when creating a temp file of this type,...
Definition: Types.cpp:83
bool isObjC(ID Id)
isObjC - Is this an "ObjC" input (Obj-C and Obj-C++ sources and headers).
Definition: Types.cpp:215
ID getPreprocessedType(ID Id)
getPreprocessedType - Get the ID of the type for this input when it has been preprocessed,...
Definition: Types.cpp:56
bool isCuda(ID Id)
isCuda - Is this a CUDA input.
Definition: Types.cpp:265
bool onlyPrecompileType(ID Id)
onlyPrecompileType - Should this type only be precompiled.
Definition: Types.cpp:100
bool isLLVMIR(ID Id)
Is this LLVM IR.
Definition: Types.cpp:252
const char * getTypeName(ID Id)
getTypeName - Return the name of the type for Id.
Definition: Types.cpp:52
bool isOpenCL(ID Id)
isOpenCL - Is this an "OpenCL" input.
Definition: Types.cpp:228
bool canTypeBeUserSpecified(ID Id)
canTypeBeUserSpecified - Can this type be specified on the command line (by the type name); this is u...
Definition: Types.cpp:105
llvm::SmallVector< phases::ID, phases::MaxNumberOfPhases > getCompilationPhases(ID Id, phases::ID LastPhase=phases::IfsMerge)
getCompilationPhases - Get the list of compilation phases ('Phases') to be done for type 'Id' up unti...
Definition: Types.cpp:381
bool isSrcFile(ID Id)
isSrcFile - Is this a source file, i.e.
Definition: Types.cpp:291
bool isDerivedFromC(ID Id)
isDerivedFromC - Is the input derived from C.
Definition: Types.cpp:176
ID lookupCXXTypeForCType(ID Id)
lookupCXXTypeForCType - Lookup CXX input type that corresponds to given C type (used for clang++ emul...
Definition: Types.cpp:397
ID getPrecompiledType(ID Id)
getPrecompiledType - Get the ID of the type for this input when it has been precompiled,...
Definition: Types.cpp:73
bool isHIP(ID Id)
isHIP - Is this a HIP input.
Definition: Types.cpp:277
bool isAcceptedByClang(ID Id)
isAcceptedByClang - Can clang handle this input type.
Definition: Types.cpp:129
bool appendSuffixForType(ID Id)
appendSuffixForType - When generating outputs of this type, should the suffix be appended (instead of...
Definition: Types.cpp:117
bool canLipoType(ID Id)
canLipoType - Is this type acceptable as the output of a universal build (currently,...
Definition: Types.cpp:122
ID lookupHeaderTypeForSourceType(ID Id)
Lookup header file input type that corresponds to given source file type (used for clang-cl emulation...
Definition: Types.cpp:413
ID lookupTypeForExtension(llvm::StringRef Ext)
lookupTypeForExtension - Lookup the type to use for the file extension Ext.
Definition: Types.cpp:295
bool isAcceptedByFlang(ID Id)
isAcceptedByFlang - Can flang handle this input type.
Definition: Types.cpp:162
bool isCXX(ID Id)
isCXX - Is this a "C++" input (C++ and Obj-C++ sources and headers).
Definition: Types.cpp:230
class TypeInfo::PhasesBitSet Phases
const char * TempSuffix
Definition: Types.cpp:25
ID PreprocessedType
Definition: Types.cpp:26
const char * Name
Definition: Types.cpp:24