#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'.
/// \pre \p EltTy must be a built-in type.
QualType getScalableVectorType(QualType EltTy, unsigned NumElts) const;
- /// Return a WebAssembly externref type.
- QualType getWebAssemblyExternrefType() const;
-
/// Return the unique reference to a vector type of the specified
/// element type and size.
///
/// Returns true for SVE scalable vector types.
bool isSVESizelessBuiltinType() const;
- /// Check if this is a WebAssembly Reference Type.
- bool isWebAssemblyReferenceType() const;
- bool isWebAssemblyExternrefType() 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.
// 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
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"
TARGET_BUILTIN(__builtin_wasm_relaxed_dot_i8x16_i7x16_add_s_i32x4, "V4iV16ScV16ScV4i", "nc", "relaxed-simd")
TARGET_BUILTIN(__builtin_wasm_relaxed_dot_bf16x8_add_f32_f32x4, "V4fV8UsV8UsV4f", "nc", "relaxed-simd")
-// Reference Types builtins
-
-TARGET_BUILTIN(__builtin_wasm_ref_null_extern, "i", "nct", "reference-types")
-
#undef BUILTIN
#undef TARGET_BUILTIN
"used%select{| in pointer arithmetic| in buffer access}0 here">;
def err_loongarch_builtin_requires_la32 : Error<
"this builtin requires target: loongarch32">;
-
-// WebAssembly reference type and table diagnostics.
-def err_wasm_reference_pr : Error<
- "%select{pointer|reference}0 to WebAssembly reference type is not allowed">;
-def err_wasm_ca_reference : Error<
- "cannot %select{capture|take address of}0 WebAssembly reference">;
} // end of sema component.
+++ /dev/null
-//===-- 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. 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.
-//
-// - MangledNameBase is the base used for name mangling.
-//
-// - 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, MangledNameBase, 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
CallExpr *TheCall);
bool CheckLoongArchBuiltinFunctionCall(const TargetInfo &TI,
unsigned BuiltinID, CallExpr *TheCall);
- bool CheckWebAssemblyBuiltinFunctionCall(const TargetInfo &TI,
- unsigned BuiltinID,
- CallExpr *TheCall);
bool SemaBuiltinVAStart(unsigned BuiltinID, CallExpr *TheCall);
bool SemaBuiltinVAStartARMMicrosoft(CallExpr *Call);
ExprResult SemaBuiltinMatrixColumnMajorStore(CallExpr *TheCall,
ExprResult CallResult);
- // WebAssembly builtin handling.
- bool BuiltinWasmRefNullExtern(CallExpr *TheCall);
-
public:
enum FormatStringType {
FST_Scanf,
// \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
textual header "Basic/Sanitizers.def"
textual header "Basic/TargetCXXABI.def"
textual header "Basic/TransformTypeTraits.def"
- textual header "Basic/TokenKinds.def"
- textual header "Basic/WebAssemblyReferenceTypes.def"
module * { export * }
}
#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);
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:
}
}
-/// getExternrefType - Return a WebAssembly externref type, which represents an
-/// opaque reference to a host value.
-QualType ASTContext::getWebAssemblyExternrefType() const {
- if (Target->getTriple().isWasm() && 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"
- }
- llvm_unreachable(
- "shouldn't try to generate type externref outside WebAssembly target");
-}
-
/// getScalableVectorType - Return the unique reference to a scalable vector
/// type of the specified element type and size. VectorType must be a built-in
/// type.
#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,
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;
#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:
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 << 'u' << type_name.size() << type_name; \
- break;
-#include "clang/Basic/WebAssemblyReferenceTypes.def"
}
}
mangleArtificialTagType(TTK_Struct, "__bf16", {"__clang"});
break;
-#define WASM_REF_TYPE(InternalName, MangledName, Id, SingletonId, AS) \
- case BuiltinType::Id: \
- mangleArtificialTagType(TTK_Struct, MangledName); \
- mangleArtificialTagType(TTK_Struct, MangledName, {"__clang"}); \
- break;
-
-#include "clang/Basic/WebAssemblyReferenceTypes.def"
#define SVE_TYPE(Name, Id, SingletonId) \
case BuiltinType::Id:
#include "clang/Basic/AArch64SVEACLETypes.def"
#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:
#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)
#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;
}
return false;
}
-bool Type::isWebAssemblyReferenceType() const {
- return isWebAssemblyExternrefType();
-}
-
-bool Type::isWebAssemblyExternrefType() const {
- if (const auto *BT = getAs<BuiltinType>())
- return BT->getKind() == BuiltinType::WasmExternRef;
- return false;
-}
-
bool Type::isSizelessType() const { return isSizelessBuiltinType(); }
bool Type::isSVESizelessBuiltinType() const {
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.");
#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:
#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:
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_swizzle_i8x16: {
Value *Src = EmitScalarExpr(E->getArg(0));
Value *Indices = EmitScalarExpr(E->getArg(1));
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;
#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<const void *, llvm::TrackingMDRef> TypeCache;
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:
+ case BuiltinType::Dependent:
#define BUILTIN_TYPE(Id, SingletonId)
#define PLACEHOLDER_TYPE(Id, SingletonId) \
case BuiltinType::Id:
#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:
Fn->addFnAttr("no-prototype");
}
}
-
- /// Return the WebAssembly externref reference type.
- virtual llvm::Type *getWasmExternrefReferenceType() const override {
- return llvm::Type::getWasm_ExternrefTy(getABIInfo().getVMContext());
- }
};
/// Classify argument of given type \p Ty.
return nullptr;
}
- /// Return the WebAssembly externref reference type.
- virtual llvm::Type *getWasmExternrefReferenceType() const { return nullptr; }
-
/// Emit the device-side copy of the builtin surface type.
virtual bool emitCUDADeviceBuiltinSurfaceDeviceCopy(CodeGenFunction &CGF,
LValue Dst,
case BuiltinType::Id: \
Out << "@BT@" << Name; break;
#include "clang/Basic/RISCVVTypes.def"
-#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
-#include "clang/Basic/WebAssemblyReferenceTypes.def"
case BuiltinType::ShortAccum:
Out << "@BT@ShortAccum"; break;
case BuiltinType::Accum:
#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())
case llvm::Triple::loongarch32:
case llvm::Triple::loongarch64:
return CheckLoongArchBuiltinFunctionCall(TI, BuiltinID, TheCall);
- case llvm::Triple::wasm32:
- case llvm::Triple::wasm64:
- return CheckWebAssemblyBuiltinFunctionCall(TI, BuiltinID, TheCall);
}
}
return SemaBuiltinConstantArgRange(TheCall, i, l, u);
}
-bool Sema::CheckWebAssemblyBuiltinFunctionCall(const TargetInfo &TI,
- unsigned BuiltinID,
- CallExpr *TheCall) {
- switch (BuiltinID) {
- case WebAssembly::BI__builtin_wasm_ref_null_extern:
- return BuiltinWasmRefNullExtern(TheCall);
- }
-
- return false;
-}
-
/// SemaBuiltinCpuSupports - Handle __builtin_cpu_supports(char *).
/// This checks that the target supports __builtin_cpu_supports and
/// that the string argument is constant and valid.
return false;
}
-bool Sema::BuiltinWasmRefNullExtern(CallExpr *TheCall) {
- if (TheCall->getNumArgs() != 0)
- return true;
-
- TheCall->setType(Context.getWebAssemblyExternrefType());
-
- 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
return;
}
- if (!NewVD->hasLocalStorage() && T->isSizelessType() &&
- !T->isWebAssemblyReferenceType()) {
+ if (!NewVD->hasLocalStorage() && T->isSizelessType()) {
Diag(NewVD->getLocation(), diag::err_sizeless_nonlocal) << T;
NewVD->setInvalidDecl();
return;
if (Ty.isDestructedType() == QualType::DK_nontrivial_c_struct)
return VAK_Invalid;
- if (Context.getTargetInfo().getTriple().isWasm() &&
- Ty->isWebAssemblyReferenceType()) {
- return VAK_Invalid;
- }
-
if (Ty.isCXX98PODType(Context))
return VAK_Valid;
#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"
if (op->getType()->isObjCObjectType())
return Context.getObjCObjectPointerType(op->getType());
- if (Context.getTargetInfo().getTriple().isWasm() &&
- op->getType()->isWebAssemblyReferenceType()) {
- Diag(OpLoc, diag::err_wasm_ca_reference)
- << 1 << OrigOp.get()->getSourceRange();
- return QualType();
- }
-
CheckAddressOfPackedMember(op);
return Context.getPointerType(op->getType());
Invalid = true;
}
- if (BuildAndDiagnose && S.Context.getTargetInfo().getTriple().isWasm() &&
- CaptureType.getNonReferenceType()->isWebAssemblyReferenceType()) {
- S.Diag(Loc, diag::err_wasm_ca_reference) << 0;
- Invalid = true;
- }
-
// Compute the type of the field that will capture this variable.
if (ByRef) {
// C++11 [expr.prim.lambda]p15:
#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"
if (getLangOpts().OpenCL)
T = deduceOpenCLPointeeAddrSpace(*this, T);
- // In WebAssembly, pointers to reference types are illegal.
- if (getASTContext().getTargetInfo().getTriple().isWasm() &&
- T->isWebAssemblyReferenceType()) {
- Diag(Loc, diag::err_wasm_reference_pr) << 0;
- return QualType();
- }
-
// Build the pointer type.
return Context.getPointerType(T);
}
if (getLangOpts().OpenCL)
T = deduceOpenCLPointeeAddrSpace(*this, T);
- // In WebAssembly, references to reference types are illegal.
- if (getASTContext().getTargetInfo().getTriple().isWasm() &&
- T->isWebAssemblyReferenceType()) {
- Diag(Loc, diag::err_wasm_reference_pr) << 1;
- return QualType();
- }
-
// Handle restrict on references.
if (LValueRef)
return Context.getLValueReferenceType(T, SpelledAsLValue);
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;
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");
+++ /dev/null
-// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
-// RUN: %clang_cc1 -triple wasm32-unknown-unknown -target-feature +reference-types -o - -emit-llvm %s | FileCheck %s
-
-typedef __externref_t externref_t;
-
-void helper(externref_t);
-
-// CHECK-LABEL: @handle(
-// CHECK-NEXT: entry:
-// CHECK-NEXT: [[OBJ_ADDR:%.*]] = alloca ptr addrspace(10), align 1
-// CHECK-NEXT: store ptr addrspace(10) [[OBJ:%.*]], ptr [[OBJ_ADDR]], align 1
-// CHECK-NEXT: [[TMP0:%.*]] = load ptr addrspace(10), ptr [[OBJ_ADDR]], align 1
-// CHECK-NEXT: call void @helper(ptr addrspace(10) [[TMP0]])
-// CHECK-NEXT: ret void
-//
-void handle(externref_t obj) {
- helper(obj);
-}
-// 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
+// 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
// SIMD convenience types
typedef signed char i8x16 __attribute((vector_size(16)));
// WEBASSEMBLY-SAME: <8 x i16> %a, <8 x i16> %b, <4 x float> %c)
// WEBASSEMBLY-NEXT: ret
}
-
-__externref_t externref_null() {
- return __builtin_wasm_ref_null_extern();
- // WEBASSEMBLY: tail call ptr addrspace(10) @llvm.wasm.ref.null.extern()
- // WEBASSEMBLY-NEXT: ret
-}
+++ /dev/null
-// 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: _Z2f1u11externref_t
-void f1(__externref_t) {}
+++ /dev/null
-// 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: @_ZTSu11externref_t = {{.*}} c"u11externref_t\00", {{.*}}
-// CHECK-DAG: @_ZTIu11externref_t = {{.*}} @_ZTVN10__cxxabiv123__fundamental_type_infoE, {{.*}} @_ZTSu11externref_t {{.*}}
+++ /dev/null
-// RUN: %clang_cc1 -fsyntax-only -verify -triple wasm32 -target-feature +reference-types %s
-
-// Note: As WebAssembly references are sizeless types, we don't exhaustively
-// test for cases covered by sizeless-1.c and similar tests.
-
-// Unlike standard sizeless types, reftype globals are supported.
-__externref_t r1;
-extern __externref_t r2;
-static __externref_t r3;
-
-__externref_t *t1; // expected-error {{pointer to WebAssembly reference type is not allowed}}
-__externref_t **t2; // expected-error {{pointer to WebAssembly reference type is not allowed}}
-__externref_t ******t3; // expected-error {{pointer to WebAssembly reference type is not allowed}}
-static __externref_t t4[3]; // expected-error {{array has sizeless element type '__externref_t'}}
-static __externref_t t5[]; // expected-error {{array has sizeless element type '__externref_t'}}
-static __externref_t t6[] = {0}; // expected-error {{array has sizeless element type '__externref_t'}}
-__externref_t t7[0]; // expected-error {{array has sizeless element type '__externref_t'}}
-static __externref_t t8[0][0]; // expected-error {{array has sizeless element type '__externref_t'}}
-
-static __externref_t table[0]; // expected-error {{array has sizeless element type '__externref_t'}}
-
-struct s {
- __externref_t f1; // expected-error {{field has sizeless type '__externref_t'}}
- __externref_t f2[0]; // expected-error {{array has sizeless element type '__externref_t'}}
- __externref_t f3[]; // expected-error {{array has sizeless element type '__externref_t'}}
- __externref_t f4[0][0]; // expected-error {{array has sizeless element type '__externref_t'}}
- __externref_t *f5; // expected-error {{pointer to WebAssembly reference type is not allowed}}
- __externref_t ****f6; // expected-error {{pointer to WebAssembly reference type is not allowed}}
-};
-
-union u {
- __externref_t f1; // expected-error {{field has sizeless type '__externref_t'}}
- __externref_t f2[0]; // expected-error {{array has sizeless element type '__externref_t'}}
- __externref_t f3[]; // expected-error {{array has sizeless element type '__externref_t'}}
- __externref_t f4[0][0]; // expected-error {{array has sizeless element type '__externref_t'}}
- __externref_t *f5; // expected-error {{pointer to WebAssembly reference type is not allowed}}
- __externref_t ****f6; // expected-error {{pointer to WebAssembly reference type is not allowed}}
-};
-
-void illegal_argument_1(__externref_t table[]); // expected-error {{array has sizeless element type '__externref_t'}}
-void illegal_argument_2(__externref_t table[0][0]); // expected-error {{array has sizeless element type '__externref_t'}}
-void illegal_argument_3(__externref_t *table); // expected-error {{pointer to WebAssembly reference type is not allowed}}
-void illegal_argument_4(__externref_t ***table); // expected-error {{pointer to WebAssembly reference type is not allowed}}
-
-__externref_t *illegal_return_1(); // expected-error {{pointer to WebAssembly reference type is not allowed}}
-__externref_t ***illegal_return_2(); // expected-error {{pointer to WebAssembly reference type is not allowed}}
-
-void varargs(int, ...);
-
-__externref_t func(__externref_t ref) {
- &ref; // expected-error {{cannot take address of WebAssembly reference}}
- int foo = 40;
- (__externref_t *)(&foo); // expected-error {{pointer to WebAssembly reference type is not allowed}}
- (__externref_t ****)(&foo); // expected-error {{pointer to WebAssembly reference type is not allowed}}
- sizeof(ref); // expected-error {{invalid application of 'sizeof' to sizeless type '__externref_t'}}
- sizeof(__externref_t); // expected-error {{invalid application of 'sizeof' to sizeless type '__externref_t'}}
- sizeof(__externref_t[0]); // expected-error {{array has sizeless element type '__externref_t'}}
- sizeof(__externref_t[0][0]); // expected-error {{array has sizeless element type '__externref_t'}}
- sizeof(__externref_t *); // expected-error {{pointer to WebAssembly reference type is not allowed}}
- sizeof(__externref_t ***); // expected-error {{pointer to WebAssembly reference type is not allowed}};
- // expected-warning@+1 {{'_Alignof' applied to an expression is a GNU extension}}
- _Alignof(ref); // expected-error {{invalid application of 'alignof' to sizeless type '__externref_t'}}
- _Alignof(__externref_t); // expected-error {{invalid application of 'alignof' to sizeless type '__externref_t'}}
- _Alignof(__externref_t[]); // expected-error {{array has sizeless element type '__externref_t'}}
- _Alignof(__externref_t[0][0]); // expected-error {{array has sizeless element type '__externref_t'}}
- _Alignof(__externref_t *); // expected-error {{pointer to WebAssembly reference type is not allowed}}
- _Alignof(__externref_t ***); // expected-error {{pointer to WebAssembly reference type is not allowed}};
- varargs(1, ref); // expected-error {{cannot pass expression of type '__externref_t' to variadic function}}
-
- return ref;
-}
+++ /dev/null
-// RUN: %clang_cc1 -fcxx-exceptions -fsyntax-only -verify -std=gnu++11 -triple wasm32 -Wno-unused-value -target-feature +reference-types %s
-
-// This file tests C++ specific constructs with WebAssembly references and
-// tables. See wasm-refs-and-tables.c for C constructs.
-
-__externref_t ref;
-__externref_t &ref_ref1 = ref; // expected-error {{reference to WebAssembly reference type is not allowed}}
-__externref_t &ref_ref2(ref); // expected-error {{reference to WebAssembly reference type is not allowed}}
-
-static __externref_t table[0]; // expected-error {{array has sizeless element type '__externref_t'}}
-static __externref_t (&ref_to_table1)[0] = table; // expected-error {{array has sizeless element type '__externref_t'}}
-static __externref_t (&ref_to_table2)[0](table); // expected-error {{array has sizeless element type '__externref_t'}}
-
-void illegal_argument_1(__externref_t &r); // expected-error {{reference to WebAssembly reference type is not allowed}}
-void illegal_argument_2(__externref_t (&t)[0]); // expected-error {{array has sizeless element type '__externref_t'}}
-
-__externref_t &illegal_return_1(); // expected-error {{reference to WebAssembly reference type is not allowed}}
-__externref_t (&illegal_return_2())[0]; // expected-error {{array has sizeless element type '__externref_t'}}
-
-void illegal_throw1() throw(__externref_t); // expected-error {{sizeless type '__externref_t' is not allowed in exception specification}}
-void illegal_throw2() throw(__externref_t *); // expected-error {{pointer to WebAssembly reference type is not allowed}}
-void illegal_throw3() throw(__externref_t &); // expected-error {{reference to WebAssembly reference type is not allowed}}
-void illegal_throw4() throw(__externref_t[0]); // expected-error {{array has sizeless element type '__externref_t'}}
-
-class RefClass {
- __externref_t f1; // expected-error {{field has sizeless type '__externref_t'}}
- __externref_t f2[0]; // expected-error {{array has sizeless element type '__externref_t'}}
- __externref_t f3[]; // expected-error {{array has sizeless element type '__externref_t'}}
- __externref_t f4[0][0]; // expected-error {{array has sizeless element type '__externref_t'}}
- __externref_t *f5; // expected-error {{pointer to WebAssembly reference type is not allowed}}
- __externref_t ****f6; // expected-error {{pointer to WebAssembly reference type is not allowed}}
- __externref_t (*f7)[0]; // expected-error {{array has sizeless element type '__externref_t'}}
-};
-
-struct AStruct {};
-
-template <typename T>
-struct TemplatedStruct {
- T f; // expected-error {{field has sizeless type '__externref_t'}}
- void foo(T);
- T bar(void);
- T arr[0]; // expected-error {{array has sizeless element type '__externref_t'}}
- T *ptr; // expected-error {{pointer to WebAssembly reference type is not allowed}}
-};
-
-void func() {
- int foo = 40;
- static_cast<__externref_t>(foo); // expected-error {{static_cast from 'int' to '__externref_t' is not allowed}}
- static_cast<__externref_t *>(&foo); // expected-error {{pointer to WebAssembly reference type is not allowed}}
- static_cast<int>(ref); // expected-error {{static_cast from '__externref_t' to 'int' is not allowed}}
- __externref_t(10); // expected-error {{functional-style cast from 'int' to '__externref_t' is not allowed}}
- int i(ref); // expected-error {{cannot initialize a variable of type 'int' with an lvalue of type '__externref_t'}}
- const_cast<__externref_t[0]>(table); // expected-error {{array has sizeless element type '__externref_t'}}
- const_cast<__externref_t *>(table); // expected-error {{pointer to WebAssembly reference type is not allowed}}
- reinterpret_cast<__externref_t>(foo); // expected-error {{reinterpret_cast from 'int' to '__externref_t' is not allowed}}
- reinterpret_cast<int>(ref); // expected-error {{reinterpret_cast from '__externref_t' to 'int' is not allowed}}
- int iarr[0];
- reinterpret_cast<__externref_t[0]>(iarr); // expected-error {{array has sizeless element type '__externref_t'}}
- reinterpret_cast<__externref_t *>(iarr); // expected-error {{pointer to WebAssembly reference type is not allowed}}
- dynamic_cast<__externref_t>(foo); // expected-error {{invalid target type '__externref_t' for dynamic_cast; target type must be a reference or pointer type to a defined class}}
- dynamic_cast<__externref_t *>(&foo); // expected-error {{pointer to WebAssembly reference type is not allowed}}
-
- TemplatedStruct<__externref_t> ts1; // expected-note {{in instantiation}}
- TemplatedStruct<__externref_t *> ts2; // expected-error {{pointer to WebAssembly reference type is not allowed}}
- TemplatedStruct<__externref_t &> ts3; // expected-error {{reference to WebAssembly reference type is not allowed}}
- TemplatedStruct<__externref_t[0]> ts4; // expected-error {{array has sizeless element type '__externref_t'}}
-
- auto auto_ref = ref;
-
- auto fn1 = [](__externref_t x) { return x; };
- auto fn2 = [](__externref_t *x) { return x; }; // expected-error {{pointer to WebAssembly reference type is not allowed}}
- auto fn3 = [](__externref_t &x) { return x; }; // expected-error {{reference to WebAssembly reference type is not allowed}}
- auto fn4 = [](__externref_t x[0]) { return x; }; // expected-error {{array has sizeless element type '__externref_t'}}
- auto fn5 = [&auto_ref](void) { return true; }; // expected-error {{cannot capture WebAssembly reference}}
- auto fn6 = [auto_ref](void) { return true; }; // expected-error {{cannot capture WebAssembly reference}}
- auto fn7 = [&](void) { auto_ref; return true; }; // expected-error {{cannot capture WebAssembly reference}}
- auto fn8 = [=](void) { auto_ref; return true; }; // expected-error {{cannot capture WebAssembly reference}}
-
- alignof(__externref_t); // expected-error {{invalid application of 'alignof' to sizeless type '__externref_t'}}
- alignof(ref); // expected-warning {{'alignof' applied to an expression is a GNU extension}} expected-error {{invalid application of 'alignof' to sizeless type '__externref_t'}}
- alignof(__externref_t[0]); // expected-error {{array has sizeless element type '__externref_t'}}
-
- throw ref; // expected-error {{cannot throw object of sizeless type '__externref_t'}}
- throw &ref; // expected-error {{cannot take address of WebAssembly reference}}
-
- try {
- } catch (__externref_t) { // expected-error {{cannot catch sizeless type '__externref_t'}}
- }
- try {
- } catch (__externref_t *) { // expected-error {{pointer to WebAssembly reference type is not allowed}}
- }
- try {
- } catch (__externref_t &) { // expected-error {{reference to WebAssembly reference type is not allowed}}
- }
- try {
- } catch (__externref_t[0]) { // expected-error {{array has sizeless element type '__externref_t'}}
- }
-
- new __externref_t; // expected-error {{allocation of sizeless type '__externref_t'}}
- new __externref_t[0]; // expected-error {{allocation of sizeless type '__externref_t'}}
-
- delete ref; // expected-error {{cannot delete expression of type '__externref_t'}}
-}
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<0x7FFFEB>();
tooBig<8388650>(); // expected-note {{in instantiation of function template specialization 'tooBig<8388650L>' requested here}}
__attribute__((address_space(1))) char *x;
#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:
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).
// %Y = load i32* %X
// ret i32 %Y
//
-FunctionPass *createPromoteMemoryToRegisterPass(bool IsForced = false);
+FunctionPass *createPromoteMemoryToRegisterPass();
//===----------------------------------------------------------------------===//
//
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: return Type::getWasm_ExternrefTy(Context);
- case MVT::funcref: return Type::getWasm_FuncrefTy(Context);
+ 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::v1i1:
return FixedVectorType::get(Type::getInt1Ty(Context), 1);
case MVT::v2i1:
return getInt64Ty(C)->getPointerTo(AS);
}
-Type *Type::getWasm_ExternrefTy(LLVMContext &C) {
- // opaque pointer in addrspace(10)
- static PointerType *Ty = PointerType::get(C, 10);
- return Ty;
-}
-
-Type *Type::getWasm_FuncrefTy(LLVMContext &C) {
- // opaque pointer in addrspace(20)
- static PointerType *Ty = PointerType::get(C, 20);
- return Ty;
-}
-
//===----------------------------------------------------------------------===//
// IntegerType Implementation
//===----------------------------------------------------------------------===//
#include "TargetInfo/WebAssemblyTargetInfo.h"
#include "Utils/WebAssemblyUtilities.h"
#include "WebAssembly.h"
-#include "WebAssemblyISelLowering.h"
#include "WebAssemblyMachineFunctionInfo.h"
#include "WebAssemblyTargetObjectFile.h"
#include "WebAssemblyTargetTransformInfo.h"
}
void WebAssemblyPassConfig::addISelPrepare() {
- WebAssemblyTargetMachine *WasmTM = static_cast<WebAssemblyTargetMachine*>(TM);
- const WebAssemblySubtarget *Subtarget = WasmTM
- ->getSubtargetImpl(std::string(WasmTM->getTargetCPU()),
- std::string(WasmTM->getTargetFeatureString()));
- if(Subtarget->hasReferenceTypes()) {
- // We need to remove allocas for reference types
- addPass(createPromoteMemoryToRegisterPass(true));
- }
// Lower atomics and TLS if necessary
addPass(new CoalesceFeaturesAndStripAtomics(&getWebAssemblyTargetMachine()));
struct PromoteLegacyPass : public FunctionPass {
// Pass identification, replacement for typeid
static char ID;
- bool ForcePass; /// If true, forces pass to execute, instead of skipping.
- PromoteLegacyPass() : FunctionPass(ID), ForcePass(false) {
- initializePromoteLegacyPassPass(*PassRegistry::getPassRegistry());
- }
- PromoteLegacyPass(bool IsForced) : FunctionPass(ID), ForcePass(IsForced) {
+ PromoteLegacyPass() : FunctionPass(ID) {
initializePromoteLegacyPassPass(*PassRegistry::getPassRegistry());
}
// runOnFunction - To run this pass, first we calculate the alloca
// instructions that are safe for promotion, then we promote each one.
bool runOnFunction(Function &F) override {
- if (!ForcePass && skipFunction(F))
+ if (skipFunction(F))
return false;
DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
AU.addRequired<DominatorTreeWrapperPass>();
AU.setPreservesCFG();
}
-
};
} // end anonymous namespace
false, false)
// createPromoteMemoryToRegister - Provide an entry point to create this pass.
-FunctionPass *llvm::createPromoteMemoryToRegisterPass(bool IsForced) {
- return new PromoteLegacyPass(IsForced);
+FunctionPass *llvm::createPromoteMemoryToRegisterPass() {
+ return new PromoteLegacyPass();
}
projects / platform / upstream / llvm.git / commitdiff