diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/binaryen-c.cpp | 186 | ||||
| -rw-r--r-- | src/binaryen-c.h | 122 |
2 files changed, 308 insertions, 0 deletions
diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp index e827392c0..f7e8142f1 100644 --- a/src/binaryen-c.cpp +++ b/src/binaryen-c.cpp @@ -239,6 +239,37 @@ BinaryenPackedType BinaryenPackedTypeInt16(void) { // Heap types +BinaryenHeapType BinaryenHeapTypeFunc() { + return static_cast<BinaryenHeapType>(HeapType::BasicHeapType::func); +} +BinaryenHeapType BinaryenHeapTypeAny() { + return static_cast<BinaryenHeapType>(HeapType::BasicHeapType::any); +} +BinaryenHeapType BinaryenHeapTypeEq() { + return static_cast<BinaryenHeapType>(HeapType::BasicHeapType::eq); +} +BinaryenHeapType BinaryenHeapTypeI31() { + return static_cast<BinaryenHeapType>(HeapType::BasicHeapType::i31); +} +BinaryenHeapType BinaryenHeapTypeData() { + return static_cast<BinaryenHeapType>(HeapType::BasicHeapType::data); +} +BinaryenHeapType BinaryenHeapTypeString() { + return static_cast<BinaryenHeapType>(HeapType::BasicHeapType::string); +} +BinaryenHeapType BinaryenHeapTypeStringviewWTF8() { + return static_cast<BinaryenHeapType>( + HeapType::BasicHeapType::stringview_wtf8); +} +BinaryenHeapType BinaryenHeapTypeStringviewWTF16() { + return static_cast<BinaryenHeapType>( + HeapType::BasicHeapType::stringview_wtf16); +} +BinaryenHeapType BinaryenHeapTypeStringviewIter() { + return static_cast<BinaryenHeapType>( + HeapType::BasicHeapType::stringview_iter); +} + BinaryenHeapType BinaryenTypeGetHeapType(BinaryenType type) { return Type(type).getHeapType().getID(); } @@ -4781,6 +4812,161 @@ ExpressionRunnerRunAndDispose(ExpressionRunnerRef runner, } // +// ========= Type builder ========= +// + +TypeBuilderErrorReason TypeBuilderErrorReasonSelfSupertype() { + return static_cast<TypeBuilderErrorReason>( + TypeBuilder::ErrorReason::SelfSupertype); +} +TypeBuilderErrorReason TypeBuilderErrorReasonInvalidSupertype() { + return static_cast<TypeBuilderErrorReason>( + TypeBuilder::ErrorReason::InvalidSupertype); +} +TypeBuilderErrorReason TypeBuilderErrorReasonForwardSupertypeReference() { + return static_cast<TypeBuilderErrorReason>( + TypeBuilder::ErrorReason::ForwardSupertypeReference); +} +TypeBuilderErrorReason TypeBuilderErrorReasonForwardChildReference() { + return static_cast<TypeBuilderErrorReason>( + TypeBuilder::ErrorReason::ForwardChildReference); +} + +TypeBuilderRef TypeBuilderCreate(BinaryenIndex size) { + return static_cast<TypeBuilderRef>(new TypeBuilder(size)); +} +void TypeBuilderGrow(TypeBuilderRef builder, BinaryenIndex count) { + ((TypeBuilder*)builder)->grow(count); +} +BinaryenIndex TypeBuilderGetSize(TypeBuilderRef builder) { + return ((TypeBuilder*)builder)->size(); +} +void TypeBuilderSetBasicHeapType(TypeBuilderRef builder, + BinaryenIndex index, + BinaryenBasicHeapType basicHeapType) { + ((TypeBuilder*)builder) + ->setHeapType(index, HeapType::BasicHeapType(basicHeapType)); +} +void TypeBuilderSetSignatureType(TypeBuilderRef builder, + BinaryenIndex index, + BinaryenType paramTypes, + BinaryenType resultTypes) { + ((TypeBuilder*)builder) + ->setHeapType(index, Signature(Type(paramTypes), Type(resultTypes))); +} +void TypeBuilderSetStructType(TypeBuilderRef builder, + BinaryenIndex index, + BinaryenType* fieldTypes, + BinaryenPackedType* fieldPackedTypes, + bool* fieldMutables, + int numFields) { + auto* B = (TypeBuilder*)builder; + FieldList fields; + for (int cur = 0; cur < numFields; ++cur) { + Field field(Type(fieldTypes[cur]), + fieldMutables[cur] ? Mutability::Mutable + : Mutability::Immutable); + if (field.type == Type::i32) { + field.packedType = Field::PackedType(fieldPackedTypes[cur]); + } else { + assert(fieldPackedTypes[cur] == Field::PackedType::not_packed); + } + fields.push_back(field); + } + B->setHeapType(index, Struct(fields)); +} +void TypeBuilderSetArrayType(TypeBuilderRef builder, + BinaryenIndex index, + BinaryenType elementType, + BinaryenPackedType elementPackedType, + int elementMutable) { + auto* B = (TypeBuilder*)builder; + Field element(Type(elementType), + elementMutable ? Mutability::Mutable : Mutability::Immutable); + if (element.type == Type::i32) { + element.packedType = Field::PackedType(elementPackedType); + } else { + assert(elementPackedType == Field::PackedType::not_packed); + } + B->setHeapType(index, Array(element)); +} +bool TypeBuilderIsBasic(TypeBuilderRef builder, BinaryenIndex index) { + return ((TypeBuilder*)builder)->isBasic(index); +} +BinaryenBasicHeapType TypeBuilderGetBasic(TypeBuilderRef builder, + BinaryenIndex index) { + return BinaryenBasicHeapType(((TypeBuilder*)builder)->getBasic(index)); +} +BinaryenHeapType TypeBuilderGetTempHeapType(TypeBuilderRef builder, + BinaryenIndex index) { + return ((TypeBuilder*)builder)->getTempHeapType(index).getID(); +} +BinaryenType TypeBuilderGetTempTupleType(TypeBuilderRef builder, + BinaryenType* types, + BinaryenIndex numTypes) { + TypeList typeList(numTypes); + for (BinaryenIndex cur = 0; cur < numTypes; ++cur) { + typeList[cur] = Type(types[cur]); + } + return ((TypeBuilder*)builder)->getTempTupleType(Tuple(typeList)).getID(); +} +BinaryenType TypeBuilderGetTempRttType(TypeBuilderRef builder, + BinaryenIndex depth, + BinaryenHeapType heapType) { + return ((TypeBuilder*)builder) + ->getTempRttType(Rtt(depth, HeapType(heapType))) + .getID(); +} +BinaryenType TypeBuilderGetTempRefType(TypeBuilderRef builder, + BinaryenHeapType heapType, + int nullable) { + return ((TypeBuilder*)builder) + ->getTempRefType(HeapType(heapType), nullable ? Nullable : NonNullable) + .getID(); +} +void TypeBuilderSetSubType(TypeBuilderRef builder, + BinaryenIndex index, + BinaryenIndex superIndex) { + ((TypeBuilder*)builder)->setSubType(index, superIndex); +} +void TypeBuilderCreateRecGroup(TypeBuilderRef builder, + BinaryenIndex index, + BinaryenIndex length) { + ((TypeBuilder*)builder)->createRecGroup(index, length); +} +bool TypeBuilderBuildAndDispose(TypeBuilderRef builder, + BinaryenHeapType* heapTypes, + BinaryenIndex* errorIndex, + TypeBuilderErrorReason* errorReason) { + auto* B = (TypeBuilder*)builder; + auto result = B->build(); + if (auto err = result.getError()) { + *errorIndex = err->index; + *errorReason = static_cast<TypeBuilderErrorReason>(err->reason); + delete B; + return false; + } + auto types = *result; + for (size_t cur = 0; cur < types.size(); ++cur) { + heapTypes[cur] = types[cur].getID(); + } + delete B; + return true; +} + +void BinaryenModuleSetTypeName(BinaryenModuleRef module, + BinaryenHeapType heapType, + const char* name) { + ((Module*)module)->typeNames[HeapType(heapType)].name = name; +} +void BinaryenModuleSetFieldName(BinaryenModuleRef module, + BinaryenHeapType heapType, + BinaryenIndex index, + const char* name) { + ((Module*)module)->typeNames[HeapType(heapType)].fieldNames[index] = name; +} + +// // ========= Utilities ========= // diff --git a/src/binaryen-c.h b/src/binaryen-c.h index 4f74eef4e..6a2222f71 100644 --- a/src/binaryen-c.h +++ b/src/binaryen-c.h @@ -137,6 +137,16 @@ BINARYEN_API BinaryenPackedType BinaryenPackedTypeInt16(void); typedef uintptr_t BinaryenHeapType; +BINARYEN_API BinaryenHeapType BinaryenHeapTypeFunc(void); +BINARYEN_API BinaryenHeapType BinaryenHeapTypeAny(void); +BINARYEN_API BinaryenHeapType BinaryenHeapTypeEq(void); +BINARYEN_API BinaryenHeapType BinaryenHeapTypeI31(void); +BINARYEN_API BinaryenHeapType BinaryenHeapTypeData(void); +BINARYEN_API BinaryenHeapType BinaryenHeapTypeString(void); +BINARYEN_API BinaryenHeapType BinaryenHeapTypeStringviewWTF8(void); +BINARYEN_API BinaryenHeapType BinaryenHeapTypeStringviewWTF16(void); +BINARYEN_API BinaryenHeapType BinaryenHeapTypeStringviewIter(void); + BINARYEN_API BinaryenHeapType BinaryenTypeGetHeapType(BinaryenType type); BINARYEN_API bool BinaryenTypeIsNullable(BinaryenType type); BINARYEN_API BinaryenType BinaryenTypeFromHeapType(BinaryenHeapType heapType, @@ -2896,6 +2906,118 @@ BINARYEN_API BinaryenExpressionRef ExpressionRunnerRunAndDispose( ExpressionRunnerRef runner, BinaryenExpressionRef expr); // +// ========= TypeBuilder ========= +// + +#ifdef __cplusplus +namespace wasm { +struct TypeBuilder; +} // namespace wasm +typedef struct wasm::TypeBuilder* TypeBuilderRef; +#else +typedef struct TypeBuilder* TypeBuilderRef; +#endif + +typedef uint32_t TypeBuilderErrorReason; + +// Indicates a cycle in the supertype relation. +BINARYEN_API TypeBuilderErrorReason TypeBuilderErrorReasonSelfSupertype(void); +// Indicates that the declared supertype of a type is invalid. +BINARYEN_API TypeBuilderErrorReason +TypeBuilderErrorReasonInvalidSupertype(void); +// Indicates that the declared supertype is an invalid forward reference. +BINARYEN_API TypeBuilderErrorReason +TypeBuilderErrorReasonForwardSupertypeReference(void); +// Indicates that a child of a type is an invalid forward reference. +BINARYEN_API TypeBuilderErrorReason +TypeBuilderErrorReasonForwardChildReference(void); + +typedef uint32_t BinaryenBasicHeapType; + +// Constructs a new type builder that allows for the construction of recursive +// types. Contains a table of `size` mutable heap types. +BINARYEN_API TypeBuilderRef TypeBuilderCreate(BinaryenIndex size); +// Grows the backing table of the type builder by `count` slots. +BINARYEN_API void TypeBuilderGrow(TypeBuilderRef builder, BinaryenIndex count); +// Gets the size of the backing table of the type builder. +BINARYEN_API BinaryenIndex TypeBuilderGetSize(TypeBuilderRef builder); +// Sets the heap type at index `index` to a basic heap type. Must not be used in +// nominal mode. +BINARYEN_API void +TypeBuilderSetBasicHeapType(TypeBuilderRef builder, + BinaryenIndex index, + BinaryenBasicHeapType basicHeapType); +// Sets the heap type at index `index` to a concrete signature type. Expects +// temporary tuple types if multiple parameter and/or result types include +// temporary types. +BINARYEN_API void TypeBuilderSetSignatureType(TypeBuilderRef builder, + BinaryenIndex index, + BinaryenType paramTypes, + BinaryenType resultTypes); +// Sets the heap type at index `index` to a concrete struct type. +BINARYEN_API void TypeBuilderSetStructType(TypeBuilderRef builder, + BinaryenIndex index, + BinaryenType* fieldTypes, + BinaryenPackedType* fieldPackedTypes, + bool* fieldMutables, + int numFields); +// Sets the heap type at index `index` to a concrete array type. +BINARYEN_API void TypeBuilderSetArrayType(TypeBuilderRef builder, + BinaryenIndex index, + BinaryenType elementType, + BinaryenPackedType elementPackedType, + int elementMutable); +// Tests if the heap type at index `index` is a basic heap type. +BINARYEN_API bool TypeBuilderIsBasic(TypeBuilderRef builder, + BinaryenIndex index); +// Gets the basic heap type at index `index`. +BINARYEN_API BinaryenBasicHeapType TypeBuilderGetBasic(TypeBuilderRef builder, + BinaryenIndex index); +// Gets the temporary heap type to use at index `index`. Temporary heap types +// may only be used to construct temporary types using the type builder. +BINARYEN_API BinaryenHeapType TypeBuilderGetTempHeapType(TypeBuilderRef builder, + BinaryenIndex index); +// Gets a temporary tuple type for use with and owned by the type builder. +BINARYEN_API BinaryenType TypeBuilderGetTempTupleType(TypeBuilderRef builder, + BinaryenType* types, + BinaryenIndex numTypes); +// Gets a temporary reference type for use with and owned by the type builder. +BINARYEN_API BinaryenType TypeBuilderGetTempRefType(TypeBuilderRef builder, + BinaryenHeapType heapType, + int nullable); +// Gets a temporary RTT for use with and owned by the type builder. +BINARYEN_API BinaryenType TypeBuilderGetTempRttType(TypeBuilderRef builder, + BinaryenIndex depth, + BinaryenHeapType heapType); +// Sets the type at `index` to be a subtype of the type at `superIndex`. +BINARYEN_API void TypeBuilderSetSubType(TypeBuilderRef builder, + BinaryenIndex index, + BinaryenIndex superIndex); +// Creates a new recursion group in the range `index` inclusive to `index + +// length` exclusive. Recursion groups must not overlap. +BINARYEN_API void TypeBuilderCreateRecGroup(TypeBuilderRef builder, + BinaryenIndex index, + BinaryenIndex length); +// Builds the heap type hierarchy and disposes the builder. Returns `false` and +// populates `errorIndex` and `errorReason` on failure. +BINARYEN_API bool +TypeBuilderBuildAndDispose(TypeBuilderRef builder, + BinaryenHeapType* heapTypes, + BinaryenIndex* errorIndex, + TypeBuilderErrorReason* errorReason); + +// Sets the textual name of a compound `heapType`. Has no effect if the type +// already has a canonical name. +BINARYEN_API void BinaryenModuleSetTypeName(BinaryenModuleRef module, + BinaryenHeapType heapType, + const char* name); +// Sets the field name of a struct `heapType` at index `index`. +BINARYEN_API void BinaryenModuleSetFieldName(BinaryenModuleRef module, + BinaryenHeapType heapType, + BinaryenIndex index, + const char* name); + +// // ========= Utilities ========= // |