clang/lib/Basic/Targets/WebAssembly.cpp

   1 //===--- WebAssembly.cpp - Implement WebAssembly target feature support ---===//
   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 // This file implements WebAssembly TargetInfo objects.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "WebAssembly.h"
  14 #include "Targets.h"
  15 #include "clang/Basic/Builtins.h"
  16 #include "clang/Basic/Diagnostic.h"
  17 #include "clang/Basic/TargetBuiltins.h"
  18 #include "llvm/ADT/StringSwitch.h"
  19
  20 using namespace clang;
  21 using namespace clang::targets;
  22
  23 const Builtin::Info WebAssemblyTargetInfo::BuiltinInfo[] = {
  24 #define BUILTIN(ID, TYPE, ATTRS)                                               \
  25   {#ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr},
  26 #define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE)                               \
  27   {#ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, FEATURE},
  28 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER)                                    \
  29   {#ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr},
  30 #include "clang/Basic/BuiltinsWebAssembly.def"
  31 };
  32
  33 static constexpr llvm::StringLiteral ValidCPUNames[] = {
  34     {"mvp"}, {"bleeding-edge"}, {"generic"}};
  35
  36 StringRef WebAssemblyTargetInfo::getABI() const { return ABI; }
  37
  38 bool WebAssemblyTargetInfo::setABI(const std::string &Name) {
  39   if (Name != "mvp" && Name != "experimental-mv")
  40     return false;
  41
  42   ABI = Name;
  43   return true;
  44 }
  45
  46 bool WebAssemblyTargetInfo::hasFeature(StringRef Feature) const {
  47   return llvm::StringSwitch<bool>(Feature)
  48       .Case("simd128", SIMDLevel >= SIMD128)
  49       .Case("relaxed-simd", SIMDLevel >= RelaxedSIMD)
  50       .Case("nontrapping-fptoint", HasNontrappingFPToInt)
  51       .Case("sign-ext", HasSignExt)
  52       .Case("exception-handling", HasExceptionHandling)
  53       .Case("bulk-memory", HasBulkMemory)
  54       .Case("atomics", HasAtomics)
  55       .Case("mutable-globals", HasMutableGlobals)
  56       .Case("multivalue", HasMultivalue)
  57       .Case("tail-call", HasTailCall)
  58       .Case("reference-types", HasReferenceTypes)
  59       .Case("extended-const", HasExtendedConst)
  60       .Default(false);
  61 }
  62
  63 bool WebAssemblyTargetInfo::isValidCPUName(StringRef Name) const {
  64   return llvm::is_contained(ValidCPUNames, Name);
  65 }
  66
  67 void WebAssemblyTargetInfo::fillValidCPUList(
  68     SmallVectorImpl<StringRef> &Values) const {
  69   Values.append(std::begin(ValidCPUNames), std::end(ValidCPUNames));
  70 }
  71
  72 void WebAssemblyTargetInfo::getTargetDefines(const LangOptions &Opts,
  73                                              MacroBuilder &Builder) const {
  74   defineCPUMacros(Builder, "wasm", /*Tuning=*/false);
  75   if (SIMDLevel >= SIMD128)
  76     Builder.defineMacro("__wasm_simd128__");
  77   if (SIMDLevel >= RelaxedSIMD)
  78     Builder.defineMacro("__wasm_relaxed_simd__");
  79   if (HasNontrappingFPToInt)
  80     Builder.defineMacro("__wasm_nontrapping_fptoint__");
  81   if (HasSignExt)
  82     Builder.defineMacro("__wasm_sign_ext__");
  83   if (HasExceptionHandling)
  84     Builder.defineMacro("__wasm_exception_handling__");
  85   if (HasBulkMemory)
  86     Builder.defineMacro("__wasm_bulk_memory__");
  87   if (HasAtomics)
  88     Builder.defineMacro("__wasm_atomics__");
  89   if (HasMutableGlobals)
  90     Builder.defineMacro("__wasm_mutable_globals__");
  91   if (HasMultivalue)
  92     Builder.defineMacro("__wasm_multivalue__");
  93   if (HasTailCall)
  94     Builder.defineMacro("__wasm_tail_call__");
  95   if (HasReferenceTypes)
  96     Builder.defineMacro("__wasm_reference_types__");
  97   if (HasExtendedConst)
  98     Builder.defineMacro("__wasm_extended_const__");
  99 }
 100
 101 void WebAssemblyTargetInfo::setSIMDLevel(llvm::StringMap<bool> &Features,
 102                                          SIMDEnum Level, bool Enabled) {
 103   if (Enabled) {
 104     switch (Level) {
 105     case RelaxedSIMD:
 106       Features["relaxed-simd"] = true;
 107       [[fallthrough]];
 108     case SIMD128:
 109       Features["simd128"] = true;
 110       [[fallthrough]];
 111     case NoSIMD:
 112       break;
 113     }
 114     return;
 115   }
 116
 117   switch (Level) {
 118   case NoSIMD:
 119   case SIMD128:
 120     Features["simd128"] = false;
 121     [[fallthrough]];
 122   case RelaxedSIMD:
 123     Features["relaxed-simd"] = false;
 124     break;
 125   }
 126 }
 127
 128 void WebAssemblyTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
 129                                               StringRef Name,
 130                                               bool Enabled) const {
 131   if (Name == "simd128")
 132     setSIMDLevel(Features, SIMD128, Enabled);
 133   else if (Name == "relaxed-simd")
 134     setSIMDLevel(Features, RelaxedSIMD, Enabled);
 135   else
 136     Features[Name] = Enabled;
 137 }
 138
 139 bool WebAssemblyTargetInfo::initFeatureMap(
 140     llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
 141     const std::vector<std::string> &FeaturesVec) const {
 142   if (CPU == "bleeding-edge") {
 143     Features["nontrapping-fptoint"] = true;
 144     Features["sign-ext"] = true;
 145     Features["bulk-memory"] = true;
 146     Features["atomics"] = true;
 147     Features["mutable-globals"] = true;
 148     Features["tail-call"] = true;
 149     setSIMDLevel(Features, SIMD128, true);
 150   }
 151
 152   return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
 153 }
 154
 155 bool WebAssemblyTargetInfo::handleTargetFeatures(
 156     std::vector<std::string> &Features, DiagnosticsEngine &Diags) {
 157   for (const auto &Feature : Features) {
 158     if (Feature == "+simd128") {
 159       SIMDLevel = std::max(SIMDLevel, SIMD128);
 160       continue;
 161     }
 162     if (Feature == "-simd128") {
 163       SIMDLevel = std::min(SIMDLevel, SIMDEnum(SIMD128 - 1));
 164       continue;
 165     }
 166     if (Feature == "+relaxed-simd") {
 167       SIMDLevel = std::max(SIMDLevel, RelaxedSIMD);
 168       continue;
 169     }
 170     if (Feature == "-relaxed-simd") {
 171       SIMDLevel = std::min(SIMDLevel, SIMDEnum(RelaxedSIMD - 1));
 172       continue;
 173     }
 174     if (Feature == "+nontrapping-fptoint") {
 175       HasNontrappingFPToInt = true;
 176       continue;
 177     }
 178     if (Feature == "-nontrapping-fptoint") {
 179       HasNontrappingFPToInt = false;
 180       continue;
 181     }
 182     if (Feature == "+sign-ext") {
 183       HasSignExt = true;
 184       continue;
 185     }
 186     if (Feature == "-sign-ext") {
 187       HasSignExt = false;
 188       continue;
 189     }
 190     if (Feature == "+exception-handling") {
 191       HasExceptionHandling = true;
 192       continue;
 193     }
 194     if (Feature == "-exception-handling") {
 195       HasExceptionHandling = false;
 196       continue;
 197     }
 198     if (Feature == "+bulk-memory") {
 199       HasBulkMemory = true;
 200       continue;
 201     }
 202     if (Feature == "-bulk-memory") {
 203       HasBulkMemory = false;
 204       continue;
 205     }
 206     if (Feature == "+atomics") {
 207       HasAtomics = true;
 208       continue;
 209     }
 210     if (Feature == "-atomics") {
 211       HasAtomics = false;
 212       continue;
 213     }
 214     if (Feature == "+mutable-globals") {
 215       HasMutableGlobals = true;
 216       continue;
 217     }
 218     if (Feature == "-mutable-globals") {
 219       HasMutableGlobals = false;
 220       continue;
 221     }
 222     if (Feature == "+multivalue") {
 223       HasMultivalue = true;
 224       continue;
 225     }
 226     if (Feature == "-multivalue") {
 227       HasMultivalue = false;
 228       continue;
 229     }
 230     if (Feature == "+tail-call") {
 231       HasTailCall = true;
 232       continue;
 233     }
 234     if (Feature == "-tail-call") {
 235       HasTailCall = false;
 236       continue;
 237     }
 238     if (Feature == "+reference-types") {
 239       HasReferenceTypes = true;
 240       continue;
 241     }
 242     if (Feature == "-reference-types") {
 243       HasReferenceTypes = false;
 244       continue;
 245     }
 246     if (Feature == "+extended-const") {
 247       HasExtendedConst = true;
 248       continue;
 249     }
 250     if (Feature == "-extended-const") {
 251       HasExtendedConst = false;
 252       continue;
 253     }
 254
 255     Diags.Report(diag::err_opt_not_valid_with_opt)
 256         << Feature << "-target-feature";
 257     return false;
 258   }
 259   return true;
 260 }
 261
 262 ArrayRef<Builtin::Info> WebAssemblyTargetInfo::getTargetBuiltins() const {
 263   return llvm::makeArrayRef(BuiltinInfo, clang::WebAssembly::LastTSBuiltin -
 264                                              Builtin::FirstTSBuiltin);
 265 }
 266
 267 void WebAssemblyTargetInfo::adjust(DiagnosticsEngine &Diags,
 268                                    LangOptions &Opts) {
 269   TargetInfo::adjust(Diags, Opts);
 270   // Turn off POSIXThreads and ThreadModel so that we don't predefine _REENTRANT
 271   // or __STDCPP_THREADS__ if we will eventually end up stripping atomics
 272   // because they are unsupported.
 273   if (!HasAtomics || !HasBulkMemory) {
 274     Opts.POSIXThreads = false;
 275     Opts.setThreadModel(LangOptions::ThreadModelKind::Single);
 276     Opts.ThreadsafeStatics = false;
 277   }
 278 }
 279
 280 void WebAssembly32TargetInfo::getTargetDefines(const LangOptions &Opts,
 281                                                MacroBuilder &Builder) const {
 282   WebAssemblyTargetInfo::getTargetDefines(Opts, Builder);
 283   defineCPUMacros(Builder, "wasm32", /*Tuning=*/false);
 284 }
 285
 286 void WebAssembly64TargetInfo::getTargetDefines(const LangOptions &Opts,
 287                                                MacroBuilder &Builder) const {
 288   WebAssemblyTargetInfo::getTargetDefines(Opts, Builder);
 289   defineCPUMacros(Builder, "wasm64", /*Tuning=*/false);
 290 }