ca79ff07d8
Reverts llvm/llvm-project#118734 There are currently some specific versions of MSVC that are miscompiling this code (we think). We don't know why as all the other build bots and at least some folks' local Windows builds work fine. This is a candidate revert to help the relevant folks catch their builders up and have time to debug the issue. However, the expectation is to roll forward at some point with a workaround if at all possible.
392 lines
12 KiB
C++
392 lines
12 KiB
C++
//===--- WebAssembly.cpp - Implement WebAssembly target feature support ---===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements WebAssembly TargetInfo objects.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "WebAssembly.h"
|
|
#include "Targets.h"
|
|
#include "clang/Basic/Builtins.h"
|
|
#include "clang/Basic/Diagnostic.h"
|
|
#include "clang/Basic/TargetBuiltins.h"
|
|
#include "llvm/ADT/StringSwitch.h"
|
|
|
|
using namespace clang;
|
|
using namespace clang::targets;
|
|
|
|
static constexpr Builtin::Info BuiltinInfo[] = {
|
|
#define BUILTIN(ID, TYPE, ATTRS) \
|
|
{#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
|
|
#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
|
|
{#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
|
|
#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
|
|
{#ID, TYPE, ATTRS, nullptr, HeaderDesc::HEADER, ALL_LANGUAGES},
|
|
#include "clang/Basic/BuiltinsWebAssembly.def"
|
|
};
|
|
|
|
static constexpr llvm::StringLiteral ValidCPUNames[] = {
|
|
{"mvp"}, {"bleeding-edge"}, {"generic"}, {"lime1"}};
|
|
|
|
StringRef WebAssemblyTargetInfo::getABI() const { return ABI; }
|
|
|
|
bool WebAssemblyTargetInfo::setABI(const std::string &Name) {
|
|
if (Name != "mvp" && Name != "experimental-mv")
|
|
return false;
|
|
|
|
ABI = Name;
|
|
return true;
|
|
}
|
|
|
|
bool WebAssemblyTargetInfo::hasFeature(StringRef Feature) const {
|
|
return llvm::StringSwitch<bool>(Feature)
|
|
.Case("atomics", HasAtomics)
|
|
.Case("bulk-memory", HasBulkMemory)
|
|
.Case("bulk-memory-opt", HasBulkMemoryOpt)
|
|
.Case("call-indirect-overlong", HasCallIndirectOverlong)
|
|
.Case("exception-handling", HasExceptionHandling)
|
|
.Case("extended-const", HasExtendedConst)
|
|
.Case("fp16", HasFP16)
|
|
.Case("multimemory", HasMultiMemory)
|
|
.Case("multivalue", HasMultivalue)
|
|
.Case("mutable-globals", HasMutableGlobals)
|
|
.Case("nontrapping-fptoint", HasNontrappingFPToInt)
|
|
.Case("reference-types", HasReferenceTypes)
|
|
.Case("relaxed-simd", SIMDLevel >= RelaxedSIMD)
|
|
.Case("sign-ext", HasSignExt)
|
|
.Case("simd128", SIMDLevel >= SIMD128)
|
|
.Case("tail-call", HasTailCall)
|
|
.Case("wide-arithmetic", HasWideArithmetic)
|
|
.Default(false);
|
|
}
|
|
|
|
bool WebAssemblyTargetInfo::isValidCPUName(StringRef Name) const {
|
|
return llvm::is_contained(ValidCPUNames, Name);
|
|
}
|
|
|
|
void WebAssemblyTargetInfo::fillValidCPUList(
|
|
SmallVectorImpl<StringRef> &Values) const {
|
|
Values.append(std::begin(ValidCPUNames), std::end(ValidCPUNames));
|
|
}
|
|
|
|
void WebAssemblyTargetInfo::getTargetDefines(const LangOptions &Opts,
|
|
MacroBuilder &Builder) const {
|
|
defineCPUMacros(Builder, "wasm", /*Tuning=*/false);
|
|
if (HasAtomics)
|
|
Builder.defineMacro("__wasm_atomics__");
|
|
if (HasBulkMemory)
|
|
Builder.defineMacro("__wasm_bulk_memory__");
|
|
if (HasBulkMemoryOpt)
|
|
Builder.defineMacro("__wasm_bulk_memory_opt__");
|
|
if (HasExceptionHandling)
|
|
Builder.defineMacro("__wasm_exception_handling__");
|
|
if (HasExtendedConst)
|
|
Builder.defineMacro("__wasm_extended_const__");
|
|
if (HasMultiMemory)
|
|
Builder.defineMacro("__wasm_multimemory__");
|
|
if (HasFP16)
|
|
Builder.defineMacro("__wasm_fp16__");
|
|
if (HasMultivalue)
|
|
Builder.defineMacro("__wasm_multivalue__");
|
|
if (HasMutableGlobals)
|
|
Builder.defineMacro("__wasm_mutable_globals__");
|
|
if (HasNontrappingFPToInt)
|
|
Builder.defineMacro("__wasm_nontrapping_fptoint__");
|
|
if (HasReferenceTypes)
|
|
Builder.defineMacro("__wasm_reference_types__");
|
|
if (SIMDLevel >= RelaxedSIMD)
|
|
Builder.defineMacro("__wasm_relaxed_simd__");
|
|
if (HasSignExt)
|
|
Builder.defineMacro("__wasm_sign_ext__");
|
|
if (SIMDLevel >= SIMD128)
|
|
Builder.defineMacro("__wasm_simd128__");
|
|
if (HasTailCall)
|
|
Builder.defineMacro("__wasm_tail_call__");
|
|
if (HasWideArithmetic)
|
|
Builder.defineMacro("__wasm_wide_arithmetic__");
|
|
|
|
Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
|
|
Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
|
|
Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
|
|
Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
|
|
}
|
|
|
|
void WebAssemblyTargetInfo::setSIMDLevel(llvm::StringMap<bool> &Features,
|
|
SIMDEnum Level, bool Enabled) {
|
|
if (Enabled) {
|
|
switch (Level) {
|
|
case RelaxedSIMD:
|
|
Features["relaxed-simd"] = true;
|
|
[[fallthrough]];
|
|
case SIMD128:
|
|
Features["simd128"] = true;
|
|
[[fallthrough]];
|
|
case NoSIMD:
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
switch (Level) {
|
|
case NoSIMD:
|
|
case SIMD128:
|
|
Features["simd128"] = false;
|
|
[[fallthrough]];
|
|
case RelaxedSIMD:
|
|
Features["relaxed-simd"] = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void WebAssemblyTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
|
|
StringRef Name,
|
|
bool Enabled) const {
|
|
if (Name == "simd128")
|
|
setSIMDLevel(Features, SIMD128, Enabled);
|
|
else if (Name == "relaxed-simd")
|
|
setSIMDLevel(Features, RelaxedSIMD, Enabled);
|
|
else
|
|
Features[Name] = Enabled;
|
|
}
|
|
|
|
bool WebAssemblyTargetInfo::initFeatureMap(
|
|
llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
|
|
const std::vector<std::string> &FeaturesVec) const {
|
|
auto addGenericFeatures = [&]() {
|
|
Features["bulk-memory"] = true;
|
|
Features["bulk-memory-opt"] = true;
|
|
Features["call-indirect-overlong"] = true;
|
|
Features["multivalue"] = true;
|
|
Features["mutable-globals"] = true;
|
|
Features["nontrapping-fptoint"] = true;
|
|
Features["reference-types"] = true;
|
|
Features["sign-ext"] = true;
|
|
};
|
|
auto addLime1Features = [&]() {
|
|
// Lime1:
|
|
// <https://github.com/WebAssembly/tool-conventions/blob/main/Lime.md#lime1>
|
|
Features["bulk-memory-opt"] = true;
|
|
Features["call-indirect-overlong"] = true;
|
|
Features["extended-const"] = true;
|
|
Features["multivalue"] = true;
|
|
Features["mutable-globals"] = true;
|
|
Features["nontrapping-fptoint"] = true;
|
|
Features["sign-ext"] = true;
|
|
};
|
|
auto addBleedingEdgeFeatures = [&]() {
|
|
addGenericFeatures();
|
|
Features["atomics"] = true;
|
|
Features["exception-handling"] = true;
|
|
Features["extended-const"] = true;
|
|
Features["fp16"] = true;
|
|
Features["multimemory"] = true;
|
|
Features["tail-call"] = true;
|
|
Features["wide-arithmetic"] = true;
|
|
setSIMDLevel(Features, RelaxedSIMD, true);
|
|
};
|
|
if (CPU == "generic") {
|
|
addGenericFeatures();
|
|
} else if (CPU == "lime1") {
|
|
addLime1Features();
|
|
} else if (CPU == "bleeding-edge") {
|
|
addBleedingEdgeFeatures();
|
|
}
|
|
|
|
return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
|
|
}
|
|
|
|
bool WebAssemblyTargetInfo::handleTargetFeatures(
|
|
std::vector<std::string> &Features, DiagnosticsEngine &Diags) {
|
|
for (const auto &Feature : Features) {
|
|
if (Feature == "+atomics") {
|
|
HasAtomics = true;
|
|
continue;
|
|
}
|
|
if (Feature == "-atomics") {
|
|
HasAtomics = false;
|
|
continue;
|
|
}
|
|
if (Feature == "+bulk-memory") {
|
|
HasBulkMemory = true;
|
|
continue;
|
|
}
|
|
if (Feature == "-bulk-memory") {
|
|
HasBulkMemory = false;
|
|
continue;
|
|
}
|
|
if (Feature == "+bulk-memory-opt") {
|
|
HasBulkMemoryOpt = true;
|
|
continue;
|
|
}
|
|
if (Feature == "-bulk-memory-opt") {
|
|
HasBulkMemoryOpt = false;
|
|
continue;
|
|
}
|
|
if (Feature == "+call-indirect-overlong") {
|
|
HasCallIndirectOverlong = true;
|
|
continue;
|
|
}
|
|
if (Feature == "-call-indirect-overlong") {
|
|
HasCallIndirectOverlong = false;
|
|
continue;
|
|
}
|
|
if (Feature == "+exception-handling") {
|
|
HasExceptionHandling = true;
|
|
continue;
|
|
}
|
|
if (Feature == "-exception-handling") {
|
|
HasExceptionHandling = false;
|
|
continue;
|
|
}
|
|
if (Feature == "+extended-const") {
|
|
HasExtendedConst = true;
|
|
continue;
|
|
}
|
|
if (Feature == "-extended-const") {
|
|
HasExtendedConst = false;
|
|
continue;
|
|
}
|
|
if (Feature == "+fp16") {
|
|
SIMDLevel = std::max(SIMDLevel, SIMD128);
|
|
HasFP16 = true;
|
|
continue;
|
|
}
|
|
if (Feature == "-fp16") {
|
|
HasFP16 = false;
|
|
continue;
|
|
}
|
|
if (Feature == "+multimemory") {
|
|
HasMultiMemory = true;
|
|
continue;
|
|
}
|
|
if (Feature == "-multimemory") {
|
|
HasMultiMemory = false;
|
|
continue;
|
|
}
|
|
if (Feature == "+multivalue") {
|
|
HasMultivalue = true;
|
|
continue;
|
|
}
|
|
if (Feature == "-multivalue") {
|
|
HasMultivalue = false;
|
|
continue;
|
|
}
|
|
if (Feature == "+mutable-globals") {
|
|
HasMutableGlobals = true;
|
|
continue;
|
|
}
|
|
if (Feature == "-mutable-globals") {
|
|
HasMutableGlobals = false;
|
|
continue;
|
|
}
|
|
if (Feature == "+nontrapping-fptoint") {
|
|
HasNontrappingFPToInt = true;
|
|
continue;
|
|
}
|
|
if (Feature == "-nontrapping-fptoint") {
|
|
HasNontrappingFPToInt = false;
|
|
continue;
|
|
}
|
|
if (Feature == "+reference-types") {
|
|
HasReferenceTypes = true;
|
|
continue;
|
|
}
|
|
if (Feature == "-reference-types") {
|
|
HasReferenceTypes = false;
|
|
continue;
|
|
}
|
|
if (Feature == "+relaxed-simd") {
|
|
SIMDLevel = std::max(SIMDLevel, RelaxedSIMD);
|
|
continue;
|
|
}
|
|
if (Feature == "-relaxed-simd") {
|
|
SIMDLevel = std::min(SIMDLevel, SIMDEnum(RelaxedSIMD - 1));
|
|
continue;
|
|
}
|
|
if (Feature == "+sign-ext") {
|
|
HasSignExt = true;
|
|
continue;
|
|
}
|
|
if (Feature == "-sign-ext") {
|
|
HasSignExt = false;
|
|
continue;
|
|
}
|
|
if (Feature == "+simd128") {
|
|
SIMDLevel = std::max(SIMDLevel, SIMD128);
|
|
continue;
|
|
}
|
|
if (Feature == "-simd128") {
|
|
SIMDLevel = std::min(SIMDLevel, SIMDEnum(SIMD128 - 1));
|
|
continue;
|
|
}
|
|
if (Feature == "+tail-call") {
|
|
HasTailCall = true;
|
|
continue;
|
|
}
|
|
if (Feature == "-tail-call") {
|
|
HasTailCall = false;
|
|
continue;
|
|
}
|
|
if (Feature == "+wide-arithmetic") {
|
|
HasWideArithmetic = true;
|
|
continue;
|
|
}
|
|
if (Feature == "-wide-arithmetic") {
|
|
HasWideArithmetic = false;
|
|
continue;
|
|
}
|
|
|
|
Diags.Report(diag::err_opt_not_valid_with_opt)
|
|
<< Feature << "-target-feature";
|
|
return false;
|
|
}
|
|
|
|
// bulk-memory-opt is a subset of bulk-memory.
|
|
if (HasBulkMemory) {
|
|
HasBulkMemoryOpt = true;
|
|
}
|
|
|
|
// The reference-types feature included the change to `call_indirect`
|
|
// encodings to support overlong immediates.
|
|
if (HasReferenceTypes) {
|
|
HasCallIndirectOverlong = true;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
ArrayRef<Builtin::Info> WebAssemblyTargetInfo::getTargetBuiltins() const {
|
|
return llvm::ArrayRef(BuiltinInfo, clang::WebAssembly::LastTSBuiltin -
|
|
Builtin::FirstTSBuiltin);
|
|
}
|
|
|
|
void WebAssemblyTargetInfo::adjust(DiagnosticsEngine &Diags,
|
|
LangOptions &Opts) {
|
|
TargetInfo::adjust(Diags, Opts);
|
|
// Turn off POSIXThreads and ThreadModel so that we don't predefine _REENTRANT
|
|
// or __STDCPP_THREADS__ if we will eventually end up stripping atomics
|
|
// because they are unsupported.
|
|
if (!HasAtomics || !HasBulkMemory) {
|
|
Opts.POSIXThreads = false;
|
|
Opts.setThreadModel(LangOptions::ThreadModelKind::Single);
|
|
Opts.ThreadsafeStatics = false;
|
|
}
|
|
}
|
|
|
|
void WebAssembly32TargetInfo::getTargetDefines(const LangOptions &Opts,
|
|
MacroBuilder &Builder) const {
|
|
WebAssemblyTargetInfo::getTargetDefines(Opts, Builder);
|
|
defineCPUMacros(Builder, "wasm32", /*Tuning=*/false);
|
|
}
|
|
|
|
void WebAssembly64TargetInfo::getTargetDefines(const LangOptions &Opts,
|
|
MacroBuilder &Builder) const {
|
|
WebAssemblyTargetInfo::getTargetDefines(Opts, Builder);
|
|
defineCPUMacros(Builder, "wasm64", /*Tuning=*/false);
|
|
}
|