Home | History | Annotate | Line # | Download | only in Driver 
      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 = llvm::array_lengthof(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 types::ID types::getPrecompiledType(ID Id) {
     69   if (isPreprocessedModuleType(Id))
     70     return TY_ModuleFile;
     71   if (onlyPrecompileType(Id))
     72     return TY_PCH;
     73   return TY_INVALID;
     74 }
     75 
     76 const char *types::getTypeTempSuffix(ID Id, bool CLMode) {
     77   if (CLMode) {
     78     switch (Id) {
     79     case TY_Object:
     80     case TY_LTO_BC:
     81       return "obj";
     82     case TY_Image:
     83       return "exe";
     84     case TY_PP_Asm:
     85       return "asm";
     86     default:
     87       break;
     88     }
     89   }
     90   return getInfo(Id).TempSuffix;
     91 }
     92 
     93 bool types::onlyPrecompileType(ID Id) {
     94   return getInfo(Id).Phases.contains(phases::Precompile) &&
     95          !isPreprocessedModuleType(Id);
     96 }
     97 
     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);
    108 }
    109 
    110 bool types::appendSuffixForType(ID Id) {
    111   return Id == TY_PCH || Id == TY_dSYM || Id == TY_CUDA_FATBIN ||
    112          Id == TY_HIP_FATBIN;
    113 }
    114 
    115 bool types::canLipoType(ID Id) {
    116   return (Id == TY_Nothing ||
    117           Id == TY_Image ||
    118           Id == TY_Object ||
    119           Id == TY_LTO_BC);
    120 }
    121 
    122 bool types::isAcceptedByClang(ID Id) {
    123   switch (Id) {
    124   default:
    125     return false;
    126 
    127   case TY_Asm:
    128   case TY_C: case TY_PP_C:
    129   case TY_CL: case TY_CLCXX:
    130   case TY_CUDA: case TY_PP_CUDA:
    131   case TY_CUDA_DEVICE:
    132   case TY_HIP:
    133   case TY_PP_HIP:
    134   case TY_HIP_DEVICE:
    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:
    139   case TY_CLHeader:
    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:
    146     return true;
    147   }
    148 }
    149 
    150 bool types::isObjC(ID Id) {
    151   switch (Id) {
    152   default:
    153     return false;
    154 
    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:
    159     return true;
    160   }
    161 }
    162 
    163 bool types::isOpenCL(ID Id) { return Id == TY_CL || Id == TY_CLCXX; }
    164 
    165 bool types::isCXX(ID Id) {
    166   switch (Id) {
    167   default:
    168     return false;
    169 
    170   case TY_CXX: case TY_PP_CXX:
    171   case TY_ObjCXX: case TY_PP_ObjCXX: case TY_PP_ObjCXX_Alias:
    172   case TY_CXXHeader: case TY_PP_CXXHeader:
    173   case TY_ObjCXXHeader: case TY_PP_ObjCXXHeader:
    174   case TY_CXXModule: case TY_PP_CXXModule:
    175   case TY_CUDA: case TY_PP_CUDA: case TY_CUDA_DEVICE:
    176   case TY_HIP:
    177   case TY_PP_HIP:
    178   case TY_HIP_DEVICE:
    179     return true;
    180   }
    181 }
    182 
    183 bool types::isLLVMIR(ID Id) {
    184   switch (Id) {
    185   default:
    186     return false;
    187 
    188   case TY_LLVM_IR:
    189   case TY_LLVM_BC:
    190   case TY_LTO_IR:
    191   case TY_LTO_BC:
    192     return true;
    193   }
    194 }
    195 
    196 bool types::isCuda(ID Id) {
    197   switch (Id) {
    198   default:
    199     return false;
    200 
    201   case TY_CUDA:
    202   case TY_PP_CUDA:
    203   case TY_CUDA_DEVICE:
    204     return true;
    205   }
    206 }
    207 
    208 bool types::isHIP(ID Id) {
    209   switch (Id) {
    210   default:
    211     return false;
    212 
    213   case TY_HIP:
    214   case TY_PP_HIP:
    215   case TY_HIP_DEVICE:
    216     return true;
    217   }
    218 }
    219 
    220 bool types::isFortran(ID Id) {
    221   switch (Id) {
    222   default:
    223     return false;
    224 
    225   case TY_Fortran: case TY_PP_Fortran:
    226     return true;
    227   }
    228 }
    229 
    230 bool types::isSrcFile(ID Id) {
    231   return Id != TY_Object && getPreprocessedType(Id) != TY_INVALID;
    232 }
    233 
    234 types::ID types::lookupTypeForExtension(llvm::StringRef Ext) {
    235   return llvm::StringSwitch<types::ID>(Ext)
    236            .Case("c", TY_C)
    237            .Case("C", TY_CXX)
    238            .Case("F", TY_Fortran)
    239            .Case("f", TY_PP_Fortran)
    240            .Case("h", TY_CHeader)
    241            .Case("H", TY_CXXHeader)
    242            .Case("i", TY_PP_C)
    243            .Case("m", TY_ObjC)
    244            .Case("M", TY_ObjCXX)
    245            .Case("o", TY_Object)
    246            .Case("S", TY_Asm)
    247            .Case("s", TY_PP_Asm)
    248            .Case("bc", TY_LLVM_BC)
    249            .Case("cc", TY_CXX)
    250            .Case("CC", TY_CXX)
    251            .Case("cl", TY_CL)
    252            .Case("clcpp", TY_CLCXX)
    253            .Case("cp", TY_CXX)
    254            .Case("cu", TY_CUDA)
    255            .Case("hh", TY_CXXHeader)
    256            .Case("ii", TY_PP_CXX)
    257            .Case("ll", TY_LLVM_IR)
    258            .Case("mi", TY_PP_ObjC)
    259            .Case("mm", TY_ObjCXX)
    260            .Case("rs", TY_RenderScript)
    261            .Case("adb", TY_Ada)
    262            .Case("ads", TY_Ada)
    263            .Case("asm", TY_PP_Asm)
    264            .Case("ast", TY_AST)
    265            .Case("ccm", TY_CXXModule)
    266            .Case("cpp", TY_CXX)
    267            .Case("CPP", TY_CXX)
    268            .Case("c++", TY_CXX)
    269            .Case("C++", TY_CXX)
    270            .Case("cui", TY_PP_CUDA)
    271            .Case("cxx", TY_CXX)
    272            .Case("CXX", TY_CXX)
    273            .Case("F90", TY_Fortran)
    274            .Case("f90", TY_PP_Fortran)
    275            .Case("F95", TY_Fortran)
    276            .Case("f95", TY_PP_Fortran)
    277            .Case("for", TY_PP_Fortran)
    278            .Case("FOR", TY_PP_Fortran)
    279            .Case("fpp", TY_Fortran)
    280            .Case("FPP", TY_Fortran)
    281            .Case("gch", TY_PCH)
    282            .Case("hip", TY_HIP)
    283            .Case("hpp", TY_CXXHeader)
    284            .Case("hxx", TY_CXXHeader)
    285            .Case("iim", TY_PP_CXXModule)
    286            .Case("lib", TY_Object)
    287            .Case("mii", TY_PP_ObjCXX)
    288            .Case("obj", TY_Object)
    289            .Case("ifs", TY_IFS)
    290            .Case("pch", TY_PCH)
    291            .Case("pcm", TY_ModuleFile)
    292            .Case("c++m", TY_CXXModule)
    293            .Case("cppm", TY_CXXModule)
    294            .Case("cxxm", TY_CXXModule)
    295            .Default(TY_INVALID);
    296 }
    297 
    298 types::ID types::lookupTypeForTypeSpecifier(const char *Name) {
    299   for (unsigned i=0; i<numTypes; ++i) {
    300     types::ID Id = (types::ID) (i + 1);
    301     if (canTypeBeUserSpecified(Id) &&
    302         strcmp(Name, getInfo(Id).Name) == 0)
    303       return Id;
    304   }
    305   // Accept "cu" as an alias for "cuda" for NVCC compatibility
    306   if (strcmp(Name, "cu") == 0) {
    307     return types::TY_CUDA;
    308   }
    309   return TY_INVALID;
    310 }
    311 
    312 llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases>
    313 types::getCompilationPhases(ID Id, phases::ID LastPhase) {
    314   llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> P;
    315   const auto &Info = getInfo(Id);
    316   for (int I = 0; I <= LastPhase; ++I)
    317     if (Info.Phases.contains(static_cast<phases::ID>(I)))
    318       P.push_back(static_cast<phases::ID>(I));
    319   assert(P.size() <= phases::MaxNumberOfPhases && "Too many phases in list");
    320   return P;
    321 }
    322 
    323 llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases>
    324 types::getCompilationPhases(const clang::driver::Driver &Driver,
    325                             llvm::opt::DerivedArgList &DAL, ID Id) {
    326   phases::ID LastPhase;
    327 
    328   // Filter to compiler mode. When the compiler is run as a preprocessor then
    329   // compilation is not an option.
    330   // -S runs the compiler in Assembly listing mode.
    331   if (Driver.CCCIsCPP() || DAL.getLastArg(options::OPT_E) ||
    332       DAL.getLastArg(options::OPT__SLASH_EP) ||
    333       DAL.getLastArg(options::OPT_M, options::OPT_MM) ||
    334       DAL.getLastArg(options::OPT__SLASH_P))
    335     LastPhase = phases::Preprocess;
    336 
    337   // --precompile only runs up to precompilation.
    338   // This is a clang extension and is not compatible with GCC.
    339   else if (DAL.getLastArg(options::OPT__precompile))
    340     LastPhase = phases::Precompile;
    341 
    342   // -{fsyntax-only,-analyze,emit-ast} only run up to the compiler.
    343   else if (DAL.getLastArg(options::OPT_fsyntax_only) ||
    344            DAL.getLastArg(options::OPT_print_supported_cpus) ||
    345            DAL.getLastArg(options::OPT_module_file_info) ||
    346            DAL.getLastArg(options::OPT_verify_pch) ||
    347            DAL.getLastArg(options::OPT_rewrite_objc) ||
    348            DAL.getLastArg(options::OPT_rewrite_legacy_objc) ||
    349            DAL.getLastArg(options::OPT__migrate) ||
    350            DAL.getLastArg(options::OPT__analyze) ||
    351            DAL.getLastArg(options::OPT_emit_ast))
    352     LastPhase = phases::Compile;
    353 
    354   else if (DAL.getLastArg(options::OPT_S) ||
    355            DAL.getLastArg(options::OPT_emit_llvm))
    356     LastPhase = phases::Backend;
    357 
    358   else if (DAL.getLastArg(options::OPT_c))
    359     LastPhase = phases::Assemble;
    360 
    361   // Generally means, do every phase until Link.
    362   else
    363     LastPhase = phases::LastPhase;
    364 
    365   return types::getCompilationPhases(Id, LastPhase);
    366 }
    367 
    368 ID types::lookupCXXTypeForCType(ID Id) {
    369   switch (Id) {
    370   default:
    371     return Id;
    372 
    373   case types::TY_C:
    374     return types::TY_CXX;
    375   case types::TY_PP_C:
    376     return types::TY_PP_CXX;
    377   case types::TY_CHeader:
    378     return types::TY_CXXHeader;
    379   case types::TY_PP_CHeader:
    380     return types::TY_PP_CXXHeader;
    381   }
    382 }
    383 
    384 ID types::lookupHeaderTypeForSourceType(ID Id) {
    385   switch (Id) {
    386   default:
    387     return Id;
    388 
    389   // FIXME: Handle preprocessed input types.
    390   case types::TY_C:
    391     return types::TY_CHeader;
    392   case types::TY_CXX:
    393   case types::TY_CXXModule:
    394     return types::TY_CXXHeader;
    395   case types::TY_ObjC:
    396     return types::TY_ObjCHeader;
    397   case types::TY_ObjCXX:
    398     return types::TY_ObjCXXHeader;
    399   case types::TY_CL:
    400   case types::TY_CLCXX:
    401     return types::TY_CLHeader;
    402   }
    403 }
    404