clang  3.7.0
Types.cpp
Go to the documentation of this file.
1 //===--- Types.cpp - Driver input & temporary type information ------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "clang/Driver/Types.h"
11 #include "llvm/ADT/STLExtras.h"
12 #include "llvm/ADT/StringSwitch.h"
13 #include <cassert>
14 #include <string.h>
15 
16 using namespace clang::driver;
17 using namespace clang::driver::types;
18 
19 struct TypeInfo {
20  const char *Name;
21  const char *Flags;
22  const char *TempSuffix;
24 };
25 
26 static const TypeInfo TypeInfos[] = {
27 #define TYPE(NAME, ID, PP_TYPE, TEMP_SUFFIX, FLAGS) \
28  { NAME, FLAGS, TEMP_SUFFIX, TY_##PP_TYPE, },
29 #include "clang/Driver/Types.def"
30 #undef TYPE
31 };
32 static const unsigned numTypes = llvm::array_lengthof(TypeInfos);
33 
34 static const TypeInfo &getInfo(unsigned id) {
35  assert(id > 0 && id - 1 < numTypes && "Invalid Type ID.");
36  return TypeInfos[id - 1];
37 }
38 
39 const char *types::getTypeName(ID Id) {
40  return getInfo(Id).Name;
41 }
42 
44  return getInfo(Id).PreprocessedType;
45 }
46 
47 const char *types::getTypeTempSuffix(ID Id, bool CLMode) {
48  if (Id == TY_Object && CLMode)
49  return "obj";
50  if (Id == TY_Image && CLMode)
51  return "exe";
52  if (Id == TY_PP_Asm && CLMode)
53  return "asm";
54  return getInfo(Id).TempSuffix;
55 }
56 
58  return strchr(getInfo(Id).Flags, 'a');
59 }
60 
62  return strchr(getInfo(Id).Flags, 'p');
63 }
64 
66  return strchr(getInfo(Id).Flags, 'u');
67 }
68 
70  return strchr(getInfo(Id).Flags, 'A');
71 }
72 
74  return (Id == TY_Nothing ||
75  Id == TY_Image ||
76  Id == TY_Object ||
77  Id == TY_LTO_BC);
78 }
79 
81  switch (Id) {
82  default:
83  return false;
84 
85  case TY_Asm:
86  case TY_C: case TY_PP_C:
87  case TY_CL:
88  case TY_CUDA: case TY_PP_CUDA:
89  case TY_CUDA_DEVICE:
90  case TY_ObjC: case TY_PP_ObjC: case TY_PP_ObjC_Alias:
91  case TY_CXX: case TY_PP_CXX:
92  case TY_ObjCXX: case TY_PP_ObjCXX: case TY_PP_ObjCXX_Alias:
93  case TY_CHeader: case TY_PP_CHeader:
94  case TY_CLHeader:
95  case TY_ObjCHeader: case TY_PP_ObjCHeader:
96  case TY_CXXHeader: case TY_PP_CXXHeader:
97  case TY_ObjCXXHeader: case TY_PP_ObjCXXHeader:
98  case TY_AST: case TY_ModuleFile:
99  case TY_LLVM_IR: case TY_LLVM_BC:
100  return true;
101  }
102 }
103 
104 bool types::isObjC(ID Id) {
105  switch (Id) {
106  default:
107  return false;
108 
109  case TY_ObjC: case TY_PP_ObjC: case TY_PP_ObjC_Alias:
110  case TY_ObjCXX: case TY_PP_ObjCXX:
111  case TY_ObjCHeader: case TY_PP_ObjCHeader:
112  case TY_ObjCXXHeader: case TY_PP_ObjCXXHeader: case TY_PP_ObjCXX_Alias:
113  return true;
114  }
115 }
116 
117 bool types::isCXX(ID Id) {
118  switch (Id) {
119  default:
120  return false;
121 
122  case TY_CXX: case TY_PP_CXX:
123  case TY_ObjCXX: case TY_PP_ObjCXX: case TY_PP_ObjCXX_Alias:
124  case TY_CXXHeader: case TY_PP_CXXHeader:
125  case TY_ObjCXXHeader: case TY_PP_ObjCXXHeader:
126  case TY_CUDA: case TY_PP_CUDA: case TY_CUDA_DEVICE:
127  return true;
128  }
129 }
130 
131 bool types::isCuda(ID Id) {
132  switch (Id) {
133  default:
134  return false;
135 
136  case TY_CUDA:
137  case TY_PP_CUDA:
138  case TY_CUDA_DEVICE:
139  return true;
140  }
141 }
142 
144  return llvm::StringSwitch<types::ID>(Ext)
145  .Case("c", TY_C)
146  .Case("i", TY_PP_C)
147  .Case("m", TY_ObjC)
148  .Case("M", TY_ObjCXX)
149  .Case("h", TY_CHeader)
150  .Case("C", TY_CXX)
151  .Case("H", TY_CXXHeader)
152  .Case("f", TY_PP_Fortran)
153  .Case("F", TY_Fortran)
154  .Case("s", TY_PP_Asm)
155  .Case("asm", TY_PP_Asm)
156  .Case("S", TY_Asm)
157  .Case("o", TY_Object)
158  .Case("obj", TY_Object)
159  .Case("lib", TY_Object)
160  .Case("ii", TY_PP_CXX)
161  .Case("mi", TY_PP_ObjC)
162  .Case("mm", TY_ObjCXX)
163  .Case("bc", TY_LLVM_BC)
164  .Case("cc", TY_CXX)
165  .Case("CC", TY_CXX)
166  .Case("cl", TY_CL)
167  .Case("cp", TY_CXX)
168  .Case("cu", TY_CUDA)
169  .Case("cui", TY_PP_CUDA)
170  .Case("hh", TY_CXXHeader)
171  .Case("ll", TY_LLVM_IR)
172  .Case("hpp", TY_CXXHeader)
173  .Case("ads", TY_Ada)
174  .Case("adb", TY_Ada)
175  .Case("ast", TY_AST)
176  .Case("c++", TY_CXX)
177  .Case("C++", TY_CXX)
178  .Case("cxx", TY_CXX)
179  .Case("cpp", TY_CXX)
180  .Case("CPP", TY_CXX)
181  .Case("CXX", TY_CXX)
182  .Case("for", TY_PP_Fortran)
183  .Case("FOR", TY_PP_Fortran)
184  .Case("fpp", TY_Fortran)
185  .Case("FPP", TY_Fortran)
186  .Case("f90", TY_PP_Fortran)
187  .Case("f95", TY_PP_Fortran)
188  .Case("F90", TY_Fortran)
189  .Case("F95", TY_Fortran)
190  .Case("mii", TY_PP_ObjCXX)
191  .Case("pcm", TY_ModuleFile)
192  .Case("pch", TY_PCH)
193  .Case("gch", TY_PCH)
194  .Default(TY_INVALID);
195 }
196 
198  for (unsigned i=0; i<numTypes; ++i) {
199  types::ID Id = (types::ID) (i + 1);
200  if (canTypeBeUserSpecified(Id) &&
201  strcmp(Name, getInfo(Id).Name) == 0)
202  return Id;
203  }
204 
205  return TY_INVALID;
206 }
207 
208 // FIXME: Why don't we just put this list in the defs file, eh.
210  if (Id != TY_Object) {
211  if (getPreprocessedType(Id) != TY_INVALID) {
212  P.push_back(phases::Preprocess);
213  }
214 
215  if (onlyPrecompileType(Id)) {
216  P.push_back(phases::Precompile);
217  } else {
218  if (!onlyAssembleType(Id)) {
219  P.push_back(phases::Compile);
220  P.push_back(phases::Backend);
221  }
222  if (Id != TY_CUDA_DEVICE)
223  P.push_back(phases::Assemble);
224  }
225  }
226 
227  if (!onlyPrecompileType(Id) && Id != TY_CUDA_DEVICE) {
228  P.push_back(phases::Link);
229  }
230  assert(0 < P.size() && "Not enough phases in list");
231  assert(P.size() <= phases::MaxNumberOfPhases && "Too many phases in list");
232  return;
233 }
234 
236  switch (Id) {
237  default:
238  return Id;
239 
240  case types::TY_C:
241  return types::TY_CXX;
242  case types::TY_PP_C:
243  return types::TY_PP_CXX;
244  case types::TY_CHeader:
245  return types::TY_CXXHeader;
246  case types::TY_PP_CHeader:
247  return types::TY_PP_CXXHeader;
248  }
249 }
ID lookupTypeForExtension(const char *Ext)
Definition: Types.cpp:143
bool canLipoType(ID Id)
Definition: Types.cpp:73
const char * getTypeTempSuffix(ID Id, bool CLMode=false)
Definition: Types.cpp:47
bool onlyAssembleType(ID Id)
onlyAssembleType - Should this type only be assembled.
Definition: Types.cpp:57
bool canTypeBeUserSpecified(ID Id)
Definition: Types.cpp:65
ID lookupCXXTypeForCType(ID Id)
Definition: Types.cpp:235
const char * Flags
Definition: Types.cpp:21
const char * Name
Definition: Types.cpp:20
static const unsigned numTypes
Definition: Types.cpp:32
ID PreprocessedType
Definition: Types.cpp:23
AnnotatingParser & P
ID getPreprocessedType(ID Id)
Definition: Types.cpp:43
static const TypeInfo TypeInfos[]
Definition: Types.cpp:26
const char * getTypeName(ID Id)
getTypeName - Return the name of the type for Id.
Definition: Types.cpp:39
void getCompilationPhases(ID Id, llvm::SmallVectorImpl< phases::ID > &Phases)
Definition: Types.cpp:209
const char * TempSuffix
Definition: Types.cpp:22
bool isCuda(ID Id)
isCuda - Is this a CUDA input.
Definition: Types.cpp:131
bool isAcceptedByClang(ID Id)
isAcceptedByClang - Can clang handle this input type.
Definition: Types.cpp:80
static const TypeInfo & getInfo(unsigned id)
Definition: Types.cpp:34
bool isCXX(ID Id)
isCXX - Is this a "C++" input (C++ and Obj-C++ sources and headers).
Definition: Types.cpp:117
bool onlyPrecompileType(ID Id)
onlyPrecompileType - Should this type only be precompiled.
Definition: Types.cpp:61
bool appendSuffixForType(ID Id)
Definition: Types.cpp:69
ID lookupTypeForTypeSpecifier(const char *Name)
Definition: Types.cpp:197
bool isObjC(ID Id)
isObjC - Is this an "ObjC" input (Obj-C and Obj-C++ sources and headers).
Definition: Types.cpp:104