diff options
35 files changed, 1282 insertions, 192 deletions
diff --git a/build-js.sh b/build-js.sh index 43cfaca7b..63f881ea8 100755 --- a/build-js.sh +++ b/build-js.sh @@ -43,6 +43,7 @@ EMCC_ARGS="$EMCC_ARGS -s DEMANGLE_SUPPORT=1" EMCC_ARGS="$EMCC_ARGS -s NO_FILESYSTEM=1" EMCC_ARGS="$EMCC_ARGS -s WASM=0" EMCC_ARGS="$EMCC_ARGS -s ERROR_ON_UNDEFINED_SYMBOLS=1" +EMCC_ARGS="$EMCC_ARGS -s BINARYEN_ASYNC_COMPILATION=0" # TODO: enable this (need nearbyint in emscripten tag) EMCC_ARGS="$EMCC_ARGS -s ERROR_ON_UNDEFINED_SYMBOLS=1" EMCC_ARGS="$EMCC_ARGS -s DISABLE_EXCEPTION_CATCHING=0" # Exceptions are thrown and caught when optimizing endless loops OUT_FILE_SUFFIX= @@ -208,6 +209,10 @@ export_function "_BinaryenSIMDReplaceId" export_function "_BinaryenSIMDShuffleId" export_function "_BinaryenSIMDBitselectId" export_function "_BinaryenSIMDShiftId" +export_function "_BinaryenMemoryInitId" +export_function "_BinaryenDataDropId" +export_function "_BinaryenMemoryCopyId" +export_function "_BinaryenMemoryFillId" # External kinds export_function "_BinaryenExternalFunction" @@ -540,6 +545,10 @@ export_function "_BinaryenSIMDReplace" export_function "_BinaryenSIMDShuffle" export_function "_BinaryenSIMDBitselect" export_function "_BinaryenSIMDShift" +export_function "_BinaryenMemoryInit" +export_function "_BinaryenDataDrop" +export_function "_BinaryenMemoryCopy" +export_function "_BinaryenMemoryFill" # 'Expression' operations export_function "_BinaryenExpressionGetId" @@ -696,6 +705,25 @@ export_function "_BinaryenSIMDShiftGetOp" export_function "_BinaryenSIMDShiftGetVec" export_function "_BinaryenSIMDShiftGetShift" +# 'MemoryInit' expression operations +export_function "_BinaryenMemoryInitGetSegment" +export_function "_BinaryenMemoryInitGetDest" +export_function "_BinaryenMemoryInitGetOffset" +export_function "_BinaryenMemoryInitGetSize" + +# 'DataDrop' expression operations +export_function "_BinaryenDataDropGetSegment" + +# 'MemoryCopy' expression operations +export_function "_BinaryenMemoryCopyGetDest" +export_function "_BinaryenMemoryCopyGetSource" +export_function "_BinaryenMemoryCopyGetSize" + +# 'MemoryFill' expression operations +export_function "_BinaryenMemoryFillGetDest" +export_function "_BinaryenMemoryFillGetValue" +export_function "_BinaryenMemoryFillGetSize" + # 'Module' operations export_function "_BinaryenModuleCreate" export_function "_BinaryenModuleDispose" @@ -55,7 +55,7 @@ def with_pass_debug(check): def run_help_tests(): print '[ checking --help is useful... ]\n' - not_executable_suffix = ['.txt', '.js', '.ilk', '.pdb', '.dll'] + not_executable_suffix = ['.txt', '.js', '.ilk', '.pdb', '.dll', '.wasm'] executables = sorted(filter(lambda x: not any(x.endswith(s) for s in not_executable_suffix) and os.path.isfile(x), os.listdir(options.binaryen_bin))) diff --git a/scripts/gen-s-parser.py b/scripts/gen-s-parser.py index 7e9e70a7c..2f63efe70 100755 --- a/scripts/gen-s-parser.py +++ b/scripts/gen-s-parser.py @@ -35,6 +35,10 @@ instructions = [ ("local.tee", "makeTeeLocal(s)"), ("global.get", "makeGetGlobal(s)"), ("global.set", "makeSetGlobal(s)"), + ("memory.init", "makeMemoryInit(s)"), + ("data.drop", "makeDataDrop(s)"), + ("memory.copy", "makeMemoryCopy(s)"), + ("memory.fill", "makeMemoryFill(s)"), ("i32.load", "makeLoad(s, i32, /*isAtomic=*/false)"), ("i64.load", "makeLoad(s, i64, /*isAtomic=*/false)"), ("f32.load", "makeLoad(s, f32, /*isAtomic=*/false)"), diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp index 9ed6ad314..36aebb523 100644 --- a/src/binaryen-c.cpp +++ b/src/binaryen-c.cpp @@ -263,6 +263,10 @@ BinaryenExpressionId BinaryenSIMDReplaceId(void) { return Expression::Id::SIMDRe BinaryenExpressionId BinaryenSIMDShuffleId(void) { return Expression::Id::SIMDShuffleId; } BinaryenExpressionId BinaryenSIMDBitselectId(void) { return Expression::Id::SIMDBitselectId; } BinaryenExpressionId BinaryenSIMDShiftId(void) { return Expression::Id::SIMDShiftId; } +BinaryenExpressionId BinaryenMemoryInitId(void) { return Expression::Id::MemoryInitId; } +BinaryenExpressionId BinaryenDataDropId(void) { return Expression::Id::DataDropId; } +BinaryenExpressionId BinaryenMemoryCopyId(void) { return Expression::Id::MemoryCopyId; } +BinaryenExpressionId BinaryenMemoryFillId(void) { return Expression::Id::MemoryFillId; } // External kinds @@ -1070,6 +1074,37 @@ BinaryenExpressionRef BinaryenSIMDShift(BinaryenModuleRef module, BinaryenOp op, } return static_cast<Expression*>(ret); } +BinaryenExpressionRef BinaryenMemoryInit(BinaryenModuleRef module, uint32_t segment, BinaryenExpressionRef dest, BinaryenExpressionRef offset, BinaryenExpressionRef size) { + auto* ret = Builder(*((Module*)module)).makeMemoryInit(segment, (Expression*)dest, (Expression*)offset, (Expression*)size); + if (tracing) { + traceExpression(ret, "BinaryenMemoryInit", segment, dest, offset, size); + } + return static_cast<Expression*>(ret); +} + +BinaryenExpressionRef BinaryenDataDrop(BinaryenModuleRef module, uint32_t segment) { + auto* ret = Builder(*((Module*)module)).makeDataDrop(segment); + if (tracing) { + traceExpression(ret, "BinaryenDataDrop", segment); + } + return static_cast<Expression*>(ret); +} + +BinaryenExpressionRef BinaryenMemoryCopy(BinaryenModuleRef module, BinaryenExpressionRef dest, BinaryenExpressionRef source, BinaryenExpressionRef size) { + auto* ret = Builder(*((Module*)module)).makeMemoryCopy((Expression*)dest, (Expression*)source, (Expression*)size); + if (tracing) { + traceExpression(ret, "BinaryenMemoryCopy", dest, source, size); + } + return static_cast<Expression*>(ret); +} + +BinaryenExpressionRef BinaryenMemoryFill(BinaryenModuleRef module, BinaryenExpressionRef dest, BinaryenExpressionRef value, BinaryenExpressionRef size) { + auto* ret = Builder(*((Module*)module)).makeMemoryFill((Expression*)dest, (Expression*)value, (Expression*)size); + if (tracing) { + traceExpression(ret, "BinaryenMemoryFill", dest, value, size); + } + return static_cast<Expression*>(ret); +} // Expression utility @@ -1969,6 +2004,109 @@ BinaryenExpressionRef BinaryenSIMDShiftGetShift(BinaryenExpressionRef expr) { assert(expression->is<SIMDShift>()); return static_cast<SIMDShift*>(expression)->shift; } +// MemoryInit +uint32_t BinaryenMemoryInitGetSegment(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenMemoryInitGetSegment(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is<MemoryInit>()); + return static_cast<MemoryInit*>(expression)->segment; +} +BinaryenExpressionRef BinaryenMemoryInitGetDest(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenMemoryInitGetDest(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is<MemoryInit>()); + return static_cast<MemoryInit*>(expression)->dest; +} +BinaryenExpressionRef BinaryenMemoryInitGetOffset(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenMemoryInitGetOffset(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is<MemoryInit>()); + return static_cast<MemoryInit*>(expression)->offset; +} +BinaryenExpressionRef BinaryenMemoryInitGetSize(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenMemoryInitGetSize(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is<MemoryInit>()); + return static_cast<MemoryInit*>(expression)->size; +} +// DataDrop +uint32_t BinaryenDataDropGetSegment(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenDataDropGetSegment(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is<DataDrop>()); + return static_cast<DataDrop*>(expression)->segment; +} +// MemoryCopy +BinaryenExpressionRef BinaryenMemoryCopyGetDest(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenMemoryCopyGetDest(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is<MemoryCopy>()); + return static_cast<MemoryCopy*>(expression)->dest; +} +BinaryenExpressionRef BinaryenMemoryCopyGetSource(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenMemoryCopyGetSource(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is<MemoryCopy>()); + return static_cast<MemoryCopy*>(expression)->source; +} +BinaryenExpressionRef BinaryenMemoryCopyGetSize(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenMemoryCopyGetSize(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is<MemoryCopy>()); + return static_cast<MemoryCopy*>(expression)->size; +} +// MemoryFill +BinaryenExpressionRef BinaryenMemoryFillGetDest(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenMemoryFillGetDest(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is<MemoryFill>()); + return static_cast<MemoryFill*>(expression)->dest; +} +BinaryenExpressionRef BinaryenMemoryFillGetValue(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenMemoryFillGetValue(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is<MemoryFill>()); + return static_cast<MemoryFill*>(expression)->value; +} +BinaryenExpressionRef BinaryenMemoryFillGetSize(BinaryenExpressionRef expr) { + if (tracing) { + std::cout << " BinaryenMemoryFillGetSize(expressions[" << expressions[expr] << "]);\n"; + } + + auto* expression = (Expression*)expr; + assert(expression->is<MemoryFill>()); + return static_cast<MemoryFill*>(expression)->size; +} // Functions diff --git a/src/binaryen-c.h b/src/binaryen-c.h index 2a3254f7b..5355ceeeb 100644 --- a/src/binaryen-c.h +++ b/src/binaryen-c.h @@ -122,6 +122,10 @@ BinaryenExpressionId BinaryenSIMDReplaceId(void); BinaryenExpressionId BinaryenSIMDShuffleId(void); BinaryenExpressionId BinaryenSIMDBitselectId(void); BinaryenExpressionId BinaryenSIMDShiftId(void); +BinaryenExpressionId BinaryenMemoryInitId(void); +BinaryenExpressionId BinaryenDataDropId(void); +BinaryenExpressionId BinaryenMemoryCopyId(void); +BinaryenExpressionId BinaryenMemoryFillId(void); // External kinds (call to get the value of each; you can cache them) @@ -540,6 +544,10 @@ BinaryenExpressionRef BinaryenSIMDReplace(BinaryenModuleRef module, BinaryenOp o BinaryenExpressionRef BinaryenSIMDShuffle(BinaryenModuleRef module, BinaryenExpressionRef left, BinaryenExpressionRef right, const uint8_t mask[16]); BinaryenExpressionRef BinaryenSIMDBitselect(BinaryenModuleRef module, BinaryenExpressionRef left, BinaryenExpressionRef right, BinaryenExpressionRef cond); BinaryenExpressionRef BinaryenSIMDShift(BinaryenModuleRef module, BinaryenOp op, BinaryenExpressionRef vec, BinaryenExpressionRef shift); +BinaryenExpressionRef BinaryenMemoryInit(BinaryenModuleRef module, uint32_t segment, BinaryenExpressionRef dest, BinaryenExpressionRef offset, BinaryenExpressionRef size); +BinaryenExpressionRef BinaryenDataDrop(BinaryenModuleRef module, uint32_t segment); +BinaryenExpressionRef BinaryenMemoryCopy(BinaryenModuleRef module, BinaryenExpressionRef dest, BinaryenExpressionRef source, BinaryenExpressionRef size); +BinaryenExpressionRef BinaryenMemoryFill(BinaryenModuleRef module, BinaryenExpressionRef dest, BinaryenExpressionRef value, BinaryenExpressionRef size); BinaryenExpressionId BinaryenExpressionGetId(BinaryenExpressionRef expr); BinaryenType BinaryenExpressionGetType(BinaryenExpressionRef expr); @@ -667,6 +675,20 @@ BinaryenOp BinaryenSIMDShiftGetOp(BinaryenExpressionRef expr); BinaryenExpressionRef BinaryenSIMDShiftGetVec(BinaryenExpressionRef expr); BinaryenExpressionRef BinaryenSIMDShiftGetShift(BinaryenExpressionRef expr); +uint32_t BinaryenMemoryInitGetSegment(BinaryenExpressionRef expr); +BinaryenExpressionRef BinaryenMemoryInitGetDest(BinaryenExpressionRef expr); +BinaryenExpressionRef BinaryenMemoryInitGetOffset(BinaryenExpressionRef expr); +BinaryenExpressionRef BinaryenMemoryInitGetSize(BinaryenExpressionRef expr); + +uint32_t BinaryenDataDropGetSegment(BinaryenExpressionRef expr); + +BinaryenExpressionRef BinaryenMemoryCopyGetDest(BinaryenExpressionRef expr); +BinaryenExpressionRef BinaryenMemoryCopyGetSource(BinaryenExpressionRef expr); +BinaryenExpressionRef BinaryenMemoryCopyGetSize(BinaryenExpressionRef expr); + +BinaryenExpressionRef BinaryenMemoryFillGetDest(BinaryenExpressionRef expr); +BinaryenExpressionRef BinaryenMemoryFillGetValue(BinaryenExpressionRef expr); +BinaryenExpressionRef BinaryenMemoryFillGetSize(BinaryenExpressionRef expr); // Functions diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc index 6db1d7a2c..710f0d829 100644 --- a/src/gen-s-parser.inc +++ b/src/gen-s-parser.inc @@ -51,9 +51,17 @@ switch (op[0]) { default: goto parse_error; } } - case 'd': - if (strcmp(op, "drop") == 0) return makeDrop(s); - goto parse_error; + case 'd': { + switch (op[1]) { + case 'a': + if (strcmp(op, "data.drop") == 0) return makeDataDrop(s); + goto parse_error; + case 'r': + if (strcmp(op, "drop") == 0) return makeDrop(s); + goto parse_error; + default: goto parse_error; + } + } case 'e': if (strcmp(op, "else") == 0) return makeThenOrElse(s); goto parse_error; @@ -2183,6 +2191,20 @@ switch (op[0]) { default: goto parse_error; } } + case 'm': { + switch (op[7]) { + case 'c': + if (strcmp(op, "memory.copy") == 0) return makeMemoryCopy(s); + goto parse_error; + case 'f': + if (strcmp(op, "memory.fill") == 0) return makeMemoryFill(s); + goto parse_error; + case 'i': + if (strcmp(op, "memory.init") == 0) return makeMemoryInit(s); + goto parse_error; + default: goto parse_error; + } + } case 'n': if (strcmp(op, "nop") == 0) return makeNop(); goto parse_error; diff --git a/src/ir/ExpressionAnalyzer.cpp b/src/ir/ExpressionAnalyzer.cpp index 0efc7b888..cd2946253 100644 --- a/src/ir/ExpressionAnalyzer.cpp +++ b/src/ir/ExpressionAnalyzer.cpp @@ -280,6 +280,29 @@ bool ExpressionAnalyzer::flexibleEqual(Expression* left, Expression* right, Expr PUSH(SIMDShift, shift); break; } + case Expression::Id::MemoryInitId: { + CHECK(MemoryInit, segment); + PUSH(MemoryInit, dest); + PUSH(MemoryInit, offset); + PUSH(MemoryInit, size); + break; + } + case Expression::Id::DataDropId: { + CHECK(DataDrop, segment); + break; + } + case Expression::Id::MemoryCopyId: { + PUSH(MemoryCopy, dest); + PUSH(MemoryCopy, source); + PUSH(MemoryCopy, size); + break; + } + case Expression::Id::MemoryFillId: { + PUSH(MemoryFill, dest); + PUSH(MemoryFill, value); + PUSH(MemoryFill, size); + break; + } case Expression::Id::ConstId: { if (left->cast<Const>()->value != right->cast<Const>()->value) { return false; @@ -561,6 +584,29 @@ HashType ExpressionAnalyzer::hash(Expression* curr) { PUSH(SIMDShift, shift); break; } + case Expression::Id::MemoryInitId: { + HASH(MemoryInit, segment); + PUSH(MemoryInit, dest); + PUSH(MemoryInit, offset); + PUSH(MemoryInit, size); + break; + } + case Expression::Id::DataDropId: { + HASH(DataDrop, segment); + break; + } + case Expression::Id::MemoryCopyId: { + PUSH(MemoryCopy, dest); + PUSH(MemoryCopy, source); + PUSH(MemoryCopy, size); + break; + } + case Expression::Id::MemoryFillId: { + PUSH(MemoryFill, dest); + PUSH(MemoryFill, value); + PUSH(MemoryFill, size); + break; + } case Expression::Id::ConstId: { auto* c = curr->cast<Const>(); hash(c->type); diff --git a/src/ir/ExpressionManipulator.cpp b/src/ir/ExpressionManipulator.cpp index 700f7fdb8..32ee442b7 100644 --- a/src/ir/ExpressionManipulator.cpp +++ b/src/ir/ExpressionManipulator.cpp @@ -129,9 +129,21 @@ Expression* flexibleCopy(Expression* original, Module& wasm, CustomCopier custom Expression* visitSIMDShift(SIMDShift* curr) { return builder.makeSIMDShift(curr->op, copy(curr->vec), copy(curr->shift)); } - Expression* visitConst(Const *curr) { + Expression* visitConst(Const* curr) { return builder.makeConst(curr->value); } + Expression* visitMemoryInit(MemoryInit* curr) { + return builder.makeMemoryInit(curr->segment, copy(curr->dest), copy(curr->offset), copy(curr->size)); + } + Expression* visitDataDrop(DataDrop* curr) { + return builder.makeDataDrop(curr->segment); + } + Expression* visitMemoryCopy(MemoryCopy* curr) { + return builder.makeMemoryCopy(copy(curr->dest), copy(curr->source), copy(curr->size)); + } + Expression* visitMemoryFill(MemoryFill* curr) { + return builder.makeMemoryFill(copy(curr->dest), copy(curr->value), copy(curr->size)); + } Expression* visitUnary(Unary *curr) { return builder.makeUnary(curr->op, copy(curr->value)); } diff --git a/src/ir/ReFinalize.cpp b/src/ir/ReFinalize.cpp index 68526678a..3f374265c 100644 --- a/src/ir/ReFinalize.cpp +++ b/src/ir/ReFinalize.cpp @@ -142,6 +142,10 @@ void ReFinalize::visitSIMDReplace(SIMDReplace* curr) { curr->finalize(); } void ReFinalize::visitSIMDShuffle(SIMDShuffle* curr) { curr->finalize(); } void ReFinalize::visitSIMDBitselect(SIMDBitselect* curr) { curr->finalize(); } void ReFinalize::visitSIMDShift(SIMDShift* curr) { curr->finalize(); } +void ReFinalize::visitMemoryInit(MemoryInit* curr) { curr->finalize(); } +void ReFinalize::visitDataDrop(DataDrop* curr) { curr->finalize(); } +void ReFinalize::visitMemoryCopy(MemoryCopy* curr) { curr->finalize(); } +void ReFinalize::visitMemoryFill(MemoryFill* curr) { curr->finalize(); } void ReFinalize::visitConst(Const* curr) { curr->finalize(); } void ReFinalize::visitUnary(Unary* curr) { curr->finalize(); } void ReFinalize::visitBinary(Binary* curr) { curr->finalize(); } diff --git a/src/ir/utils.h b/src/ir/utils.h index afb63b01c..85c485552 100644 --- a/src/ir/utils.h +++ b/src/ir/utils.h @@ -134,6 +134,10 @@ struct ReFinalize : public WalkerPass<PostWalker<ReFinalize, OverriddenVisitor<R void visitSIMDShuffle(SIMDShuffle* curr); void visitSIMDBitselect(SIMDBitselect* curr); void visitSIMDShift(SIMDShift* curr); + void visitMemoryInit(MemoryInit* curr); + void visitDataDrop(DataDrop* curr); + void visitMemoryCopy(MemoryCopy* curr); + void visitMemoryFill(MemoryFill* curr); void visitConst(Const* curr); void visitUnary(Unary* curr); void visitBinary(Binary* curr); @@ -186,6 +190,10 @@ struct ReFinalizeNode : public OverriddenVisitor<ReFinalizeNode> { void visitSIMDShuffle(SIMDShuffle* curr) { curr->finalize(); } void visitSIMDBitselect(SIMDBitselect* curr) { curr->finalize(); } void visitSIMDShift(SIMDShift* curr) { curr->finalize(); } + void visitMemoryInit(MemoryInit* curr) { curr->finalize(); } + void visitDataDrop(DataDrop* curr) { curr->finalize(); } + void visitMemoryCopy(MemoryCopy* curr) { curr->finalize(); } + void visitMemoryFill(MemoryFill* curr) { curr->finalize(); } void visitConst(Const* curr) { curr->finalize(); } void visitUnary(Unary* curr) { curr->finalize(); } void visitBinary(Binary* curr) { curr->finalize(); } diff --git a/src/js/binaryen.js-post.js b/src/js/binaryen.js-post.js index aa2e613ce..b2dba075b 100644 --- a/src/js/binaryen.js-post.js +++ b/src/js/binaryen.js-post.js @@ -73,6 +73,10 @@ Module['SIMDReplaceId'] = Module['_BinaryenSIMDReplaceId'](); Module['SIMDShuffleId'] = Module['_BinaryenSIMDShuffleId'](); Module['SIMDBitselectId'] = Module['_BinaryenSIMDBitselectId'](); Module['SIMDShiftId'] = Module['_BinaryenSIMDShiftId'](); +Module['MemoryInitId'] = Module['_BinaryenMemoryInitId'](); +Module['DataDropId'] = Module['_BinaryenDataDropId'](); +Module['MemoryCopyId'] = Module['_BinaryenMemoryCopyId'](); +Module['MemoryFillId'] = Module['_BinaryenMemoryFillId'](); // External kinds Module['ExternalFunction'] = Module['_BinaryenExternalFunction'](); @@ -460,6 +464,24 @@ function wrapModule(module, self) { return Module['_BinaryenHost'](module, Module['GrowMemory'], null, i32sToStack([value]), 1); } + self['memory'] = { + 'init': function(segment, dest, offset, size) { + return Module['_BinaryenMemoryInit'](module, segment, dest, offset, size); + }, + 'copy': function(dest, source, size) { + return Module['_BinaryenMemoryCopy'](module, dest, source, size); + }, + 'fill': function(dest, value, size) { + return Module['_BinaryenMemoryFill'](module, dest, value, size); + } + } + + self['data'] = { + 'drop': function(segment) { + return Module['_BinaryenDataDrop'](module, segment); + } + } + // The Const creation API is a little different: we don't want users to // need to make their own Literals, as the C API handles them by value, // which means we would leak them. Instead, this is the only API that @@ -2211,6 +2233,34 @@ Module['getExpressionInfo'] = function(expr) { 'vec': Module['_BinaryenSIMDShiftGetVec'](expr), 'shift': Module['_BinaryenSIMDShiftGetShift'](expr) }; + case Module['MemoryInitId']: + return { + 'id': id, + 'segment': Module['_BinaryenMemoryInitGetSegment'](expr), + 'dest': Module['_BinaryenMemoryInitGetDest'](expr), + 'offset': Module['_BinaryenMemoryInitGetOffset'](expr), + 'size': Module['_BinaryenMemoryInitGetSize'](expr) + }; + case Module['DataDropId']: + return { + 'id': id, + 'segment': Module['_BinaryenDataDropGetSegment'](expr), + }; + case Module['MemoryCopyId']: + return { + 'id': id, + 'dest': Module['_BinaryenMemoryCopyGetDest'](expr), + 'source': Module['_BinaryenMemoryCopyGetSource'](expr), + 'size': Module['_BinaryenMemoryCopyGetSize'](expr) + }; + case Module['MemoryFillId']: + return { + 'id': id, + 'dest': Module['_BinaryenMemoryFillGetDest'](expr), + 'value': Module['_BinaryenMemoryFillGetValue'](expr), + 'size': Module['_BinaryenMemoryFillGetSize'](expr) + }; + default: throw Error('unexpected id: ' + id); } diff --git a/src/passes/DeadCodeElimination.cpp b/src/passes/DeadCodeElimination.cpp index 6e70fc55d..a6b20a7ba 100644 --- a/src/passes/DeadCodeElimination.cpp +++ b/src/passes/DeadCodeElimination.cpp @@ -262,6 +262,10 @@ struct DeadCodeElimination : public WalkerPass<PostWalker<DeadCodeElimination>> case Expression::Id::SIMDShuffleId: DELEGATE(SIMDShuffle); case Expression::Id::SIMDBitselectId: DELEGATE(SIMDBitselect); case Expression::Id::SIMDShiftId: DELEGATE(SIMDShift); + case Expression::Id::MemoryInitId: DELEGATE(MemoryInit); + case Expression::Id::DataDropId: DELEGATE(DataDrop); + case Expression::Id::MemoryCopyId: DELEGATE(MemoryCopy); + case Expression::Id::MemoryFillId: DELEGATE(MemoryFill); case Expression::Id::InvalidId: WASM_UNREACHABLE(); case Expression::Id::NumExpressionIds: WASM_UNREACHABLE(); } diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp index 3de8b5c01..761c9e3d4 100644 --- a/src/passes/Print.cpp +++ b/src/passes/Print.cpp @@ -293,6 +293,22 @@ struct PrintExpressionContents : public Visitor<PrintExpressionContents> { case ShrUVecI64x2: o << "i64x2.shr_u"; break; } } + void visitMemoryInit(MemoryInit* curr) { + prepareColor(o); + o << "memory.init " << curr->segment; + } + void visitDataDrop(DataDrop* curr) { + prepareColor(o); + o << "data.drop " << curr->segment; + } + void visitMemoryCopy(MemoryCopy* curr) { + prepareColor(o); + o << "memory.copy"; + } + void visitMemoryFill(MemoryFill* curr) { + prepareColor(o); + o << "memory.fill"; + } void visitConst(Const* curr) { o << curr->value; } @@ -936,6 +952,38 @@ struct PrintSExpression : public Visitor<PrintSExpression> { printFullLine(curr->shift); decIndent(); } + void visitMemoryInit(MemoryInit* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->dest); + printFullLine(curr->offset); + printFullLine(curr->size); + decIndent(); + } + void visitDataDrop(DataDrop* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + o << ')'; + } + void visitMemoryCopy(MemoryCopy* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->dest); + printFullLine(curr->source); + printFullLine(curr->size); + decIndent(); + } + void visitMemoryFill(MemoryFill* curr) { + o << '('; + PrintExpressionContents(currFunction, o).visit(curr); + incIndent(); + printFullLine(curr->dest); + printFullLine(curr->value); + printFullLine(curr->size); + decIndent(); + } void visitConst(Const* curr) { o << '('; PrintExpressionContents(currFunction, o).visit(curr); diff --git a/src/tools/fuzzing.h b/src/tools/fuzzing.h index 56c633f14..63e7dca43 100644 --- a/src/tools/fuzzing.h +++ b/src/tools/fuzzing.h @@ -727,6 +727,9 @@ private: &Self::makeSelect, &Self::makeGetGlobal) .add(FeatureSet::SIMD, &Self::makeSIMD); + if (type == none) { + options.add(FeatureSet::BulkMemory, &Self::makeBulkMemory); + } if (type == i32 || type == i64) { options.add(FeatureSet::Atomics, &Self::makeAtomic); } @@ -1713,6 +1716,44 @@ private: return builder.makeSIMDShift(op, vec, shift); } + Expression* makeBulkMemory(Type type) { + assert(features.hasBulkMemory()); + assert(type == none); + switch (upTo(4)) { + case 0: return makeMemoryInit(); + case 1: return makeDataDrop(); + case 2: return makeMemoryCopy(); + case 3: return makeMemoryFill(); + } + WASM_UNREACHABLE(); + } + + Expression* makeMemoryInit() { + auto segment = uint32_t(get32()); + Expression* dest = make(i32); + Expression* offset = make(i32); + Expression* size = make(i32); + return builder.makeMemoryInit(segment, dest, offset, size); + } + + Expression* makeDataDrop() { + return builder.makeDataDrop(get32()); + } + + Expression* makeMemoryCopy() { + Expression* dest = make(i32); + Expression* source = make(i32); + Expression* size = make(i32); + return builder.makeMemoryCopy(dest, source, size); + } + + Expression* makeMemoryFill() { + Expression* dest = make(i32); + Expression* value = make(i32); + Expression* size = make(i32); + return builder.makeMemoryFill(dest, value, size); + } + // special makers Expression* makeLogging() { diff --git a/src/tools/tool-options.h b/src/tools/tool-options.h index 9aff8e619..5620883ec 100644 --- a/src/tools/tool-options.h +++ b/src/tools/tool-options.h @@ -72,17 +72,29 @@ struct ToolOptions : public Options { passOptions.features.setTruncSat(false); }) .add("--enable-simd", "", - "Enable nontrapping float-to-int operations", + "Enable SIMD operations and types", Options::Arguments::Zero, [this](Options *o, const std::string& arguments) { passOptions.features.setSIMD(); }) .add("--disable-simd", "", - "Disable nontrapping float-to-int operations", + "Disable SIMD operations and types", Options::Arguments::Zero, [this](Options *o, const std::string& arguments) { passOptions.features.setSIMD(false); }) + .add("--enable-bulk-memory", "", + "Enable bulk memory operations", + Options::Arguments::Zero, + [this](Options *o, const std::string& arguments) { + passOptions.features.setBulkMemory(); + }) + .add("--disable-bulk-memory", "", + "Disable bulk memory operations", + Options::Arguments::Zero, + [this](Options *o, const std::string& arguments) { + passOptions.features.setBulkMemory(false); + }) .add("--no-validation", "-n", "Disables validation, assumes inputs are correct", Options::Arguments::Zero, [this](Options* o, const std::string& argument) { diff --git a/src/wasm-binary.h b/src/wasm-binary.h index 2402375dc..a875db791 100644 --- a/src/wasm-binary.h +++ b/src/wasm-binary.h @@ -550,7 +550,7 @@ enum ASTNodes { I64ExtendS16 = 0xc3, I64ExtendS32 = 0xc4, - TruncSatPrefix = 0xfc, + MiscPrefix = 0xfc, SIMDPrefix = 0xfd, AtomicPrefix = 0xfe }; @@ -785,6 +785,13 @@ enum SIMDOpcodes { F64x2ConvertUI64x2 = 0xb2 }; +enum BulkMemoryOpcodes { + MemoryInit = 0x08, + DataDrop = 0x09, + MemoryCopy = 0x0a, + MemoryFill = 0x0b +}; + enum MemoryAccess { Offset = 0x10, // bit 4 Alignment = 0x80, // bit 7 @@ -1115,6 +1122,10 @@ public: bool maybeVisitSIMDShuffle(Expression*& out, uint32_t code); bool maybeVisitSIMDBitselect(Expression*& out, uint32_t code); bool maybeVisitSIMDShift(Expression*& out, uint32_t code); + bool maybeVisitMemoryInit(Expression*& out, uint32_t code); + bool maybeVisitDataDrop(Expression*& out, uint32_t code); + bool maybeVisitMemoryCopy(Expression*& out, uint32_t code); + bool maybeVisitMemoryFill(Expression*& out, uint32_t code); void visitSelect(Select* curr); void visitReturn(Return* curr); bool maybeVisitHost(Expression*& out, uint8_t code); diff --git a/src/wasm-builder.h b/src/wasm-builder.h index f182b1df2..eee4e3b79 100644 --- a/src/wasm-builder.h +++ b/src/wasm-builder.h @@ -334,6 +334,37 @@ public: ret->finalize(); return ret; } + MemoryInit* makeMemoryInit(uint32_t segment, Expression* dest, Expression* offset, Expression* size) { + auto* ret = allocator.alloc<MemoryInit>(); + ret->segment = segment; + ret->dest = dest; + ret->offset = offset; + ret->size = size; + ret->finalize(); + return ret; + } + DataDrop* makeDataDrop(uint32_t segment) { + auto* ret = allocator.alloc<DataDrop>(); + ret->segment = segment; + ret->finalize(); + return ret; + } + MemoryCopy* makeMemoryCopy(Expression* dest, Expression* source, Expression* size) { + auto* ret = allocator.alloc<MemoryCopy>(); + ret->dest = dest; + ret->source = source; + ret->size = size; + ret->finalize(); + return ret; + } + MemoryFill* makeMemoryFill(Expression* dest, Expression* value, Expression* size) { + auto* ret = allocator.alloc<MemoryFill>(); + ret->dest = dest; + ret->value = value; + ret->size = size; + ret->finalize(); + return ret; + } Const* makeConst(Literal value) { assert(isConcreteType(value.type)); auto* ret = allocator.alloc<Const>(); diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h index b10f3087f..c584f0ea7 100644 --- a/src/wasm-interpreter.h +++ b/src/wasm-interpreter.h @@ -727,6 +727,10 @@ public: Flow visitLoad(Load *curr) { WASM_UNREACHABLE(); } Flow visitStore(Store *curr) { WASM_UNREACHABLE(); } Flow visitHost(Host *curr) { WASM_UNREACHABLE(); } + Flow visitMemoryInit(MemoryInit *curr) { WASM_UNREACHABLE(); } + Flow visitDataDrop(DataDrop *curr) { WASM_UNREACHABLE(); } + Flow visitMemoryCopy(MemoryCopy *curr) { WASM_UNREACHABLE(); } + Flow visitMemoryFill(MemoryFill *curr) { WASM_UNREACHABLE(); } }; // @@ -1152,6 +1156,26 @@ public: } WASM_UNREACHABLE(); } + Flow visitMemoryInit(MemoryInit *curr) { + NOTE_ENTER("MemoryInit"); + // TODO(tlively): implement me + return {}; + } + Flow visitDataDrop(DataDrop *curr) { + NOTE_ENTER("DataDrop"); + // TODO(tlively): implement me + return {}; + } + Flow visitMemoryCopy(MemoryCopy *curr) { + NOTE_ENTER("MemoryCopy"); + // TODO(tlively): implement me + return {}; + } + Flow visitMemoryFill(MemoryFill *curr) { + NOTE_ENTER("MemoryFill"); + // TODO(tlively): implement me + return {}; + } void trap(const char* why) override { instance.externalInterface->trap(why); diff --git a/src/wasm-s-parser.h b/src/wasm-s-parser.h index ef6e8d36b..f0ed79409 100644 --- a/src/wasm-s-parser.h +++ b/src/wasm-s-parser.h @@ -195,7 +195,11 @@ private: Expression* makeSIMDReplace(Element& s, SIMDReplaceOp op, size_t lanes); Expression* makeSIMDShuffle(Element& s); Expression* makeSIMDBitselect(Element& s); - Expression* makeSIMDShift(Element& s, SIMDShiftOp); + Expression* makeSIMDShift(Element& s, SIMDShiftOp op); + Expression* makeMemoryInit(Element& s); + Expression* makeDataDrop(Element& s); + Expression* makeMemoryCopy(Element& s); + Expression* makeMemoryFill(Element& s); Expression* makeIf(Element& s); Expression* makeMaybeBlock(Element& s, size_t i, Type type); Expression* makeLoop(Element& s); diff --git a/src/wasm-stack.h b/src/wasm-stack.h index c64fd2759..7419d5dca 100644 --- a/src/wasm-stack.h +++ b/src/wasm-stack.h @@ -140,6 +140,10 @@ public: void visitSIMDShuffle(SIMDShuffle* curr); void visitSIMDBitselect(SIMDBitselect* curr); void visitSIMDShift(SIMDShift* curr); + void visitMemoryInit(MemoryInit* curr); + void visitDataDrop(DataDrop* curr); + void visitMemoryCopy(MemoryCopy* curr); + void visitMemoryFill(MemoryFill* curr); void visitConst(Const* curr); void visitUnary(Unary* curr); void visitBinary(Binary* curr); @@ -955,6 +959,47 @@ void StackWriter<Mode, Parent>::visitSIMDShift(SIMDShift* curr) { } template<StackWriterMode Mode, typename Parent> +void StackWriter<Mode, Parent>::visitMemoryInit(MemoryInit* curr) { + visitChild(curr->dest); + visitChild(curr->offset); + visitChild(curr->size); + if (justAddToStack(curr)) return; + o << int8_t(BinaryConsts::MiscPrefix); + o << U32LEB(BinaryConsts::MemoryInit); + o << U32LEB(curr->segment) << int8_t(0); +} + +template<StackWriterMode Mode, typename Parent> +void StackWriter<Mode, Parent>::visitDataDrop(DataDrop* curr) { + if (justAddToStack(curr)) return; + o << int8_t(BinaryConsts::MiscPrefix); + o << U32LEB(BinaryConsts::DataDrop); + o << U32LEB(curr->segment); +} + +template<StackWriterMode Mode, typename Parent> +void StackWriter<Mode, Parent>::visitMemoryCopy(MemoryCopy* curr) { + visitChild(curr->dest); + visitChild(curr->source); + visitChild(curr->size); + if (justAddToStack(curr)) return; + o << int8_t(BinaryConsts::MiscPrefix); + o << U32LEB(BinaryConsts::MemoryCopy); + o << int8_t(0) << int8_t(0); +} + +template<StackWriterMode Mode, typename Parent> +void StackWriter<Mode, Parent>::visitMemoryFill(MemoryFill* curr) { + visitChild(curr->dest); + visitChild(curr->value); + visitChild(curr->size); + if (justAddToStack(curr)) return; + o << int8_t(BinaryConsts::MiscPrefix); + o << U32LEB(BinaryConsts::MemoryFill); + o << int8_t(0); +} + +template<StackWriterMode Mode, typename Parent> void StackWriter<Mode, Parent>::visitConst(Const* curr) { if (debug) std::cerr << "zz node: Const" << curr << " : " << curr->type << std::endl; if (justAddToStack(curr)) return; @@ -1052,14 +1097,14 @@ void StackWriter<Mode, Parent>::visitUnary(Unary* curr) { case ExtendS8Int64: o << int8_t(BinaryConsts::I64ExtendS8); break; case ExtendS16Int64: o << int8_t(BinaryConsts::I64ExtendS16); break; case ExtendS32Int64: o << int8_t(BinaryConsts::I64ExtendS32); break; - case TruncSatSFloat32ToInt32: o << int8_t(BinaryConsts::TruncSatPrefix) << U32LEB(BinaryConsts::I32STruncSatF32); break; - case TruncSatUFloat32ToInt32: o << int8_t(BinaryConsts::TruncSatPrefix) << U32LEB(BinaryConsts::I32UTruncSatF32); break; - case TruncSatSFloat64ToInt32: o << int8_t(BinaryConsts::TruncSatPrefix) << U32LEB(BinaryConsts::I32STruncSatF64); break; - case TruncSatUFloat64ToInt32: o << int8_t(BinaryConsts::TruncSatPrefix) << U32LEB(BinaryConsts::I32UTruncSatF64); break; - case TruncSatSFloat32ToInt64: o << int8_t(BinaryConsts::TruncSatPrefix) << U32LEB(BinaryConsts::I64STruncSatF32); break; - case TruncSatUFloat32ToInt64: o << int8_t(BinaryConsts::TruncSatPrefix) << U32LEB(BinaryConsts::I64UTruncSatF32); break; - case TruncSatSFloat64ToInt64: o << int8_t(BinaryConsts::TruncSatPrefix) << U32LEB(BinaryConsts::I64STruncSatF64); break; - case TruncSatUFloat64ToInt64: o << int8_t(BinaryConsts::TruncSatPrefix) << U32LEB(BinaryConsts::I64UTruncSatF64); break; + case TruncSatSFloat32ToInt32: o << int8_t(BinaryConsts::MiscPrefix) << U32LEB(BinaryConsts::I32STruncSatF32); break; + case TruncSatUFloat32ToInt32: o << int8_t(BinaryConsts::MiscPrefix) << U32LEB(BinaryConsts::I32UTruncSatF32); break; + case TruncSatSFloat64ToInt32: o << int8_t(BinaryConsts::MiscPrefix) << U32LEB(BinaryConsts::I32STruncSatF64); break; + case TruncSatUFloat64ToInt32: o << int8_t(BinaryConsts::MiscPrefix) << U32LEB(BinaryConsts::I32UTruncSatF64); break; + case TruncSatSFloat32ToInt64: o << int8_t(BinaryConsts::MiscPrefix) << U32LEB(BinaryConsts::I64STruncSatF32); break; + case TruncSatUFloat32ToInt64: o << int8_t(BinaryConsts::MiscPrefix) << U32LEB(BinaryConsts::I64UTruncSatF32); break; + case TruncSatSFloat64ToInt64: o << int8_t(BinaryConsts::MiscPrefix) << U32LEB(BinaryConsts::I64STruncSatF64); break; + case TruncSatUFloat64ToInt64: o << int8_t(BinaryConsts::MiscPrefix) << U32LEB(BinaryConsts::I64UTruncSatF64); break; case SplatVecI8x16: o << int8_t(BinaryConsts::SIMDPrefix) << U32LEB(BinaryConsts::I8x16Splat); break; case SplatVecI16x8: o << int8_t(BinaryConsts::SIMDPrefix) << U32LEB(BinaryConsts::I16x8Splat); break; case SplatVecI32x4: o << int8_t(BinaryConsts::SIMDPrefix) << U32LEB(BinaryConsts::I32x4Splat); break; diff --git a/src/wasm-traversal.h b/src/wasm-traversal.h index fe3e3c5dd..f569da888 100644 --- a/src/wasm-traversal.h +++ b/src/wasm-traversal.h @@ -59,6 +59,10 @@ struct Visitor { ReturnType visitSIMDShuffle(SIMDShuffle* curr) { return ReturnType(); } ReturnType visitSIMDBitselect(SIMDBitselect* curr) { return ReturnType(); } ReturnType visitSIMDShift(SIMDShift* curr) { return ReturnType(); } + ReturnType visitMemoryInit(MemoryInit* curr) { return ReturnType(); } + ReturnType visitDataDrop(DataDrop* curr) { return ReturnType(); } + ReturnType visitMemoryCopy(MemoryCopy* curr) { return ReturnType(); } + ReturnType visitMemoryFill(MemoryFill* curr) { return ReturnType(); } ReturnType visitConst(Const* curr) { return ReturnType(); } ReturnType visitUnary(Unary* curr) { return ReturnType(); } ReturnType visitBinary(Binary* curr) { return ReturnType(); } @@ -107,6 +111,10 @@ struct Visitor { case Expression::Id::SIMDShuffleId: DELEGATE(SIMDShuffle); case Expression::Id::SIMDBitselectId: DELEGATE(SIMDBitselect); case Expression::Id::SIMDShiftId: DELEGATE(SIMDShift); + case Expression::Id::MemoryInitId: DELEGATE(MemoryInit); + case Expression::Id::DataDropId: DELEGATE(DataDrop); + case Expression::Id::MemoryCopyId: DELEGATE(MemoryCopy); + case Expression::Id::MemoryFillId: DELEGATE(MemoryFill); case Expression::Id::ConstId: DELEGATE(Const); case Expression::Id::UnaryId: DELEGATE(Unary); case Expression::Id::BinaryId: DELEGATE(Binary); @@ -157,6 +165,10 @@ struct OverriddenVisitor { UNIMPLEMENTED(SIMDShuffle); UNIMPLEMENTED(SIMDBitselect); UNIMPLEMENTED(SIMDShift); + UNIMPLEMENTED(MemoryInit); + UNIMPLEMENTED(DataDrop); + UNIMPLEMENTED(MemoryCopy); + UNIMPLEMENTED(MemoryFill); UNIMPLEMENTED(Const); UNIMPLEMENTED(Unary); UNIMPLEMENTED(Binary); @@ -206,6 +218,10 @@ struct OverriddenVisitor { case Expression::Id::SIMDShuffleId: DELEGATE(SIMDShuffle); case Expression::Id::SIMDBitselectId: DELEGATE(SIMDBitselect); case Expression::Id::SIMDShiftId: DELEGATE(SIMDShift); + case Expression::Id::MemoryInitId: DELEGATE(MemoryInit); + case Expression::Id::DataDropId: DELEGATE(DataDrop); + case Expression::Id::MemoryCopyId: DELEGATE(MemoryCopy); + case Expression::Id::MemoryFillId: DELEGATE(MemoryFill); case Expression::Id::ConstId: DELEGATE(Const); case Expression::Id::UnaryId: DELEGATE(Unary); case Expression::Id::BinaryId: DELEGATE(Binary); @@ -254,6 +270,10 @@ struct UnifiedExpressionVisitor : public Visitor<SubType, ReturnType> { ReturnType visitSIMDShuffle(SIMDShuffle* curr) { return static_cast<SubType*>(this)->visitExpression(curr); } ReturnType visitSIMDBitselect(SIMDBitselect* curr) { return static_cast<SubType*>(this)->visitExpression(curr); } ReturnType visitSIMDShift(SIMDShift* curr) { return static_cast<SubType*>(this)->visitExpression(curr); } + ReturnType visitMemoryInit(MemoryInit* curr) { return static_cast<SubType*>(this)->visitExpression(curr); } + ReturnType visitDataDrop(DataDrop* curr) { return static_cast<SubType*>(this)->visitExpression(curr); } + ReturnType visitMemoryCopy(MemoryCopy* curr) { return static_cast<SubType*>(this)->visitExpression(curr); } + ReturnType visitMemoryFill(MemoryFill* curr) { return static_cast<SubType*>(this)->visitExpression(curr); } ReturnType visitConst(Const* curr) { return static_cast<SubType*>(this)->visitExpression(curr); } ReturnType visitUnary(Unary* curr) { return static_cast<SubType*>(this)->visitExpression(curr); } ReturnType visitBinary(Binary* curr) { return static_cast<SubType*>(this)->visitExpression(curr); } @@ -444,6 +464,10 @@ struct Walker : public VisitorType { static void doVisitSIMDShuffle(SubType* self, Expression** currp) { self->visitSIMDShuffle((*currp)->cast<SIMDShuffle>()); } static void doVisitSIMDBitselect(SubType* self, Expression** currp) { self->visitSIMDBitselect((*currp)->cast<SIMDBitselect>()); } static void doVisitSIMDShift(SubType* self, Expression** currp) { self->visitSIMDShift((*currp)->cast<SIMDShift>()); } + static void doVisitMemoryInit(SubType* self, Expression** currp) { self->visitMemoryInit((*currp)->cast<MemoryInit>()); } + static void doVisitDataDrop(SubType* self, Expression** currp) { self->visitDataDrop((*currp)->cast<DataDrop>()); } + static void doVisitMemoryCopy(SubType* self, Expression** currp) { self->visitMemoryCopy((*currp)->cast<MemoryCopy>()); } + static void doVisitMemoryFill(SubType* self, Expression** currp) { self->visitMemoryFill((*currp)->cast<MemoryFill>()); } static void doVisitConst(SubType* self, Expression** currp) { self->visitConst((*currp)->cast<Const>()); } static void doVisitUnary(SubType* self, Expression** currp) { self->visitUnary((*currp)->cast<Unary>()); } static void doVisitBinary(SubType* self, Expression** currp) { self->visitBinary((*currp)->cast<Binary>()); } @@ -614,6 +638,31 @@ struct PostWalker : public Walker<SubType, VisitorType> { self->pushTask(SubType::scan, &curr->cast<SIMDShift>()->vec); break; } + case Expression::Id::MemoryInitId: { + self->pushTask(SubType::doVisitMemoryInit, currp); + self->pushTask(SubType::scan, &curr->cast<MemoryInit>()->dest); + self->pushTask(SubType::scan, &curr->cast<MemoryInit>()->offset); + self->pushTask(SubType::scan, &curr->cast<MemoryInit>()->size); + break; + } + case Expression::Id::DataDropId: { + self->pushTask(SubType::doVisitDataDrop, currp); + break; + } + case Expression::Id::MemoryCopyId: { + self->pushTask(SubType::doVisitMemoryCopy, currp); + self->pushTask(SubType::scan, &curr->cast<MemoryCopy>()->dest); + self->pushTask(SubType::scan, &curr->cast<MemoryCopy>()->source); + self->pushTask(SubType::scan, &curr->cast<MemoryCopy>()->size); + break; + } + case Expression::Id::MemoryFillId: { + self->pushTask(SubType::doVisitMemoryFill, currp); + self->pushTask(SubType::scan, &curr->cast<MemoryFill>()->dest); + self->pushTask(SubType::scan, &curr->cast<MemoryFill>()->value); + self->pushTask(SubType::scan, &curr->cast<MemoryFill>()->size); + break; + } case Expression::Id::ConstId: { self->pushTask(SubType::doVisitConst, currp); break; diff --git a/src/wasm.h b/src/wasm.h index dc24b0f1c..0370f8ae8 100644 --- a/src/wasm.h +++ b/src/wasm.h @@ -45,7 +45,8 @@ struct FeatureSet { MutableGlobals = 1 << 1, TruncSat = 1 << 2, SIMD = 1 << 3, - All = Atomics | MutableGlobals | TruncSat | SIMD + BulkMemory = 1 << 4, + All = Atomics | MutableGlobals | TruncSat | SIMD | BulkMemory }; FeatureSet() : features(MVP) {} @@ -57,6 +58,7 @@ struct FeatureSet { bool hasMutableGlobals() const { return features & MutableGlobals; } bool hasTruncSat() const { return features & TruncSat; } bool hasSIMD() const { return features & SIMD; } + bool hasBulkMemory() const { return features & BulkMemory; } bool hasAll() const { return features & All; } void makeMVP() { features = MVP; } @@ -65,6 +67,7 @@ struct FeatureSet { void setMutableGlobals(bool v = true) { set(MutableGlobals, v); } void setTruncSat(bool v = true) { set(TruncSat, v); } void setSIMD(bool v = true) { set(SIMD, v); } + void setBulkMemory(bool v = true) { set(BulkMemory, v); } void setAll(bool v = true) { features = v ? All : MVP; } bool operator<=(const FeatureSet& other) { @@ -255,6 +258,10 @@ public: SIMDShuffleId, SIMDBitselectId, SIMDShiftId, + MemoryInitId, + DataDropId, + MemoryCopyId, + MemoryFillId, NumExpressionIds }; Id _id; @@ -613,6 +620,53 @@ class SIMDShift : public SpecificExpression<Expression::SIMDShiftId> { void finalize(); }; +class MemoryInit : public SpecificExpression<Expression::MemoryInitId> { + public: + MemoryInit() = default; + MemoryInit(MixedArena& allocator) : MemoryInit() {} + + uint32_t segment; + Expression* dest; + Expression* offset; + Expression* size; + + void finalize(); +}; + +class DataDrop : public SpecificExpression<Expression::DataDropId> { + public: + DataDrop() = default; + DataDrop(MixedArena& allocator) : DataDrop() {} + + uint32_t segment; + + void finalize(); +}; + +class MemoryCopy : public SpecificExpression<Expression::MemoryCopyId> { + public: + MemoryCopy() = default; + MemoryCopy(MixedArena& allocator) : MemoryCopy() {} + + Expression* dest; + Expression* source; + Expression* size; + + void finalize(); +}; + +class MemoryFill : public SpecificExpression<Expression::MemoryFillId> { + public: + MemoryFill() = default; + MemoryFill(MixedArena& allocator) : MemoryFill() {} + + Expression* dest; + Expression* value; + Expression* size; + + void finalize(); +}; + class Const : public SpecificExpression<Expression::ConstId> { public: Const() = default; diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp index 90a588bb9..721884126 100644 --- a/src/wasm/wasm-binary.cpp +++ b/src/wasm/wasm-binary.cpp @@ -1715,10 +1715,14 @@ BinaryConsts::ASTNodes WasmBinaryBuilder::readExpression(Expression*& curr) { throwError("invalid code after atomic prefix: " + std::to_string(code)); break; } - case BinaryConsts::TruncSatPrefix: { + case BinaryConsts::MiscPrefix: { auto opcode = getU32LEB(); if (maybeVisitTruncSat(curr, opcode)) break; - throwError("invalid code after nontrapping float-to-int prefix: " + std::to_string(code)); + if (maybeVisitMemoryInit(curr, opcode)) break; + if (maybeVisitDataDrop(curr, opcode)) break; + if (maybeVisitMemoryCopy(curr, opcode)) break; + if (maybeVisitMemoryFill(curr, opcode)) break; + throwError("invalid code after nontrapping float-to-int prefix: " + std::to_string(opcode)); break; } case BinaryConsts::SIMDPrefix: { @@ -2342,6 +2346,66 @@ bool WasmBinaryBuilder::maybeVisitTruncSat(Expression*& out, uint32_t code) { return true; } +bool WasmBinaryBuilder::maybeVisitMemoryInit(Expression*& out, uint32_t code) { + if (code != BinaryConsts::MemoryInit) { + return false; + } + auto* curr = allocator.alloc<MemoryInit>(); + curr->size = popNonVoidExpression(); + curr->offset = popNonVoidExpression(); + curr->dest = popNonVoidExpression(); + curr->segment = getU32LEB(); + if (getInt8() != 0) { + throwError("Unexpected nonzero memory index"); + } + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitDataDrop(Expression*& out, uint32_t code) { + if (code != BinaryConsts::DataDrop) { + return false; + } + auto* curr = allocator.alloc<DataDrop>(); + curr->segment = getU32LEB(); + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitMemoryCopy(Expression*& out, uint32_t code) { + if (code != BinaryConsts::MemoryCopy) { + return false; + } + auto* curr = allocator.alloc<MemoryCopy>(); + curr->size = popNonVoidExpression(); + curr->source = popNonVoidExpression(); + curr->dest = popNonVoidExpression(); + if (getInt8() != 0 || getInt8() != 0) { + throwError("Unexpected nonzero memory index"); + } + curr->finalize(); + out = curr; + return true; +} + +bool WasmBinaryBuilder::maybeVisitMemoryFill(Expression*& out, uint32_t code) { + if (code != BinaryConsts::MemoryFill) { + return false; + } + auto* curr = allocator.alloc<MemoryFill>(); + curr->size = popNonVoidExpression(); + curr->value = popNonVoidExpression(); + curr->dest = popNonVoidExpression(); + if (getInt8() != 0) { + throwError("Unexpected nonzero memory index"); + } + curr->finalize(); + out = curr; + return true; +} + bool WasmBinaryBuilder::maybeVisitBinary(Expression*& out, uint8_t code) { Binary* curr; #define INT_TYPED_CODE(code) { \ diff --git a/src/wasm/wasm-s-parser.cpp b/src/wasm/wasm-s-parser.cpp index eca4c7493..09cc044bf 100644 --- a/src/wasm/wasm-s-parser.cpp +++ b/src/wasm/wasm-s-parser.cpp @@ -1134,6 +1134,41 @@ Expression* SExpressionWasmBuilder::makeSIMDShift(Element& s, SIMDShiftOp op) { return ret; } +Expression* SExpressionWasmBuilder::makeMemoryInit(Element& s) { + auto ret = allocator.alloc<MemoryInit>(); + ret->segment = atoi(s[1]->str().c_str()); + ret->dest = parseExpression(s[2]); + ret->offset = parseExpression(s[3]); + ret->size = parseExpression(s[4]); + ret->finalize(); + return ret; +} + +Expression* SExpressionWasmBuilder::makeDataDrop(Element& s) { + auto ret = allocator.alloc<DataDrop>(); + ret->segment = atoi(s[1]->str().c_str()); + ret->finalize(); + return ret; +} + +Expression* SExpressionWasmBuilder::makeMemoryCopy(Element& s) { + auto ret = allocator.alloc<MemoryCopy>(); + ret->dest = parseExpression(s[1]); + ret->source = parseExpression(s[2]); + ret->size = parseExpression(s[3]); + ret->finalize(); + return ret; +} + +Expression* SExpressionWasmBuilder::makeMemoryFill(Element& s) { + auto ret = allocator.alloc<MemoryFill>(); + ret->dest = parseExpression(s[1]); + ret->value = parseExpression(s[2]); + ret->size = parseExpression(s[3]); + ret->finalize(); + return ret; +} + Expression* SExpressionWasmBuilder::makeIf(Element& s) { auto ret = allocator.alloc<If>(); Index i = 1; diff --git a/src/wasm/wasm-validator.cpp b/src/wasm/wasm-validator.cpp index f1ccb2cfa..84a0efbff 100644 --- a/src/wasm/wasm-validator.cpp +++ b/src/wasm/wasm-validator.cpp @@ -250,6 +250,10 @@ public: void visitSIMDShuffle(SIMDShuffle* curr); void visitSIMDBitselect(SIMDBitselect* curr); void visitSIMDShift(SIMDShift* curr); + void visitMemoryInit(MemoryInit* curr); + void visitDataDrop(DataDrop* curr); + void visitMemoryCopy(MemoryCopy* curr); + void visitMemoryFill(MemoryFill* curr); void visitBinary(Binary* curr); void visitUnary(Unary* curr); void visitSelect(Select* curr); @@ -636,6 +640,37 @@ void FunctionValidator::visitSIMDShift(SIMDShift* curr) { shouldBeEqualOrFirstIsUnreachable(curr->shift->type, i32, curr, "expected shift amount to have type i32"); } +void FunctionValidator::visitMemoryInit(MemoryInit* curr) { + shouldBeTrue(info.features.hasBulkMemory(), curr, "Bulk memory operation (bulk memory is disabled)"); + shouldBeEqualOrFirstIsUnreachable(curr->type, none, curr, "memory.init must have type none"); + shouldBeEqualOrFirstIsUnreachable(curr->dest->type, i32, curr, "memory.init dest must be an i32"); + shouldBeEqualOrFirstIsUnreachable(curr->offset->type, i32, curr, "memory.init offset must be an i32"); + shouldBeEqualOrFirstIsUnreachable(curr->size->type, i32, curr, "memory.init size must be an i32"); + shouldBeTrue(curr->segment < getModule()->memory.segments.size(), curr, "memory.init segment index out of bounds"); +} + +void FunctionValidator::visitDataDrop(DataDrop* curr) { + shouldBeTrue(info.features.hasBulkMemory(), curr, "Bulk memory operation (bulk memory is disabled)"); + shouldBeEqualOrFirstIsUnreachable(curr->type, none, curr, "data.drop must have type none"); + shouldBeTrue(curr->segment < getModule()->memory.segments.size(), curr, "data.drop segment index out of bounds"); +} + +void FunctionValidator::visitMemoryCopy(MemoryCopy* curr) { + shouldBeTrue(info.features.hasBulkMemory(), curr, "Bulk memory operation (bulk memory is disabled)"); + shouldBeEqualOrFirstIsUnreachable(curr->type, none, curr, "memory.copy must have type none"); + shouldBeEqualOrFirstIsUnreachable(curr->dest->type, i32, curr, "memory.copy dest must be an i32"); + shouldBeEqualOrFirstIsUnreachable(curr->source->type, i32, curr, "memory.copy source must be an i32"); + shouldBeEqualOrFirstIsUnreachable(curr->size->type, i32, curr, "memory.copy size must be an i32"); +} + +void FunctionValidator::visitMemoryFill(MemoryFill* curr) { + shouldBeTrue(info.features.hasBulkMemory(), curr, "Bulk memory operation (bulk memory is disabled)"); + shouldBeEqualOrFirstIsUnreachable(curr->type, none, curr, "memory.fill must have type none"); + shouldBeEqualOrFirstIsUnreachable(curr->dest->type, i32, curr, "memory.fill dest must be an i32"); + shouldBeEqualOrFirstIsUnreachable(curr->value->type, i32, curr, "memory.fill value must be an i32"); + shouldBeEqualOrFirstIsUnreachable(curr->size->type, i32, curr, "memory.fill size must be an i32"); +} + void FunctionValidator::validateMemBytes(uint8_t bytes, Type type, Expression* curr) { switch (type) { case i32: shouldBeTrue(bytes == 1 || bytes == 2 || bytes == 4, curr, "expected i32 operation to touch 1, 2, or 4 bytes"); break; diff --git a/src/wasm/wasm.cpp b/src/wasm/wasm.cpp index 0d5f3d5b5..847df5ce6 100644 --- a/src/wasm/wasm.cpp +++ b/src/wasm/wasm.cpp @@ -110,6 +110,10 @@ const char* getExpressionName(Expression* curr) { case Expression::Id::SIMDShuffleId: return "simd_shuffle"; case Expression::Id::SIMDBitselectId: return "simd_bitselect"; case Expression::Id::SIMDShiftId: return "simd_shift"; + case Expression::Id::MemoryInitId: return "memory_init"; + case Expression::Id::DataDropId: return "data_drop"; + case Expression::Id::MemoryCopyId: return "memory_copy"; + case Expression::Id::MemoryFillId: return "memory_fill"; case Expression::Id::NumExpressionIds: WASM_UNREACHABLE(); } WASM_UNREACHABLE(); @@ -464,6 +468,34 @@ void SIMDBitselect::finalize() { } } +void MemoryInit::finalize() { + assert(dest && offset && size); + type = none; + if (dest->type == unreachable || offset->type == unreachable || size->type == unreachable) { + type = unreachable; + } +} + +void DataDrop::finalize() { + type = none; +} + +void MemoryCopy::finalize() { + assert(dest && source && size); + type = none; + if (dest->type == unreachable || source->type == unreachable || size->type == unreachable) { + type = unreachable; + } +} + +void MemoryFill::finalize() { + assert(dest && value && size); + type = none; + if (dest->type == unreachable || value->type == unreachable || size->type == unreachable) { + type = unreachable; + } +} + void SIMDShift::finalize() { assert(vec && shift); type = v128; diff --git a/test/binaryen.js/kitchen-sink.js b/test/binaryen.js/kitchen-sink.js index 27eba3a8c..c5c919035 100644 --- a/test/binaryen.js/kitchen-sink.js +++ b/test/binaryen.js/kitchen-sink.js @@ -94,6 +94,10 @@ function test_ids() { console.log("BinaryenSIMDShuffleId: " + Binaryen.SIMDShuffleId); console.log("BinaryenSIMDBitselectId: " + Binaryen.SIMDBitselectId); console.log("BinaryenSIMDShiftId: " + Binaryen.SIMDShiftId); + console.log("MemoryInitId: " + Binaryen.MemoryInitId); + console.log("DataDropId: " + Binaryen.DataDropId); + console.log("MemoryCopyId: " + Binaryen.MemoryCopyId); + console.log("MemoryFillId: " + Binaryen.MemoryFillId); } function test_core() { @@ -340,6 +344,11 @@ function test_core() { // Other SIMD module.v8x16.shuffle(module.v128.const(v128_bytes), module.v128.const(v128_bytes), v128_bytes), module.v128.bitselect(module.v128.const(v128_bytes), module.v128.const(v128_bytes), module.v128.const(v128_bytes)), + // Bulk memory + module.memory.init(0, makeInt32(1024), makeInt32(0), makeInt32(12)), + module.data.drop(0), + module.memory.copy(makeInt32(2048), makeInt32(1024), makeInt32(12)), + module.memory.fill(makeInt32(0), makeInt32(42), makeInt32(1024)), // All the rest module.block('', []), // block with no name module.if(temp1, temp2, temp3), diff --git a/test/binaryen.js/kitchen-sink.js.txt b/test/binaryen.js/kitchen-sink.js.txt index 69b971b9c..9ecfcce49 100644 --- a/test/binaryen.js/kitchen-sink.js.txt +++ b/test/binaryen.js/kitchen-sink.js.txt @@ -38,6 +38,10 @@ BinaryenSIMDReplaceId: 28 BinaryenSIMDShuffleId: 29 BinaryenSIMDBitselectId: 30 BinaryenSIMDShiftId: 31 +MemoryInitId: 32 +DataDropId: 33 +MemoryCopyId: 34 +MemoryFillId: 35 getExpressionInfo={"id":15,"type":3,"op":6} (f32.neg (f32.const -33.61199951171875) @@ -1251,6 +1255,22 @@ getExpressionInfo(f64.const)={"id":14,"type":4,"value":9.5} (v128.const i32 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10) ) ) + (memory.init 0 + (i32.const 1024) + (i32.const 0) + (i32.const 12) + ) + (data.drop 0) + (memory.copy + (i32.const 2048) + (i32.const 1024) + (i32.const 12) + ) + (memory.fill + (i32.const 0) + (i32.const 42) + (i32.const 1024) + ) (block ) (if @@ -3129,80 +3149,93 @@ int main() { expressions[576] = BinaryenConst(the_module, BinaryenLiteralVec128(t209)); } expressions[577] = BinaryenSIMDBitselect(the_module, expressions[574], expressions[575], expressions[576]); + expressions[578] = BinaryenConst(the_module, BinaryenLiteralInt32(1024)); + expressions[579] = BinaryenConst(the_module, BinaryenLiteralInt32(0)); + expressions[580] = BinaryenConst(the_module, BinaryenLiteralInt32(12)); + expressions[581] = BinaryenMemoryInit(the_module, 0, expressions[578], expressions[579], expressions[580]); + expressions[582] = BinaryenDataDrop(the_module, 0); + expressions[583] = BinaryenConst(the_module, BinaryenLiteralInt32(2048)); + expressions[584] = BinaryenConst(the_module, BinaryenLiteralInt32(1024)); + expressions[585] = BinaryenConst(the_module, BinaryenLiteralInt32(12)); + expressions[586] = BinaryenMemoryCopy(the_module, expressions[583], expressions[584], expressions[585]); + expressions[587] = BinaryenConst(the_module, BinaryenLiteralInt32(0)); + expressions[588] = BinaryenConst(the_module, BinaryenLiteralInt32(42)); + expressions[589] = BinaryenConst(the_module, BinaryenLiteralInt32(1024)); + expressions[590] = BinaryenMemoryFill(the_module, expressions[587], expressions[588], expressions[589]); { BinaryenExpressionRef children[] = { 0 }; - expressions[578] = BinaryenBlock(the_module, NULL, children, 0, 0); - } - expressions[579] = BinaryenIf(the_module, expressions[7], expressions[8], expressions[9]); - expressions[580] = BinaryenIf(the_module, expressions[10], expressions[11], expressions[0]); - expressions[581] = BinaryenConst(the_module, BinaryenLiteralInt32(0)); - expressions[582] = BinaryenLoop(the_module, "in", expressions[581]); - expressions[583] = BinaryenConst(the_module, BinaryenLiteralInt32(0)); - expressions[584] = BinaryenLoop(the_module, NULL, expressions[583]); - expressions[585] = BinaryenBreak(the_module, "the-value", expressions[12], expressions[13]); - expressions[586] = BinaryenConst(the_module, BinaryenLiteralInt32(2)); - expressions[587] = BinaryenBreak(the_module, "the-nothing", expressions[586], expressions[0]); - expressions[588] = BinaryenConst(the_module, BinaryenLiteralInt32(3)); - expressions[589] = BinaryenBreak(the_module, "the-value", expressions[0], expressions[588]); - expressions[590] = BinaryenBreak(the_module, "the-nothing", expressions[0], expressions[0]); + expressions[591] = BinaryenBlock(the_module, NULL, children, 0, 0); + } + expressions[592] = BinaryenIf(the_module, expressions[7], expressions[8], expressions[9]); + expressions[593] = BinaryenIf(the_module, expressions[10], expressions[11], expressions[0]); + expressions[594] = BinaryenConst(the_module, BinaryenLiteralInt32(0)); + expressions[595] = BinaryenLoop(the_module, "in", expressions[594]); + expressions[596] = BinaryenConst(the_module, BinaryenLiteralInt32(0)); + expressions[597] = BinaryenLoop(the_module, NULL, expressions[596]); + expressions[598] = BinaryenBreak(the_module, "the-value", expressions[12], expressions[13]); + expressions[599] = BinaryenConst(the_module, BinaryenLiteralInt32(2)); + expressions[600] = BinaryenBreak(the_module, "the-nothing", expressions[599], expressions[0]); + expressions[601] = BinaryenConst(the_module, BinaryenLiteralInt32(3)); + expressions[602] = BinaryenBreak(the_module, "the-value", expressions[0], expressions[601]); + expressions[603] = BinaryenBreak(the_module, "the-nothing", expressions[0], expressions[0]); { const char* names[] = { "the-value" }; - expressions[591] = BinaryenSwitch(the_module, names, 1, "the-value", expressions[14], expressions[15]); + expressions[604] = BinaryenSwitch(the_module, names, 1, "the-value", expressions[14], expressions[15]); } - expressions[592] = BinaryenConst(the_module, BinaryenLiteralInt32(2)); + expressions[605] = BinaryenConst(the_module, BinaryenLiteralInt32(2)); { const char* names[] = { "the-nothing" }; - expressions[593] = BinaryenSwitch(the_module, names, 1, "the-nothing", expressions[592], expressions[0]); - } - expressions[594] = BinaryenConst(the_module, BinaryenLiteralInt32(13)); - expressions[595] = BinaryenConst(the_module, BinaryenLiteralInt64(37)); - expressions[596] = BinaryenConst(the_module, BinaryenLiteralFloat32(1.3)); - expressions[597] = BinaryenConst(the_module, BinaryenLiteralFloat64(3.7)); - { - BinaryenExpressionRef operands[] = { expressions[594], expressions[595], expressions[596], expressions[597] }; - expressions[598] = BinaryenCall(the_module, "kitchen()sinker", operands, 4, 1); - } - expressions[599] = BinaryenUnary(the_module, 20, expressions[598]); - expressions[600] = BinaryenConst(the_module, BinaryenLiteralInt32(13)); - expressions[601] = BinaryenConst(the_module, BinaryenLiteralFloat64(3.7)); - { - BinaryenExpressionRef operands[] = { expressions[600], expressions[601] }; - expressions[602] = BinaryenCall(the_module, "an-imported", operands, 2, 3); - } - expressions[603] = BinaryenUnary(the_module, 25, expressions[602]); - expressions[604] = BinaryenUnary(the_module, 20, expressions[603]); - expressions[605] = BinaryenConst(the_module, BinaryenLiteralInt32(2449)); - expressions[606] = BinaryenConst(the_module, BinaryenLiteralInt32(13)); - expressions[607] = BinaryenConst(the_module, BinaryenLiteralInt64(37)); - expressions[608] = BinaryenConst(the_module, BinaryenLiteralFloat32(1.3)); - expressions[609] = BinaryenConst(the_module, BinaryenLiteralFloat64(3.7)); - { - BinaryenExpressionRef operands[] = { expressions[606], expressions[607], expressions[608], expressions[609] }; - expressions[610] = BinaryenCallIndirect(the_module, expressions[605], operands, 4, "iiIfF"); - } - expressions[611] = BinaryenUnary(the_module, 20, expressions[610]); - expressions[612] = BinaryenGetLocal(the_module, 0, 1); - expressions[613] = BinaryenDrop(the_module, expressions[612]); - expressions[614] = BinaryenConst(the_module, BinaryenLiteralInt32(101)); - expressions[615] = BinaryenSetLocal(the_module, 0, expressions[614]); - expressions[616] = BinaryenConst(the_module, BinaryenLiteralInt32(102)); - expressions[617] = BinaryenTeeLocal(the_module, 0, expressions[616]); - expressions[618] = BinaryenDrop(the_module, expressions[617]); - expressions[619] = BinaryenConst(the_module, BinaryenLiteralInt32(1)); - expressions[620] = BinaryenLoad(the_module, 4, 1, 0, 0, 1, expressions[619]); - expressions[621] = BinaryenConst(the_module, BinaryenLiteralInt32(8)); - expressions[622] = BinaryenLoad(the_module, 2, 1, 2, 1, 2, expressions[621]); - expressions[623] = BinaryenConst(the_module, BinaryenLiteralInt32(2)); - expressions[624] = BinaryenLoad(the_module, 4, 1, 0, 0, 3, expressions[623]); - expressions[625] = BinaryenConst(the_module, BinaryenLiteralInt32(9)); - expressions[626] = BinaryenLoad(the_module, 8, 1, 2, 8, 4, expressions[625]); - expressions[627] = BinaryenStore(the_module, 4, 0, 0, expressions[19], expressions[20], 1); - expressions[628] = BinaryenStore(the_module, 8, 2, 4, expressions[21], expressions[22], 2); - expressions[629] = BinaryenSelect(the_module, expressions[16], expressions[17], expressions[18]); - expressions[630] = BinaryenConst(the_module, BinaryenLiteralInt32(1337)); - expressions[631] = BinaryenReturn(the_module, expressions[630]); - expressions[632] = BinaryenNop(the_module); - expressions[633] = BinaryenUnreachable(the_module); + expressions[606] = BinaryenSwitch(the_module, names, 1, "the-nothing", expressions[605], expressions[0]); + } + expressions[607] = BinaryenConst(the_module, BinaryenLiteralInt32(13)); + expressions[608] = BinaryenConst(the_module, BinaryenLiteralInt64(37)); + expressions[609] = BinaryenConst(the_module, BinaryenLiteralFloat32(1.3)); + expressions[610] = BinaryenConst(the_module, BinaryenLiteralFloat64(3.7)); + { + BinaryenExpressionRef operands[] = { expressions[607], expressions[608], expressions[609], expressions[610] }; + expressions[611] = BinaryenCall(the_module, "kitchen()sinker", operands, 4, 1); + } + expressions[612] = BinaryenUnary(the_module, 20, expressions[611]); + expressions[613] = BinaryenConst(the_module, BinaryenLiteralInt32(13)); + expressions[614] = BinaryenConst(the_module, BinaryenLiteralFloat64(3.7)); + { + BinaryenExpressionRef operands[] = { expressions[613], expressions[614] }; + expressions[615] = BinaryenCall(the_module, "an-imported", operands, 2, 3); + } + expressions[616] = BinaryenUnary(the_module, 25, expressions[615]); + expressions[617] = BinaryenUnary(the_module, 20, expressions[616]); + expressions[618] = BinaryenConst(the_module, BinaryenLiteralInt32(2449)); + expressions[619] = BinaryenConst(the_module, BinaryenLiteralInt32(13)); + expressions[620] = BinaryenConst(the_module, BinaryenLiteralInt64(37)); + expressions[621] = BinaryenConst(the_module, BinaryenLiteralFloat32(1.3)); + expressions[622] = BinaryenConst(the_module, BinaryenLiteralFloat64(3.7)); + { + BinaryenExpressionRef operands[] = { expressions[619], expressions[620], expressions[621], expressions[622] }; + expressions[623] = BinaryenCallIndirect(the_module, expressions[618], operands, 4, "iiIfF"); + } + expressions[624] = BinaryenUnary(the_module, 20, expressions[623]); + expressions[625] = BinaryenGetLocal(the_module, 0, 1); + expressions[626] = BinaryenDrop(the_module, expressions[625]); + expressions[627] = BinaryenConst(the_module, BinaryenLiteralInt32(101)); + expressions[628] = BinaryenSetLocal(the_module, 0, expressions[627]); + expressions[629] = BinaryenConst(the_module, BinaryenLiteralInt32(102)); + expressions[630] = BinaryenTeeLocal(the_module, 0, expressions[629]); + expressions[631] = BinaryenDrop(the_module, expressions[630]); + expressions[632] = BinaryenConst(the_module, BinaryenLiteralInt32(1)); + expressions[633] = BinaryenLoad(the_module, 4, 1, 0, 0, 1, expressions[632]); + expressions[634] = BinaryenConst(the_module, BinaryenLiteralInt32(8)); + expressions[635] = BinaryenLoad(the_module, 2, 1, 2, 1, 2, expressions[634]); + expressions[636] = BinaryenConst(the_module, BinaryenLiteralInt32(2)); + expressions[637] = BinaryenLoad(the_module, 4, 1, 0, 0, 3, expressions[636]); + expressions[638] = BinaryenConst(the_module, BinaryenLiteralInt32(9)); + expressions[639] = BinaryenLoad(the_module, 8, 1, 2, 8, 4, expressions[638]); + expressions[640] = BinaryenStore(the_module, 4, 0, 0, expressions[19], expressions[20], 1); + expressions[641] = BinaryenStore(the_module, 8, 2, 4, expressions[21], expressions[22], 2); + expressions[642] = BinaryenSelect(the_module, expressions[16], expressions[17], expressions[18]); + expressions[643] = BinaryenConst(the_module, BinaryenLiteralInt32(1337)); + expressions[644] = BinaryenReturn(the_module, expressions[643]); + expressions[645] = BinaryenNop(the_module); + expressions[646] = BinaryenUnreachable(the_module); BinaryenExpressionGetId(expressions[30]); BinaryenExpressionGetType(expressions[30]); BinaryenUnaryGetOp(expressions[30]); @@ -3213,26 +3246,26 @@ getExpressionInfo={"id":15,"type":3,"op":6} (f32.const -33.61199951171875) ) - expressions[634] = BinaryenConst(the_module, BinaryenLiteralInt32(5)); - BinaryenExpressionGetId(expressions[634]); - BinaryenExpressionGetType(expressions[634]); - BinaryenConstGetValueI32(expressions[634]); + expressions[647] = BinaryenConst(the_module, BinaryenLiteralInt32(5)); + BinaryenExpressionGetId(expressions[647]); + BinaryenExpressionGetType(expressions[647]); + BinaryenConstGetValueI32(expressions[647]); getExpressionInfo(i32.const)={"id":14,"type":1,"value":5} - expressions[635] = BinaryenConst(the_module, BinaryenLiteralInt64(30064771078)); - BinaryenExpressionGetId(expressions[635]); - BinaryenExpressionGetType(expressions[635]); - BinaryenConstGetValueI64Low(expressions[635]); - BinaryenConstGetValueI64High(expressions[635]); + expressions[648] = BinaryenConst(the_module, BinaryenLiteralInt64(30064771078)); + BinaryenExpressionGetId(expressions[648]); + BinaryenExpressionGetType(expressions[648]); + BinaryenConstGetValueI64Low(expressions[648]); + BinaryenConstGetValueI64High(expressions[648]); getExpressionInfo(i64.const)={"id":14,"type":2,"value":{"low":6,"high":7}} - expressions[636] = BinaryenConst(the_module, BinaryenLiteralFloat32(8.5)); - BinaryenExpressionGetId(expressions[636]); - BinaryenExpressionGetType(expressions[636]); - BinaryenConstGetValueF32(expressions[636]); + expressions[649] = BinaryenConst(the_module, BinaryenLiteralFloat32(8.5)); + BinaryenExpressionGetId(expressions[649]); + BinaryenExpressionGetType(expressions[649]); + BinaryenConstGetValueF32(expressions[649]); getExpressionInfo(f32.const)={"id":14,"type":3,"value":8.5} - expressions[637] = BinaryenConst(the_module, BinaryenLiteralFloat64(9.5)); - BinaryenExpressionGetId(expressions[637]); - BinaryenExpressionGetType(expressions[637]); - BinaryenConstGetValueF64(expressions[637]); + expressions[650] = BinaryenConst(the_module, BinaryenLiteralFloat64(9.5)); + BinaryenExpressionGetId(expressions[650]); + BinaryenExpressionGetType(expressions[650]); + BinaryenConstGetValueF64(expressions[650]); getExpressionInfo(f64.const)={"id":14,"type":4,"value":9.5} { BinaryenExpressionRef children[] = { expressions[24], expressions[26], expressions[28], expressions[30], expressions[32], @@ -3270,27 +3303,27 @@ getExpressionInfo(f64.const)={"id":14,"type":4,"value":9.5} expressions[514], expressions[516], expressions[519], expressions[522], expressions[525], expressions[528], expressions[531], expressions[534], expressions[537], expressions[540], expressions[543], expressions[546], expressions[549], expressions[552], expressions[555], expressions[558], expressions[561], expressions[564], - expressions[567], expressions[570], expressions[573], expressions[577], expressions[578], expressions[579], - expressions[580], expressions[582], expressions[584], expressions[585], expressions[587], expressions[589], - expressions[590], expressions[591], expressions[593], expressions[599], expressions[604], expressions[611], - expressions[613], expressions[615], expressions[618], expressions[620], expressions[622], expressions[624], - expressions[626], expressions[627], expressions[628], expressions[629], expressions[631], expressions[632], - expressions[633] }; - expressions[638] = BinaryenBlock(the_module, "the-value", children, 240, 0); + expressions[567], expressions[570], expressions[573], expressions[577], expressions[581], expressions[582], + expressions[586], expressions[590], expressions[591], expressions[592], expressions[593], expressions[595], + expressions[597], expressions[598], expressions[600], expressions[602], expressions[603], expressions[604], + expressions[606], expressions[612], expressions[617], expressions[624], expressions[626], expressions[628], + expressions[631], expressions[633], expressions[635], expressions[637], expressions[639], expressions[640], + expressions[641], expressions[642], expressions[644], expressions[645], expressions[646] }; + expressions[651] = BinaryenBlock(the_module, "the-value", children, 244, 0); } - expressions[639] = BinaryenDrop(the_module, expressions[638]); + expressions[652] = BinaryenDrop(the_module, expressions[651]); { - BinaryenExpressionRef children[] = { expressions[639] }; - expressions[640] = BinaryenBlock(the_module, "the-nothing", children, 1, 0); + BinaryenExpressionRef children[] = { expressions[652] }; + expressions[653] = BinaryenBlock(the_module, "the-nothing", children, 1, 0); } - expressions[641] = BinaryenConst(the_module, BinaryenLiteralInt32(42)); + expressions[654] = BinaryenConst(the_module, BinaryenLiteralInt32(42)); { - BinaryenExpressionRef children[] = { expressions[640], expressions[641] }; - expressions[642] = BinaryenBlock(the_module, "the-body", children, 2, 0); + BinaryenExpressionRef children[] = { expressions[653], expressions[654] }; + expressions[655] = BinaryenBlock(the_module, "the-body", children, 2, 0); } { BinaryenType varTypes[] = { 1 }; - functions[0] = BinaryenAddFunction(the_module, "kitchen()sinker", functionTypes[0], varTypes, 1, expressions[642]); + functions[0] = BinaryenAddFunction(the_module, "kitchen()sinker", functionTypes[0], varTypes, 1, expressions[655]); } { BinaryenType paramTypes[] = { 1, 4 }; @@ -3315,11 +3348,11 @@ getExpressionInfo(f64.const)={"id":14,"type":4,"value":9.5} const char* funcNames[] = { "kitchen()sinker" }; BinaryenSetFunctionTable(the_module, 1, 4294967295, funcNames, 1); } - expressions[643] = BinaryenConst(the_module, BinaryenLiteralInt32(10)); + expressions[656] = BinaryenConst(the_module, BinaryenLiteralInt32(10)); { const char segment0[] = { 104, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100 }; const char* segments[] = { segment0 }; - BinaryenExpressionRef segmentOffsets[] = { expressions[643] }; + BinaryenExpressionRef segmentOffsets[] = { expressions[656] }; BinaryenIndex segmentSizes[] = { 12 }; BinaryenSetMemory(the_module, 1, 256, "mem", segments, segmentOffsets, segmentSizes, 1, 0); } @@ -3327,10 +3360,10 @@ getExpressionInfo(f64.const)={"id":14,"type":4,"value":9.5} BinaryenType paramTypes[] = { 0 }; functionTypes[2] = BinaryenAddFunctionType(the_module, "v", 0, paramTypes, 0); } - expressions[644] = BinaryenNop(the_module); + expressions[657] = BinaryenNop(the_module); { BinaryenType varTypes[] = { 0 }; - functions[1] = BinaryenAddFunction(the_module, "starter", functionTypes[2], varTypes, 0, expressions[644]); + functions[1] = BinaryenAddFunction(the_module, "starter", functionTypes[2], varTypes, 0, expressions[657]); } BinaryenSetStart(the_module, functions[1]); { @@ -4544,6 +4577,22 @@ getExpressionInfo(f64.const)={"id":14,"type":4,"value":9.5} (v128.const i32 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10) ) ) + (memory.init 0 + (i32.const 1024) + (i32.const 0) + (i32.const 12) + ) + (data.drop 0) + (memory.copy + (i32.const 2048) + (i32.const 1024) + (i32.const 12) + ) + (memory.fill + (i32.const 0) + (i32.const 42) + (i32.const 1024) + ) (block ) (if diff --git a/test/bulk-memory.wast b/test/bulk-memory.wast new file mode 100644 index 000000000..91f8c23a2 --- /dev/null +++ b/test/bulk-memory.wast @@ -0,0 +1,29 @@ +(module + (memory 1024 1024 + (segment 0 "hello, world") + ) + (func $memory.init + (memory.init 0 + (i32.const 512) + (i32.const 0) + (i32.const 12) + ) + ) + (func $data.drop + (data.drop 0) + ) + (func $memory.copy + (memory.copy + (i32.const 512) + (i32.const 0) + (i32.const 12) + ) + ) + (func $memory.fill + (memory.fill + (i32.const 0) + (i32.const 42) + (i32.const 1024) + ) + ) +) diff --git a/test/bulk-memory.wast.from-wast b/test/bulk-memory.wast.from-wast new file mode 100644 index 000000000..0f4ec70fa --- /dev/null +++ b/test/bulk-memory.wast.from-wast @@ -0,0 +1,29 @@ +(module + (type $0 (func)) + (memory $0 1024 1024) + (data (i32.const 0) "hello, world") + (func $memory.init (; 0 ;) (type $0) + (memory.init 0 + (i32.const 512) + (i32.const 0) + (i32.const 12) + ) + ) + (func $data.drop (; 1 ;) (type $0) + (data.drop 0) + ) + (func $memory.copy (; 2 ;) (type $0) + (memory.copy + (i32.const 512) + (i32.const 0) + (i32.const 12) + ) + ) + (func $memory.fill (; 3 ;) (type $0) + (memory.fill + (i32.const 0) + (i32.const 42) + (i32.const 1024) + ) + ) +) diff --git a/test/bulk-memory.wast.fromBinary b/test/bulk-memory.wast.fromBinary new file mode 100644 index 000000000..0659c0184 --- /dev/null +++ b/test/bulk-memory.wast.fromBinary @@ -0,0 +1,30 @@ +(module + (type $0 (func)) + (memory $0 1024 1024) + (data (i32.const 0) "hello, world") + (func $memory.init (; 0 ;) (type $0) + (memory.init 0 + (i32.const 512) + (i32.const 0) + (i32.const 12) + ) + ) + (func $data.drop (; 1 ;) (type $0) + (data.drop 0) + ) + (func $memory.copy (; 2 ;) (type $0) + (memory.copy + (i32.const 512) + (i32.const 0) + (i32.const 12) + ) + ) + (func $memory.fill (; 3 ;) (type $0) + (memory.fill + (i32.const 0) + (i32.const 42) + (i32.const 1024) + ) + ) +) + diff --git a/test/bulk-memory.wast.fromBinary.noDebugInfo b/test/bulk-memory.wast.fromBinary.noDebugInfo new file mode 100644 index 000000000..69d8db333 --- /dev/null +++ b/test/bulk-memory.wast.fromBinary.noDebugInfo @@ -0,0 +1,30 @@ +(module + (type $0 (func)) + (memory $0 1024 1024) + (data (i32.const 0) "hello, world") + (func $0 (; 0 ;) (type $0) + (memory.init 0 + (i32.const 512) + (i32.const 0) + (i32.const 12) + ) + ) + (func $1 (; 1 ;) (type $0) + (data.drop 0) + ) + (func $2 (; 2 ;) (type $0) + (memory.copy + (i32.const 512) + (i32.const 0) + (i32.const 12) + ) + ) + (func $3 (; 3 ;) (type $0) + (memory.fill + (i32.const 0) + (i32.const 42) + (i32.const 1024) + ) + ) +) + diff --git a/test/example/c-api-kitchen-sink.c b/test/example/c-api-kitchen-sink.c index cf2ce6c04..244ecc9b5 100644 --- a/test/example/c-api-kitchen-sink.c +++ b/test/example/c-api-kitchen-sink.c @@ -121,6 +121,31 @@ BinaryenExpressionRef makeSIMDShift(BinaryenModuleRef module, BinaryenOp op) { return BinaryenSIMDShift(module, op, vec, makeInt32(module, 1)); } +BinaryenExpressionRef makeMemoryInit(BinaryenModuleRef module) { + BinaryenExpressionRef dest = makeInt32(module, 1024); + BinaryenExpressionRef offset = makeInt32(module, 0); + BinaryenExpressionRef size = makeInt32(module, 12); + return BinaryenMemoryInit(module, 0, dest, offset, size); +}; + +BinaryenExpressionRef makeDataDrop(BinaryenModuleRef module) { + return BinaryenDataDrop(module, 0); +}; + +BinaryenExpressionRef makeMemoryCopy(BinaryenModuleRef module) { + BinaryenExpressionRef dest = makeInt32(module, 2048); + BinaryenExpressionRef source = makeInt32(module, 1024); + BinaryenExpressionRef size = makeInt32(module, 12); + return BinaryenMemoryCopy(module, dest, source, size); +}; + +BinaryenExpressionRef makeMemoryFill(BinaryenModuleRef module) { + BinaryenExpressionRef dest = makeInt32(module, 0); + BinaryenExpressionRef value = makeInt32(module, 42); + BinaryenExpressionRef size = makeInt32(module, 1024); + return BinaryenMemoryFill(module, dest, value, size); +}; + // tests void test_types() { @@ -387,6 +412,11 @@ void test_core() { // Other SIMD makeSIMDShuffle(module), makeSIMDBitselect(module), + // Bulk memory + makeMemoryInit(module), + makeDataDrop(module), + makeMemoryCopy(module), + makeMemoryFill(module), // All the rest BinaryenBlock(module, NULL, NULL, 0, -1), // block with no name and no type BinaryenIf(module, temp1, temp2, temp3), diff --git a/test/example/c-api-kitchen-sink.txt b/test/example/c-api-kitchen-sink.txt index 797d4e5e1..beb4e8f6f 100644 --- a/test/example/c-api-kitchen-sink.txt +++ b/test/example/c-api-kitchen-sink.txt @@ -1224,6 +1224,22 @@ BinaryenTypeAuto: -1 (v128.const i32 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10) ) ) + (memory.init 0 + (i32.const 1024) + (i32.const 0) + (i32.const 12) + ) + (data.drop 0) + (memory.copy + (i32.const 2048) + (i32.const 1024) + (i32.const 12) + ) + (memory.fill + (i32.const 0) + (i32.const 42) + (i32.const 1024) + ) (block ) (if @@ -3115,70 +3131,83 @@ int main() { expressions[587] = BinaryenConst(the_module, BinaryenLiteralVec128(t210)); } expressions[588] = BinaryenSIMDBitselect(the_module, expressions[585], expressions[586], expressions[587]); + expressions[589] = BinaryenConst(the_module, BinaryenLiteralInt32(1024)); + expressions[590] = BinaryenConst(the_module, BinaryenLiteralInt32(0)); + expressions[591] = BinaryenConst(the_module, BinaryenLiteralInt32(12)); + expressions[592] = BinaryenMemoryInit(the_module, 0, expressions[589], expressions[590], expressions[591]); + expressions[593] = BinaryenDataDrop(the_module, 0); + expressions[594] = BinaryenConst(the_module, BinaryenLiteralInt32(2048)); + expressions[595] = BinaryenConst(the_module, BinaryenLiteralInt32(1024)); + expressions[596] = BinaryenConst(the_module, BinaryenLiteralInt32(12)); + expressions[597] = BinaryenMemoryCopy(the_module, expressions[594], expressions[595], expressions[596]); + expressions[598] = BinaryenConst(the_module, BinaryenLiteralInt32(0)); + expressions[599] = BinaryenConst(the_module, BinaryenLiteralInt32(42)); + expressions[600] = BinaryenConst(the_module, BinaryenLiteralInt32(1024)); + expressions[601] = BinaryenMemoryFill(the_module, expressions[598], expressions[599], expressions[600]); { BinaryenExpressionRef children[] = { 0 }; - expressions[589] = BinaryenBlock(the_module, NULL, children, 0, BinaryenTypeAuto()); - } - expressions[590] = BinaryenIf(the_module, expressions[18], expressions[19], expressions[20]); - expressions[591] = BinaryenIf(the_module, expressions[21], expressions[22], expressions[0]); - expressions[592] = BinaryenConst(the_module, BinaryenLiteralInt32(0)); - expressions[593] = BinaryenLoop(the_module, "in", expressions[592]); - expressions[594] = BinaryenConst(the_module, BinaryenLiteralInt32(0)); - expressions[595] = BinaryenLoop(the_module, NULL, expressions[594]); - expressions[596] = BinaryenBreak(the_module, "the-value", expressions[23], expressions[24]); - expressions[597] = BinaryenConst(the_module, BinaryenLiteralInt32(2)); - expressions[598] = BinaryenBreak(the_module, "the-nothing", expressions[597], expressions[0]); - expressions[599] = BinaryenConst(the_module, BinaryenLiteralInt32(3)); - expressions[600] = BinaryenBreak(the_module, "the-value", expressions[0], expressions[599]); - expressions[601] = BinaryenBreak(the_module, "the-nothing", expressions[0], expressions[0]); + expressions[602] = BinaryenBlock(the_module, NULL, children, 0, BinaryenTypeAuto()); + } + expressions[603] = BinaryenIf(the_module, expressions[18], expressions[19], expressions[20]); + expressions[604] = BinaryenIf(the_module, expressions[21], expressions[22], expressions[0]); + expressions[605] = BinaryenConst(the_module, BinaryenLiteralInt32(0)); + expressions[606] = BinaryenLoop(the_module, "in", expressions[605]); + expressions[607] = BinaryenConst(the_module, BinaryenLiteralInt32(0)); + expressions[608] = BinaryenLoop(the_module, NULL, expressions[607]); + expressions[609] = BinaryenBreak(the_module, "the-value", expressions[23], expressions[24]); + expressions[610] = BinaryenConst(the_module, BinaryenLiteralInt32(2)); + expressions[611] = BinaryenBreak(the_module, "the-nothing", expressions[610], expressions[0]); + expressions[612] = BinaryenConst(the_module, BinaryenLiteralInt32(3)); + expressions[613] = BinaryenBreak(the_module, "the-value", expressions[0], expressions[612]); + expressions[614] = BinaryenBreak(the_module, "the-nothing", expressions[0], expressions[0]); { const char* names[] = { "the-value" }; - expressions[602] = BinaryenSwitch(the_module, names, 1, "the-value", expressions[25], expressions[26]); + expressions[615] = BinaryenSwitch(the_module, names, 1, "the-value", expressions[25], expressions[26]); } - expressions[603] = BinaryenConst(the_module, BinaryenLiteralInt32(2)); + expressions[616] = BinaryenConst(the_module, BinaryenLiteralInt32(2)); { const char* names[] = { "the-nothing" }; - expressions[604] = BinaryenSwitch(the_module, names, 1, "the-nothing", expressions[603], expressions[0]); + expressions[617] = BinaryenSwitch(the_module, names, 1, "the-nothing", expressions[616], expressions[0]); } { BinaryenExpressionRef operands[] = { expressions[10], expressions[11], expressions[12], expressions[13] }; - expressions[605] = BinaryenCall(the_module, "kitchen()sinker", operands, 4, 1); + expressions[618] = BinaryenCall(the_module, "kitchen()sinker", operands, 4, 1); } - expressions[606] = BinaryenUnary(the_module, 20, expressions[605]); + expressions[619] = BinaryenUnary(the_module, 20, expressions[618]); { BinaryenExpressionRef operands[] = { expressions[8], expressions[9] }; - expressions[607] = BinaryenCall(the_module, "an-imported", operands, 2, 3); + expressions[620] = BinaryenCall(the_module, "an-imported", operands, 2, 3); } - expressions[608] = BinaryenUnary(the_module, 25, expressions[607]); - expressions[609] = BinaryenUnary(the_module, 20, expressions[608]); - expressions[610] = BinaryenConst(the_module, BinaryenLiteralInt32(2449)); + expressions[621] = BinaryenUnary(the_module, 25, expressions[620]); + expressions[622] = BinaryenUnary(the_module, 20, expressions[621]); + expressions[623] = BinaryenConst(the_module, BinaryenLiteralInt32(2449)); { BinaryenExpressionRef operands[] = { expressions[14], expressions[15], expressions[16], expressions[17] }; - expressions[611] = BinaryenCallIndirect(the_module, expressions[610], operands, 4, "iiIfF"); - } - expressions[612] = BinaryenUnary(the_module, 20, expressions[611]); - expressions[613] = BinaryenGetLocal(the_module, 0, 1); - expressions[614] = BinaryenDrop(the_module, expressions[613]); - expressions[615] = BinaryenConst(the_module, BinaryenLiteralInt32(101)); - expressions[616] = BinaryenSetLocal(the_module, 0, expressions[615]); - expressions[617] = BinaryenConst(the_module, BinaryenLiteralInt32(102)); - expressions[618] = BinaryenTeeLocal(the_module, 0, expressions[617]); - expressions[619] = BinaryenDrop(the_module, expressions[618]); - expressions[620] = BinaryenConst(the_module, BinaryenLiteralInt32(1)); - expressions[621] = BinaryenLoad(the_module, 4, 0, 0, 0, 1, expressions[620]); - expressions[622] = BinaryenConst(the_module, BinaryenLiteralInt32(8)); - expressions[623] = BinaryenLoad(the_module, 2, 1, 2, 1, 2, expressions[622]); - expressions[624] = BinaryenConst(the_module, BinaryenLiteralInt32(2)); - expressions[625] = BinaryenLoad(the_module, 4, 0, 0, 0, 3, expressions[624]); - expressions[626] = BinaryenConst(the_module, BinaryenLiteralInt32(9)); - expressions[627] = BinaryenLoad(the_module, 8, 0, 2, 8, 4, expressions[626]); - expressions[628] = BinaryenStore(the_module, 4, 0, 0, expressions[30], expressions[31], 1); - expressions[629] = BinaryenStore(the_module, 8, 2, 4, expressions[32], expressions[33], 2); - expressions[630] = BinaryenSelect(the_module, expressions[27], expressions[28], expressions[29]); - expressions[631] = BinaryenConst(the_module, BinaryenLiteralInt32(1337)); - expressions[632] = BinaryenReturn(the_module, expressions[631]); - expressions[633] = BinaryenNop(the_module); - expressions[634] = BinaryenUnreachable(the_module); + expressions[624] = BinaryenCallIndirect(the_module, expressions[623], operands, 4, "iiIfF"); + } + expressions[625] = BinaryenUnary(the_module, 20, expressions[624]); + expressions[626] = BinaryenGetLocal(the_module, 0, 1); + expressions[627] = BinaryenDrop(the_module, expressions[626]); + expressions[628] = BinaryenConst(the_module, BinaryenLiteralInt32(101)); + expressions[629] = BinaryenSetLocal(the_module, 0, expressions[628]); + expressions[630] = BinaryenConst(the_module, BinaryenLiteralInt32(102)); + expressions[631] = BinaryenTeeLocal(the_module, 0, expressions[630]); + expressions[632] = BinaryenDrop(the_module, expressions[631]); + expressions[633] = BinaryenConst(the_module, BinaryenLiteralInt32(1)); + expressions[634] = BinaryenLoad(the_module, 4, 0, 0, 0, 1, expressions[633]); + expressions[635] = BinaryenConst(the_module, BinaryenLiteralInt32(8)); + expressions[636] = BinaryenLoad(the_module, 2, 1, 2, 1, 2, expressions[635]); + expressions[637] = BinaryenConst(the_module, BinaryenLiteralInt32(2)); + expressions[638] = BinaryenLoad(the_module, 4, 0, 0, 0, 3, expressions[637]); + expressions[639] = BinaryenConst(the_module, BinaryenLiteralInt32(9)); + expressions[640] = BinaryenLoad(the_module, 8, 0, 2, 8, 4, expressions[639]); + expressions[641] = BinaryenStore(the_module, 4, 0, 0, expressions[30], expressions[31], 1); + expressions[642] = BinaryenStore(the_module, 8, 2, 4, expressions[32], expressions[33], 2); + expressions[643] = BinaryenSelect(the_module, expressions[27], expressions[28], expressions[29]); + expressions[644] = BinaryenConst(the_module, BinaryenLiteralInt32(1337)); + expressions[645] = BinaryenReturn(the_module, expressions[644]); + expressions[646] = BinaryenNop(the_module); + expressions[647] = BinaryenUnreachable(the_module); BinaryenExpressionPrint(expressions[41]); (f32.neg (f32.const -33.61199951171875) @@ -3219,32 +3248,32 @@ int main() { expressions[525], expressions[527], expressions[530], expressions[533], expressions[536], expressions[539], expressions[542], expressions[545], expressions[548], expressions[551], expressions[554], expressions[557], expressions[560], expressions[563], expressions[566], expressions[569], expressions[572], expressions[575], - expressions[578], expressions[581], expressions[584], expressions[588], expressions[589], expressions[590], - expressions[591], expressions[593], expressions[595], expressions[596], expressions[598], expressions[600], - expressions[601], expressions[602], expressions[604], expressions[606], expressions[609], expressions[612], - expressions[614], expressions[616], expressions[619], expressions[621], expressions[623], expressions[625], - expressions[627], expressions[628], expressions[629], expressions[630], expressions[632], expressions[633], - expressions[634] }; - expressions[635] = BinaryenBlock(the_module, "the-value", children, 240, BinaryenTypeAuto()); + expressions[578], expressions[581], expressions[584], expressions[588], expressions[592], expressions[593], + expressions[597], expressions[601], expressions[602], expressions[603], expressions[604], expressions[606], + expressions[608], expressions[609], expressions[611], expressions[613], expressions[614], expressions[615], + expressions[617], expressions[619], expressions[622], expressions[625], expressions[627], expressions[629], + expressions[632], expressions[634], expressions[636], expressions[638], expressions[640], expressions[641], + expressions[642], expressions[643], expressions[645], expressions[646], expressions[647] }; + expressions[648] = BinaryenBlock(the_module, "the-value", children, 244, BinaryenTypeAuto()); } - expressions[636] = BinaryenDrop(the_module, expressions[635]); + expressions[649] = BinaryenDrop(the_module, expressions[648]); { - BinaryenExpressionRef children[] = { expressions[636] }; - expressions[637] = BinaryenBlock(the_module, "the-nothing", children, 1, BinaryenTypeAuto()); + BinaryenExpressionRef children[] = { expressions[649] }; + expressions[650] = BinaryenBlock(the_module, "the-nothing", children, 1, BinaryenTypeAuto()); } - expressions[638] = BinaryenConst(the_module, BinaryenLiteralInt32(42)); + expressions[651] = BinaryenConst(the_module, BinaryenLiteralInt32(42)); { - BinaryenExpressionRef children[] = { expressions[637], expressions[638] }; - expressions[639] = BinaryenBlock(the_module, "the-body", children, 2, BinaryenTypeAuto()); + BinaryenExpressionRef children[] = { expressions[650], expressions[651] }; + expressions[652] = BinaryenBlock(the_module, "the-body", children, 2, BinaryenTypeAuto()); } { BinaryenType varTypes[] = { 1 }; - functions[0] = BinaryenAddFunction(the_module, "kitchen()sinker", functionTypes[0], varTypes, 1, expressions[639]); + functions[0] = BinaryenAddFunction(the_module, "kitchen()sinker", functionTypes[0], varTypes, 1, expressions[652]); } - expressions[640] = BinaryenConst(the_module, BinaryenLiteralInt32(7)); - BinaryenAddGlobal(the_module, "a-global", 1, 0, expressions[640]); - expressions[641] = BinaryenConst(the_module, BinaryenLiteralFloat32(7.5)); - BinaryenAddGlobal(the_module, "a-mutable-global", 3, 1, expressions[641]); + expressions[653] = BinaryenConst(the_module, BinaryenLiteralInt32(7)); + BinaryenAddGlobal(the_module, "a-global", 1, 0, expressions[653]); + expressions[654] = BinaryenConst(the_module, BinaryenLiteralFloat32(7.5)); + BinaryenAddGlobal(the_module, "a-mutable-global", 3, 1, expressions[654]); { BinaryenType paramTypes[] = { 1, 4 }; functionTypes[1] = BinaryenAddFunctionType(the_module, "fiF", 3, paramTypes, 2); @@ -3256,11 +3285,11 @@ int main() { const char* funcNames[] = { "kitchen()sinker" }; BinaryenSetFunctionTable(the_module, 1, 1, funcNames, 1); } - expressions[642] = BinaryenConst(the_module, BinaryenLiteralInt32(10)); + expressions[655] = BinaryenConst(the_module, BinaryenLiteralInt32(10)); { const char segment0[] = { 104, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100 }; const char* segments[] = { segment0 }; - BinaryenExpressionRef segmentOffsets[] = { expressions[642] }; + BinaryenExpressionRef segmentOffsets[] = { expressions[655] }; BinaryenIndex segmentSizes[] = { 12 }; BinaryenSetMemory(the_module, 1, 256, "mem", segments, segmentOffsets, segmentSizes, 1, 0); } @@ -3268,10 +3297,10 @@ int main() { BinaryenType paramTypes[] = { 0 }; functionTypes[2] = BinaryenAddFunctionType(the_module, "v", 0, paramTypes, 0); } - expressions[643] = BinaryenNop(the_module); + expressions[656] = BinaryenNop(the_module); { BinaryenType varTypes[] = { 0 }; - functions[1] = BinaryenAddFunction(the_module, "starter", functionTypes[2], varTypes, 0, expressions[643]); + functions[1] = BinaryenAddFunction(the_module, "starter", functionTypes[2], varTypes, 0, expressions[656]); } BinaryenSetStart(the_module, functions[1]); { @@ -4496,6 +4525,22 @@ int main() { (v128.const i32 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10) ) ) + (memory.init 0 + (i32.const 1024) + (i32.const 0) + (i32.const 12) + ) + (data.drop 0) + (memory.copy + (i32.const 2048) + (i32.const 1024) + (i32.const 12) + ) + (memory.fill + (i32.const 0) + (i32.const 42) + (i32.const 1024) + ) (block ) (if diff --git a/test/example/c-api-kitchen-sink.txt.txt b/test/example/c-api-kitchen-sink.txt.txt index 3546b5dd1..32e726abe 100644 --- a/test/example/c-api-kitchen-sink.txt.txt +++ b/test/example/c-api-kitchen-sink.txt.txt @@ -1216,6 +1216,22 @@ (v128.const i32 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10) ) ) + (memory.init 0 + (i32.const 1024) + (i32.const 0) + (i32.const 12) + ) + (data.drop 0) + (memory.copy + (i32.const 2048) + (i32.const 1024) + (i32.const 12) + ) + (memory.fill + (i32.const 0) + (i32.const 42) + (i32.const 1024) + ) (block ) (if |