diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h --- a/clang/include/clang/AST/ASTContext.h +++ b/clang/include/clang/AST/ASTContext.h @@ -1141,6 +1141,9 @@ #define RVV_TYPE(Name, Id, SingletonId) \ CanQualType SingletonId; #include "clang/Basic/RISCVVTypes.def" +#define WASM_TYPE(Name, Id, SingletonId) \ + CanQualType SingletonId; +#include "clang/Basic/WebAssemblyReferenceTypes.def" // Types for deductions in C++0x [stmt.ranged]'s desugaring. Built on demand. mutable QualType AutoDeductTy; // Deduction against 'auto'. @@ -1482,6 +1485,12 @@ /// \pre \p EltTy must be a built-in type. QualType getScalableVectorType(QualType EltTy, unsigned NumElts) const; + /// Return a WebAssembly externref type + QualType getExternrefType() const; + + /// Return a WebAssembly funcref type + QualType getFuncrefType() const; + /// Return the unique reference to a vector type of the specified /// element type and size. /// 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 @@ -1420,8 +1420,12 @@ return Quals.getObjCLifetime(); } - bool hasAddressSpace() const { return Quals.hasAddressSpace(); } - LangAS getAddressSpace() const { return Quals.getAddressSpace(); } + bool hasAddressSpace() const { + return Quals.hasAddressSpace(); + } + LangAS getAddressSpace() const { + return Quals.getAddressSpace(); + } const Type *getBaseType() const { return BaseType; } @@ -1903,6 +1907,11 @@ bool isSizelessType() const; bool isSizelessBuiltinType() const; + /// Check if this is a WebAssembly Reference Type. + bool isWebAssemblyReferenceType() const; + bool isWebAssemblyExternrefType() const; + bool isWebAssemblyFuncrefType() const; + /// Determines if this is a sizeless type supported by the /// 'arm_sve_vector_bits' type attribute, which can be applied to a single /// SVE vector or predicate, excluding tuple types such as svint32x4_t. @@ -2513,6 +2522,9 @@ // RVV Types #define RVV_TYPE(Name, Id, SingletonId) Id, #include "clang/Basic/RISCVVTypes.def" +// WebAssembly reference types +#define WASM_TYPE(Name, Id, SingletonId) Id, +#include "clang/Basic/WebAssemblyReferenceTypes.def" // All other builtin types #define BUILTIN_TYPE(Id, SingletonId) Id, #define LAST_BUILTIN_TYPE(Id) LastKind = Id @@ -6609,6 +6621,9 @@ /// Return the address space of this type. inline LangAS QualType::getAddressSpace() const { + if (getTypePtr()->isWebAssemblyFuncrefType()) { + return LangAS::wasm_funcref; + } return getQualifiers().getAddressSpace(); } @@ -6776,6 +6791,11 @@ return false; } +inline bool Type::isWebAssemblyFuncrefType() const { + return isFunctionPointerType() && + hasAttr(attr::WebAssemblyFuncref); +} + inline bool Type::isFunctionReferenceType() const { if (const auto *T = getAs()) return T->getPointeeType()->isFunctionType(); diff --git a/clang/include/clang/AST/TypeProperties.td b/clang/include/clang/AST/TypeProperties.td --- a/clang/include/clang/AST/TypeProperties.td +++ b/clang/include/clang/AST/TypeProperties.td @@ -799,6 +799,10 @@ case BuiltinType::ID: return ctx.SINGLETON_ID; #include "clang/Basic/RISCVVTypes.def" +#define WASM_TYPE(NAME, ID, SINGLETON_ID) \ + case BuiltinType::ID: return ctx.SINGLETON_ID; +#include "clang/Basic/WebAssemblyReferenceTypes.def" + #define BUILTIN_TYPE(ID, SINGLETON_ID) \ case BuiltinType::ID: return ctx.SINGLETON_ID; #include "clang/AST/BuiltinTypes.def" 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 @@ -56,6 +56,10 @@ ptr32_uptr, ptr64, + wasm_var, + wasm_externref, + 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 @@ -3937,3 +3937,9 @@ let Subjects = SubjectList<[Function], ErrorDiag>; let Documentation = [ErrorAttrDocs]; } + +def WebAssemblyFuncref : TypeAttr, TargetSpecificAttr { + let Spellings = [Clang<"__funcref">]; + let Args = []; + let Documentation = [Undocumented]; +} \ No newline at end of file diff --git a/clang/include/clang/Basic/Builtins.def b/clang/include/clang/Basic/Builtins.def --- a/clang/include/clang/Basic/Builtins.def +++ b/clang/include/clang/Basic/Builtins.def @@ -47,6 +47,7 @@ // SJ -> sigjmp_buf // K -> ucontext_t // p -> pid_t +// e -> wasm externref // . -> "...". This may only occur at the end of the function list. // // Types may be prefixed with the following modifiers: 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 @@ -184,5 +184,13 @@ TARGET_BUILTIN(__builtin_wasm_relaxed_trunc_s_zero_i32x4_f64x2, "V4iV2d", "nc", "relaxed-simd") TARGET_BUILTIN(__builtin_wasm_relaxed_trunc_u_zero_i32x4_f64x2, "V4UiV2d", "nc", "relaxed-simd") +// Reference Types builtins +// Some builtins are polymorphic - 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, "e", "nc", "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 @@ -7243,6 +7243,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< + "'__clang_webassembly_funcref' attribute can only be applied to function pointer types">; def warn_setter_getter_impl_required : Warning< "property %0 requires method %1 to be defined - " diff --git a/clang/include/clang/Basic/WebAssemblyReferenceTypes.def b/clang/include/clang/Basic/WebAssemblyReferenceTypes.def new file mode 100644 --- /dev/null +++ b/clang/include/clang/Basic/WebAssemblyReferenceTypes.def @@ -0,0 +1,38 @@ +//===-- WebAssemblyReferenceTypes.def - Wasm reference types ----*- C++ -*-===// +// +// 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 defines externref_t, funcref_t, and the like. The macros are: +// +// WASM_TYPE(Name, Id, SingletonId) +// WASM_REF_TYPE(Name, MangledName, Id, SingletonId, AS) +// +// where: +// +// - Name is the name of the builtin type. MangledName is the mangled name. +// +// - BuiltinType::Id is the enumerator defining the type. +// +// - Context.SingletonId is the global singleton of this type. +// +// - AS indicates the address space for values of this type. +// +// To include this file, define either WASM_REF_TYPE or WASM_TYPE, depending on +// how much information you want. The macros will be undefined after inclusion. +// +//===----------------------------------------------------------------------===// + + +#ifndef WASM_REF_TYPE +#define WASM_REF_TYPE(Name, MangledName, Id, SingletonId, AS) \ + WASM_TYPE(Name, Id, SingletonId) +#endif + +WASM_REF_TYPE("__externref_t", "externref_t", WasmExternRef, WasmExternRefTy, 10) + +#undef WASM_TYPE +#undef WASM_REF_TYPE 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 @@ -12877,6 +12877,9 @@ ExprResult SemaBuiltinMatrixColumnMajorStore(CallExpr *TheCall, ExprResult CallResult); + // WebAssembly builtin handling + bool SemaBuiltinWasmRefNullFunc(CallExpr *TheCall); + public: enum FormatStringType { FST_Scanf, diff --git a/clang/include/clang/Serialization/ASTBitCodes.h b/clang/include/clang/Serialization/ASTBitCodes.h --- a/clang/include/clang/Serialization/ASTBitCodes.h +++ b/clang/include/clang/Serialization/ASTBitCodes.h @@ -1089,6 +1089,9 @@ // \brief RISC-V V types with auto numeration #define RVV_TYPE(Name, Id, SingletonId) PREDEF_TYPE_##Id##_ID, #include "clang/Basic/RISCVVTypes.def" +// \brief WebAssembly reference types with auto numeration +#define WASM_TYPE(Name, Id, SingletonId) PREDEF_TYPE_##Id##_ID, +#include "clang/Basic/WebAssemblyReferenceTypes.def" }; /// The number of predefined type IDs that are reserved for diff --git a/clang/include/clang/module.modulemap b/clang/include/clang/module.modulemap --- a/clang/include/clang/module.modulemap +++ b/clang/include/clang/module.modulemap @@ -72,6 +72,7 @@ textual header "Basic/Sanitizers.def" textual header "Basic/TargetCXXABI.def" textual header "Basic/TokenKinds.def" + textual header "Basic/WebAssemblyReferenceTypes.def" module * { export * } } 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 @@ -948,7 +948,10 @@ 0, // sycl_private 10, // ptr32_sptr 11, // ptr32_uptr - 12 // ptr64 + 12, // ptr64 + 1, // wasm_var + 10, // wasm_externref, + 20, // wasm_funcref }; return &FakeAddrSpaceMap; } else { @@ -1460,6 +1463,13 @@ #include "clang/Basic/RISCVVTypes.def" } + if (Target.getTriple().isWasm() && + Target.hasFeature("reference-types")) { +#define WASM_TYPE(Name, Id, SingletonId) \ + InitBuiltinType(SingletonId, BuiltinType::Id); +#include "clang/Basic/WebAssemblyReferenceTypes.def" + } + // Builtin type for __objc_yes and __objc_no ObjCBuiltinBoolTy = (Target.useSignedCharForObjCBool() ? SignedCharTy : BoolTy); @@ -2233,6 +2243,12 @@ Align = 8; \ break; #include "clang/Basic/RISCVVTypes.def" +#define WASM_TYPE(Name, Id, SingletonId) \ + case BuiltinType::Id: \ + Width = 0; \ + Align = 8; /* ? */ \ + break; +#include "clang/Basic/WebAssemblyReferenceTypes.def" } break; case Type::ObjCObjectPointer: @@ -3937,6 +3953,26 @@ } } +/// getExternrefType - Return a WebAssembly externref type, which represents an +/// opaque reference to a host value. +QualType ASTContext::getExternrefType() const { + if (Target->hasFeature("reference-types")) { +#define WASM_REF_TYPE(Name, MangledName, Id, SingletonId, AS) \ + if (BuiltinType::Id == BuiltinType::WasmExternRef) \ + return SingletonId; +#include "clang/Basic/WebAssemblyReferenceTypes.def" + } + return QualType(); +} + +/// getFuncrefType - Return a WebAssembly funcref type, which represents an +/// opaque reference to a function. +QualType ASTContext::getFuncrefType() const { + // FIXME: this cannot be written because there's no single funcref type + // anymore + return QualType(); +} + /// getScalableVectorType - Return the unique reference to a scalable vector /// type of the specified element type and size. VectorType must be a built-in /// type. @@ -7828,6 +7864,8 @@ #include "clang/Basic/AArch64SVEACLETypes.def" #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id: #include "clang/Basic/RISCVVTypes.def" +#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id: +#include "clang/Basic/WebAssemblyReferenceTypes.def" { DiagnosticsEngine &Diags = C->getDiagnostics(); unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, @@ -11045,6 +11083,10 @@ Type = Context.getScalableVectorType(ElementType, NumElements); break; } + case 'e': { + Type = Context.getExternrefType(); + break; + } case 'V': { char *End; unsigned NumElements = strtoul(Str, &End, 10); diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp --- a/clang/lib/AST/ASTImporter.cpp +++ b/clang/lib/AST/ASTImporter.cpp @@ -1058,6 +1058,10 @@ case BuiltinType::Id: \ return Importer.getToContext().SingletonId; #include "clang/Basic/RISCVVTypes.def" +#define WASM_TYPE(Name, Id, SingletonId) \ + case BuiltinType::Id: \ + return Importer.getToContext().SingletonId; +#include "clang/Basic/WebAssemblyReferenceTypes.def" #define SHARED_SINGLETON_TYPE(Expansion) #define BUILTIN_TYPE(Id, SingletonId) \ case BuiltinType::Id: return Importer.getToContext().SingletonId; diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp --- a/clang/lib/AST/ExprConstant.cpp +++ b/clang/lib/AST/ExprConstant.cpp @@ -11178,6 +11178,9 @@ #include "clang/Basic/PPCTypes.def" #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id: #include "clang/Basic/RISCVVTypes.def" +#define WASM_TYPE(Name, Id, SingletonId) \ + case BuiltinType::Id: +#include "clang/Basic/WebAssemblyReferenceTypes.def" return GCCTypeClass::None; case BuiltinType::Dependent: diff --git a/clang/lib/AST/ItaniumMangle.cpp b/clang/lib/AST/ItaniumMangle.cpp --- a/clang/lib/AST/ItaniumMangle.cpp +++ b/clang/lib/AST/ItaniumMangle.cpp @@ -3116,6 +3116,13 @@ Out << 'u' << type_name.size() << type_name; \ break; #include "clang/Basic/RISCVVTypes.def" +#define WASM_REF_TYPE(InternalName, MangledName, Id, SingletonId, AS) \ + case BuiltinType::Id: \ + type_name = MangledName; \ + Out << (type_name == InternalName ? "u" : "") << type_name.size() \ + << type_name; \ + break; +#include "clang/Basic/WebAssemblyReferenceTypes.def" } } diff --git a/clang/lib/AST/MicrosoftMangle.cpp b/clang/lib/AST/MicrosoftMangle.cpp --- a/clang/lib/AST/MicrosoftMangle.cpp +++ b/clang/lib/AST/MicrosoftMangle.cpp @@ -2470,6 +2470,9 @@ #include "clang/Basic/PPCTypes.def" #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id: #include "clang/Basic/RISCVVTypes.def" +#define WASM_TYPE(Name, Id, SingletonId) \ + case BuiltinType::Id: +#include "clang/Basic/WebAssemblyReferenceTypes.def" case BuiltinType::ShortAccum: case BuiltinType::Accum: case BuiltinType::LongAccum: diff --git a/clang/lib/AST/NSAPI.cpp b/clang/lib/AST/NSAPI.cpp --- a/clang/lib/AST/NSAPI.cpp +++ b/clang/lib/AST/NSAPI.cpp @@ -480,6 +480,8 @@ #include "clang/Basic/PPCTypes.def" #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id: #include "clang/Basic/RISCVVTypes.def" +#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id: +#include "clang/Basic/WebAssemblyReferenceTypes.def" case BuiltinType::BoundMember: case BuiltinType::Dependent: case BuiltinType::Overload: diff --git a/clang/lib/AST/PrintfFormatString.cpp b/clang/lib/AST/PrintfFormatString.cpp --- a/clang/lib/AST/PrintfFormatString.cpp +++ b/clang/lib/AST/PrintfFormatString.cpp @@ -797,6 +797,9 @@ #include "clang/Basic/PPCTypes.def" #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id: #include "clang/Basic/RISCVVTypes.def" +#define WASM_TYPE(Name, Id, SingletonId) \ + case BuiltinType::Id: +#include "clang/Basic/WebAssemblyReferenceTypes.def" #define SIGNED_TYPE(Id, SingletonId) #define UNSIGNED_TYPE(Id, SingletonId) #define FLOATING_TYPE(Id, SingletonId) 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 @@ -2312,6 +2312,10 @@ #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id: #include "clang/Basic/RISCVVTypes.def" return true; + // WebAssembly reference types +#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id: +#include "clang/Basic/WebAssemblyReferenceTypes.def" + return true; default: return false; } @@ -2319,6 +2323,18 @@ return false; } +bool Type::isWebAssemblyReferenceType() const { + return isWebAssemblyFuncrefType() || + isWebAssemblyExternrefType(); +} + +bool Type::isWebAssemblyExternrefType() const { + const BuiltinType *BT = getAs(); + if (BT && BT->getKind() == BuiltinType::WasmExternRef) + return true; + return false; +} + bool Type::isSizelessType() const { return isSizelessBuiltinType(); } bool Type::isVLSTBuiltinType() const { @@ -3144,6 +3160,10 @@ case Id: \ return Name; #include "clang/Basic/RISCVVTypes.def" +#define WASM_TYPE(Name, Id, SingletonId) \ + case Id: \ + return Name; +#include "clang/Basic/WebAssemblyReferenceTypes.def" } llvm_unreachable("Invalid builtin type."); @@ -4181,6 +4201,9 @@ #include "clang/Basic/PPCTypes.def" #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id: #include "clang/Basic/RISCVVTypes.def" +#define WASM_TYPE(Name, Id, SingletonId) \ + case BuiltinType::Id: +#include "clang/Basic/WebAssemblyReferenceTypes.def" case BuiltinType::BuiltinFn: case BuiltinType::NullPtr: case BuiltinType::IncompleteMatrixIdx: diff --git a/clang/lib/AST/TypeLoc.cpp b/clang/lib/AST/TypeLoc.cpp --- a/clang/lib/AST/TypeLoc.cpp +++ b/clang/lib/AST/TypeLoc.cpp @@ -418,6 +418,8 @@ #include "clang/Basic/PPCTypes.def" #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id: #include "clang/Basic/RISCVVTypes.def" +#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id: +#include "clang/Basic/WebAssemblyReferenceTypes.def" case BuiltinType::BuiltinFn: case BuiltinType::IncompleteMatrixIdx: case BuiltinType::OMPArraySection: 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 @@ -1704,6 +1704,8 @@ // AttributedType nodes for them. break; + case attr::WebAssemblyFuncref: OS << "__funcref"; break; + case attr::LifetimeBound: case attr::TypeNonNull: case attr::TypeNullable: 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 @@ -29,20 +29,23 @@ 4, // opencl_constant 0, // opencl_private // FIXME: generic has to be added to the target - 0, // opencl_generic - 1, // opencl_global_device - 1, // opencl_global_host - 1, // cuda_device - 4, // cuda_constant - 3, // cuda_shared - 1, // sycl_global - 1, // sycl_global_device - 1, // sycl_global_host - 3, // sycl_local - 0, // sycl_private - 0, // ptr32_sptr - 0, // ptr32_uptr - 0 // ptr64 + 0, // opencl_generic + 1, // opencl_global_device + 1, // opencl_global_host + 1, // cuda_device + 4, // cuda_constant + 3, // cuda_shared + 1, // sycl_global + 1, // sycl_global_device + 1, // sycl_global_host + 3, // sycl_local + 0, // sycl_private + 0, // ptr32_sptr + 0, // ptr32_uptr + 0, // ptr64 + 1, // wasm_var + 10, // wasm_externref, + 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 @@ -42,7 +42,10 @@ 0, // sycl_private 0, // ptr32_sptr 0, // ptr32_uptr - 0 // ptr64 + 0, // ptr64 + 1, // wasm_var + 10,// wasm_externref + 20,// wasm_funcref }; // Used by both the SPIR and SPIR-V targets. @@ -71,7 +74,10 @@ 0, // sycl_private 0, // ptr32_sptr 0, // ptr32_uptr - 0 // ptr64 + 0, // ptr64 + 1, // wasm_var + 10,// wasm_externref, + 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 @@ -38,18 +38,21 @@ 1, // opencl_global_device 1, // opencl_global_host // FIXME: generic has to be added to the target - 0, // opencl_generic - 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 + 0, // opencl_generic + 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 + 1, // wasm_var + 10, // wasm_externref, + 20, // wasm_funcref }; class LLVM_LIBRARY_VISIBILITY TCETargetInfo : public TargetInfo { 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 @@ -42,7 +42,10 @@ 0, // sycl_private 270, // ptr32_sptr 271, // ptr32_uptr - 272 // ptr64 + 272, // ptr64 + 1, // wasm_var + 10, // wasm_externref, + 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 @@ -18269,6 +18269,14 @@ Function *Callee = CGM.getIntrinsic(IntNo, ConvertType(E->getType())); return Builder.CreateCall(Callee, Value); } + case WebAssembly::BI__builtin_wasm_ref_null_extern: { + 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)); @@ -18390,7 +18398,7 @@ IntNo = Intrinsic::wasm_extadd_pairwise_unsigned; break; default: - llvm_unreachable("unexptected builtin ID"); + llvm_unreachable("unexpected builtin ID"); } Function *Callee = CGM.getIntrinsic(IntNo, ConvertType(E->getType())); diff --git a/clang/lib/CodeGen/CGDebugInfo.h b/clang/lib/CodeGen/CGDebugInfo.h --- a/clang/lib/CodeGen/CGDebugInfo.h +++ b/clang/lib/CodeGen/CGDebugInfo.h @@ -80,6 +80,9 @@ #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \ llvm::DIType *Id##Ty = nullptr; #include "clang/Basic/OpenCLExtensionTypes.def" +#define WASM_TYPE(Name, Id, SingletonId) \ + llvm::DIType *SingletonId = nullptr; +#include "clang/Basic/WebAssemblyReferenceTypes.def" /// Cache of previously constructed Types. llvm::DenseMap TypeCache; diff --git a/clang/lib/CodeGen/CGDebugInfo.cpp b/clang/lib/CodeGen/CGDebugInfo.cpp --- a/clang/lib/CodeGen/CGDebugInfo.cpp +++ b/clang/lib/CodeGen/CGDebugInfo.cpp @@ -796,6 +796,17 @@ return DBuilder.createVectorType(/*Size=*/0, Align, ElemTy, SubscriptArray); } + +#define WASM_REF_TYPE(Name, MangledName, Id, SingletonId, AS) \ + case BuiltinType::Id: { \ + if (!SingletonId) \ + SingletonId = DBuilder.createForwardDecl( \ + llvm::dwarf::DW_TAG_structure_type, MangledName, TheCU, \ + TheCU->getFile(), 0); \ + return SingletonId; \ + } +#include "clang/Basic/WebAssemblyReferenceTypes.def" + case BuiltinType::UChar: case BuiltinType::Char_U: Encoding = llvm::dwarf::DW_ATE_unsigned_char; diff --git a/clang/lib/CodeGen/CGExprScalar.cpp b/clang/lib/CodeGen/CGExprScalar.cpp --- a/clang/lib/CodeGen/CGExprScalar.cpp +++ b/clang/lib/CodeGen/CGExprScalar.cpp @@ -2033,6 +2033,17 @@ Value *Src = Visit(const_cast(E)); llvm::Type *SrcTy = Src->getType(); llvm::Type *DstTy = ConvertType(DestTy); + + // If the destination type is a WebAssembly Funcref then, we allow the + // types to have different address spaces and the one not in the + // funcref address space is converted at this point. + if (DestTy->isWebAssemblyFuncrefType()) { + llvm::PointerType *PtrTy = cast(DstTy); + // FIXME: hardcoded addrspace, should be + // llvm::WebAssembly::WasmAddressSpace::WASM_ADDRESS_SPACE_FUNCREF + DstTy = llvm::PointerType::getWithSamePointeeType(PtrTy, 20); + } + if (SrcTy->isPtrOrPtrVectorTy() && DstTy->isPtrOrPtrVectorTy() && SrcTy->getPointerAddressSpace() != DstTy->getPointerAddressSpace()) { llvm_unreachable("wrong cast for pointers in different address spaces" diff --git a/clang/lib/CodeGen/CodeGenTypes.cpp b/clang/lib/CodeGen/CodeGenTypes.cpp --- a/clang/lib/CodeGen/CodeGenTypes.cpp +++ b/clang/lib/CodeGen/CodeGenTypes.cpp @@ -633,6 +633,17 @@ Info.EC.getKnownMinValue() * Info.NumVectors); } +#define WASM_REF_TYPE(Name, MangledName, Id, SingletonId, AS) \ + case BuiltinType::Id: \ + { \ + if (BuiltinType::Id == BuiltinType::WasmExternRef) \ + ResultType = CGM.getTargetCodeGenInfo() \ + .getWasmExternrefReferenceType(); \ + else \ + llvm_unreachable("Unexpected wasm reference builtin type!"); \ + } \ + break; +#include "clang/Basic/WebAssemblyReferenceTypes.def" case BuiltinType::Dependent: #define BUILTIN_TYPE(Id, SingletonId) #define PLACEHOLDER_TYPE(Id, SingletonId) \ diff --git a/clang/lib/CodeGen/ItaniumCXXABI.cpp b/clang/lib/CodeGen/ItaniumCXXABI.cpp --- a/clang/lib/CodeGen/ItaniumCXXABI.cpp +++ b/clang/lib/CodeGen/ItaniumCXXABI.cpp @@ -3257,6 +3257,9 @@ #include "clang/Basic/PPCTypes.def" #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id: #include "clang/Basic/RISCVVTypes.def" +#define WASM_TYPE(Name, Id, SingletonId) \ + case BuiltinType::Id: +#include "clang/Basic/WebAssemblyReferenceTypes.def" case BuiltinType::ShortAccum: case BuiltinType::Accum: case BuiltinType::LongAccum: 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 @@ -349,6 +349,15 @@ return nullptr; } + /// 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 @@ -878,6 +878,15 @@ Fn->addFnAttr("no-prototype"); } } + + /// Return the WebAssembly externref reference type. + 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/Index/USRGeneration.cpp b/clang/lib/Index/USRGeneration.cpp --- a/clang/lib/Index/USRGeneration.cpp +++ b/clang/lib/Index/USRGeneration.cpp @@ -735,6 +735,9 @@ #include "clang/Basic/PPCTypes.def" #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id: #include "clang/Basic/RISCVVTypes.def" +#define WASM_TYPE(Name, Id, SingletonId) \ + case BuiltinType::Id: +#include "clang/Basic/WebAssemblyReferenceTypes.def" case BuiltinType::ShortAccum: case BuiltinType::Accum: case BuiltinType::LongAccum: diff --git a/clang/lib/Sema/Sema.cpp b/clang/lib/Sema/Sema.cpp --- a/clang/lib/Sema/Sema.cpp +++ b/clang/lib/Sema/Sema.cpp @@ -454,6 +454,13 @@ #include "clang/Basic/RISCVVTypes.def" } + if (Context.getTargetInfo().getTriple().isWasm() && + Context.getTargetInfo().hasFeature("reference-types")) { +#define WASM_TYPE(Name, Id, SingletonId) \ + addImplicitTypedef(Name, Context.SingletonId); +#include "clang/Basic/WebAssemblyReferenceTypes.def" + } + if (Context.getTargetInfo().hasBuiltinMSVaList()) { DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list"); if (IdResolver.begin(MSVaList) == IdResolver.end()) 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 @@ -2349,7 +2349,14 @@ diag::err_hip_invalid_args_builtin_mangled_name); return ExprError(); } + break; } + + case WebAssembly::BI__builtin_wasm_ref_null_func: + if (SemaBuiltinWasmRefNullFunc(TheCall)) + return ExprError(); + break; + } // Since the target specific builtins for each arch overlap, only check those @@ -6150,6 +6157,20 @@ return false; } +bool +Sema::SemaBuiltinWasmRefNullFunc(CallExpr *TheCall) { + if (TheCall->getNumArgs() != 0) + return true; + + // Set return type to a function pointer with the funcref attribute attached + QualType FnType = Context.getFunctionType(Context.VoidTy, {}, {}); + QualType FnPtrType = Context.getPointerType(FnType); + + TheCall->setType(FnPtrType); + + 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/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp --- a/clang/lib/Sema/SemaExpr.cpp +++ b/clang/lib/Sema/SemaExpr.cpp @@ -6254,6 +6254,9 @@ #include "clang/Basic/PPCTypes.def" #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id: #include "clang/Basic/RISCVVTypes.def" +#define WASM_TYPE(Name, Id, SingletonId) \ + case BuiltinType::Id: +#include "clang/Basic/WebAssemblyReferenceTypes.def" #define PLACEHOLDER_TYPE(ID, SINGLETON_ID) #define BUILTIN_TYPE(ID, SINGLETON_ID) case BuiltinType::ID: #include "clang/AST/BuiltinTypes.def" @@ -20166,6 +20169,9 @@ #include "clang/Basic/PPCTypes.def" #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id: #include "clang/Basic/RISCVVTypes.def" +#define WASM_TYPE(Name, Id, SingletonId) \ + case BuiltinType::Id: +#include "clang/Basic/WebAssemblyReferenceTypes.def" #define BUILTIN_TYPE(Id, SingletonId) case BuiltinType::Id: #define PLACEHOLDER_TYPE(Id, SingletonId) #include "clang/AST/BuiltinTypes.def" 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 @@ -8036,6 +8036,27 @@ CurType, CurType); } +static void HandleWebAssemblyFuncrefAttr(TypeProcessingState &State, + QualType &CurType, + ParsedAttr &Attr) { + if (!CurType->isFunctionPointerType()) { + State.getSema().Diag(Attr.getLoc(), + diag::err_attribute_webassembly_funcref); + Attr.setInvalid(); + return; + } + + // Add attribute + CurType = + State.getAttributedType(createSimpleAttr( + State.getSema().Context, Attr), + CurType, CurType); + + // Change address space to the funcref addrspace + Qualifiers Q = CurType.getQualifiers(); + Q.setAddressSpace(LangAS::wasm_funcref); +} + /// Handle OpenCL Access Qualifier Attribute. static void HandleOpenCLAccessAttr(QualType &CurType, const ParsedAttr &Attr, Sema &S) { @@ -8280,6 +8301,12 @@ attr.setUsedAsTypeAttr(); break; + case ParsedAttr::AT_WebAssemblyFuncref: { + HandleWebAssemblyFuncrefAttr(state, type, attr); + attr.setUsedAsTypeAttr(); + break; + } + MS_TYPE_ATTRS_CASELIST: if (!handleMSPointerTypeQualifierAttr(state, attr, type)) attr.setUsedAsTypeAttr(); diff --git a/clang/lib/Serialization/ASTCommon.cpp b/clang/lib/Serialization/ASTCommon.cpp --- a/clang/lib/Serialization/ASTCommon.cpp +++ b/clang/lib/Serialization/ASTCommon.cpp @@ -250,6 +250,11 @@ ID = PREDEF_TYPE_##Id##_ID; \ break; #include "clang/Basic/RISCVVTypes.def" +#define WASM_TYPE(Name, Id, SingletonId) \ + case BuiltinType::Id: \ + ID = PREDEF_TYPE_##Id##_ID; \ + break; +#include "clang/Basic/WebAssemblyReferenceTypes.def" case BuiltinType::BuiltinFn: ID = PREDEF_TYPE_BUILTIN_FN; break; diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp --- a/clang/lib/Serialization/ASTReader.cpp +++ b/clang/lib/Serialization/ASTReader.cpp @@ -7087,6 +7087,11 @@ T = Context.SingletonId; \ break; #include "clang/Basic/RISCVVTypes.def" +#define WASM_TYPE(Name, Id, SingletonId) \ + case PREDEF_TYPE_##Id##_ID: \ + T = Context.SingletonId; \ + break; +#include "clang/Basic/WebAssemblyReferenceTypes.def" } assert(!T.isNull() && "Unknown predefined type"); diff --git a/clang/test/CodeGen/WebAssembly/wasm-externref.c b/clang/test/CodeGen/WebAssembly/wasm-externref.c new file mode 100644 --- /dev/null +++ b/clang/test/CodeGen/WebAssembly/wasm-externref.c @@ -0,0 +1,26 @@ +// RUN: %clang_cc1 -triple wasm32-unknown-unknown -target-feature +reference-types -o - -emit-llvm %s | FileCheck %s + +typedef __externref_t externref_t; + +externref_t get_null() { +// CHECK: define {} addrspace(10)* @get_null() #0 { +// CHECK-NEXT: entry: +// CHECK-NEXT: %0 = call {} addrspace(10)* @llvm.wasm.ref.null.extern() +// CHECK-NEXT: ret {} addrspace(10)* %0 +// CHECK-NEXT: } + return __builtin_wasm_ref_null_extern(); +} + +void helper(externref_t); + +void handle(externref_t obj) { +// CHECK: define void @handle({} addrspace(10)* %obj) #0 { +// CHECK-NEXT: entry: +// CHECK-NEXT: %obj.addr = alloca {} addrspace(10)*, align 1 +// CHECK-NEXT: store {} addrspace(10)* %obj, {} addrspace(10)** %obj.addr, align 1 +// CHECK-NEXT: %0 = load {} addrspace(10)*, {} addrspace(10)** %obj.addr, align 1 +// CHECK-NEXT: call void @helper({} addrspace(10)* %0) +// CHECK-NEXT: ret void +// CHECK-NEXT: } + helper(obj); +} 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,38 @@ +// RUN: %clang_cc1 -triple wasm32 -target-feature +reference-types -o - -emit-llvm %s | FileCheck %s + +typedef void (*funcref_t)() __attribute__((__funcref)); + +funcref_t get_null() { +// CHECK: define i8 addrspace(20)* @get_null() #0 { +// CHECK-NEXT: entry: +// CHECK-NEXT: %0 = call i8 addrspace(20)* @llvm.wasm.ref.null.func() +// CHECK-NEXT: ret i8 addrspace(20)* %0 +// CHECK-NEXT: } + return __builtin_wasm_ref_null_func(); +} + +void helper(funcref_t); + +void handle(funcref_t fn) { +// CHECK: define void @handle(i8 addrspace(20)* %fn) #0 { +// CHECK-NEXT: entry: +// CHECK-NEXT: %fn.addr = alloca i8 addrspace(20)*, align 1 +// CHECK-NEXT: store i8 addrspace(20)* %fn, i8 addrspace(20)** %fn.addr, align 1 +// CHECK-NEXT: %0 = load i8 addrspace(20)*, i8 addrspace(20)** %fn.addr, align 1 +// CHECK-NEXT: call void @helper(i8 addrspace(20)* %0) +// CHECK-NEXT: ret void +// CHECK-NEXT: } + helper(fn); +} + +typedef int (*fn_t)(int); +typedef fn_t __attribute__((__funcref)) fn_funcref_t; + +// What happens when we move a function pointer into a funcref and then call it? +fn_funcref_t get_ref(fn_t fnptr) { + return fnptr; +} + +int call_fn(fn_funcref_t ref, int x) { + return ref(x); +} diff --git a/clang/test/CodeGen/builtins-wasm.c b/clang/test/CodeGen/builtins-wasm.c --- a/clang/test/CodeGen/builtins-wasm.c +++ b/clang/test/CodeGen/builtins-wasm.c @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -triple wasm32-unknown-unknown -target-feature +simd128 -target-feature +relaxed-simd -target-feature +nontrapping-fptoint -target-feature +exception-handling -target-feature +bulk-memory -target-feature +atomics -flax-vector-conversions=none -O3 -emit-llvm -o - %s | FileCheck %s -check-prefixes WEBASSEMBLY,WEBASSEMBLY32 -// RUN: %clang_cc1 -triple wasm64-unknown-unknown -target-feature +simd128 -target-feature +relaxed-simd -target-feature +nontrapping-fptoint -target-feature +exception-handling -target-feature +bulk-memory -target-feature +atomics -flax-vector-conversions=none -O3 -emit-llvm -o - %s | FileCheck %s -check-prefixes WEBASSEMBLY,WEBASSEMBLY64 -// RUN: not %clang_cc1 -triple wasm64-unknown-unknown -target-feature +nontrapping-fptoint -target-feature +exception-handling -target-feature +bulk-memory -target-feature +atomics -flax-vector-conversions=none -O3 -emit-llvm -o - %s 2>&1 | FileCheck %s -check-prefixes MISSING-SIMD +// RUN: %clang_cc1 -triple wasm32-unknown-unknown -target-feature +reference-types -target-feature +simd128 -target-feature +relaxed-simd -target-feature +nontrapping-fptoint -target-feature +exception-handling -target-feature +bulk-memory -target-feature +atomics -flax-vector-conversions=none -O3 -emit-llvm -o - %s | FileCheck %s -check-prefixes WEBASSEMBLY,WEBASSEMBLY32 +// RUN: %clang_cc1 -triple wasm64-unknown-unknown -target-feature +reference-types -target-feature +simd128 -target-feature +relaxed-simd -target-feature +nontrapping-fptoint -target-feature +exception-handling -target-feature +bulk-memory -target-feature +atomics -flax-vector-conversions=none -O3 -emit-llvm -o - %s | FileCheck %s -check-prefixes WEBASSEMBLY,WEBASSEMBLY64 +// RUN: not %clang_cc1 -triple wasm64-unknown-unknown -target-feature +reference-types -target-feature +nontrapping-fptoint -target-feature +exception-handling -target-feature +bulk-memory -target-feature +atomics -flax-vector-conversions=none -O3 -emit-llvm -o - %s 2>&1 | FileCheck %s -check-prefixes MISSING-SIMD // SIMD convenience types typedef signed char i8x16 __attribute((vector_size(16))); @@ -777,3 +777,9 @@ // WEBASSEMBLY: call <4 x i32> @llvm.wasm.relaxed.trunc.unsigned.zero(<2 x double> %x) // WEBASSEMBLY-NEXT: ret } + +__externref_t externref_null() { + return __builtin_wasm_ref_null_extern(); + // WEBASSEMBLY: tail call {} addrspace(10)* @llvm.wasm.ref.null.extern() + // WEBASSEMBLY-NEXT: ret +} diff --git a/clang/test/CodeGenCXX/wasm-reftypes-mangle.cpp b/clang/test/CodeGenCXX/wasm-reftypes-mangle.cpp new file mode 100644 --- /dev/null +++ b/clang/test/CodeGenCXX/wasm-reftypes-mangle.cpp @@ -0,0 +1,7 @@ +// REQUIRES: webassembly-registered-target +// RUN: %clang_cc1 %s -triple wasm32-unknown-unknown -target-feature +reference-types -emit-llvm -o - -std=c++11 | FileCheck %s +// RUN: %clang_cc1 %s -triple wasm64-unknown-unknown -target-feature +reference-types -emit-llvm -o - -std=c++11 | FileCheck %s + +// CHECK: _Z2f111externref_t +void f1(__externref_t) {} + diff --git a/clang/test/CodeGenCXX/wasm-reftypes-typeinfo.cpp b/clang/test/CodeGenCXX/wasm-reftypes-typeinfo.cpp new file mode 100644 --- /dev/null +++ b/clang/test/CodeGenCXX/wasm-reftypes-typeinfo.cpp @@ -0,0 +1,10 @@ +// REQUIRES: webassembly-registered-target +// RUN: %clang_cc1 %s -triple wasm32-unknown-unknown -target-feature +reference-types -emit-llvm -o - -std=c++11 | FileCheck %s +// RUN: %clang_cc1 %s -triple wasm64-unknown-unknown -target-feature +reference-types -emit-llvm -o - -std=c++11 | FileCheck %s + +namespace std { class type_info; }; + +auto &externref = typeid(__externref_t); + +// CHECK-DAG: @_ZTS11externref_t = {{.*}} c"11externref_t\00" +// CHECK-DAG: @_ZTI11externref_t = {{.*}} @_ZTVN10__cxxabiv123__fundamental_type_infoE, {{.*}} @_ZTS11externref_t diff --git a/clang/tools/libclang/CIndex.cpp b/clang/tools/libclang/CIndex.cpp --- a/clang/tools/libclang/CIndex.cpp +++ b/clang/tools/libclang/CIndex.cpp @@ -1551,6 +1551,8 @@ #include "clang/Basic/PPCTypes.def" #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id: #include "clang/Basic/RISCVVTypes.def" +#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id: +#include "clang/Basic/WebAssemblyReferenceTypes.def" #define BUILTIN_TYPE(Id, SingletonId) #define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id: #define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id: diff --git a/llvm/include/llvm/IR/Type.h b/llvm/include/llvm/IR/Type.h --- a/llvm/include/llvm/IR/Type.h +++ b/llvm/include/llvm/IR/Type.h @@ -464,6 +464,8 @@ static PointerType *getInt16PtrTy(LLVMContext &C, unsigned AS = 0); static PointerType *getInt32PtrTy(LLVMContext &C, unsigned AS = 0); static PointerType *getInt64PtrTy(LLVMContext &C, unsigned AS = 0); + static Type *getWasm_ExternrefTy(LLVMContext &C); + static Type *getWasm_FuncrefTy(LLVMContext &C); /// Return a pointer to the current type. This is equivalent to /// PointerType::get(Foo, AddrSpace). diff --git a/llvm/lib/CodeGen/ValueTypes.cpp b/llvm/lib/CodeGen/ValueTypes.cpp --- a/llvm/lib/CodeGen/ValueTypes.cpp +++ b/llvm/lib/CodeGen/ValueTypes.cpp @@ -201,12 +201,8 @@ case MVT::x86mmx: return Type::getX86_MMXTy(Context); case MVT::x86amx: return Type::getX86_AMXTy(Context); case MVT::i64x8: return IntegerType::get(Context, 512); - case MVT::externref: - // pointer to opaque struct in addrspace(10) - return PointerType::get(StructType::create(Context), 10); - case MVT::funcref: - // pointer to i8 addrspace(20) - return PointerType::get(Type::getInt8Ty(Context), 20); + case MVT::externref: return Type::getWasm_ExternrefTy(Context); + case MVT::funcref: return Type::getWasm_FuncrefTy(Context); case MVT::v1i1: return FixedVectorType::get(Type::getInt1Ty(Context), 1); case MVT::v2i1: diff --git a/llvm/lib/IR/Type.cpp b/llvm/lib/IR/Type.cpp --- a/llvm/lib/IR/Type.cpp +++ b/llvm/lib/IR/Type.cpp @@ -304,6 +304,18 @@ return getInt64Ty(C)->getPointerTo(AS); } +Type *Type::getWasm_ExternrefTy(LLVMContext &C) { + // pointer to opaque struct in addrspace(10) + static PointerType *Ty = PointerType::get(StructType::get(C), 10); + return Ty; +} + +Type *Type::getWasm_FuncrefTy(LLVMContext &C) { + // pointer to i8 addrspace(20) + static PointerType *Ty = PointerType::get(Type::getInt8Ty(C), 20); + return Ty; +} + //===----------------------------------------------------------------------===// // IntegerType Implementation //===----------------------------------------------------------------------===// diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp --- a/llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp @@ -404,11 +404,17 @@ } //===----------------------------------------------------------------------===// -// The following functions are called from lib/CodeGen/Passes.cpp to modify -// the CodeGen pass sequence. +// The following functions are called from lib/CodeGen/TargetPassConfig.cpp +// to modify the CodeGen pass sequence. //===----------------------------------------------------------------------===// void WebAssemblyPassConfig::addIRPasses() { + // Run mem2reg to remove alloca references - needed for reference types + // FIXME: this should only be added when the subtarget has reference types + // enabled but the subtarget is dependent on the function being compiled to + // which we don't have access atm. + addPass(createPromoteMemoryToRegisterPass()); + // Add signatures to prototype-less function declarations addPass(createWebAssemblyAddMissingPrototypes());