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 static constexpr Builtin::Info BuiltinInfo[] = {
  24 #define BUILTIN(ID, TYPE, ATTRS)                                               \
  25   {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
  26 #define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE)                               \
  27   {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
  28 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER)                                    \
  29   {#ID, TYPE, ATTRS, nullptr, HeaderDesc::HEADER, ALL_LANGUAGES},
  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   Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
 101   Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
 102   Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
 103   Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
 104 }
 105
 106 void WebAssemblyTargetInfo::setSIMDLevel(llvm::StringMap<bool> &Features,
 107                                          SIMDEnum Level, bool Enabled) {
 108   if (Enabled) {
 109     switch (Level) {
 110     case RelaxedSIMD:
 111       Features["relaxed-simd"] = true;
 112       [[fallthrough]];
 113     case SIMD128:
 114       Features["simd128"] = true;
 115       [[fallthrough]];
 116     case NoSIMD:
 117       break;
 118     }
 119     return;
 120   }
 121
 122   switch (Level) {
 123   case NoSIMD:
 124   case SIMD128:
 125     Features["simd128"] = false;
 126     [[fallthrough]];
 127   case RelaxedSIMD:
 128     Features["relaxed-simd"] = false;
 129     break;
 130   }
 131 }
 132
 133 void WebAssemblyTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
 134                                               StringRef Name,
 135                                               bool Enabled) const {
 136   if (Name == "simd128")
 137     setSIMDLevel(Features, SIMD128, Enabled);
 138   else if (Name == "relaxed-simd")
 139     setSIMDLevel(Features, RelaxedSIMD, Enabled);
 140   else
 141     Features[Name] = Enabled;
 142 }
 143
 144 bool WebAssemblyTargetInfo::initFeatureMap(
 145     llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
 146     const std::vector<std::string> &FeaturesVec) const {
 147   if (CPU == "bleeding-edge") {
 148     Features["nontrapping-fptoint"] = true;
 149     Features["sign-ext"] = true;
 150     Features["bulk-memory"] = true;
 151     Features["atomics"] = true;
 152     Features["mutable-globals"] = true;
 153     Features["tail-call"] = true;
 154     setSIMDLevel(Features, SIMD128, true);
 155   } else if (CPU == "generic") {
 156     Features["sign-ext"] = true;
 157     Features["mutable-globals"] = true;
 158   }
 159
 160   return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
 161 }
 162
 163 bool WebAssemblyTargetInfo::handleTargetFeatures(
 164     std::vector<std::string> &Features, DiagnosticsEngine &Diags) {
 165   for (const auto &Feature : Features) {
 166     if (Feature == "+simd128") {
 167       SIMDLevel = std::max(SIMDLevel, SIMD128);
 168       continue;
 169     }
 170     if (Feature == "-simd128") {
 171       SIMDLevel = std::min(SIMDLevel, SIMDEnum(SIMD128 - 1));
 172       continue;
 173     }
 174     if (Feature == "+relaxed-simd") {
 175       SIMDLevel = std::max(SIMDLevel, RelaxedSIMD);
 176       continue;
 177     }
 178     if (Feature == "-relaxed-simd") {
 179       SIMDLevel = std::min(SIMDLevel, SIMDEnum(RelaxedSIMD - 1));
 180       continue;
 181     }
 182     if (Feature == "+nontrapping-fptoint") {
 183       HasNontrappingFPToInt = true;
 184       continue;
 185     }
 186     if (Feature == "-nontrapping-fptoint") {
 187       HasNontrappingFPToInt = false;
 188       continue;
 189     }
 190     if (Feature == "+sign-ext") {
 191       HasSignExt = true;
 192       continue;
 193     }
 194     if (Feature == "-sign-ext") {
 195       HasSignExt = false;
 196       continue;
 197     }
 198     if (Feature == "+exception-handling") {
 199       HasExceptionHandling = true;
 200       continue;
 201     }
 202     if (Feature == "-exception-handling") {
 203       HasExceptionHandling = false;
 204       continue;
 205     }
 206     if (Feature == "+bulk-memory") {
 207       HasBulkMemory = true;
 208       continue;
 209     }
 210     if (Feature == "-bulk-memory") {
 211       HasBulkMemory = false;
 212       continue;
 213     }
 214     if (Feature == "+atomics") {
 215       HasAtomics = true;
 216       continue;
 217     }
 218     if (Feature == "-atomics") {
 219       HasAtomics = false;
 220       continue;
 221     }
 222     if (Feature == "+mutable-globals") {
 223       HasMutableGlobals = true;
 224       continue;
 225     }
 226     if (Feature == "-mutable-globals") {
 227       HasMutableGlobals = false;
 228       continue;
 229     }
 230     if (Feature == "+multivalue") {
 231       HasMultivalue = true;
 232       continue;
 233     }
 234     if (Feature == "-multivalue") {
 235       HasMultivalue = false;
 236       continue;
 237     }
 238     if (Feature == "+tail-call") {
 239       HasTailCall = true;
 240       continue;
 241     }
 242     if (Feature == "-tail-call") {
 243       HasTailCall = false;
 244       continue;
 245     }
 246     if (Feature == "+reference-types") {
 247       HasReferenceTypes = true;
 248       continue;
 249     }
 250     if (Feature == "-reference-types") {
 251       HasReferenceTypes = false;
 252       continue;
 253     }
 254     if (Feature == "+extended-const") {
 255       HasExtendedConst = true;
 256       continue;
 257     }
 258     if (Feature == "-extended-const") {
 259       HasExtendedConst = false;
 260       continue;
 261     }
 262
 263     Diags.Report(diag::err_opt_not_valid_with_opt)
 264         << Feature << "-target-feature";
 265     return false;
 266   }
 267   return true;
 268 }
 269
 270 ArrayRef<Builtin::Info> WebAssemblyTargetInfo::getTargetBuiltins() const {
 271   return llvm::ArrayRef(BuiltinInfo, clang::WebAssembly::LastTSBuiltin -
 272                                          Builtin::FirstTSBuiltin);
 273 }
 274
 275 void WebAssemblyTargetInfo::adjust(DiagnosticsEngine &Diags,
 276                                    LangOptions &Opts) {
 277   TargetInfo::adjust(Diags, Opts);
 278   // Turn off POSIXThreads and ThreadModel so that we don't predefine _REENTRANT
 279   // or __STDCPP_THREADS__ if we will eventually end up stripping atomics
 280   // because they are unsupported.
 281   if (!HasAtomics || !HasBulkMemory) {
 282     Opts.POSIXThreads = false;
 283     Opts.setThreadModel(LangOptions::ThreadModelKind::Single);
 284     Opts.ThreadsafeStatics = false;
 285   }
 286 }
 287
 288 void WebAssembly32TargetInfo::getTargetDefines(const LangOptions &Opts,
 289                                                MacroBuilder &Builder) const {
 290   WebAssemblyTargetInfo::getTargetDefines(Opts, Builder);
 291   defineCPUMacros(Builder, "wasm32", /*Tuning=*/false);
 292 }
 293
 294 void WebAssembly64TargetInfo::getTargetDefines(const LangOptions &Opts,
 295                                                MacroBuilder &Builder) const {
 296   WebAssemblyTargetInfo::getTargetDefines(Opts, Builder);
 297   defineCPUMacros(Builder, "wasm64", /*Tuning=*/false);
 298 }