clang/lib/Driver/Types.cpp

   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("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("hipi", TY_PP_HIP)
 345       .Case("hpp", TY_CXXHeader)
 346       .Case("hxx", TY_CXXHeader)
 347       .Case("iim", TY_PP_CXXModule)
 348       .Case("iih", TY_PP_CXXHeaderUnit)
 349       .Case("lib", TY_Object)
 350       .Case("mii", TY_PP_ObjCXX)
 351       .Case("obj", TY_Object)
 352       .Case("ifs", TY_IFS)
 353       .Case("pch", TY_PCH)
 354       .Case("pcm", TY_ModuleFile)
 355       .Case("c++m", TY_CXXModule)
 356       .Case("cppm", TY_CXXModule)
 357       .Case("cxxm", TY_CXXModule)
 358       .Case("hlsl", TY_HLSL)
 359       .Default(TY_INVALID);
 360 }
 361
 362 types::ID types::lookupTypeForTypeSpecifier(const char *Name) {
 363   for (unsigned i=0; i<numTypes; ++i) {
 364     types::ID Id = (types::ID) (i + 1);
 365     if (canTypeBeUserSpecified(Id) &&
 366         strcmp(Name, getInfo(Id).Name) == 0)
 367       return Id;
 368   }
 369   // Accept "cu" as an alias for "cuda" for NVCC compatibility
 370   if (strcmp(Name, "cu") == 0) {
 371     return types::TY_CUDA;
 372   }
 373   return TY_INVALID;
 374 }
 375
 376 llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases>
 377 types::getCompilationPhases(ID Id, phases::ID LastPhase) {
 378   llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> P;
 379   const auto &Info = getInfo(Id);
 380   for (int I = 0; I <= LastPhase; ++I)
 381     if (Info.Phases.contains(static_cast<phases::ID>(I)))
 382       P.push_back(static_cast<phases::ID>(I));
 383   assert(P.size() <= phases::MaxNumberOfPhases && "Too many phases in list");
 384   return P;
 385 }
 386
 387 llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases>
 388 types::getCompilationPhases(const clang::driver::Driver &Driver,
 389                             llvm::opt::DerivedArgList &DAL, ID Id) {
 390   return types::getCompilationPhases(Id, Driver.getFinalPhase(DAL));
 391 }
 392
 393 ID types::lookupCXXTypeForCType(ID Id) {
 394   switch (Id) {
 395   default:
 396     return Id;
 397
 398   case types::TY_C:
 399     return types::TY_CXX;
 400   case types::TY_PP_C:
 401     return types::TY_PP_CXX;
 402   case types::TY_CHeader:
 403     return types::TY_CXXHeader;
 404   case types::TY_PP_CHeader:
 405     return types::TY_PP_CXXHeader;
 406   }
 407 }
 408
 409 ID types::lookupHeaderTypeForSourceType(ID Id) {
 410   switch (Id) {
 411   default:
 412     return Id;
 413
 414   // FIXME: Handle preprocessed input types.
 415   case types::TY_C:
 416     return types::TY_CHeader;
 417   case types::TY_CXX:
 418   case types::TY_CXXModule:
 419     return types::TY_CXXHeader;
 420   case types::TY_ObjC:
 421     return types::TY_ObjCHeader;
 422   case types::TY_ObjCXX:
 423     return types::TY_ObjCXXHeader;
 424   case types::TY_CL:
 425   case types::TY_CLCXX:
 426     return types::TY_CLHeader;
 427   }
 428 }