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 LLVM_FALLTHROUGH; 108 case SIMD128: 109 Features["simd128"] = true; 110 LLVM_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 LLVM_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 } 291