clang  16.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"
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;
27  class PhasesBitSet {
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); }
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 = std::size(TypeInfos);
46 
47 static const TypeInfo &getInfo(unsigned id) {
48  assert(id > 0 && id - 1 < numTypes && "Invalid Type ID.");
49  return TypeInfos[id - 1];
50 }
51 
52 const 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 
83 const 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 
228 bool 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 
289 bool 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("F90", TY_Fortran)
335  .Case("f90", TY_PP_Fortran)
336  .Case("F95", TY_Fortran)
337  .Case("f95", TY_PP_Fortran)
338  .Case("for", TY_PP_Fortran)
339  .Case("FOR", TY_PP_Fortran)
340  .Case("fpp", TY_Fortran)
341  .Case("FPP", TY_Fortran)
342  .Case("gch", TY_PCH)
343  .Case("hip", TY_HIP)
344  .Case("hpp", TY_CXXHeader)
345  .Case("hxx", TY_CXXHeader)
346  .Case("iim", TY_PP_CXXModule)
347  .Case("iih", TY_PP_CXXHeaderUnit)
348  .Case("lib", TY_Object)
349  .Case("mii", TY_PP_ObjCXX)
350  .Case("obj", TY_Object)
351  .Case("ifs", TY_IFS)
352  .Case("pch", TY_PCH)
353  .Case("pcm", TY_ModuleFile)
354  .Case("c++m", TY_CXXModule)
355  .Case("cppm", TY_CXXModule)
356  .Case("cxxm", TY_CXXModule)
357  .Case("hlsl", TY_HLSL)
358  .Default(TY_INVALID);
359 }
360 
362  for (unsigned i=0; i<numTypes; ++i) {
363  types::ID Id = (types::ID) (i + 1);
364  if (canTypeBeUserSpecified(Id) &&
365  strcmp(Name, getInfo(Id).Name) == 0)
366  return Id;
367  }
368  // Accept "cu" as an alias for "cuda" for NVCC compatibility
369  if (strcmp(Name, "cu") == 0) {
370  return types::TY_CUDA;
371  }
372  return TY_INVALID;
373 }
374 
378  const auto &Info = getInfo(Id);
379  for (int I = 0; I <= LastPhase; ++I)
380  if (Info.Phases.contains(static_cast<phases::ID>(I)))
381  P.push_back(static_cast<phases::ID>(I));
382  assert(P.size() <= phases::MaxNumberOfPhases && "Too many phases in list");
383  return P;
384 }
385 
388  llvm::opt::DerivedArgList &DAL, ID Id) {
390 }
391 
393  switch (Id) {
394  default:
395  return Id;
396 
397  case types::TY_C:
398  return types::TY_CXX;
399  case types::TY_PP_C:
400  return types::TY_PP_CXX;
401  case types::TY_CHeader:
402  return types::TY_CXXHeader;
403  case types::TY_PP_CHeader:
404  return types::TY_PP_CXXHeader;
405  }
406 }
407 
409  switch (Id) {
410  default:
411  return Id;
412 
413  // FIXME: Handle preprocessed input types.
414  case types::TY_C:
415  return types::TY_CHeader;
416  case types::TY_CXX:
417  case types::TY_CXXModule:
418  return types::TY_CXXHeader;
419  case types::TY_ObjC:
420  return types::TY_ObjCHeader;
421  case types::TY_ObjCXX:
422  return types::TY_ObjCXXHeader;
423  case types::TY_CL:
424  case types::TY_CLCXX:
425  return types::TY_CLHeader;
426  }
427 }
isPreprocessedModuleType
static bool isPreprocessedModuleType(ID Id)
Definition: Types.cpp:64
clang::driver::types::isHLSL
bool isHLSL(ID Id)
isHLSL - Is this an HLSL input.
Definition: Types.cpp:289
TypeInfo::Name
const char * Name
Definition: Types.cpp:24
TypeInfo::PhasesBitSet
Definition: Types.cpp:27
clang::driver::types::isCuda
bool isCuda(ID Id)
isCuda - Is this a CUDA input.
Definition: Types.cpp:265
Driver.h
clang::driver::types::getCompilationPhases
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:376
isPreprocessedHeaderUnitType
static bool isPreprocessedHeaderUnitType(ID Id)
Definition: Types.cpp:68
llvm::SmallVector
Definition: LLVM.h:38
clang::driver::phases::Preprocess
@ Preprocess
Definition: Phases.h:18
TypeInfo::TempSuffix
const char * TempSuffix
Definition: Types.cpp:25
TypeInfos
static constexpr TypeInfo TypeInfos[]
Definition: Types.cpp:39
clang::driver::phases::ID
ID
ID - Ordered values for successive stages in the compilation process which interact with user options...
Definition: Phases.h:17
TypeInfo::PhasesBitSet::contains
bool contains(phases::ID Id) const
Definition: Types.cpp:35
TypeInfo
Definition: Types.cpp:23
clang::driver::types::isAcceptedByClang
bool isAcceptedByClang(ID Id)
isAcceptedByClang - Can clang handle this input type.
Definition: Types.cpp:129
clang::driver::types::getPrecompiledType
ID getPrecompiledType(ID Id)
getPrecompiledType - Get the ID of the type for this input when it has been precompiled,...
Definition: Types.cpp:73
clang::driver::types::isCXX
bool isCXX(ID Id)
isCXX - Is this a "C++" input (C++ and Obj-C++ sources and headers).
Definition: Types.cpp:230
clang::driver::types::lookupTypeForExtension
ID lookupTypeForExtension(llvm::StringRef Ext)
lookupTypeForExtension - Lookup the type to use for the file extension Ext.
Definition: Types.cpp:295
clang::driver::types::onlyPrecompileType
bool onlyPrecompileType(ID Id)
onlyPrecompileType - Should this type only be precompiled.
Definition: Types.cpp:100
TypeInfo::PreprocessedType
ID PreprocessedType
Definition: Types.cpp:26
numTypes
static const unsigned numTypes
Definition: Types.cpp:45
Options.h
Id
int Id
Definition: ASTDiff.cpp:191
clang::driver::types::lookupTypeForTypeSpecifier
ID lookupTypeForTypeSpecifier(const char *Name)
lookupTypeForTypSpecifier - Lookup the type to use for a user specified type name.
Definition: Types.cpp:361
DriverDiagnostic.h
clang::driver::types::TY_INVALID
@ TY_INVALID
Definition: Types.h:24
clang::driver::types::isSrcFile
bool isSrcFile(ID Id)
isSrcFile - Is this a source file, i.e.
Definition: Types.cpp:291
clang::driver::types::isObjC
bool isObjC(ID Id)
isObjC - Is this an "ObjC" input (Obj-C and Obj-C++ sources and headers).
Definition: Types.cpp:215
clang::driver::types::appendSuffixForType
bool appendSuffixForType(ID Id)
appendSuffixForType - When generating outputs of this type, should the suffix be appended (instead of...
Definition: Types.cpp:117
clang::driver::types::isLLVMIR
bool isLLVMIR(ID Id)
Is this LLVM IR.
Definition: Types.cpp:252
TypeInfo::PhasesBitSet::PhasesBitSet
constexpr PhasesBitSet(std::initializer_list< phases::ID > Phases)
Definition: Types.cpp:31
clang::driver::types::canTypeBeUserSpecified
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
clang::driver::Driver::getFinalPhase
phases::ID getFinalPhase(const llvm::opt::DerivedArgList &DAL, llvm::opt::Arg **FinalPhaseArg=nullptr) const
Definition: Driver.cpp:336
clang::driver::types::isOpenCL
bool isOpenCL(ID Id)
isOpenCL - Is this an "OpenCL" input.
Definition: Types.cpp:228
P
StringRef P
Definition: ASTMatchersInternal.cpp:563
clang::driver::types::isAcceptedByFlang
bool isAcceptedByFlang(ID Id)
isAcceptedByFlang - Can flang handle this input type.
Definition: Types.cpp:162
clang::driver::types::canLipoType
bool canLipoType(ID Id)
canLipoType - Is this type acceptable as the output of a universal build (currently,...
Definition: Types.cpp:122
clang::driver::types::getTypeTempSuffix
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
getInfo
static const TypeInfo & getInfo(unsigned id)
Definition: Types.cpp:47
clang::driver::types::ID
ID
Definition: Types.h:23
clang::driver::types::isDerivedFromC
bool isDerivedFromC(ID Id)
isDerivedFromC - Is the input derived from C.
Definition: Types.cpp:176
clang::driver::types
Definition: Types.h:22
clang::driver::phases::Precompile
@ Precompile
Definition: Phases.h:19
clang::driver::Driver
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:72
clang::driver::types::lookupCXXTypeForCType
ID lookupCXXTypeForCType(ID Id)
lookupCXXTypeForCType - Lookup CXX input type that corresponds to given C type (used for clang++ emul...
Definition: Types.cpp:392
clang::driver::phases::MaxNumberOfPhases
@ MaxNumberOfPhases
Definition: Phases.h:28
clang::driver::types::isHIP
bool isHIP(ID Id)
isHIP - Is this a HIP input.
Definition: Types.cpp:277
Types.h
clang::driver::types::getPreprocessedType
ID getPreprocessedType(ID Id)
getPreprocessedType - Get the ID of the type for this input when it has been preprocessed,...
Definition: Types.cpp:56
TypeInfo::Phases
class TypeInfo::PhasesBitSet Phases
clang::driver
Definition: Action.h:31
clang::driver::types::getTypeName
const char * getTypeName(ID Id)
getTypeName - Return the name of the type for Id.
Definition: Types.cpp:52
clang::driver::types::lookupHeaderTypeForSourceType
ID lookupHeaderTypeForSourceType(ID Id)
Lookup header file input type that corresponds to given source file type (used for clang-cl emulation...
Definition: Types.cpp:408