diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h --- a/clang/include/clang/AST/Type.h +++ b/clang/include/clang/AST/Type.h @@ -4922,6 +4922,8 @@ bool isMSTypeSpec() const; + bool isWebAssemblyFuncrefSpec() const; + bool isCallingConv() const; llvm::Optional getImmediateNullability() const; diff --git a/clang/include/clang/Basic/AddressSpaces.h b/clang/include/clang/Basic/AddressSpaces.h --- a/clang/include/clang/Basic/AddressSpaces.h +++ b/clang/include/clang/Basic/AddressSpaces.h @@ -59,6 +59,9 @@ // HLSL specific address spaces. hlsl_groupshared, + // Wasm specific address spaces. + wasm_funcref, + // This denotes the count of language-specific address spaces and also // the offset added to the target-specific address spaces, which are usually // specified by address space attributes __attribute__(address_space(n))). diff --git a/clang/include/clang/Basic/Attr.td b/clang/include/clang/Basic/Attr.td --- a/clang/include/clang/Basic/Attr.td +++ b/clang/include/clang/Basic/Attr.td @@ -4096,3 +4096,9 @@ let Subjects = SubjectList<[Function]>; let Documentation = [FunctionReturnThunksDocs]; } + +def WebAssemblyFuncref : TypeAttr, TargetSpecificAttr { + let Spellings = [Keyword<"__funcref">]; + let Documentation = [WebAssemblyExportNameDocs]; + let Subjects = SubjectList<[TypedefName], ErrorDiag>; +} diff --git a/clang/include/clang/Basic/AttrDocs.td b/clang/include/clang/Basic/AttrDocs.td --- a/clang/include/clang/Basic/AttrDocs.td +++ b/clang/include/clang/Basic/AttrDocs.td @@ -6770,3 +6770,12 @@ As such, this function attribute is currently only supported on X86 targets. }]; } + +def WebAssemblyFuncrefDocs : Documentation { + let Category = DocCatFunction; + let Content = [{ +Clang supports the ``__funcref`` attribute for the WebAssembly target. +This attribute may be attached to a function pointer declaration, where it modifies +its underlying representation to be a WebAssembly ``funcref``. + }]; +} \ No newline at end of file diff --git a/clang/include/clang/Basic/BuiltinsWebAssembly.def b/clang/include/clang/Basic/BuiltinsWebAssembly.def --- a/clang/include/clang/Basic/BuiltinsWebAssembly.def +++ b/clang/include/clang/Basic/BuiltinsWebAssembly.def @@ -191,8 +191,15 @@ TARGET_BUILTIN(__builtin_wasm_relaxed_dot_bf16x8_add_f32_f32x4, "V4fV8UsV8UsV4f", "nc", "relaxed-simd") // Reference Types builtins +// Some builtins are custom type-checked - see 't' as part of the third argument, +// in which case the argument spec (second argument) is unused. TARGET_BUILTIN(__builtin_wasm_ref_null_extern, "i", "nct", "reference-types") +// A funcref represented as a function pointer with the funcref attribute +// attached to the type, therefore SemaChecking will check for the right +// return type. +TARGET_BUILTIN(__builtin_wasm_ref_null_func, "i", "nct", "reference-types") + #undef BUILTIN #undef TARGET_BUILTIN diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -7371,6 +7371,8 @@ "'__clang_arm_builtin_alias' attribute can only be applied to an ARM builtin">; def err_attribute_arm_mve_polymorphism : Error< "'__clang_arm_mve_strict_polymorphism' attribute can only be applied to an MVE/NEON vector type">; +def err_attribute_webassembly_funcref : Error< + "'__funcref' attribute can only be applied to a function pointer type">; def warn_setter_getter_impl_required : Warning< "property %0 requires method %1 to be defined - " diff --git a/clang/include/clang/Basic/TokenKinds.def b/clang/include/clang/Basic/TokenKinds.def --- a/clang/include/clang/Basic/TokenKinds.def +++ b/clang/include/clang/Basic/TokenKinds.def @@ -678,6 +678,9 @@ KEYWORD(_Nullable_result , KEYALL) KEYWORD(_Null_unspecified , KEYALL) +// WebAssembly Type Extension +KEYWORD(__funcref , KEYALL) + // Microsoft extensions which should be disabled in strict conformance mode KEYWORD(__ptr64 , KEYMS) KEYWORD(__ptr32 , KEYMS) diff --git a/clang/include/clang/Parse/Parser.h b/clang/include/clang/Parse/Parser.h --- a/clang/include/clang/Parse/Parser.h +++ b/clang/include/clang/Parse/Parser.h @@ -2920,6 +2920,7 @@ SourceLocation AttrNameLoc, ParsedAttributes &Attrs); void ParseMicrosoftTypeAttributes(ParsedAttributes &attrs); + void ParseWebAssemblyFuncrefTypeAttribute(ParsedAttributes &Attrs); void DiagnoseAndSkipExtendedMicrosoftTypeAttributes(); SourceLocation SkipExtendedMicrosoftTypeAttributes(); void ParseMicrosoftInheritanceClassAttributes(ParsedAttributes &attrs); diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -13533,6 +13533,7 @@ // WebAssembly builtin handling. bool BuiltinWasmRefNullExtern(CallExpr *TheCall); + bool BuiltinWasmRefNullFunc(CallExpr *TheCall); public: enum FormatStringType { diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp --- a/clang/lib/AST/ASTContext.cpp +++ b/clang/lib/AST/ASTContext.cpp @@ -955,6 +955,8 @@ 11, // ptr32_uptr 12, // ptr64 13, // hlsl_groupshared + // Wasm address space values for this map are dummy + 20, // wasm_funcref }; return &FakeAddrSpaceMap; } else { diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp --- a/clang/lib/AST/Type.cpp +++ b/clang/lib/AST/Type.cpp @@ -3619,6 +3619,10 @@ llvm_unreachable("invalid attr kind"); } +bool AttributedType::isWebAssemblyFuncrefSpec() const { + return getAttrKind() == attr::WebAssemblyFuncref; +} + bool AttributedType::isCallingConv() const { // FIXME: Generate this with TableGen. switch (getAttrKind()) { diff --git a/clang/lib/AST/TypePrinter.cpp b/clang/lib/AST/TypePrinter.cpp --- a/clang/lib/AST/TypePrinter.cpp +++ b/clang/lib/AST/TypePrinter.cpp @@ -1649,6 +1649,11 @@ spaceBeforePlaceHolder(OS); } + if (T->isWebAssemblyFuncrefSpec()) { + assert(T->getAttrKind() == attr::WebAssemblyFuncref); + OS << "__funcref"; + } + // Print nullability type specifiers. if (T->getImmediateNullability()) { if (T->getAttrKind() == attr::TypeNonNull) @@ -1682,8 +1687,8 @@ // Some attributes are printed as qualifiers before the type, so we have // nothing left to do. - if (T->getAttrKind() == attr::ObjCKindOf || - T->isMSTypeSpec() || T->getImmediateNullability()) + if (T->getAttrKind() == attr::ObjCKindOf || T->isMSTypeSpec() || + T->getImmediateNullability() || T->isWebAssemblyFuncrefSpec()) return; // Don't print the inert __unsafe_unretained attribute at all. @@ -1755,6 +1760,7 @@ case attr::AddressSpace: case attr::CmseNSCall: case attr::AnnotateType: + case attr::WebAssemblyFuncref: llvm_unreachable("This attribute should have been handled already"); case attr::NSReturnsRetained: @@ -2230,6 +2236,8 @@ return "__uptr __ptr32"; case LangAS::ptr64: return "__ptr64"; + case LangAS::wasm_funcref: + return "__funcref"; case LangAS::hlsl_groupshared: return "groupshared"; default: diff --git a/clang/lib/Basic/Targets/DirectX.h b/clang/lib/Basic/Targets/DirectX.h --- a/clang/lib/Basic/Targets/DirectX.h +++ b/clang/lib/Basic/Targets/DirectX.h @@ -42,6 +42,8 @@ 0, // ptr32_uptr 0, // ptr64 3, // hlsl_groupshared + // Wasm address space values for this map are dummy + 20, // wasm_funcref }; class LLVM_LIBRARY_VISIBILITY DirectXTargetInfo : public TargetInfo { diff --git a/clang/lib/Basic/Targets/NVPTX.h b/clang/lib/Basic/Targets/NVPTX.h --- a/clang/lib/Basic/Targets/NVPTX.h +++ b/clang/lib/Basic/Targets/NVPTX.h @@ -44,6 +44,8 @@ 0, // ptr32_uptr 0, // ptr64 0, // hlsl_groupshared + // Wasm address space values for this map are dummy + 20, // wasm_funcref }; /// The DWARF address class. Taken from diff --git a/clang/lib/Basic/Targets/SPIR.h b/clang/lib/Basic/Targets/SPIR.h --- a/clang/lib/Basic/Targets/SPIR.h +++ b/clang/lib/Basic/Targets/SPIR.h @@ -44,6 +44,8 @@ 0, // ptr32_uptr 0, // ptr64 0, // hlsl_groupshared + // Wasm address space values for this map are dummy + 20, // wasm_funcref }; // Used by both the SPIR and SPIR-V targets. @@ -74,6 +76,8 @@ 0, // ptr32_uptr 0, // ptr64 0, // hlsl_groupshared + // Wasm address space values for this map are dummy + 20, // wasm_funcref }; // Base class for SPIR and SPIR-V target info. diff --git a/clang/lib/Basic/Targets/TCE.h b/clang/lib/Basic/Targets/TCE.h --- a/clang/lib/Basic/Targets/TCE.h +++ b/clang/lib/Basic/Targets/TCE.h @@ -51,6 +51,8 @@ 0, // ptr32_uptr 0, // ptr64 0, // hlsl_groupshared + // Wasm address space values for this map are dummy + 20, // wasm_funcref }; class LLVM_LIBRARY_VISIBILITY TCETargetInfo : public TargetInfo { diff --git a/clang/lib/Basic/Targets/WebAssembly.h b/clang/lib/Basic/Targets/WebAssembly.h --- a/clang/lib/Basic/Targets/WebAssembly.h +++ b/clang/lib/Basic/Targets/WebAssembly.h @@ -21,6 +21,30 @@ namespace clang { namespace targets { +static const unsigned WebAssemblyAddrSpaceMap[] = { + 0, // Default + 0, // opencl_global + 0, // opencl_local + 0, // opencl_constant + 0, // opencl_private + 0, // opencl_generic + 0, // opencl_global_device + 0, // opencl_global_host + 0, // cuda_device + 0, // cuda_constant + 0, // cuda_shared + 0, // sycl_global + 0, // sycl_global_device + 0, // sycl_global_host + 0, // sycl_local + 0, // sycl_private + 0, // ptr32_sptr + 0, // ptr32_uptr + 0, // ptr64 + 10, // wasm_externref, + 20, // wasm_funcref +}; + class LLVM_LIBRARY_VISIBILITY WebAssemblyTargetInfo : public TargetInfo { static const Builtin::Info BuiltinInfo[]; @@ -46,6 +70,7 @@ public: explicit WebAssemblyTargetInfo(const llvm::Triple &T, const TargetOptions &) : TargetInfo(T) { + AddrSpaceMap = &WebAssemblyAddrSpaceMap; NoAsmVariants = true; SuitableAlign = 128; LargeArrayMinWidth = 128; diff --git a/clang/lib/Basic/Targets/X86.h b/clang/lib/Basic/Targets/X86.h --- a/clang/lib/Basic/Targets/X86.h +++ b/clang/lib/Basic/Targets/X86.h @@ -45,6 +45,8 @@ 271, // ptr32_uptr 272, // ptr64 0, // hlsl_groupshared + // Wasm address space values for this map are dummy + 20, // wasm_funcref }; // X86 target abstract base class; x86-32 and x86-64 are very close, so diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -18798,6 +18798,10 @@ Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_ref_null_extern); return Builder.CreateCall(Callee); } + case WebAssembly::BI__builtin_wasm_ref_null_func: { + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_ref_null_func); + return Builder.CreateCall(Callee); + } case WebAssembly::BI__builtin_wasm_swizzle_i8x16: { Value *Src = EmitScalarExpr(E->getArg(0)); Value *Indices = EmitScalarExpr(E->getArg(1)); diff --git a/clang/lib/CodeGen/TargetInfo.h b/clang/lib/CodeGen/TargetInfo.h --- a/clang/lib/CodeGen/TargetInfo.h +++ b/clang/lib/CodeGen/TargetInfo.h @@ -365,6 +365,9 @@ /// Return the WebAssembly externref reference type. virtual llvm::Type *getWasmExternrefReferenceType() const { return nullptr; } + /// Return the WebAssembly funcref reference type. + virtual llvm::Type *getWasmFuncrefReferenceType() const { return nullptr; } + /// Emit the device-side copy of the builtin surface type. virtual bool emitCUDADeviceBuiltinSurfaceDeviceCopy(CodeGenFunction &CGF, LValue Dst, diff --git a/clang/lib/CodeGen/TargetInfo.cpp b/clang/lib/CodeGen/TargetInfo.cpp --- a/clang/lib/CodeGen/TargetInfo.cpp +++ b/clang/lib/CodeGen/TargetInfo.cpp @@ -904,6 +904,10 @@ virtual llvm::Type *getWasmExternrefReferenceType() const override { return llvm::Type::getWasm_ExternrefTy(getABIInfo().getVMContext()); } + /// Return the WebAssembly funcref reference type. + virtual llvm::Type *getWasmFuncrefReferenceType() const override { + return llvm::Type::getWasm_FuncrefTy(getABIInfo().getVMContext()); + } }; /// Classify argument of given type \p Ty. diff --git a/clang/lib/Format/FormatToken.h b/clang/lib/Format/FormatToken.h --- a/clang/lib/Format/FormatToken.h +++ b/clang/lib/Format/FormatToken.h @@ -596,7 +596,7 @@ return isOneOf(tok::kw_const, tok::kw_restrict, tok::kw_volatile, tok::kw___attribute, tok::kw__Nonnull, tok::kw__Nullable, tok::kw__Null_unspecified, tok::kw___ptr32, tok::kw___ptr64, - TT_AttributeMacro); + tok::kw___funcref, TT_AttributeMacro); } /// Determine whether the token is a simple-type-specifier. diff --git a/clang/lib/Parse/ParseDecl.cpp b/clang/lib/Parse/ParseDecl.cpp --- a/clang/lib/Parse/ParseDecl.cpp +++ b/clang/lib/Parse/ParseDecl.cpp @@ -840,6 +840,15 @@ } } +void Parser::ParseWebAssemblyFuncrefTypeAttribute(ParsedAttributes &attrs) { + if (Tok.is(tok::kw___funcref)) { + IdentifierInfo *AttrName = Tok.getIdentifierInfo(); + SourceLocation AttrNameLoc = ConsumeToken(); + attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0, + ParsedAttr::AS_Keyword); + } +} + void Parser::DiagnoseAndSkipExtendedMicrosoftTypeAttributes() { SourceLocation StartLoc = Tok.getLocation(); SourceLocation EndLoc = SkipExtendedMicrosoftTypeAttributes(); @@ -3811,6 +3820,10 @@ ParseMicrosoftTypeAttributes(DS.getAttributes()); continue; + case tok::kw___funcref: + ParseWebAssemblyFuncrefTypeAttribute(DS.getAttributes()); + continue; + // Borland single token adornments. case tok::kw___pascal: ParseBorlandTypeAttributes(DS.getAttributes()); @@ -5368,7 +5381,7 @@ case tok::kw___read_only: case tok::kw___read_write: case tok::kw___write_only: - + case tok::kw___funcref: case tok::kw_groupshared: return true; @@ -5612,6 +5625,7 @@ #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t: #include "clang/Basic/OpenCLImageTypes.def" + case tok::kw___funcref: case tok::kw_groupshared: return true; @@ -5873,6 +5887,14 @@ continue; } goto DoneWithTypeQuals; + + case tok::kw___funcref: + if (AttrReqs & AR_DeclspecAttributesParsed) { + ParseWebAssemblyFuncrefTypeAttribute(DS.getAttributes()); + continue; + } + goto DoneWithTypeQuals; + case tok::kw___pascal: if (AttrReqs & AR_VendorAttributesParsed) { ParseBorlandTypeAttributes(DS.getAttributes()); diff --git a/clang/lib/Parse/ParseTentative.cpp b/clang/lib/Parse/ParseTentative.cpp --- a/clang/lib/Parse/ParseTentative.cpp +++ b/clang/lib/Parse/ParseTentative.cpp @@ -1472,6 +1472,10 @@ case tok::kw___kindof: return TPResult::True; + // WebAssemblyFuncref + case tok::kw___funcref: + return TPResult::True; + // Borland case tok::kw___pascal: return TPResult::True; diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp --- a/clang/lib/Sema/SemaChecking.cpp +++ b/clang/lib/Sema/SemaChecking.cpp @@ -4592,6 +4592,8 @@ switch (BuiltinID) { case WebAssembly::BI__builtin_wasm_ref_null_extern: return BuiltinWasmRefNullExtern(TheCall); + case WebAssembly::BI__builtin_wasm_ref_null_func: + return BuiltinWasmRefNullFunc(TheCall); } return false; @@ -6628,6 +6630,32 @@ return false; } +bool Sema::BuiltinWasmRefNullFunc(CallExpr *TheCall) { + if (TheCall->getNumArgs() != 0) + return true; + + // The call we get looks like + // CallExpr + // `- ImplicitCastExpr + // `- DeclRefExpr + // + // Therefore we need to change the types of the DeclRefExpr (stored in FDecl) + // and regenerate a straight up CallExpr on the modified FDecl. + // returning + // CallExpr + // `- FunctionDecl + + // Prepare FDecl type + QualType Pointee = Context.getFunctionType(Context.VoidTy, {}, {}); + QualType Type = Context.getPointerType(Pointee); + Pointee = Context.getAddrSpaceQualType(Pointee, LangAS::wasm_funcref); + Type = Context.getAttributedType(attr::WebAssemblyFuncref, Type, + Context.getPointerType(Pointee)); + TheCall->setType(Type); + + return false; +} + /// We have a call to a function like __sync_fetch_and_add, which is an /// overloaded function based on the pointer type of its first argument. /// The main BuildCallExpr routines have already promoted the types of diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -14651,7 +14651,11 @@ // OpenCL allows function arguments declared to be an array of a type // to be qualified with an address space. !(getLangOpts().OpenCL && - (T->isArrayType() || T.getAddressSpace() == LangAS::opencl_private))) { + (T->isArrayType() || T.getAddressSpace() == LangAS::opencl_private)) && + // WebAssembly allows reference types as parameters. Funcref in particular + // lives in a different address space + !(T->isFunctionPointerType() && + T.getAddressSpace() == LangAS::wasm_funcref)) { Diag(NameLoc, diag::err_arg_with_address_space); New->setInvalidDecl(); } diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp --- a/clang/lib/Sema/SemaType.cpp +++ b/clang/lib/Sema/SemaType.cpp @@ -7323,6 +7323,55 @@ return false; } +static bool HandleWebAssemblyFuncrefAttr(TypeProcessingState &State, + QualType &Type, ParsedAttr &PAttr) { + assert(PAttr.getKind() == ParsedAttr::AT_WebAssemblyFuncref); + + Sema &S = State.getSema(); + Attr *A = createSimpleAttr(S.Context, PAttr); + + std::bitset Attrs; + attr::Kind NewAttrKind = A->getKind(); + QualType Desugared = Type; + const auto *AT = dyn_cast(Type); + while (AT) { + Attrs[AT->getAttrKind()] = true; + Desugared = AT->getModifiedType(); + AT = dyn_cast(Desugared); + } + + // You cannot specify duplicate type attributes, so if the attribute has + // already been applied, flag it. + if (Attrs[NewAttrKind]) { + S.Diag(PAttr.getLoc(), diag::warn_duplicate_attribute_exact) << PAttr; + return true; + } + Attrs[NewAttrKind] = true; + + // Pointer type qualifiers can only operate on pointer types, but not + // pointer-to-member types. + // + // FIXME: Should we really be disallowing this attribute if there is any + // type sugar between it and the pointer (other than attributes)? Eg, this + // disallows the attribute on a parenthesized pointer. + // And if so, should we really allow *any* type attribute? + if (!isa(Desugared)) { + if (Type->isMemberPointerType()) + S.Diag(PAttr.getLoc(), diag::err_attribute_no_member_pointers) << PAttr; + else + S.Diag(PAttr.getLoc(), diag::err_attribute_pointers_only) << PAttr << 0; + return true; + } + + // Add address space to type based on its attributes. + LangAS ASIdx = LangAS::wasm_funcref; + QualType Pointee = Type->getPointeeType(); + Pointee = S.Context.getAddrSpaceQualType( + S.Context.removeAddrSpaceQualType(Pointee), ASIdx); + Type = State.getAttributedType(A, Type, S.Context.getPointerType(Pointee)); + return false; +} + /// Map a nullability attribute kind to a nullability kind. static NullabilityKind mapNullabilityAttrKind(ParsedAttr::Kind kind) { switch (kind) { @@ -8480,6 +8529,12 @@ attr.setUsedAsTypeAttr(); break; + case ParsedAttr::AT_WebAssemblyFuncref: { + if (!HandleWebAssemblyFuncrefAttr(state, type, attr)) + attr.setUsedAsTypeAttr(); + break; + } + MS_TYPE_ATTRS_CASELIST: if (!handleMSPointerTypeQualifierAttr(state, attr, type)) attr.setUsedAsTypeAttr(); diff --git a/clang/test/CodeGen/WebAssembly/wasm-funcref.c b/clang/test/CodeGen/WebAssembly/wasm-funcref.c new file mode 100644 --- /dev/null +++ b/clang/test/CodeGen/WebAssembly/wasm-funcref.c @@ -0,0 +1,84 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py +// RUN: %clang_cc1 -triple wasm32 -target-feature +reference-types -o - -emit-llvm %s | FileCheck %s + +typedef void (*__funcref funcref_t)(); +typedef int (*__funcref fn_funcref_t)(int); +typedef int (*fn_t)(int); + +// Null funcref builtin call +// CHECK-LABEL: @get_null( +// CHECK-NEXT: entry: +// CHECK-NEXT: [[TMP0:%.*]] = call ptr addrspace(20) @llvm.wasm.ref.null.func() +// CHECK-NEXT: ret ptr addrspace(20) [[TMP0]] +// +funcref_t get_null() { + return __builtin_wasm_ref_null_func(); +} + +// Call to null funcref builtin but requires cast since +// default return value for builtin is a funcref with function type () -> (). +// CHECK-LABEL: @get_null_ii( +// CHECK-NEXT: entry: +// CHECK-NEXT: [[TMP0:%.*]] = call ptr addrspace(20) @llvm.wasm.ref.null.func() +// CHECK-NEXT: ret ptr addrspace(20) [[TMP0]] +// +fn_funcref_t get_null_ii() { + return (fn_funcref_t) __builtin_wasm_ref_null_func(); +} + +// Identity function for funcref. +// CHECK-LABEL: @identity( +// CHECK-NEXT: entry: +// CHECK-NEXT: [[FN_ADDR:%.*]] = alloca ptr addrspace(20), align 4 +// CHECK-NEXT: store ptr addrspace(20) [[FN:%.*]], ptr [[FN_ADDR]], align 4 +// CHECK-NEXT: [[TMP0:%.*]] = load ptr addrspace(20), ptr [[FN_ADDR]], align 4 +// CHECK-NEXT: ret ptr addrspace(20) [[TMP0]] +// +funcref_t identity(funcref_t fn) { + return fn; +} + +void helper(funcref_t); + +// Pass funcref ref as an argument to a helper function. +// CHECK-LABEL: @handle( +// CHECK-NEXT: entry: +// CHECK-NEXT: [[FN_ADDR:%.*]] = alloca ptr addrspace(20), align 4 +// CHECK-NEXT: store ptr addrspace(20) [[FN:%.*]], ptr [[FN_ADDR]], align 4 +// CHECK-NEXT: [[TMP0:%.*]] = load ptr addrspace(20), ptr [[FN_ADDR]], align 4 +// CHECK-NEXT: call void @helper(ptr addrspace(20) noundef [[TMP0]]) +// CHECK-NEXT: ret i32 0 +// +int handle(funcref_t fn) { + helper(fn); + return 0; +} + +// Return funcref from function pointer. +// CHECK-LABEL: @get_ref( +// CHECK-NEXT: entry: +// CHECK-NEXT: [[FNPTR_ADDR:%.*]] = alloca ptr, align 4 +// CHECK-NEXT: store ptr [[FNPTR:%.*]], ptr [[FNPTR_ADDR]], align 4 +// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[FNPTR_ADDR]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = addrspacecast ptr [[TMP0]] to ptr addrspace(20) +// CHECK-NEXT: ret ptr addrspace(20) [[TMP1]] +// +fn_funcref_t get_ref(fn_t fnptr) { + return (fn_funcref_t) fnptr; +} + +// Call funcref +// CHECK-LABEL: @call_fn( +// CHECK-NEXT: entry: +// CHECK-NEXT: [[REF_ADDR:%.*]] = alloca ptr addrspace(20), align 4 +// CHECK-NEXT: [[X_ADDR:%.*]] = alloca i32, align 4 +// CHECK-NEXT: store ptr addrspace(20) [[REF:%.*]], ptr [[REF_ADDR]], align 4 +// CHECK-NEXT: store i32 [[X:%.*]], ptr [[X_ADDR]], align 4 +// CHECK-NEXT: [[TMP0:%.*]] = load ptr addrspace(20), ptr [[REF_ADDR]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[X_ADDR]], align 4 +// CHECK-NEXT: [[CALL:%.*]] = call addrspace(20) i32 [[TMP0]](i32 noundef [[TMP1]]) +// CHECK-NEXT: ret i32 [[CALL]] +// +int call_fn(fn_funcref_t ref, int x) { + return ref(x); +} diff --git a/clang/test/SemaTemplate/address_space-dependent.cpp b/clang/test/SemaTemplate/address_space-dependent.cpp --- a/clang/test/SemaTemplate/address_space-dependent.cpp +++ b/clang/test/SemaTemplate/address_space-dependent.cpp @@ -43,7 +43,7 @@ template void tooBig() { - __attribute__((address_space(I))) int *bounds; // expected-error {{address space is larger than the maximum supported (8388587)}} + __attribute__((address_space(I))) int *bounds; // expected-error {{address space is larger than the maximum supported (8388586)}} } template @@ -101,7 +101,7 @@ car<1, 2, 3>(); // expected-note {{in instantiation of function template specialization 'car<1, 2, 3>' requested here}} HasASTemplateFields<1> HASTF; neg<-1>(); // expected-note {{in instantiation of function template specialization 'neg<-1>' requested here}} - correct<0x7FFFEA>(); + correct<0x7FFFE9>(); tooBig<8388650>(); // expected-note {{in instantiation of function template specialization 'tooBig<8388650L>' requested here}} __attribute__((address_space(1))) char *x;