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:
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 
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 
64 static bool isPreprocessedModuleType(ID Id) {
65   return Id == TY_CXXModule || Id == TY_PP_CXXModule;
66 }
67 
68 static bool isPreprocessedHeaderUnitType(ID Id) {
69   return Id == TY_CXXSHeader || Id == TY_CXXUHeader || Id == TY_CXXHUHeader ||
70          Id == TY_PP_CXXHeaderUnit;
71 }
72 
73 types::ID types::getPrecompiledType(ID Id) {
74   if (isPreprocessedModuleType(Id))
75     return TY_ModuleFile;
76   if (isPreprocessedHeaderUnitType(Id))
77     return TY_HeaderUnit;
78   if (onlyPrecompileType(Id))
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 
100 bool types::onlyPrecompileType(ID Id) {
101   return getInfo(Id).Phases.contains(phases::Precompile) &&
102          !isPreprocessedModuleType(Id);
103 }
104 
105 bool types::canTypeBeUserSpecified(ID Id) {
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 
117 bool types::appendSuffixForType(ID Id) {
118   return Id == TY_PCH || Id == TY_dSYM || Id == TY_CUDA_FATBIN ||
119          Id == TY_HIP_FATBIN;
120 }
121 
122 bool types::canLipoType(ID Id) {
123   return (Id == TY_Nothing ||
124           Id == TY_Image ||
125           Id == TY_Object ||
126           Id == TY_LTO_BC);
127 }
128 
129 bool types::isAcceptedByClang(ID Id) {
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 
162 bool types::isAcceptedByFlang(ID Id) {
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 
176 bool 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_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 
215 bool types::isObjC(ID Id) {
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 
230 bool types::isCXX(ID Id) {
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 
252 bool types::isLLVMIR(ID Id) {
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 
265 bool types::isCuda(ID Id) {
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 
277 bool types::isHIP(ID Id) {
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 
291 bool types::isSrcFile(ID Id) {
292   return Id != TY_Object && getPreprocessedType(Id) != TY_INVALID;
293 }
294 
295 types::ID types::lookupTypeForExtension(llvm::StringRef Ext) {
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 
366 types::ID types::lookupTypeForTypeSpecifier(const char *Name) {
367   for (unsigned i=0; i<numTypes; ++i) {
368     types::ID Id = (types::ID) (i + 1);
369     if (canTypeBeUserSpecified(Id) &&
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 
380 llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases>
381 types::getCompilationPhases(ID Id, phases::ID LastPhase) {
382   llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> P;
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 
391 llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases>
392 types::getCompilationPhases(const clang::driver::Driver &Driver,
393                             llvm::opt::DerivedArgList &DAL, ID Id) {
394   return types::getCompilationPhases(Id, Driver.getFinalPhase(DAL));
395 }
396 
397 ID types::lookupCXXTypeForCType(ID Id) {
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 
413 ID types::lookupHeaderTypeForSourceType(ID Id) {
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 }
433