From 4b3cc981a63282330cb06fe654c14c0f184637aa Mon Sep 17 00:00:00 2001 From: dcodeIO Date: Fri, 15 Dec 2017 17:23:04 +0100 Subject: [PATCH] Portable conversions --- README.md | 6 +- src/builtins.ts | 430 +++++++++++------- src/compiler.ts | 2 +- src/program.ts | 2 + tests/compiler/assert.wast | 24 +- tests/compiler/binary.wast | 24 +- tests/compiler/builtins.wast | 24 +- tests/compiler/class.wast | 24 +- tests/compiler/declare.wast | 24 +- tests/compiler/do.wast | 24 +- tests/compiler/enum.wast | 24 +- tests/compiler/export.wast | 24 +- tests/compiler/for.wast | 24 +- tests/compiler/game-of-life.wast | 24 +- tests/compiler/i64.wast | 24 +- tests/compiler/if.wast | 24 +- tests/compiler/import.wast | 24 +- tests/compiler/limits.wast | 68 +-- tests/compiler/literals.wast | 24 +- tests/compiler/logical.wast | 24 +- tests/compiler/memcpy.wast | 24 +- tests/compiler/namespace.wast | 24 +- .../portable-conversions.optimized.wast | 120 +++++ tests/compiler/portable-conversions.ts | 69 +++ tests/compiler/portable-conversions.wast | 381 ++++++++++++++++ tests/compiler/reexport.wast | 24 +- tests/compiler/switch.wast | 24 +- tests/compiler/ternary.wast | 24 +- tests/compiler/tlsf.wast | 24 +- tests/compiler/unary.wast | 24 +- tests/compiler/while.wast | 24 +- 31 files changed, 1147 insertions(+), 483 deletions(-) create mode 100644 tests/compiler/portable-conversions.optimized.wast create mode 100644 tests/compiler/portable-conversions.ts create mode 100644 tests/compiler/portable-conversions.wast diff --git a/README.md b/README.md index 3add3056..e69f27bb 100644 --- a/README.md +++ b/README.md @@ -28,8 +28,8 @@ Getting started This version of the compiler is not on [npm](https://www.npmjs.com/package/assemblyscript), yet, but if you'd like to try it today or even plan to contribute, this is how you do it: ``` -$> git clone https://github.com/AssemblyScript/next.git -$> cd next +$> git clone https://github.com/AssemblyScript/assemblyscript.git +$> cd assemblyscript $> npm install ``` @@ -47,7 +47,7 @@ $> node bin/asc yourModule.ts Building -------- -Building an UMD bundle to `dist/assemblyscript.js` (does not bundle [binaryen.js](https://github.com/AssemblyScript/binaryen.js)): +Building an UMD bundle to `dist/assemblyscript.js` (does not bundle [binaryen.js](https://github.com/AssemblyScript/binaryen.js) which remains an external dependency): ``` $> npm run build diff --git a/src/builtins.ts b/src/builtins.ts index 185ea53c..16cfcda7 100644 --- a/src/builtins.ts +++ b/src/builtins.ts @@ -1,4 +1,4 @@ -import { Compiler, Target, typeToNativeType, typeToNativeOne, typeToNativeZero } from "./compiler"; +import { Compiler, Target, ConversionKind, typeToNativeType, typeToNativeOne, typeToNativeZero } from "./compiler"; import { DiagnosticCode } from "./diagnostics"; import { Node, Expression } from "./ast"; import { Type } from "./types"; @@ -7,35 +7,48 @@ import { Program, ElementFlags, Element, Global, FunctionPrototype, Local } from /** Initializes the specified program with built-in functions. */ export function initialize(program: Program): void { + + // math + addFunction(program, "isNaN", true); + addFunction(program, "isFinite", true); addFunction(program, "clz", true); addFunction(program, "ctz", true); addFunction(program, "popcnt", true); addFunction(program, "rotl", true); addFunction(program, "rotr", true); addFunction(program, "abs", true); - addFunction(program, "ceil", true); - addFunction(program, "copysign", true); - addFunction(program, "floor", true); addFunction(program, "max", true); addFunction(program, "min", true); + addFunction(program, "ceil", true); + addFunction(program, "floor", true); + addFunction(program, "copysign", true); addFunction(program, "nearest", true); + addFunction(program, "reinterpret", true); addFunction(program, "sqrt", true); addFunction(program, "trunc", true); - addFunction(program, "current_memory"); - addFunction(program, "grow_memory"); - addFunction(program, "unreachable"); + + // memory access addFunction(program, "load", true); addFunction(program, "store", true); - addFunction(program, "reinterpret", true); - addFunction(program, "select", true); addFunction(program, "sizeof", true); - addFunction(program, "changetype", true); - addFunction(program, "isNaN", true); - addFunction(program, "isFinite", true); - addFunction(program, "assert"); + + // control flow + addFunction(program, "select", true); + addFunction(program, "unreachable"); + + // host operations + addFunction(program, "current_memory"); + addFunction(program, "grow_memory"); + + // imported addFunction(program, "parseInt"); addFunction(program, "parseFloat"); + // other + addFunction(program, "changetype", true); + addFunction(program, "assert"); + + // conversions and limits addFunction(program, "i8").members = new Map([ [ "MIN_VALUE", new Global(program, "i8.MIN_VALUE", null, Type.i8).withConstantIntegerValue(-128, -1) ], [ "MAX_VALUE", new Global(program, "i8.MAX_VALUE", null, Type.i8).withConstantIntegerValue(127, 0) ] @@ -116,6 +129,76 @@ export function compileCall(compiler: Compiler, prototype: FunctionPrototype, ty switch (prototype.internalName) { + // math + + case "isNaN": // isNaN(value: T) -> bool + compiler.currentType = Type.bool; + if (!validateCall(compiler, typeArguments, 1, operands, 1, reportNode)) + return module.createUnreachable(); + if (typeArguments[0].isAnyInteger) + return module.createI32(0); + if (typeArguments[0].isAnyFloat) { + arg0 = compiler.compileExpression(operands[0], typeArguments[0]); // reports + compiler.currentType = Type.bool; + if (typeArguments[0] == Type.f32) { + tempLocal0 = compiler.currentFunction.getAndFreeTempLocal(Type.f32); + return module.createBinary(BinaryOp.NeF32, + module.createTeeLocal(tempLocal0.index, arg0), + module.createGetLocal(tempLocal0.index, NativeType.F32) + ); + } else { + tempLocal0 = compiler.currentFunction.getAndFreeTempLocal(Type.f64); + return module.createBinary(BinaryOp.NeF64, + module.createTeeLocal(tempLocal0.index, arg0), + module.createGetLocal(tempLocal0.index, NativeType.F64) + ); + } + } + break; + + case "isFinite": // isFinite(value: T) -> bool + compiler.currentType = Type.bool; + if (!validateCall(compiler, typeArguments, 1, operands, 1, reportNode)) + return module.createUnreachable(); + if (typeArguments[0].isAnyInteger) + return module.createI32(1); + if (typeArguments[0].isAnyFloat) { + arg0 = compiler.compileExpression(operands[0], typeArguments[0]); // reports + compiler.currentType = Type.bool; + if (typeArguments[0] == Type.f32) { + tempLocal0 = compiler.currentFunction.getAndFreeTempLocal(Type.f32); + return module.createSelect( + module.createBinary(BinaryOp.NeF32, + module.createUnary(UnaryOp.AbsF32, + module.createTeeLocal(tempLocal0.index, arg0) + ), + module.createF32(Infinity) + ), + module.createI32(0), + module.createBinary(BinaryOp.EqF32, + module.createGetLocal(tempLocal0.index, NativeType.F32), + module.createGetLocal(tempLocal0.index, NativeType.F32) + ) + ); + } else { + tempLocal0 = compiler.currentFunction.getAndFreeTempLocal(Type.f64); + return module.createSelect( + module.createBinary(BinaryOp.NeF64, + module.createUnary(UnaryOp.AbsF64, + module.createTeeLocal(tempLocal0.index, arg0) + ), + module.createF64(Infinity) + ), + module.createI32(0), + module.createBinary(BinaryOp.EqF64, + module.createGetLocal(tempLocal0.index, NativeType.F64), + module.createGetLocal(tempLocal0.index, NativeType.F64) + ) + ); + } + } + break; + case "clz": // clz(value: T) -> T if (!validateCall(compiler, typeArguments, 1, operands, 1, reportNode)) return module.createUnreachable(); @@ -357,47 +440,6 @@ export function compileCall(compiler: Compiler, prototype: FunctionPrototype, ty } break; - case "sqrt": // sqrt(value: T) -> T - if (!validateCall(compiler, typeArguments, 1, operands, 1, reportNode)) - return module.createUnreachable(); - if ((compiler.currentType = typeArguments[0]).isAnyFloat) { - arg0 = compiler.compileExpression(operands[0], typeArguments[0]); - return (compiler.currentType = typeArguments[0]) == Type.f32 // sic - ? module.createUnary(UnaryOp.SqrtF32, arg0) - : module.createUnary(UnaryOp.SqrtF64, arg0); - } - break; - - case "trunc": // trunc(value: T) -> T - if (!validateCall(compiler, typeArguments, 1, operands, 1, reportNode)) - return module.createUnreachable(); - if ((compiler.currentType = typeArguments[0]).isAnyFloat) { - arg0 = compiler.compileExpression(operands[0], typeArguments[0]); - return (compiler.currentType = typeArguments[0]) == Type.f32 // sic - ? module.createUnary(UnaryOp.TruncF32, arg0) - : module.createUnary(UnaryOp.TruncF64, arg0); - } - break; - - case "load": // load(offset: usize) -> T - if (!validateCall(compiler, typeArguments, 1, operands, 1, reportNode)) - return module.createUnreachable(); - arg0 = compiler.compileExpression(operands[0], usizeType); // reports - if ((compiler.currentType = typeArguments[0]) != Type.void) - return module.createLoad(typeArguments[0].byteSize, typeArguments[0].isSignedInteger, arg0, typeToNativeType(typeArguments[0])); - break; - - case "store": // store(offset: usize, value: T) -> void - compiler.currentType = Type.void; - if (!validateCall(compiler, typeArguments, 1, operands, 2, reportNode)) - return module.createUnreachable(); - arg0 = compiler.compileExpression(operands[0], usizeType); // reports - arg1 = compiler.compileExpression(operands[1], typeArguments[0]); // reports - compiler.currentType = Type.void; - if (typeArguments[0] != Type.void) - return module.createStore(typeArguments[0].byteSize, arg0, arg1, typeToNativeType(typeArguments[0])); - break; - case "reinterpret": // reinterpret(value: T1) -> T2 if (!validateCall(compiler, typeArguments, 2, operands, 1, reportNode)) return module.createUnreachable(); @@ -424,6 +466,59 @@ export function compileCall(compiler: Compiler, prototype: FunctionPrototype, ty } break; + case "sqrt": // sqrt(value: T) -> T + if (!validateCall(compiler, typeArguments, 1, operands, 1, reportNode)) + return module.createUnreachable(); + if ((compiler.currentType = typeArguments[0]).isAnyFloat) { + arg0 = compiler.compileExpression(operands[0], typeArguments[0]); + return (compiler.currentType = typeArguments[0]) == Type.f32 // sic + ? module.createUnary(UnaryOp.SqrtF32, arg0) + : module.createUnary(UnaryOp.SqrtF64, arg0); + } + break; + + case "trunc": // trunc(value: T) -> T + if (!validateCall(compiler, typeArguments, 1, operands, 1, reportNode)) + return module.createUnreachable(); + if ((compiler.currentType = typeArguments[0]).isAnyFloat) { + arg0 = compiler.compileExpression(operands[0], typeArguments[0]); + return (compiler.currentType = typeArguments[0]) == Type.f32 // sic + ? module.createUnary(UnaryOp.TruncF32, arg0) + : module.createUnary(UnaryOp.TruncF64, arg0); + } + break; + + // memory access + + case "load": // load(offset: usize) -> T + if (!validateCall(compiler, typeArguments, 1, operands, 1, reportNode)) + return module.createUnreachable(); + arg0 = compiler.compileExpression(operands[0], usizeType); // reports + if ((compiler.currentType = typeArguments[0]) != Type.void) + return module.createLoad(typeArguments[0].byteSize, typeArguments[0].isSignedInteger, arg0, typeToNativeType(typeArguments[0])); + break; + + case "store": // store(offset: usize, value: T) -> void + compiler.currentType = Type.void; + if (!validateCall(compiler, typeArguments, 1, operands, 2, reportNode)) + return module.createUnreachable(); + arg0 = compiler.compileExpression(operands[0], usizeType); // reports + arg1 = compiler.compileExpression(operands[1], typeArguments[0]); // reports + compiler.currentType = Type.void; + if (typeArguments[0] != Type.void) + return module.createStore(typeArguments[0].byteSize, arg0, arg1, typeToNativeType(typeArguments[0])); + break; + + case "sizeof": // sizeof() -> usize + compiler.currentType = usizeType; + if (!validateCall(compiler, typeArguments, 1, operands, 0, reportNode)) + return module.createUnreachable(); + return usizeType.isLongInteger + ? module.createI64(typeArguments[0].byteSize, 0) + : module.createI32(typeArguments[0].byteSize); + + // control flow + case "select": // select(ifTrue: T, ifFalse: T, condition: bool) -> T if (!validateCall(compiler, typeArguments, 1, operands, 3, reportNode)) return module.createUnreachable(); @@ -436,6 +531,13 @@ export function compileCall(compiler: Compiler, prototype: FunctionPrototype, ty } break; + case "unreachable": // unreachable() -> * + // does not modify currentType + validateCall(compiler, typeArguments, 0, operands, 0, reportNode); + return module.createUnreachable(); + + // host operations + case "current_memory": // current_memory() -> i32 compiler.currentType = Type.i32; if (!validateCall(compiler, typeArguments, 0, operands, 0, reportNode)) @@ -449,121 +551,7 @@ export function compileCall(compiler: Compiler, prototype: FunctionPrototype, ty arg0 = compiler.compileExpression(operands[0], Type.i32); return module.createHost(HostOp.GrowMemory, null, [ arg0 ]); - case "unreachable": // unreachable() -> * - // does not modify currentType - validateCall(compiler, typeArguments, 0, operands, 0, reportNode); - return module.createUnreachable(); - - case "sizeof": // sizeof() -> usize - compiler.currentType = usizeType; - if (!validateCall(compiler, typeArguments, 1, operands, 0, reportNode)) - return module.createUnreachable(); - return usizeType.isLongInteger - ? module.createI64(typeArguments[0].byteSize, 0) - : module.createI32(typeArguments[0].byteSize); - - case "changetype": // changetype(value: T1) -> T2 - if (!validateCall(compiler, typeArguments, 2, operands, 1, reportNode)) - return module.createUnreachable(); - if ((typeArguments[0] == usizeType && typeArguments[1].classType) || (typeArguments[0].classType && typeArguments[1] == usizeType)) { - arg0 = compiler.compileExpression(operands[0], typeArguments[0]); - compiler.currentType = typeArguments[1]; - return arg0; - } - compiler.error(DiagnosticCode.Type_0_cannot_be_changed_to_type_1, reportNode.range, typeArguments[0].toString(), typeArguments[1].toString()); - return module.createUnreachable(); - - case "isNaN": // isNaN(value: T) -> bool - compiler.currentType = Type.bool; - if (!validateCall(compiler, typeArguments, 1, operands, 1, reportNode)) - return module.createUnreachable(); - if (typeArguments[0].isAnyInteger) - return module.createI32(0); - if (typeArguments[0].isAnyFloat) { - arg0 = compiler.compileExpression(operands[0], typeArguments[0]); // reports - compiler.currentType = Type.bool; - if (typeArguments[0] == Type.f32) { - tempLocal0 = compiler.currentFunction.getAndFreeTempLocal(Type.f32); - return module.createBinary(BinaryOp.NeF32, - module.createTeeLocal(tempLocal0.index, arg0), - module.createGetLocal(tempLocal0.index, NativeType.F32) - ); - } else { - tempLocal0 = compiler.currentFunction.getAndFreeTempLocal(Type.f64); - return module.createBinary(BinaryOp.NeF64, - module.createTeeLocal(tempLocal0.index, arg0), - module.createGetLocal(tempLocal0.index, NativeType.F64) - ); - } - } - break; - - case "isFinite": // isFinite(value: T) -> bool - compiler.currentType = Type.bool; - if (!validateCall(compiler, typeArguments, 1, operands, 1, reportNode)) - return module.createUnreachable(); - if (typeArguments[0].isAnyInteger) - return module.createI32(1); - if (typeArguments[0].isAnyFloat) { - arg0 = compiler.compileExpression(operands[0], typeArguments[0]); // reports - compiler.currentType = Type.bool; - if (typeArguments[0] == Type.f32) { - tempLocal0 = compiler.currentFunction.getAndFreeTempLocal(Type.f32); - return module.createSelect( - module.createBinary(BinaryOp.NeF32, - module.createUnary(UnaryOp.AbsF32, - module.createTeeLocal(tempLocal0.index, arg0) - ), - module.createF32(Infinity) - ), - module.createI32(0), - module.createBinary(BinaryOp.EqF32, - module.createGetLocal(tempLocal0.index, NativeType.F32), - module.createGetLocal(tempLocal0.index, NativeType.F32) - ) - ); - } else { - tempLocal0 = compiler.currentFunction.getAndFreeTempLocal(Type.f64); - return module.createSelect( - module.createBinary(BinaryOp.NeF64, - module.createUnary(UnaryOp.AbsF64, - module.createTeeLocal(tempLocal0.index, arg0) - ), - module.createF64(Infinity) - ), - module.createI32(0), - module.createBinary(BinaryOp.EqF64, - module.createGetLocal(tempLocal0.index, NativeType.F64), - module.createGetLocal(tempLocal0.index, NativeType.F64) - ) - ); - } - } - break; - - case "assert": // assert(isTrue: bool) -> void - compiler.currentType = Type.void; - if (typeArguments.length != 0) { - compiler.error(DiagnosticCode.Expected_0_type_arguments_but_got_1, reportNode.range, "0", typeArguments.length.toString(10)); - return module.createUnreachable(); - } - if (operands.length < 1) { - compiler.error(DiagnosticCode.Expected_at_least_0_arguments_but_got_1, reportNode.range, "1", operands.length.toString(10)); - return module.createUnreachable(); - } - if (operands.length > 2) { - compiler.error(DiagnosticCode.Expected_0_arguments_but_got_1, reportNode.range, "2", operands.length.toString(10)); - return module.createUnreachable(); - } - arg0 = compiler.compileExpression(operands[0], Type.i32); // reports - arg1 = operands.length > 1 ? compiler.compileExpression(operands[1], usizeType) : typeToNativeZero(module, usizeType); // TODO: string type - compiler.currentType = Type.void; - return compiler.options.noAssert - ? module.createNop() - : module.createIf( - module.createUnary(UnaryOp.EqzI32, arg0), - module.createUnreachable() // TODO: report message to embedder - ); + // imported case "parseInt": // takes a pointer to the string compiler.currentType = Type.f64; @@ -601,6 +589,110 @@ export function compileCall(compiler: Compiler, prototype: FunctionPrototype, ty } arg0 = compiler.compileExpression(operands[0], usizeType); // reports return module.createCallImport("parseFloat", [ arg0 ], NativeType.F64); + + // other + + case "changetype": // changetype(value: T1) -> T2 + if (!validateCall(compiler, typeArguments, 2, operands, 1, reportNode)) + return module.createUnreachable(); + if ((typeArguments[0] == usizeType && typeArguments[1].classType) || (typeArguments[0].classType && typeArguments[1] == usizeType)) { + arg0 = compiler.compileExpression(operands[0], typeArguments[0]); + compiler.currentType = typeArguments[1]; + return arg0; + } + compiler.error(DiagnosticCode.Type_0_cannot_be_changed_to_type_1, reportNode.range, typeArguments[0].toString(), typeArguments[1].toString()); + return module.createUnreachable(); + + case "assert": // assert(isTrue: bool) -> void + compiler.currentType = Type.void; + if (typeArguments.length != 0) { + compiler.error(DiagnosticCode.Expected_0_type_arguments_but_got_1, reportNode.range, "0", typeArguments.length.toString(10)); + return module.createUnreachable(); + } + if (operands.length < 1) { + compiler.error(DiagnosticCode.Expected_at_least_0_arguments_but_got_1, reportNode.range, "1", operands.length.toString(10)); + return module.createUnreachable(); + } + if (operands.length > 2) { + compiler.error(DiagnosticCode.Expected_0_arguments_but_got_1, reportNode.range, "2", operands.length.toString(10)); + return module.createUnreachable(); + } + arg0 = compiler.compileExpression(operands[0], Type.i32); // reports + arg1 = operands.length > 1 ? compiler.compileExpression(operands[1], usizeType) : typeToNativeZero(module, usizeType); // TODO: string type + compiler.currentType = Type.void; + return compiler.options.noAssert + ? module.createNop() + : module.createIf( + module.createUnary(UnaryOp.EqzI32, arg0), + module.createUnreachable() // TODO: report message to embedder + ); + + // conversions + + case "i8": + if (!validateCall(compiler, typeArguments, 0, operands, 1, reportNode)) + return module.createUnreachable(); + return compiler.compileExpression(operands[0], Type.i8, ConversionKind.EXPLICIT); + + case "i16": + if (!validateCall(compiler, typeArguments, 0, operands, 1, reportNode)) + return module.createUnreachable(); + return compiler.compileExpression(operands[0], Type.i16, ConversionKind.EXPLICIT); + + case "i32": + if (!validateCall(compiler, typeArguments, 0, operands, 1, reportNode)) + return module.createUnreachable(); + return compiler.compileExpression(operands[0], Type.i32, ConversionKind.EXPLICIT); + + case "i64": + if (!validateCall(compiler, typeArguments, 0, operands, 1, reportNode)) + return module.createUnreachable(); + return compiler.compileExpression(operands[0], Type.i64, ConversionKind.EXPLICIT); + + case "isize": + if (!validateCall(compiler, typeArguments, 0, operands, 1, reportNode)) + return module.createUnreachable(); + return compiler.compileExpression(operands[0], select(Type.isize64, Type.isize32, compiler.options.target == Target.WASM64), ConversionKind.EXPLICIT); + + case "u8": + if (!validateCall(compiler, typeArguments, 0, operands, 1, reportNode)) + return module.createUnreachable(); + return compiler.compileExpression(operands[0], Type.u8, ConversionKind.EXPLICIT); + + case "u16": + if (!validateCall(compiler, typeArguments, 0, operands, 1, reportNode)) + return module.createUnreachable(); + return compiler.compileExpression(operands[0], Type.u16, ConversionKind.EXPLICIT); + + case "u32": + if (!validateCall(compiler, typeArguments, 0, operands, 1, reportNode)) + return module.createUnreachable(); + return compiler.compileExpression(operands[0], Type.u32, ConversionKind.EXPLICIT); + + case "u64": + if (!validateCall(compiler, typeArguments, 0, operands, 1, reportNode)) + return module.createUnreachable(); + return compiler.compileExpression(operands[0], Type.u64, ConversionKind.EXPLICIT); + + case "usize": + if (!validateCall(compiler, typeArguments, 0, operands, 1, reportNode)) + return module.createUnreachable(); + return compiler.compileExpression(operands[0], usizeType, ConversionKind.EXPLICIT); + + case "bool": + if (!validateCall(compiler, typeArguments, 0, operands, 1, reportNode)) + return module.createUnreachable(); + return compiler.compileExpression(operands[0], Type.bool, ConversionKind.EXPLICIT); + + case "f32": + if (!validateCall(compiler, typeArguments, 0, operands, 1, reportNode)) + return module.createUnreachable(); + return compiler.compileExpression(operands[0], Type.f32, ConversionKind.EXPLICIT); + + case "f64": + if (!validateCall(compiler, typeArguments, 0, operands, 1, reportNode)) + return module.createUnreachable(); + return compiler.compileExpression(operands[0], Type.f64, ConversionKind.EXPLICIT); } return 0; } diff --git a/src/compiler.ts b/src/compiler.ts index 22857574..bc931f0d 100644 --- a/src/compiler.ts +++ b/src/compiler.ts @@ -127,7 +127,7 @@ export class Options { } /** Indicates the desired kind of a conversion. */ -const enum ConversionKind { +export const enum ConversionKind { /** No conversion. */ NONE, /** Implicit conversion. */ diff --git a/src/program.ts b/src/program.ts index 9f5b2e8c..639bb22f 100644 --- a/src/program.ts +++ b/src/program.ts @@ -1028,12 +1028,14 @@ export class Global extends Element { withConstantIntegerValue(lo: i32, hi: i32): this { this.constantIntegerValue = new I64(lo, hi); this.hasConstantValue = true; + this.isMutable = false; return this; } withConstantFloatValue(value: f64): this { this.constantFloatValue = value; this.hasConstantValue = true; + this.isMutable = false; return this; } } diff --git a/tests/compiler/assert.wast b/tests/compiler/assert.wast index 437d7923..392dd0ed 100644 --- a/tests/compiler/assert.wast +++ b/tests/compiler/assert.wast @@ -15,34 +15,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/binary.wast b/tests/compiler/binary.wast index 52b2095c..77ac16a1 100644 --- a/tests/compiler/binary.wast +++ b/tests/compiler/binary.wast @@ -818,34 +818,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/builtins.wast b/tests/compiler/builtins.wast index cd9ec882..0aeca301 100644 --- a/tests/compiler/builtins.wast +++ b/tests/compiler/builtins.wast @@ -1035,34 +1035,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/class.wast b/tests/compiler/class.wast index a6d129f0..95f85b9b 100644 --- a/tests/compiler/class.wast +++ b/tests/compiler/class.wast @@ -43,34 +43,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/declare.wast b/tests/compiler/declare.wast index d3436ff7..f12213c4 100644 --- a/tests/compiler/declare.wast +++ b/tests/compiler/declare.wast @@ -8,34 +8,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/do.wast b/tests/compiler/do.wast index 2018fc40..6637d2d7 100644 --- a/tests/compiler/do.wast +++ b/tests/compiler/do.wast @@ -53,34 +53,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/enum.wast b/tests/compiler/enum.wast index d8fde227..992122b3 100644 --- a/tests/compiler/enum.wast +++ b/tests/compiler/enum.wast @@ -38,34 +38,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/export.wast b/tests/compiler/export.wast index af2ba327..aeb2eb65 100644 --- a/tests/compiler/export.wast +++ b/tests/compiler/export.wast @@ -32,34 +32,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/for.wast b/tests/compiler/for.wast index 71c7245a..57b289c0 100644 --- a/tests/compiler/for.wast +++ b/tests/compiler/for.wast @@ -149,34 +149,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/game-of-life.wast b/tests/compiler/game-of-life.wast index 28ad71df..e139a737 100644 --- a/tests/compiler/game-of-life.wast +++ b/tests/compiler/game-of-life.wast @@ -310,34 +310,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/i64.wast b/tests/compiler/i64.wast index e26991b3..fa4be1cd 100644 --- a/tests/compiler/i64.wast +++ b/tests/compiler/i64.wast @@ -1191,34 +1191,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/if.wast b/tests/compiler/if.wast index 7971bbdc..a01d3c30 100644 --- a/tests/compiler/if.wast +++ b/tests/compiler/if.wast @@ -48,34 +48,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/import.wast b/tests/compiler/import.wast index 57f22c4f..8d414fce 100644 --- a/tests/compiler/import.wast +++ b/tests/compiler/import.wast @@ -43,34 +43,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/limits.wast b/tests/compiler/limits.wast index 3eda9ca7..aa3a5572 100644 --- a/tests/compiler/limits.wast +++ b/tests/compiler/limits.wast @@ -1,27 +1,27 @@ (module (type $v (func)) - (global $i8.MIN_VALUE (mut i32) (i32.const -128)) - (global $i8.MAX_VALUE (mut i32) (i32.const 127)) - (global $i16.MIN_VALUE (mut i32) (i32.const -32768)) - (global $i16.MAX_VALUE (mut i32) (i32.const 32767)) - (global $i32.MIN_VALUE (mut i32) (i32.const -2147483648)) - (global $i32.MAX_VALUE (mut i32) (i32.const 2147483647)) - (global $i64.MIN_VALUE (mut i64) (i64.const -9223372036854775808)) - (global $i64.MAX_VALUE (mut i64) (i64.const 9223372036854775807)) - (global $u8.MIN_VALUE (mut i32) (i32.const 0)) - (global $u8.MAX_VALUE (mut i32) (i32.const 255)) - (global $u16.MIN_VALUE (mut i32) (i32.const 0)) - (global $u16.MAX_VALUE (mut i32) (i32.const 65535)) - (global $u32.MIN_VALUE (mut i32) (i32.const 0)) - (global $u32.MAX_VALUE (mut i32) (i32.const -1)) - (global $u64.MIN_VALUE (mut i64) (i64.const 0)) - (global $u64.MAX_VALUE (mut i64) (i64.const -1)) - (global $bool.MIN_VALUE (mut i32) (i32.const 0)) - (global $bool.MAX_VALUE (mut i32) (i32.const 1)) - (global $f32.MIN_SAFE_INTEGER (mut f32) (f32.const -16777215)) - (global $f32.MAX_SAFE_INTEGER (mut f32) (f32.const 16777215)) - (global $f64.MIN_SAFE_INTEGER (mut f64) (f64.const -9007199254740991)) - (global $f64.MAX_SAFE_INTEGER (mut f64) (f64.const 9007199254740991)) + (global $i8.MIN_VALUE i32 (i32.const -128)) + (global $i8.MAX_VALUE i32 (i32.const 127)) + (global $i16.MIN_VALUE i32 (i32.const -32768)) + (global $i16.MAX_VALUE i32 (i32.const 32767)) + (global $i32.MIN_VALUE i32 (i32.const -2147483648)) + (global $i32.MAX_VALUE i32 (i32.const 2147483647)) + (global $i64.MIN_VALUE i64 (i64.const -9223372036854775808)) + (global $i64.MAX_VALUE i64 (i64.const 9223372036854775807)) + (global $u8.MIN_VALUE i32 (i32.const 0)) + (global $u8.MAX_VALUE i32 (i32.const 255)) + (global $u16.MIN_VALUE i32 (i32.const 0)) + (global $u16.MAX_VALUE i32 (i32.const 65535)) + (global $u32.MIN_VALUE i32 (i32.const 0)) + (global $u32.MAX_VALUE i32 (i32.const -1)) + (global $u64.MIN_VALUE i64 (i64.const 0)) + (global $u64.MAX_VALUE i64 (i64.const -1)) + (global $bool.MIN_VALUE i32 (i32.const 0)) + (global $bool.MAX_VALUE i32 (i32.const 1)) + (global $f32.MIN_SAFE_INTEGER f32 (f32.const -16777215)) + (global $f32.MAX_SAFE_INTEGER f32 (f32.const 16777215)) + (global $f64.MIN_SAFE_INTEGER f64 (f64.const -9007199254740991)) + (global $f64.MAX_SAFE_INTEGER f64 (f64.const 9007199254740991)) (global $HEAP_START i32 (i32.const 4)) (memory $0 1) (export "memory" (memory $0)) @@ -109,34 +109,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/literals.wast b/tests/compiler/literals.wast index 755e40c8..67cee1af 100644 --- a/tests/compiler/literals.wast +++ b/tests/compiler/literals.wast @@ -141,34 +141,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/logical.wast b/tests/compiler/logical.wast index d907b4bf..f518c841 100644 --- a/tests/compiler/logical.wast +++ b/tests/compiler/logical.wast @@ -257,34 +257,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/memcpy.wast b/tests/compiler/memcpy.wast index d097fa93..28e0416e 100644 --- a/tests/compiler/memcpy.wast +++ b/tests/compiler/memcpy.wast @@ -2055,34 +2055,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/namespace.wast b/tests/compiler/namespace.wast index 5e17ba81..22f90d87 100644 --- a/tests/compiler/namespace.wast +++ b/tests/compiler/namespace.wast @@ -19,34 +19,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/portable-conversions.optimized.wast b/tests/compiler/portable-conversions.optimized.wast new file mode 100644 index 00000000..ac63dd2c --- /dev/null +++ b/tests/compiler/portable-conversions.optimized.wast @@ -0,0 +1,120 @@ +(module + (type $v (func)) + (global $portable-conversions/f (mut f32) (f32.const 0)) + (global $portable-conversions/F (mut f64) (f64.const 0)) + (memory $0 1) + (export "memory" (memory $0)) + (start $start) + (func $start (; 0 ;) (type $v) + (drop + (i32.trunc_s/f32 + (get_global $portable-conversions/f) + ) + ) + (drop + (i32.trunc_s/f64 + (get_global $portable-conversions/F) + ) + ) + (drop + (i32.trunc_s/f32 + (get_global $portable-conversions/f) + ) + ) + (drop + (i32.trunc_s/f64 + (get_global $portable-conversions/F) + ) + ) + (drop + (i32.trunc_s/f32 + (get_global $portable-conversions/f) + ) + ) + (drop + (i32.trunc_s/f64 + (get_global $portable-conversions/F) + ) + ) + (drop + (i64.trunc_s/f32 + (get_global $portable-conversions/f) + ) + ) + (drop + (i64.trunc_s/f64 + (get_global $portable-conversions/F) + ) + ) + (drop + (i32.trunc_s/f32 + (get_global $portable-conversions/f) + ) + ) + (drop + (i32.trunc_s/f64 + (get_global $portable-conversions/F) + ) + ) + (drop + (i32.trunc_u/f32 + (get_global $portable-conversions/f) + ) + ) + (drop + (i32.trunc_u/f64 + (get_global $portable-conversions/F) + ) + ) + (drop + (i32.trunc_u/f32 + (get_global $portable-conversions/f) + ) + ) + (drop + (i32.trunc_u/f64 + (get_global $portable-conversions/F) + ) + ) + (drop + (i32.trunc_u/f32 + (get_global $portable-conversions/f) + ) + ) + (drop + (i32.trunc_u/f64 + (get_global $portable-conversions/F) + ) + ) + (drop + (i64.trunc_u/f32 + (get_global $portable-conversions/f) + ) + ) + (drop + (i64.trunc_u/f64 + (get_global $portable-conversions/F) + ) + ) + (drop + (i32.trunc_u/f32 + (get_global $portable-conversions/f) + ) + ) + (drop + (i32.trunc_u/f64 + (get_global $portable-conversions/F) + ) + ) + (drop + (i32.trunc_u/f32 + (get_global $portable-conversions/f) + ) + ) + (drop + (i32.trunc_u/f64 + (get_global $portable-conversions/F) + ) + ) + ) +) diff --git a/tests/compiler/portable-conversions.ts b/tests/compiler/portable-conversions.ts new file mode 100644 index 00000000..a8b6afd3 --- /dev/null +++ b/tests/compiler/portable-conversions.ts @@ -0,0 +1,69 @@ +let i: i32 = 0; +let I: i64 = 0; +let f: f32 = 0; +let F: f64 = 0; + +i8(i); +i8(I); +i8(f); +i8(F); + +i16(i); +i16(I); +i16(f); +i16(F); + +i32(i); +i32(I); +i32(f); +i32(F); + +i64(i); +i64(I); +i64(f); +i64(F); + +isize(i); +isize(I); +isize(f); +isize(F); + +u8(i); +u8(I); +u8(f); +u8(F); + +u16(i); +u16(I); +u16(f); +u16(F); + +u32(i); +u32(I); +u32(f); +u32(F); + +u64(i); +u64(I); +u64(f); +u64(F); + +usize(i); +usize(I); +usize(f); +usize(F); + +bool(i); +bool(I); +bool(f); +bool(F); + +f32(i); +f32(I); +f32(f); +f32(F); + +f64(i); +f64(I); +f64(f); +f64(F); diff --git a/tests/compiler/portable-conversions.wast b/tests/compiler/portable-conversions.wast new file mode 100644 index 00000000..fdcee716 --- /dev/null +++ b/tests/compiler/portable-conversions.wast @@ -0,0 +1,381 @@ +(module + (type $v (func)) + (global $portable-conversions/i (mut i32) (i32.const 0)) + (global $portable-conversions/I (mut i64) (i64.const 0)) + (global $portable-conversions/f (mut f32) (f32.const 0)) + (global $portable-conversions/F (mut f64) (f64.const 0)) + (global $HEAP_START i32 (i32.const 4)) + (memory $0 1) + (export "memory" (memory $0)) + (start $start) + (func $start (; 0 ;) (type $v) + (drop + (i32.shr_s + (i32.shl + (get_global $portable-conversions/i) + (i32.const 24) + ) + (i32.const 24) + ) + ) + (drop + (i32.shr_s + (i32.shl + (i32.wrap/i64 + (get_global $portable-conversions/I) + ) + (i32.const 24) + ) + (i32.const 24) + ) + ) + (drop + (i32.shr_s + (i32.shl + (i32.trunc_s/f32 + (get_global $portable-conversions/f) + ) + (i32.const 24) + ) + (i32.const 24) + ) + ) + (drop + (i32.shr_s + (i32.shl + (i32.trunc_s/f64 + (get_global $portable-conversions/F) + ) + (i32.const 24) + ) + (i32.const 24) + ) + ) + (drop + (i32.shr_s + (i32.shl + (get_global $portable-conversions/i) + (i32.const 16) + ) + (i32.const 16) + ) + ) + (drop + (i32.shr_s + (i32.shl + (i32.wrap/i64 + (get_global $portable-conversions/I) + ) + (i32.const 16) + ) + (i32.const 16) + ) + ) + (drop + (i32.shr_s + (i32.shl + (i32.trunc_s/f32 + (get_global $portable-conversions/f) + ) + (i32.const 16) + ) + (i32.const 16) + ) + ) + (drop + (i32.shr_s + (i32.shl + (i32.trunc_s/f64 + (get_global $portable-conversions/F) + ) + (i32.const 16) + ) + (i32.const 16) + ) + ) + (drop + (get_global $portable-conversions/i) + ) + (drop + (i32.wrap/i64 + (get_global $portable-conversions/I) + ) + ) + (drop + (i32.trunc_s/f32 + (get_global $portable-conversions/f) + ) + ) + (drop + (i32.trunc_s/f64 + (get_global $portable-conversions/F) + ) + ) + (drop + (i64.extend_s/i32 + (get_global $portable-conversions/i) + ) + ) + (drop + (get_global $portable-conversions/I) + ) + (drop + (i64.trunc_s/f32 + (get_global $portable-conversions/f) + ) + ) + (drop + (i64.trunc_s/f64 + (get_global $portable-conversions/F) + ) + ) + (drop + (get_global $portable-conversions/i) + ) + (drop + (i32.wrap/i64 + (get_global $portable-conversions/I) + ) + ) + (drop + (i32.trunc_s/f32 + (get_global $portable-conversions/f) + ) + ) + (drop + (i32.trunc_s/f64 + (get_global $portable-conversions/F) + ) + ) + (drop + (i32.and + (get_global $portable-conversions/i) + (i32.const 255) + ) + ) + (drop + (i32.and + (i32.wrap/i64 + (get_global $portable-conversions/I) + ) + (i32.const 255) + ) + ) + (drop + (i32.and + (i32.trunc_u/f32 + (get_global $portable-conversions/f) + ) + (i32.const 255) + ) + ) + (drop + (i32.and + (i32.trunc_u/f64 + (get_global $portable-conversions/F) + ) + (i32.const 255) + ) + ) + (drop + (i32.and + (get_global $portable-conversions/i) + (i32.const 65535) + ) + ) + (drop + (i32.and + (i32.wrap/i64 + (get_global $portable-conversions/I) + ) + (i32.const 65535) + ) + ) + (drop + (i32.and + (i32.trunc_u/f32 + (get_global $portable-conversions/f) + ) + (i32.const 65535) + ) + ) + (drop + (i32.and + (i32.trunc_u/f64 + (get_global $portable-conversions/F) + ) + (i32.const 65535) + ) + ) + (drop + (get_global $portable-conversions/i) + ) + (drop + (i32.wrap/i64 + (get_global $portable-conversions/I) + ) + ) + (drop + (i32.trunc_u/f32 + (get_global $portable-conversions/f) + ) + ) + (drop + (i32.trunc_u/f64 + (get_global $portable-conversions/F) + ) + ) + (drop + (i64.extend_u/i32 + (get_global $portable-conversions/i) + ) + ) + (drop + (get_global $portable-conversions/I) + ) + (drop + (i64.trunc_u/f32 + (get_global $portable-conversions/f) + ) + ) + (drop + (i64.trunc_u/f64 + (get_global $portable-conversions/F) + ) + ) + (drop + (get_global $portable-conversions/i) + ) + (drop + (i32.wrap/i64 + (get_global $portable-conversions/I) + ) + ) + (drop + (i32.trunc_u/f32 + (get_global $portable-conversions/f) + ) + ) + (drop + (i32.trunc_u/f64 + (get_global $portable-conversions/F) + ) + ) + (drop + (i32.and + (get_global $portable-conversions/i) + (i32.const 1) + ) + ) + (drop + (i32.and + (i32.wrap/i64 + (get_global $portable-conversions/I) + ) + (i32.const 1) + ) + ) + (drop + (i32.and + (i32.trunc_u/f32 + (get_global $portable-conversions/f) + ) + (i32.const 1) + ) + ) + (drop + (i32.and + (i32.trunc_u/f64 + (get_global $portable-conversions/F) + ) + (i32.const 1) + ) + ) + (drop + (f32.convert_s/i32 + (get_global $portable-conversions/i) + ) + ) + (drop + (f32.convert_s/i64 + (get_global $portable-conversions/I) + ) + ) + (drop + (get_global $portable-conversions/f) + ) + (drop + (f32.demote/f64 + (get_global $portable-conversions/F) + ) + ) + (drop + (f64.convert_s/i32 + (get_global $portable-conversions/i) + ) + ) + (drop + (f64.convert_s/i64 + (get_global $portable-conversions/I) + ) + ) + (drop + (f64.promote/f32 + (get_global $portable-conversions/f) + ) + ) + (drop + (get_global $portable-conversions/F) + ) + ) +) +(; +[program.elements] + isNaN + isFinite + clz + ctz + popcnt + rotl + rotr + abs + max + min + ceil + floor + copysign + nearest + reinterpret + sqrt + trunc + load + store + sizeof + select + unreachable + current_memory + grow_memory + parseInt + parseFloat + changetype + assert + i8 + i16 + i32 + i64 + u8 + u16 + u32 + u64 + bool + f32 + f64 + isize + usize + portable-conversions/i + portable-conversions/I + portable-conversions/f + portable-conversions/F +[program.exports] + +;) diff --git a/tests/compiler/reexport.wast b/tests/compiler/reexport.wast index d6945590..60ef4f40 100644 --- a/tests/compiler/reexport.wast +++ b/tests/compiler/reexport.wast @@ -48,34 +48,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/switch.wast b/tests/compiler/switch.wast index f43f69ad..935c3f75 100644 --- a/tests/compiler/switch.wast +++ b/tests/compiler/switch.wast @@ -147,34 +147,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/ternary.wast b/tests/compiler/ternary.wast index 93339422..47bef700 100644 --- a/tests/compiler/ternary.wast +++ b/tests/compiler/ternary.wast @@ -35,34 +35,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/tlsf.wast b/tests/compiler/tlsf.wast index 7cdd99cf..9264afd8 100644 --- a/tests/compiler/tlsf.wast +++ b/tests/compiler/tlsf.wast @@ -330,34 +330,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/unary.wast b/tests/compiler/unary.wast index d011f041..b3a11b0b 100644 --- a/tests/compiler/unary.wast +++ b/tests/compiler/unary.wast @@ -623,34 +623,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32 diff --git a/tests/compiler/while.wast b/tests/compiler/while.wast index ca0af6ea..4b8d5588 100644 --- a/tests/compiler/while.wast +++ b/tests/compiler/while.wast @@ -62,34 +62,34 @@ ) (; [program.elements] + isNaN + isFinite clz ctz popcnt rotl rotr abs - ceil - copysign - floor max min + ceil + floor + copysign nearest + reinterpret sqrt trunc - current_memory - grow_memory - unreachable load store - reinterpret - select sizeof - changetype - isNaN - isFinite - assert + select + unreachable + current_memory + grow_memory parseInt parseFloat + changetype + assert i8 i16 i32