xref: /freebsd/contrib/llvm-project/clang/lib/Sema/SemaWasm.cpp (revision b1879975794772ee51f0b4865753364c7d7626c3)
1 //===------ SemaWasm.cpp ---- WebAssembly target-specific routines --------===//
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 semantic analysis functions specific to WebAssembly.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "clang/Sema/SemaWasm.h"
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/Decl.h"
16 #include "clang/AST/Type.h"
17 #include "clang/Basic/AddressSpaces.h"
18 #include "clang/Basic/DiagnosticSema.h"
19 #include "clang/Basic/TargetBuiltins.h"
20 #include "clang/Sema/Attr.h"
21 #include "clang/Sema/Sema.h"
22 
23 namespace clang {
24 
25 SemaWasm::SemaWasm(Sema &S) : SemaBase(S) {}
26 
27 /// Checks the argument at the given index is a WebAssembly table and if it
28 /// is, sets ElTy to the element type.
29 static bool CheckWasmBuiltinArgIsTable(Sema &S, CallExpr *E, unsigned ArgIndex,
30                                        QualType &ElTy) {
31   Expr *ArgExpr = E->getArg(ArgIndex);
32   const auto *ATy = dyn_cast<ArrayType>(ArgExpr->getType());
33   if (!ATy || !ATy->getElementType().isWebAssemblyReferenceType()) {
34     return S.Diag(ArgExpr->getBeginLoc(),
35                   diag::err_wasm_builtin_arg_must_be_table_type)
36            << ArgIndex + 1 << ArgExpr->getSourceRange();
37   }
38   ElTy = ATy->getElementType();
39   return false;
40 }
41 
42 /// Checks the argument at the given index is an integer.
43 static bool CheckWasmBuiltinArgIsInteger(Sema &S, CallExpr *E,
44                                          unsigned ArgIndex) {
45   Expr *ArgExpr = E->getArg(ArgIndex);
46   if (!ArgExpr->getType()->isIntegerType()) {
47     return S.Diag(ArgExpr->getBeginLoc(),
48                   diag::err_wasm_builtin_arg_must_be_integer_type)
49            << ArgIndex + 1 << ArgExpr->getSourceRange();
50   }
51   return false;
52 }
53 
54 bool SemaWasm::BuiltinWasmRefNullExtern(CallExpr *TheCall) {
55   if (TheCall->getNumArgs() != 0)
56     return true;
57 
58   TheCall->setType(getASTContext().getWebAssemblyExternrefType());
59 
60   return false;
61 }
62 
63 bool SemaWasm::BuiltinWasmRefNullFunc(CallExpr *TheCall) {
64   ASTContext &Context = getASTContext();
65   if (TheCall->getNumArgs() != 0) {
66     Diag(TheCall->getBeginLoc(), diag::err_typecheck_call_too_many_args)
67         << 0 /*function call*/ << /*expected*/ 0 << TheCall->getNumArgs()
68         << /*is non object*/ 0;
69     return true;
70   }
71 
72   // This custom type checking code ensures that the nodes are as expected
73   // in order to later on generate the necessary builtin.
74   QualType Pointee = Context.getFunctionType(Context.VoidTy, {}, {});
75   QualType Type = Context.getPointerType(Pointee);
76   Pointee = Context.getAddrSpaceQualType(Pointee, LangAS::wasm_funcref);
77   Type = Context.getAttributedType(attr::WebAssemblyFuncref, Type,
78                                    Context.getPointerType(Pointee));
79   TheCall->setType(Type);
80 
81   return false;
82 }
83 
84 /// Check that the first argument is a WebAssembly table, and the second
85 /// is an index to use as index into the table.
86 bool SemaWasm::BuiltinWasmTableGet(CallExpr *TheCall) {
87   if (SemaRef.checkArgCount(TheCall, 2))
88     return true;
89 
90   QualType ElTy;
91   if (CheckWasmBuiltinArgIsTable(SemaRef, TheCall, 0, ElTy))
92     return true;
93 
94   if (CheckWasmBuiltinArgIsInteger(SemaRef, TheCall, 1))
95     return true;
96 
97   // If all is well, we set the type of TheCall to be the type of the
98   // element of the table.
99   // i.e. a table.get on an externref table has type externref,
100   // or whatever the type of the table element is.
101   TheCall->setType(ElTy);
102 
103   return false;
104 }
105 
106 /// Check that the first argumnet is a WebAssembly table, the second is
107 /// an index to use as index into the table and the third is the reference
108 /// type to set into the table.
109 bool SemaWasm::BuiltinWasmTableSet(CallExpr *TheCall) {
110   if (SemaRef.checkArgCount(TheCall, 3))
111     return true;
112 
113   QualType ElTy;
114   if (CheckWasmBuiltinArgIsTable(SemaRef, TheCall, 0, ElTy))
115     return true;
116 
117   if (CheckWasmBuiltinArgIsInteger(SemaRef, TheCall, 1))
118     return true;
119 
120   if (!getASTContext().hasSameType(ElTy, TheCall->getArg(2)->getType()))
121     return true;
122 
123   return false;
124 }
125 
126 /// Check that the argument is a WebAssembly table.
127 bool SemaWasm::BuiltinWasmTableSize(CallExpr *TheCall) {
128   if (SemaRef.checkArgCount(TheCall, 1))
129     return true;
130 
131   QualType ElTy;
132   if (CheckWasmBuiltinArgIsTable(SemaRef, TheCall, 0, ElTy))
133     return true;
134 
135   return false;
136 }
137 
138 /// Check that the first argument is a WebAssembly table, the second is the
139 /// value to use for new elements (of a type matching the table type), the
140 /// third value is an integer.
141 bool SemaWasm::BuiltinWasmTableGrow(CallExpr *TheCall) {
142   if (SemaRef.checkArgCount(TheCall, 3))
143     return true;
144 
145   QualType ElTy;
146   if (CheckWasmBuiltinArgIsTable(SemaRef, TheCall, 0, ElTy))
147     return true;
148 
149   Expr *NewElemArg = TheCall->getArg(1);
150   if (!getASTContext().hasSameType(ElTy, NewElemArg->getType())) {
151     return Diag(NewElemArg->getBeginLoc(),
152                 diag::err_wasm_builtin_arg_must_match_table_element_type)
153            << 2 << 1 << NewElemArg->getSourceRange();
154   }
155 
156   if (CheckWasmBuiltinArgIsInteger(SemaRef, TheCall, 2))
157     return true;
158 
159   return false;
160 }
161 
162 /// Check that the first argument is a WebAssembly table, the second is an
163 /// integer, the third is the value to use to fill the table (of a type
164 /// matching the table type), and the fourth is an integer.
165 bool SemaWasm::BuiltinWasmTableFill(CallExpr *TheCall) {
166   if (SemaRef.checkArgCount(TheCall, 4))
167     return true;
168 
169   QualType ElTy;
170   if (CheckWasmBuiltinArgIsTable(SemaRef, TheCall, 0, ElTy))
171     return true;
172 
173   if (CheckWasmBuiltinArgIsInteger(SemaRef, TheCall, 1))
174     return true;
175 
176   Expr *NewElemArg = TheCall->getArg(2);
177   if (!getASTContext().hasSameType(ElTy, NewElemArg->getType())) {
178     return Diag(NewElemArg->getBeginLoc(),
179                 diag::err_wasm_builtin_arg_must_match_table_element_type)
180            << 3 << 1 << NewElemArg->getSourceRange();
181   }
182 
183   if (CheckWasmBuiltinArgIsInteger(SemaRef, TheCall, 3))
184     return true;
185 
186   return false;
187 }
188 
189 /// Check that the first argument is a WebAssembly table, the second is also a
190 /// WebAssembly table (of the same element type), and the third to fifth
191 /// arguments are integers.
192 bool SemaWasm::BuiltinWasmTableCopy(CallExpr *TheCall) {
193   if (SemaRef.checkArgCount(TheCall, 5))
194     return true;
195 
196   QualType XElTy;
197   if (CheckWasmBuiltinArgIsTable(SemaRef, TheCall, 0, XElTy))
198     return true;
199 
200   QualType YElTy;
201   if (CheckWasmBuiltinArgIsTable(SemaRef, TheCall, 1, YElTy))
202     return true;
203 
204   Expr *TableYArg = TheCall->getArg(1);
205   if (!getASTContext().hasSameType(XElTy, YElTy)) {
206     return Diag(TableYArg->getBeginLoc(),
207                 diag::err_wasm_builtin_arg_must_match_table_element_type)
208            << 2 << 1 << TableYArg->getSourceRange();
209   }
210 
211   for (int I = 2; I <= 4; I++) {
212     if (CheckWasmBuiltinArgIsInteger(SemaRef, TheCall, I))
213       return true;
214   }
215 
216   return false;
217 }
218 
219 bool SemaWasm::CheckWebAssemblyBuiltinFunctionCall(const TargetInfo &TI,
220                                                    unsigned BuiltinID,
221                                                    CallExpr *TheCall) {
222   switch (BuiltinID) {
223   case WebAssembly::BI__builtin_wasm_ref_null_extern:
224     return BuiltinWasmRefNullExtern(TheCall);
225   case WebAssembly::BI__builtin_wasm_ref_null_func:
226     return BuiltinWasmRefNullFunc(TheCall);
227   case WebAssembly::BI__builtin_wasm_table_get:
228     return BuiltinWasmTableGet(TheCall);
229   case WebAssembly::BI__builtin_wasm_table_set:
230     return BuiltinWasmTableSet(TheCall);
231   case WebAssembly::BI__builtin_wasm_table_size:
232     return BuiltinWasmTableSize(TheCall);
233   case WebAssembly::BI__builtin_wasm_table_grow:
234     return BuiltinWasmTableGrow(TheCall);
235   case WebAssembly::BI__builtin_wasm_table_fill:
236     return BuiltinWasmTableFill(TheCall);
237   case WebAssembly::BI__builtin_wasm_table_copy:
238     return BuiltinWasmTableCopy(TheCall);
239   }
240 
241   return false;
242 }
243 
244 WebAssemblyImportModuleAttr *
245 SemaWasm::mergeImportModuleAttr(Decl *D,
246                                 const WebAssemblyImportModuleAttr &AL) {
247   auto *FD = cast<FunctionDecl>(D);
248 
249   if (const auto *ExistingAttr = FD->getAttr<WebAssemblyImportModuleAttr>()) {
250     if (ExistingAttr->getImportModule() == AL.getImportModule())
251       return nullptr;
252     Diag(ExistingAttr->getLocation(), diag::warn_mismatched_import)
253         << 0 << ExistingAttr->getImportModule() << AL.getImportModule();
254     Diag(AL.getLoc(), diag::note_previous_attribute);
255     return nullptr;
256   }
257   if (FD->hasBody()) {
258     Diag(AL.getLoc(), diag::warn_import_on_definition) << 0;
259     return nullptr;
260   }
261   return ::new (getASTContext())
262       WebAssemblyImportModuleAttr(getASTContext(), AL, AL.getImportModule());
263 }
264 
265 WebAssemblyImportNameAttr *
266 SemaWasm::mergeImportNameAttr(Decl *D, const WebAssemblyImportNameAttr &AL) {
267   auto *FD = cast<FunctionDecl>(D);
268 
269   if (const auto *ExistingAttr = FD->getAttr<WebAssemblyImportNameAttr>()) {
270     if (ExistingAttr->getImportName() == AL.getImportName())
271       return nullptr;
272     Diag(ExistingAttr->getLocation(), diag::warn_mismatched_import)
273         << 1 << ExistingAttr->getImportName() << AL.getImportName();
274     Diag(AL.getLoc(), diag::note_previous_attribute);
275     return nullptr;
276   }
277   if (FD->hasBody()) {
278     Diag(AL.getLoc(), diag::warn_import_on_definition) << 1;
279     return nullptr;
280   }
281   return ::new (getASTContext())
282       WebAssemblyImportNameAttr(getASTContext(), AL, AL.getImportName());
283 }
284 
285 void SemaWasm::handleWebAssemblyImportModuleAttr(Decl *D,
286                                                  const ParsedAttr &AL) {
287   auto *FD = cast<FunctionDecl>(D);
288 
289   StringRef Str;
290   SourceLocation ArgLoc;
291   if (!SemaRef.checkStringLiteralArgumentAttr(AL, 0, Str, &ArgLoc))
292     return;
293   if (FD->hasBody()) {
294     Diag(AL.getLoc(), diag::warn_import_on_definition) << 0;
295     return;
296   }
297 
298   FD->addAttr(::new (getASTContext())
299                   WebAssemblyImportModuleAttr(getASTContext(), AL, Str));
300 }
301 
302 void SemaWasm::handleWebAssemblyImportNameAttr(Decl *D, const ParsedAttr &AL) {
303   auto *FD = cast<FunctionDecl>(D);
304 
305   StringRef Str;
306   SourceLocation ArgLoc;
307   if (!SemaRef.checkStringLiteralArgumentAttr(AL, 0, Str, &ArgLoc))
308     return;
309   if (FD->hasBody()) {
310     Diag(AL.getLoc(), diag::warn_import_on_definition) << 1;
311     return;
312   }
313 
314   FD->addAttr(::new (getASTContext())
315                   WebAssemblyImportNameAttr(getASTContext(), AL, Str));
316 }
317 
318 void SemaWasm::handleWebAssemblyExportNameAttr(Decl *D, const ParsedAttr &AL) {
319   ASTContext &Context = getASTContext();
320   if (!isFuncOrMethodForAttrSubject(D)) {
321     Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
322         << AL << AL.isRegularKeywordAttribute() << ExpectedFunction;
323     return;
324   }
325 
326   auto *FD = cast<FunctionDecl>(D);
327   if (FD->isThisDeclarationADefinition()) {
328     Diag(D->getLocation(), diag::err_alias_is_definition) << FD << 0;
329     return;
330   }
331 
332   StringRef Str;
333   SourceLocation ArgLoc;
334   if (!SemaRef.checkStringLiteralArgumentAttr(AL, 0, Str, &ArgLoc))
335     return;
336 
337   D->addAttr(::new (Context) WebAssemblyExportNameAttr(Context, AL, Str));
338   D->addAttr(UsedAttr::CreateImplicit(Context));
339 }
340 
341 } // namespace clang
342