contrib/llvm/tools/clang/lib/Basic/Targets/WebAssembly.cpp

   1 //===--- WebAssembly.cpp - Implement WebAssembly target feature support ---===//
   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 // This file implements WebAssembly TargetInfo objects.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "WebAssembly.h"
  15 #include "Targets.h"
  16 #include "clang/Basic/Builtins.h"
  17 #include "clang/Basic/Diagnostic.h"
  18 #include "clang/Basic/TargetBuiltins.h"
  19 #include "llvm/ADT/StringSwitch.h"
  20
  21 using namespace clang;
  22 using namespace clang::targets;
  23
  24 const Builtin::Info WebAssemblyTargetInfo::BuiltinInfo[] = {
  25 #define BUILTIN(ID, TYPE, ATTRS)                                               \
  26   {#ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr},
  27 #define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE)                               \
  28   {#ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, FEATURE},
  29 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER)                                    \
  30   {#ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr},
  31 #include "clang/Basic/BuiltinsWebAssembly.def"
  32 };
  33
  34 static constexpr llvm::StringLiteral ValidCPUNames[] = {
  35     {"mvp"}, {"bleeding-edge"}, {"generic"}};
  36
  37 bool WebAssemblyTargetInfo::hasFeature(StringRef Feature) const {
  38   return llvm::StringSwitch<bool>(Feature)
  39       .Case("simd128", SIMDLevel >= SIMD128)
  40       .Case("unimplemented-simd128", SIMDLevel >= UnimplementedSIMD128)
  41       .Case("nontrapping-fptoint", HasNontrappingFPToInt)
  42       .Case("sign-ext", HasSignExt)
  43       .Case("exception-handling", HasExceptionHandling)
  44       .Default(false);
  45 }
  46
  47 bool WebAssemblyTargetInfo::isValidCPUName(StringRef Name) const {
  48   return llvm::find(ValidCPUNames, Name) != std::end(ValidCPUNames);
  49 }
  50
  51 void WebAssemblyTargetInfo::fillValidCPUList(
  52     SmallVectorImpl<StringRef> &Values) const {
  53   Values.append(std::begin(ValidCPUNames), std::end(ValidCPUNames));
  54 }
  55
  56 void WebAssemblyTargetInfo::getTargetDefines(const LangOptions &Opts,
  57                                              MacroBuilder &Builder) const {
  58   defineCPUMacros(Builder, "wasm", /*Tuning=*/false);
  59   if (SIMDLevel >= SIMD128)
  60     Builder.defineMacro("__wasm_simd128__");
  61   if (SIMDLevel >= UnimplementedSIMD128)
  62     Builder.defineMacro("__wasm_unimplemented_simd128__");
  63 }
  64
  65 void WebAssemblyTargetInfo::setSIMDLevel(llvm::StringMap<bool> &Features,
  66                                          SIMDEnum Level) {
  67   switch (Level) {
  68   case UnimplementedSIMD128:
  69     Features["unimplemented-simd128"] = true;
  70     LLVM_FALLTHROUGH;
  71   case SIMD128:
  72     Features["simd128"] = true;
  73     LLVM_FALLTHROUGH;
  74   case NoSIMD:
  75     break;
  76   }
  77 }
  78
  79 bool WebAssemblyTargetInfo::initFeatureMap(
  80     llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
  81     const std::vector<std::string> &FeaturesVec) const {
  82   if (CPU == "bleeding-edge") {
  83     Features["nontrapping-fptoint"] = true;
  84     Features["sign-ext"] = true;
  85     setSIMDLevel(Features, SIMD128);
  86   }
  87   // Other targets do not consider user-configured features here, but while we
  88   // are actively developing new features it is useful to let user-configured
  89   // features control availability of builtins
  90   setSIMDLevel(Features, SIMDLevel);
  91   if (HasNontrappingFPToInt)
  92     Features["nontrapping-fptoint"] = true;
  93   if (HasSignExt)
  94     Features["sign-ext"] = true;
  95   if (HasExceptionHandling)
  96     Features["exception-handling"] = true;
  97
  98   return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
  99 }
 100
 101 bool WebAssemblyTargetInfo::handleTargetFeatures(
 102     std::vector<std::string> &Features, DiagnosticsEngine &Diags) {
 103   for (const auto &Feature : Features) {
 104     if (Feature == "+simd128") {
 105       SIMDLevel = std::max(SIMDLevel, SIMD128);
 106       continue;
 107     }
 108     if (Feature == "-simd128") {
 109       SIMDLevel = std::min(SIMDLevel, SIMDEnum(SIMD128 - 1));
 110       continue;
 111     }
 112     if (Feature == "+unimplemented-simd128") {
 113       SIMDLevel = std::max(SIMDLevel, SIMDEnum(UnimplementedSIMD128));
 114       continue;
 115     }
 116     if (Feature == "-unimplemented-simd128") {
 117       SIMDLevel = std::min(SIMDLevel, SIMDEnum(UnimplementedSIMD128 - 1));
 118       continue;
 119     }
 120     if (Feature == "+nontrapping-fptoint") {
 121       HasNontrappingFPToInt = true;
 122       continue;
 123     }
 124     if (Feature == "-nontrapping-fptoint") {
 125       HasNontrappingFPToInt = false;
 126       continue;
 127     }
 128     if (Feature == "+sign-ext") {
 129       HasSignExt = true;
 130       continue;
 131     }
 132     if (Feature == "-sign-ext") {
 133       HasSignExt = false;
 134       continue;
 135     }
 136     if (Feature == "+exception-handling") {
 137       HasExceptionHandling = true;
 138       continue;
 139     }
 140     if (Feature == "-exception-handling") {
 141       HasExceptionHandling = false;
 142       continue;
 143     }
 144
 145     Diags.Report(diag::err_opt_not_valid_with_opt)
 146         << Feature << "-target-feature";
 147     return false;
 148   }
 149   return true;
 150 }
 151
 152 ArrayRef<Builtin::Info> WebAssemblyTargetInfo::getTargetBuiltins() const {
 153   return llvm::makeArrayRef(BuiltinInfo, clang::WebAssembly::LastTSBuiltin -
 154                                              Builtin::FirstTSBuiltin);
 155 }
 156
 157 void WebAssembly32TargetInfo::getTargetDefines(const LangOptions &Opts,
 158                                                MacroBuilder &Builder) const {
 159   WebAssemblyTargetInfo::getTargetDefines(Opts, Builder);
 160   defineCPUMacros(Builder, "wasm32", /*Tuning=*/false);
 161 }
 162
 163 void WebAssembly64TargetInfo::getTargetDefines(const LangOptions &Opts,
 164                                                MacroBuilder &Builder) const {
 165   WebAssemblyTargetInfo::getTargetDefines(Opts, Builder);
 166   defineCPUMacros(Builder, "wasm64", /*Tuning=*/false);
 167 }