clang 17.0.0git
WebAssembly.cpp
Go to the documentation of this file.
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"
18#include "llvm/ADT/StringSwitch.h"
19
20using namespace clang;
21using namespace clang::targets;
22
23static 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
33static constexpr llvm::StringLiteral ValidCPUNames[] = {
34 {"mvp"}, {"bleeding-edge"}, {"generic"}};
35
36StringRef WebAssemblyTargetInfo::getABI() const { return ABI; }
37
38bool 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
46bool 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
63bool WebAssemblyTargetInfo::isValidCPUName(StringRef Name) const {
64 return llvm::is_contained(ValidCPUNames, Name);
65}
66
67void WebAssemblyTargetInfo::fillValidCPUList(
68 SmallVectorImpl<StringRef> &Values) const {
69 Values.append(std::begin(ValidCPUNames), std::end(ValidCPUNames));
70}
71
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
106void 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
133void 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
144bool 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
163bool 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
270ArrayRef<Builtin::Info> WebAssemblyTargetInfo::getTargetBuiltins() const {
273}
274
275void 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
289 MacroBuilder &Builder) const {
291 defineCPUMacros(Builder, "wasm32", /*Tuning=*/false);
292}
293
295 MacroBuilder &Builder) const {
297 defineCPUMacros(Builder, "wasm64", /*Tuning=*/false);
298}
static constexpr llvm::StringLiteral ValidCPUNames[]
Definition: BPF.cpp:34
Defines the Diagnostic-related interfaces.
static constexpr Builtin::Info BuiltinInfo[]
Definition: WebAssembly.cpp:23
static constexpr llvm::StringLiteral ValidCPUNames[]
Definition: WebAssembly.cpp:33
static constexpr Builtin::Info BuiltinInfo[]
Definition: Builtins.cpp:32
Defines enum values for all the target-independent builtin functions.
Enumerates target-specific builtins in their own namespaces within namespace clang.
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:192
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1542
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:82
@ Single
Single Threaded Environment.
virtual void adjust(DiagnosticsEngine &Diags, LangOptions &Opts)
Set forced language options.
Definition: TargetInfo.cpp:390
virtual bool initFeatureMap(llvm::StringMap< bool > &Features, DiagnosticsEngine &Diags, StringRef CPU, const std::vector< std::string > &FeatureVec) const
Initialize the map with the default set of target features for the CPU this should include all legal ...
Definition: TargetInfo.cpp:520
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
===-— Other target property query methods -----------------------—===//
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
===-— Other target property query methods -----------------------—===//
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
===-— Other target property query methods -----------------------—===//
Definition: WebAssembly.cpp:72
StringRef getABI() const override
Get the ABI currently in use.
Definition: WebAssembly.cpp:36
bool setABI(const std::string &Name) override
Use the specified ABI.
Definition: WebAssembly.cpp:38
void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName, bool Tuning)
Definition: Targets.cpp:75