1 //===--- Types.cpp - Driver input & temporary type information ------------===//
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
7 //===----------------------------------------------------------------------===//
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"
20 using namespace clang::driver;
21 using namespace clang::driver::types;
25 const char *TempSuffix;
31 constexpr PhasesBitSet(std::initializer_list<phases::ID> Phases) {
32 for (auto Id : Phases)
35 bool contains(phases::ID Id) const { return Bits & (1 << Id); }
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"
45 static const unsigned numTypes = llvm::array_lengthof(TypeInfos);
47 static const TypeInfo &getInfo(unsigned id) {
48 assert(id > 0 && id - 1 < numTypes && "Invalid Type ID.");
49 return TypeInfos[id - 1];
52 const char *types::getTypeName(ID Id) {
53 return getInfo(Id).Name;
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.");
64 static bool isPreprocessedModuleType(ID Id) {
65 return Id == TY_CXXModule || Id == TY_PP_CXXModule;
68 types::ID types::getPrecompiledType(ID Id) {
69 if (isPreprocessedModuleType(Id))
71 if (onlyPrecompileType(Id))
76 const char *types::getTypeTempSuffix(ID Id, bool CLMode) {
90 return getInfo(Id).TempSuffix;
93 bool types::onlyPrecompileType(ID Id) {
94 return getInfo(Id).Phases.contains(phases::Precompile) &&
95 !isPreprocessedModuleType(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);
110 bool types::appendSuffixForType(ID Id) {
111 return Id == TY_PCH || Id == TY_dSYM || Id == TY_CUDA_FATBIN ||
115 bool types::canLipoType(ID Id) {
116 return (Id == TY_Nothing ||
122 bool types::isAcceptedByClang(ID Id) {
128 case TY_C: case TY_PP_C:
130 case TY_CUDA: case TY_PP_CUDA:
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:
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:
150 bool types::isObjC(ID Id) {
155 case TY_ObjC: case TY_PP_ObjC: case TY_PP_ObjC_Alias:
156 case TY_ObjCXX: case TY_PP_ObjCXX:
157 case TY_ObjCHeader: case TY_PP_ObjCHeader:
158 case TY_ObjCXXHeader: case TY_PP_ObjCXXHeader: case TY_PP_ObjCXX_Alias:
163 bool types::isCXX(ID Id) {
168 case TY_CXX: case TY_PP_CXX:
169 case TY_ObjCXX: case TY_PP_ObjCXX: case TY_PP_ObjCXX_Alias:
170 case TY_CXXHeader: case TY_PP_CXXHeader:
171 case TY_ObjCXXHeader: case TY_PP_ObjCXXHeader:
172 case TY_CXXModule: case TY_PP_CXXModule:
173 case TY_CUDA: case TY_PP_CUDA: case TY_CUDA_DEVICE:
181 bool types::isLLVMIR(ID Id) {
194 bool types::isCuda(ID Id) {
206 bool types::isHIP(ID Id) {
218 bool types::isFortran(ID Id) {
223 case TY_Fortran: case TY_PP_Fortran:
228 bool types::isSrcFile(ID Id) {
229 return Id != TY_Object && getPreprocessedType(Id) != TY_INVALID;
232 types::ID types::lookupTypeForExtension(llvm::StringRef Ext) {
233 return llvm::StringSwitch<types::ID>(Ext)
236 .Case("F", TY_Fortran)
237 .Case("f", TY_PP_Fortran)
238 .Case("h", TY_CHeader)
239 .Case("H", TY_CXXHeader)
242 .Case("M", TY_ObjCXX)
243 .Case("o", TY_Object)
245 .Case("s", TY_PP_Asm)
246 .Case("bc", TY_LLVM_BC)
252 .Case("hh", TY_CXXHeader)
253 .Case("ii", TY_PP_CXX)
254 .Case("ll", TY_LLVM_IR)
255 .Case("mi", TY_PP_ObjC)
256 .Case("mm", TY_ObjCXX)
257 .Case("rs", TY_RenderScript)
260 .Case("asm", TY_PP_Asm)
262 .Case("ccm", TY_CXXModule)
267 .Case("cui", TY_PP_CUDA)
270 .Case("F90", TY_Fortran)
271 .Case("f90", TY_PP_Fortran)
272 .Case("F95", TY_Fortran)
273 .Case("f95", TY_PP_Fortran)
274 .Case("for", TY_PP_Fortran)
275 .Case("FOR", TY_PP_Fortran)
276 .Case("fpp", TY_Fortran)
277 .Case("FPP", TY_Fortran)
280 .Case("hpp", TY_CXXHeader)
281 .Case("hxx", TY_CXXHeader)
282 .Case("iim", TY_PP_CXXModule)
283 .Case("lib", TY_Object)
284 .Case("mii", TY_PP_ObjCXX)
285 .Case("obj", TY_Object)
288 .Case("pcm", TY_ModuleFile)
289 .Case("c++m", TY_CXXModule)
290 .Case("cppm", TY_CXXModule)
291 .Case("cxxm", TY_CXXModule)
292 .Default(TY_INVALID);
295 types::ID types::lookupTypeForTypeSpecifier(const char *Name) {
296 for (unsigned i=0; i<numTypes; ++i) {
297 types::ID Id = (types::ID) (i + 1);
298 if (canTypeBeUserSpecified(Id) &&
299 strcmp(Name, getInfo(Id).Name) == 0)
302 // Accept "cu" as an alias for "cuda" for NVCC compatibility
303 if (strcmp(Name, "cu") == 0) {
304 return types::TY_CUDA;
309 llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases>
310 types::getCompilationPhases(ID Id, phases::ID LastPhase) {
311 llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> P;
312 const auto &Info = getInfo(Id);
313 for (int I = 0; I <= LastPhase; ++I)
314 if (Info.Phases.contains(static_cast<phases::ID>(I)))
315 P.push_back(static_cast<phases::ID>(I));
316 assert(P.size() <= phases::MaxNumberOfPhases && "Too many phases in list");
320 llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases>
321 types::getCompilationPhases(const clang::driver::Driver &Driver,
322 llvm::opt::DerivedArgList &DAL, ID Id) {
323 phases::ID LastPhase;
325 // Filter to compiler mode. When the compiler is run as a preprocessor then
326 // compilation is not an option.
327 // -S runs the compiler in Assembly listing mode.
328 if (Driver.CCCIsCPP() || DAL.getLastArg(options::OPT_E) ||
329 DAL.getLastArg(options::OPT__SLASH_EP) ||
330 DAL.getLastArg(options::OPT_M, options::OPT_MM) ||
331 DAL.getLastArg(options::OPT__SLASH_P))
332 LastPhase = phases::Preprocess;
334 // --precompile only runs up to precompilation.
335 // This is a clang extension and is not compatible with GCC.
336 else if (DAL.getLastArg(options::OPT__precompile))
337 LastPhase = phases::Precompile;
339 // -{fsyntax-only,-analyze,emit-ast} only run up to the compiler.
340 else if (DAL.getLastArg(options::OPT_fsyntax_only) ||
341 DAL.getLastArg(options::OPT_print_supported_cpus) ||
342 DAL.getLastArg(options::OPT_module_file_info) ||
343 DAL.getLastArg(options::OPT_verify_pch) ||
344 DAL.getLastArg(options::OPT_rewrite_objc) ||
345 DAL.getLastArg(options::OPT_rewrite_legacy_objc) ||
346 DAL.getLastArg(options::OPT__migrate) ||
347 DAL.getLastArg(options::OPT__analyze) ||
348 DAL.getLastArg(options::OPT_emit_ast))
349 LastPhase = phases::Compile;
351 else if (DAL.getLastArg(options::OPT_S) ||
352 DAL.getLastArg(options::OPT_emit_llvm))
353 LastPhase = phases::Backend;
355 else if (DAL.getLastArg(options::OPT_c))
356 LastPhase = phases::Assemble;
358 // Generally means, do every phase until Link.
360 LastPhase = phases::LastPhase;
362 return types::getCompilationPhases(Id, LastPhase);
365 ID types::lookupCXXTypeForCType(ID Id) {
371 return types::TY_CXX;
373 return types::TY_PP_CXX;
374 case types::TY_CHeader:
375 return types::TY_CXXHeader;
376 case types::TY_PP_CHeader:
377 return types::TY_PP_CXXHeader;
381 ID types::lookupHeaderTypeForSourceType(ID Id) {
386 // FIXME: Handle preprocessed input types.
388 return types::TY_CHeader;
390 case types::TY_CXXModule:
391 return types::TY_CXXHeader;
393 return types::TY_ObjCHeader;
394 case types::TY_ObjCXX:
395 return types::TY_ObjCXXHeader;
397 return types::TY_CLHeader;