diff options
70 files changed, 5374 insertions, 3897 deletions
diff --git a/src/binary-reader-interp.cc b/src/binary-reader-interp.cc index 9f4940a2..fe98947c 100644 --- a/src/binary-reader-interp.cc +++ b/src/binary-reader-interp.cc @@ -155,7 +155,7 @@ class BinaryReaderInterp : public BinaryReaderNop { uint32_t alignment_log2, Address offset) override; wabt::Result OnBinaryExpr(wabt::Opcode opcode) override; - wabt::Result OnBlockExpr(Index num_types, Type* sig_types) override; + wabt::Result OnBlockExpr(Type sig_type) override; wabt::Result OnBrExpr(Index depth) override; wabt::Result OnBrIfExpr(Index depth) override; wabt::Result OnBrTableExpr(Index num_targets, @@ -175,11 +175,11 @@ class BinaryReaderInterp : public BinaryReaderNop { wabt::Result OnGetLocalExpr(Index local_index) override; wabt::Result OnI32ConstExpr(uint32_t value) override; wabt::Result OnI64ConstExpr(uint64_t value) override; - wabt::Result OnIfExpr(Index num_types, Type* sig_types) override; + wabt::Result OnIfExpr(Type sig_type) override; wabt::Result OnLoadExpr(wabt::Opcode opcode, uint32_t alignment_log2, Address offset) override; - wabt::Result OnLoopExpr(Index num_types, Type* sig_types) override; + wabt::Result OnLoopExpr(Type sig_type) override; wabt::Result OnMemoryGrowExpr() override; wabt::Result OnMemorySizeExpr() override; wabt::Result OnNopExpr() override; @@ -226,6 +226,9 @@ class BinaryReaderInterp : public BinaryReaderNop { void PrintError(const char* format, ...); Index TranslateSigIndexToEnv(Index sig_index); + void GetBlockSignature(Type sig_type, + TypeVector* out_param_types, + TypeVector* out_result_types); FuncSignature* GetSignatureByModuleIndex(Index sig_index); Index TranslateFuncIndexToEnv(Index func_index); Index TranslateModuleFuncIndexToDefined(Index func_index); @@ -248,7 +251,7 @@ class BinaryReaderInterp : public BinaryReaderNop { wabt::Result EmitI64(uint64_t value); wabt::Result EmitV128(v128 value); wabt::Result EmitI32At(IstreamOffset offset, uint32_t value); - wabt::Result EmitDropKeep(uint32_t drop, uint8_t keep); + wabt::Result EmitDropKeep(uint32_t drop, uint32_t keep); wabt::Result AppendFixup(IstreamOffsetVectorVector* fixups_vector, Index index); wabt::Result EmitBrOffset(Index depth, IstreamOffset offset); @@ -357,6 +360,19 @@ Index BinaryReaderInterp::TranslateSigIndexToEnv(Index sig_index) { return sig_index_mapping_[sig_index]; } +void BinaryReaderInterp::GetBlockSignature(Type sig_type, + TypeVector* out_param_types, + TypeVector* out_result_types) { + if (IsTypeIndex(sig_type)) { + FuncSignature* func_sig = GetSignatureByModuleIndex(GetTypeIndex(sig_type)); + *out_param_types = func_sig->param_types; + *out_result_types = func_sig->result_types; + } else { + out_param_types->clear(); + *out_result_types = GetInlineTypeVector(sig_type); + } +} + FuncSignature* BinaryReaderInterp::GetSignatureByModuleIndex(Index sig_index) { return env_->GetFuncSignature(TranslateSigIndexToEnv(sig_index)); } @@ -442,16 +458,16 @@ wabt::Result BinaryReaderInterp::EmitI32At(IstreamOffset offset, return EmitDataAt(offset, &value, sizeof(value)); } -wabt::Result BinaryReaderInterp::EmitDropKeep(uint32_t drop, uint8_t keep) { +wabt::Result BinaryReaderInterp::EmitDropKeep(uint32_t drop, uint32_t keep) { assert(drop != UINT32_MAX); - assert(keep <= 1); + assert(keep != UINT32_MAX); if (drop > 0) { if (drop == 1 && keep == 0) { CHECK_RESULT(EmitOpcode(Opcode::Drop)); } else { CHECK_RESULT(EmitOpcode(Opcode::InterpDropKeep)); CHECK_RESULT(EmitI32(drop)); - CHECK_RESULT(EmitI8(keep)); + CHECK_RESULT(EmitI32(keep)); } } return wabt::Result::Ok; @@ -484,8 +500,7 @@ wabt::Result BinaryReaderInterp::GetBrDropKeepCount(Index depth, Index* out_keep_count) { TypeChecker::Label* label; CHECK_RESULT(typechecker_.GetLabel(depth, &label)); - *out_keep_count = - label->label_type != LabelType::Loop ? label->sig.size() : 0; + *out_keep_count = label->br_types().size(); if (typechecker_.IsUnreachable()) { *out_drop_count = 0; } else { @@ -518,7 +533,7 @@ wabt::Result BinaryReaderInterp::EmitBrTableOffset(Index depth) { CHECK_RESULT(GetBrDropKeepCount(depth, &drop_count, &keep_count)); CHECK_RESULT(EmitBrOffset(depth, GetLabel(depth)->offset)); CHECK_RESULT(EmitI32(drop_count)); - CHECK_RESULT(EmitI8(keep_count)); + CHECK_RESULT(EmitI32(keep_count)); return wabt::Result::Ok; } @@ -1103,7 +1118,7 @@ wabt::Result BinaryReaderInterp::BeginFunctionBody(Index index) { for (Type param_type : sig->param_types) func->param_and_local_types.push_back(param_type); - CHECK_RESULT(typechecker_.BeginFunction(&sig->result_types)); + CHECK_RESULT(typechecker_.BeginFunction(sig->result_types)); /* push implicit func label (equivalent to return) */ PushLabel(kInvalidIstreamOffset, kInvalidIstreamOffset); @@ -1253,23 +1268,26 @@ wabt::Result BinaryReaderInterp::OnBinaryExpr(wabt::Opcode opcode) { return wabt::Result::Ok; } -wabt::Result BinaryReaderInterp::OnBlockExpr(Index num_types, Type* sig_types) { - TypeVector sig(sig_types, sig_types + num_types); - CHECK_RESULT(typechecker_.OnBlock(&sig)); +wabt::Result BinaryReaderInterp::OnBlockExpr(Type sig_type) { + TypeVector param_types, result_types; + GetBlockSignature(sig_type, ¶m_types, &result_types); + CHECK_RESULT(typechecker_.OnBlock(param_types, result_types)); PushLabel(kInvalidIstreamOffset, kInvalidIstreamOffset); return wabt::Result::Ok; } -wabt::Result BinaryReaderInterp::OnLoopExpr(Index num_types, Type* sig_types) { - TypeVector sig(sig_types, sig_types + num_types); - CHECK_RESULT(typechecker_.OnLoop(&sig)); +wabt::Result BinaryReaderInterp::OnLoopExpr(Type sig_type) { + TypeVector param_types, result_types; + GetBlockSignature(sig_type, ¶m_types, &result_types); + CHECK_RESULT(typechecker_.OnLoop(param_types, result_types)); PushLabel(GetIstreamOffset(), kInvalidIstreamOffset); return wabt::Result::Ok; } -wabt::Result BinaryReaderInterp::OnIfExpr(Index num_types, Type* sig_types) { - TypeVector sig(sig_types, sig_types + num_types); - CHECK_RESULT(typechecker_.OnIf(&sig)); +wabt::Result BinaryReaderInterp::OnIfExpr(Type sig_type) { + TypeVector param_types, result_types; + GetBlockSignature(sig_type, ¶m_types, &result_types); + CHECK_RESULT(typechecker_.OnIf(param_types, result_types)); CHECK_RESULT(EmitOpcode(Opcode::InterpBrUnless)); IstreamOffset fixup_offset = GetIstreamOffset(); CHECK_RESULT(EmitI32(kInvalidIstreamOffset)); @@ -1349,7 +1367,7 @@ wabt::Result BinaryReaderInterp::OnBrTableExpr(Index num_targets, wabt::Result BinaryReaderInterp::OnCallExpr(Index func_index) { Func* func = GetFuncByModuleIndex(func_index); FuncSignature* sig = env_->GetFuncSignature(func->sig_index); - CHECK_RESULT(typechecker_.OnCall(&sig->param_types, &sig->result_types)); + CHECK_RESULT(typechecker_.OnCall(sig->param_types, sig->result_types)); if (func->is_host) { CHECK_RESULT(EmitOpcode(Opcode::InterpCallHost)); @@ -1369,7 +1387,7 @@ wabt::Result BinaryReaderInterp::OnCallIndirectExpr(Index sig_index) { } FuncSignature* sig = GetSignatureByModuleIndex(sig_index); CHECK_RESULT( - typechecker_.OnCallIndirect(&sig->param_types, &sig->result_types)); + typechecker_.OnCallIndirect(sig->param_types, sig->result_types)); CHECK_RESULT(EmitOpcode(Opcode::CallIndirect)); CHECK_RESULT(EmitI32(module_->table_index)); diff --git a/src/binary-reader-ir.cc b/src/binary-reader-ir.cc index 030e1e81..3207fc07 100644 --- a/src/binary-reader-ir.cc +++ b/src/binary-reader-ir.cc @@ -135,7 +135,7 @@ class BinaryReaderIR : public BinaryReaderNop { uint32_t alignment_log2, Address offset) override; Result OnBinaryExpr(Opcode opcode) override; - Result OnBlockExpr(Index num_types, Type* sig_types) override; + Result OnBlockExpr(Type sig_type) override; Result OnBrExpr(Index depth) override; Result OnBrIfExpr(Index depth) override; Result OnBrTableExpr(Index num_targets, @@ -156,14 +156,12 @@ class BinaryReaderIR : public BinaryReaderNop { Result OnGetLocalExpr(Index local_index) override; Result OnI32ConstExpr(uint32_t value) override; Result OnI64ConstExpr(uint64_t value) override; - Result OnIfExpr(Index num_types, Type* sig_types) override; - Result OnIfExceptExpr(Index num_types, - Type* sig_types, - Index except_index) override; + Result OnIfExpr(Type sig_type) override; + Result OnIfExceptExpr(Type sig_type, Index except_index) override; Result OnLoadExpr(Opcode opcode, uint32_t alignment_log2, Address offset) override; - Result OnLoopExpr(Index num_types, Type* sig_types) override; + Result OnLoopExpr(Type sig_type) override; Result OnMemoryGrowExpr() override; Result OnMemorySizeExpr() override; Result OnNopExpr() override; @@ -177,7 +175,7 @@ class BinaryReaderIR : public BinaryReaderNop { Address offset) override; Result OnThrowExpr(Index except_index) override; Result OnTeeLocalExpr(Index local_index) override; - Result OnTryExpr(Index num_types, Type* sig_types) override; + Result OnTryExpr(Type sig_type) override; Result OnUnaryExpr(Opcode opcode) override; Result OnTernaryExpr(Opcode opcode) override; Result OnUnreachableExpr() override; @@ -233,6 +231,7 @@ class BinaryReaderIR : public BinaryReaderNop { Result TopLabel(LabelNode** label); Result TopLabelExpr(LabelNode** label, Expr** expr); Result AppendExpr(std::unique_ptr<Expr> expr); + void SetBlockDeclaration(BlockDeclaration* decl, Type sig_type); ErrorHandler* error_handler_ = nullptr; Module* module_ = nullptr; @@ -308,6 +307,20 @@ Result BinaryReaderIR::AppendExpr(std::unique_ptr<Expr> expr) { return Result::Ok; } +void BinaryReaderIR::SetBlockDeclaration(BlockDeclaration* decl, + Type sig_type) { + if (IsTypeIndex(sig_type)) { + Index type_index = GetTypeIndex(sig_type); + decl->has_func_type = true; + decl->type_var = Var(type_index); + decl->sig = module_->func_types[type_index]->sig; + } else { + decl->has_func_type = false; + decl->sig.param_types.clear(); + decl->sig.result_types = GetInlineTypeVector(sig_type); + } +} + bool BinaryReaderIR::HandleError(ErrorLevel error_level, Offset offset, const char* message) { @@ -603,9 +616,9 @@ Result BinaryReaderIR::OnBinaryExpr(Opcode opcode) { return AppendExpr(MakeUnique<BinaryExpr>(opcode)); } -Result BinaryReaderIR::OnBlockExpr(Index num_types, Type* sig_types) { +Result BinaryReaderIR::OnBlockExpr(Type sig_type) { auto expr = MakeUnique<BlockExpr>(); - expr->block.sig.assign(sig_types, sig_types + num_types); + SetBlockDeclaration(&expr->block.decl, sig_type); ExprList* expr_list = &expr->block.exprs; CHECK_RESULT(AppendExpr(std::move(expr))); PushLabel(LabelType::Block, expr_list); @@ -748,21 +761,19 @@ Result BinaryReaderIR::OnI64ConstExpr(uint64_t value) { return AppendExpr(MakeUnique<ConstExpr>(Const::I64(value, GetLocation()))); } -Result BinaryReaderIR::OnIfExpr(Index num_types, Type* sig_types) { +Result BinaryReaderIR::OnIfExpr(Type sig_type) { auto expr = MakeUnique<IfExpr>(); - expr->true_.sig.assign(sig_types, sig_types + num_types); + SetBlockDeclaration(&expr->true_.decl, sig_type); ExprList* expr_list = &expr->true_.exprs; CHECK_RESULT(AppendExpr(std::move(expr))); PushLabel(LabelType::If, expr_list); return Result::Ok; } -Result BinaryReaderIR::OnIfExceptExpr(Index num_types, - Type* sig_types, - Index except_index) { +Result BinaryReaderIR::OnIfExceptExpr(Type sig_type, Index except_index) { auto expr = MakeUnique<IfExceptExpr>(); expr->except_var = Var(except_index, GetLocation()); - expr->true_.sig.assign(sig_types, sig_types + num_types); + SetBlockDeclaration(&expr->true_.decl, sig_type); ExprList* expr_list = &expr->true_.exprs; CHECK_RESULT(AppendExpr(std::move(expr))); PushLabel(LabelType::IfExcept, expr_list); @@ -775,9 +786,9 @@ Result BinaryReaderIR::OnLoadExpr(Opcode opcode, return AppendExpr(MakeUnique<LoadExpr>(opcode, 1 << alignment_log2, offset)); } -Result BinaryReaderIR::OnLoopExpr(Index num_types, Type* sig_types) { +Result BinaryReaderIR::OnLoopExpr(Type sig_type) { auto expr = MakeUnique<LoopExpr>(); - expr->block.sig.assign(sig_types, sig_types + num_types); + SetBlockDeclaration(&expr->block.decl, sig_type); ExprList* expr_list = &expr->block.exprs; CHECK_RESULT(AppendExpr(std::move(expr))); PushLabel(LabelType::Loop, expr_list); @@ -831,12 +842,12 @@ Result BinaryReaderIR::OnTeeLocalExpr(Index local_index) { return AppendExpr(MakeUnique<TeeLocalExpr>(Var(local_index, GetLocation()))); } -Result BinaryReaderIR::OnTryExpr(Index num_types, Type* sig_types) { +Result BinaryReaderIR::OnTryExpr(Type sig_type) { auto expr_ptr = MakeUnique<TryExpr>(); // Save expr so it can be used below, after expr_ptr has been moved. TryExpr* expr = expr_ptr.get(); ExprList* expr_list = &expr->block.exprs; - expr->block.sig.assign(sig_types, sig_types + num_types); + SetBlockDeclaration(&expr->block.decl, sig_type); CHECK_RESULT(AppendExpr(std::move(expr_ptr))); PushLabel(LabelType::Try, expr_list, expr); return Result::Ok; diff --git a/src/binary-reader-logging.cc b/src/binary-reader-logging.cc index b1896c73..f730a865 100644 --- a/src/binary-reader-logging.cc +++ b/src/binary-reader-logging.cc @@ -76,10 +76,18 @@ void BinaryReaderLogging::WriteIndent() { } } +void BinaryReaderLogging::LogType(Type type) { + if (IsTypeIndex(type)) { + LOGF_NOINDENT("funcidx[%d]", static_cast<int>(type)); + } else { + LOGF_NOINDENT("%s", GetTypeName(type)); + } +} + void BinaryReaderLogging::LogTypes(Index type_count, Type* types) { LOGF_NOINDENT("["); for (Index i = 0; i < type_count; ++i) { - LOGF_NOINDENT("%s", GetTypeName(types[i])); + LogType(types[i]); if (i != type_count - 1) { LOGF_NOINDENT(", "); } @@ -254,11 +262,11 @@ Result BinaryReaderLogging::OnLocalDecl(Index decl_index, return reader_->OnLocalDecl(decl_index, count, type); } -Result BinaryReaderLogging::OnBlockExpr(Index num_types, Type* sig_types) { +Result BinaryReaderLogging::OnBlockExpr(Type sig_type) { LOGF("OnBlockExpr(sig: "); - LogTypes(num_types, sig_types); + LogType(sig_type); LOGF_NOINDENT(")\n"); - return reader_->OnBlockExpr(num_types, sig_types); + return reader_->OnBlockExpr(sig_type); } Result BinaryReaderLogging::OnBrExpr(Index depth) { @@ -323,34 +331,32 @@ Result BinaryReaderLogging::OnI64ConstExpr(uint64_t value) { return reader_->OnI64ConstExpr(value); } -Result BinaryReaderLogging::OnIfExpr(Index num_types, Type* sig_types) { +Result BinaryReaderLogging::OnIfExpr(Type sig_type) { LOGF("OnIfExpr(sig: "); - LogTypes(num_types, sig_types); + LogType(sig_type); LOGF_NOINDENT(")\n"); - return reader_->OnIfExpr(num_types, sig_types); + return reader_->OnIfExpr(sig_type); } -Result BinaryReaderLogging::OnIfExceptExpr(Index num_types, - Type* sig_types, - Index except_index) { +Result BinaryReaderLogging::OnIfExceptExpr(Type sig_type, Index except_index) { LOGF("OnIfExceptExpr(sig: "); - LogTypes(num_types, sig_types); + LogType(sig_type); LOGF_NOINDENT(", except: %" PRIindex ")\n", except_index); - return reader_->OnIfExceptExpr(num_types, sig_types, except_index); + return reader_->OnIfExceptExpr(sig_type, except_index); } -Result BinaryReaderLogging::OnLoopExpr(Index num_types, Type* sig_types) { +Result BinaryReaderLogging::OnLoopExpr(Type sig_type) { LOGF("OnLoopExpr(sig: "); - LogTypes(num_types, sig_types); + LogType(sig_type); LOGF_NOINDENT(")\n"); - return reader_->OnLoopExpr(num_types, sig_types); + return reader_->OnLoopExpr(sig_type); } -Result BinaryReaderLogging::OnTryExpr(Index num_types, Type* sig_types) { +Result BinaryReaderLogging::OnTryExpr(Type sig_type) { LOGF("OnTryExpr(sig: "); - LogTypes(num_types, sig_types); + LogType(sig_type); LOGF_NOINDENT(")\n"); - return reader_->OnTryExpr(num_types, sig_types); + return reader_->OnTryExpr(sig_type); } Result BinaryReaderLogging::OnSimdLaneOpExpr(Opcode opcode, uint64_t value) { @@ -753,8 +759,8 @@ Result BinaryReaderLogging::OnOpcodeV128(v128 value) { return reader_->OnOpcodeV128(value); } -Result BinaryReaderLogging::OnOpcodeBlockSig(Index num_types, Type* sig_types) { - return reader_->OnOpcodeBlockSig(num_types, sig_types); +Result BinaryReaderLogging::OnOpcodeBlockSig(Type sig_type) { + return reader_->OnOpcodeBlockSig(sig_type); } Result BinaryReaderLogging::OnEndFunc() { diff --git a/src/binary-reader-logging.h b/src/binary-reader-logging.h index 26b38506..d0424954 100644 --- a/src/binary-reader-logging.h +++ b/src/binary-reader-logging.h @@ -133,7 +133,7 @@ class BinaryReaderLogging : public BinaryReaderDelegate { Result OnOpcodeF32(uint32_t value) override; Result OnOpcodeF64(uint64_t value) override; Result OnOpcodeV128(v128 value) override; - Result OnOpcodeBlockSig(Index num_types, Type* sig_types) override; + Result OnOpcodeBlockSig(Type sig_type) override; Result OnAtomicLoadExpr(Opcode opcode, uint32_t alignment_log2, Address offset) override; @@ -147,7 +147,7 @@ class BinaryReaderLogging : public BinaryReaderDelegate { uint32_t alignment_log2, Address offset) override; Result OnBinaryExpr(Opcode opcode) override; - Result OnBlockExpr(Index num_types, Type* sig_types) override; + Result OnBlockExpr(Type sig_type) override; Result OnBrExpr(Index depth) override; Result OnBrIfExpr(Index depth) override; Result OnBrTableExpr(Index num_targets, @@ -169,14 +169,12 @@ class BinaryReaderLogging : public BinaryReaderDelegate { Result OnGetLocalExpr(Index local_index) override; Result OnI32ConstExpr(uint32_t value) override; Result OnI64ConstExpr(uint64_t value) override; - Result OnIfExpr(Index num_types, Type* sig_types) override; - Result OnIfExceptExpr(Index num_types, - Type* sig_types, - Index except_index) override; + Result OnIfExpr(Type sig_type) override; + Result OnIfExceptExpr(Type sig_type, Index except_index) override; Result OnLoadExpr(Opcode opcode, uint32_t alignment_log2, Address offset) override; - Result OnLoopExpr(Index num_types, Type* sig_types) override; + Result OnLoopExpr(Type sig_type) override; Result OnMemoryGrowExpr() override; Result OnMemorySizeExpr() override; Result OnNopExpr() override; @@ -190,7 +188,7 @@ class BinaryReaderLogging : public BinaryReaderDelegate { Address offset) override; Result OnTeeLocalExpr(Index local_index) override; Result OnThrowExpr(Index except_index) override; - Result OnTryExpr(Index num_types, Type* sig_types) override; + Result OnTryExpr(Type sig_type) override; Result OnUnaryExpr(Opcode opcode) override; Result OnTernaryExpr(Opcode opcode) override; Result OnUnreachableExpr() override; @@ -300,6 +298,7 @@ class BinaryReaderLogging : public BinaryReaderDelegate { void Indent(); void Dedent(); void WriteIndent(); + void LogType(Type type); void LogTypes(Index type_count, Type* types); void LogTypes(TypeVector& types); diff --git a/src/binary-reader-nop.h b/src/binary-reader-nop.h index 37fa0ff5..a08eddd2 100644 --- a/src/binary-reader-nop.h +++ b/src/binary-reader-nop.h @@ -173,9 +173,7 @@ class BinaryReaderNop : public BinaryReaderDelegate { Result OnOpcodeF32(uint32_t value) override { return Result::Ok; } Result OnOpcodeF64(uint64_t value) override { return Result::Ok; } Result OnOpcodeV128(v128 value) override { return Result::Ok; } - Result OnOpcodeBlockSig(Index num_types, Type* sig_types) override { - return Result::Ok; - } + Result OnOpcodeBlockSig(Type sig_type) override { return Result::Ok; } Result OnAtomicLoadExpr(Opcode opcode, uint32_t alignment_log2, Address offset) override { @@ -203,9 +201,7 @@ class BinaryReaderNop : public BinaryReaderDelegate { return Result::Ok; } Result OnBinaryExpr(Opcode opcode) override { return Result::Ok; } - Result OnBlockExpr(Index num_types, Type* sig_types) override { - return Result::Ok; - } + Result OnBlockExpr(Type sig_type) override { return Result::Ok; } Result OnBrExpr(Index depth) override { return Result::Ok; } Result OnBrIfExpr(Index depth) override { return Result::Ok; } Result OnBrTableExpr(Index num_targets, @@ -229,12 +225,8 @@ class BinaryReaderNop : public BinaryReaderDelegate { Result OnGetLocalExpr(Index local_index) override { return Result::Ok; } Result OnI32ConstExpr(uint32_t value) override { return Result::Ok; } Result OnI64ConstExpr(uint64_t value) override { return Result::Ok; } - Result OnIfExpr(Index num_types, Type* sig_types) override { - return Result::Ok; - } - Result OnIfExceptExpr(Index num_types, - Type* sig_types, - Index except_index) override { + Result OnIfExpr(Type sig_type) override { return Result::Ok; } + Result OnIfExceptExpr(Type sig_type, Index except_index) override { return Result::Ok; } Result OnLoadExpr(Opcode opcode, @@ -242,9 +234,7 @@ class BinaryReaderNop : public BinaryReaderDelegate { Address offset) override { return Result::Ok; } - Result OnLoopExpr(Index num_types, Type* sig_types) override { - return Result::Ok; - } + Result OnLoopExpr(Type sig_type) override { return Result::Ok; } Result OnMemoryGrowExpr() override { return Result::Ok; } Result OnMemorySizeExpr() override { return Result::Ok; } Result OnNopExpr() override { return Result::Ok; } @@ -260,9 +250,7 @@ class BinaryReaderNop : public BinaryReaderDelegate { } Result OnTeeLocalExpr(Index local_index) override { return Result::Ok; } Result OnThrowExpr(Index depth) override { return Result::Ok; } - Result OnTryExpr(Index num_types, Type* sig_types) override { - return Result::Ok; - } + Result OnTryExpr(Type sig_type) override { return Result::Ok; } Result OnUnaryExpr(Opcode opcode) override { return Result::Ok; } Result OnTernaryExpr(Opcode opcode) override { return Result::Ok; } Result OnUnreachableExpr() override { return Result::Ok; } diff --git a/src/binary-reader-objdump.cc b/src/binary-reader-objdump.cc index 29117ad8..a9752920 100644 --- a/src/binary-reader-objdump.cc +++ b/src/binary-reader-objdump.cc @@ -327,6 +327,8 @@ class BinaryReaderObjdumpDisassemble : public BinaryReaderObjdumpBase { public: using BinaryReaderObjdumpBase::BinaryReaderObjdumpBase; + std::string BlockSigToString(Type type) const; + Result BeginFunctionBody(Index index) override; Result OnLocalDeclCount(Index count) override; @@ -340,14 +342,12 @@ class BinaryReaderObjdumpDisassemble : public BinaryReaderObjdumpBase { Result OnOpcodeUint64(uint64_t value) override; Result OnOpcodeF32(uint32_t value) override; Result OnOpcodeF64(uint64_t value) override; - Result OnOpcodeBlockSig(Index num_types, Type* sig_types) override; + Result OnOpcodeBlockSig(Type sig_type) override; Result OnBrTableExpr(Index num_targets, Index* target_depths, Index default_target_depth) override; - Result OnIfExceptExpr(Index num_types, - Type* sig_types, - Index except_index) override; + Result OnIfExceptExpr(Type sig_type, Index except_index) override; Result OnEndExpr() override; Result OnEndFunc() override; @@ -362,6 +362,16 @@ class BinaryReaderObjdumpDisassemble : public BinaryReaderObjdumpBase { Index local_index_ = 0; }; +std::string BinaryReaderObjdumpDisassemble::BlockSigToString(Type type) const { + if (IsTypeIndex(type)) { + return StringPrintf("type[%d]", GetTypeIndex(type)); + } else if (type == Type::Void) { + return ""; + } else { + return GetTypeName(type); + } +} + Result BinaryReaderObjdumpDisassemble::OnOpcode(Opcode opcode) { if (options_->debug) { const char* opcode_name = opcode.GetName(); @@ -545,12 +555,11 @@ Result BinaryReaderObjdumpDisassemble::OnBrTableExpr( return Result::Ok; } -Result BinaryReaderObjdumpDisassemble::OnIfExceptExpr(Index num_types, - Type* sig_types, +Result BinaryReaderObjdumpDisassemble::OnIfExceptExpr(Type sig_type, Index except_index) { Offset immediate_len = state->offset - current_opcode_offset; - if (num_types) { - LogOpcode(data_, immediate_len, "%s %u", GetTypeName(*sig_types), + if (sig_type != Type::Void) { + LogOpcode(data_, immediate_len, "%s %u", BlockSigToString(sig_type).c_str(), except_index); } else { LogOpcode(data_, immediate_len, "%u", except_index); @@ -583,12 +592,12 @@ Result BinaryReaderObjdumpDisassemble::BeginFunctionBody(Index index) { return Result::Ok; } -Result BinaryReaderObjdumpDisassemble::OnOpcodeBlockSig(Index num_types, - Type* sig_types) { - if (num_types) { - LogOpcode(data_, 1, "%s", GetTypeName(*sig_types)); +Result BinaryReaderObjdumpDisassemble::OnOpcodeBlockSig(Type sig_type) { + Offset immediate_len = state->offset - current_opcode_offset; + if (sig_type != Type::Void) { + LogOpcode(data_, immediate_len, "%s", BlockSigToString(sig_type).c_str()); } else { - LogOpcode(data_, 1, nullptr); + LogOpcode(data_, immediate_len, nullptr); } indent_level++; return Result::Ok; diff --git a/src/binary-reader-opcnt.cc b/src/binary-reader-opcnt.cc index 9338572c..a5f041d5 100644 --- a/src/binary-reader-opcnt.cc +++ b/src/binary-reader-opcnt.cc @@ -118,11 +118,15 @@ void OpcodeInfo::Write(Stream& stream) { stream, [&stream](uint32_t value) { stream.Writef("%u", value); }); break; - case Kind::BlockSig: - WriteArray<Type>(stream, [&stream](Type type) { - stream.Writef("%s", GetTypeName(type)); - }); + case Kind::BlockSig: { + auto type = *GetData<Type>(); + if (IsTypeIndex(type)) { + stream.Writef(" type:%d", static_cast<int>(type)); + } else if (type != Type::Void) { + stream.Writef(" %s", GetTypeName(type)); + } break; + } case Kind::BrTable: { WriteArray<Index>(stream, [&stream](Index index) { @@ -190,7 +194,7 @@ class BinaryReaderOpcnt : public BinaryReaderNop { Result OnOpcodeUint64(uint64_t value) override; Result OnOpcodeF32(uint32_t value) override; Result OnOpcodeF64(uint64_t value) override; - Result OnOpcodeBlockSig(Index num_types, Type* sig_types) override; + Result OnOpcodeBlockSig(Type sig_type) override; Result OnBrTableExpr(Index num_targets, Index* target_depths, Index default_target_depth) override; @@ -254,9 +258,8 @@ Result BinaryReaderOpcnt::OnOpcodeF64(uint64_t value) { return Emplace(current_opcode_, OpcodeInfo::Kind::Float64, &value); } -Result BinaryReaderOpcnt::OnOpcodeBlockSig(Index num_types, Type* sig_types) { - return Emplace(current_opcode_, OpcodeInfo::Kind::BlockSig, sig_types, - num_types); +Result BinaryReaderOpcnt::OnOpcodeBlockSig(Type sig_type) { + return Emplace(current_opcode_, OpcodeInfo::Kind::BlockSig, &sig_type); } Result BinaryReaderOpcnt::OnBrTableExpr(Index num_targets, diff --git a/src/binary-reader.cc b/src/binary-reader.cc index 5c958f7e..586b3335 100644 --- a/src/binary-reader.cc +++ b/src/binary-reader.cc @@ -105,8 +105,8 @@ class BinaryReader { Result ReadOffset(Offset* offset, const char* desc) WABT_WARN_UNUSED; Result ReadCount(Index* index, const char* desc) WABT_WARN_UNUSED; - bool is_concrete_type(Type); - bool is_inline_sig_type(Type); + bool IsConcreteType(Type); + bool IsBlockType(Type); Index NumTotalFuncs(); Index NumTotalTables(); @@ -145,6 +145,7 @@ class BinaryReader { BinaryReaderLogging logging_delegate_; BinaryReaderDelegate* delegate_ = nullptr; TypeVector param_types_; + TypeVector result_types_; std::vector<Index> target_depths_; const ReadBinaryOptions* options_ = nullptr; BinarySection last_known_section_ = BinarySection::Invalid; @@ -291,8 +292,8 @@ Result BinaryReader::ReadS64Leb128(uint64_t* out_value, const char* desc) { } Result BinaryReader::ReadType(Type* out_value, const char* desc) { - uint8_t type = 0; - CHECK_RESULT(ReadU8(&type, desc)); + uint32_t type = 0; + CHECK_RESULT(ReadS32Leb128(&type, desc)); *out_value = static_cast<Type>(type); return Result::Ok; } @@ -363,7 +364,7 @@ static bool is_valid_external_kind(uint8_t kind) { return kind < kExternalKindCount; } -bool BinaryReader::is_concrete_type(Type type) { +bool BinaryReader::IsConcreteType(Type type) { switch (type) { case Type::I32: case Type::I64: @@ -379,8 +380,16 @@ bool BinaryReader::is_concrete_type(Type type) { } } -bool BinaryReader::is_inline_sig_type(Type type) { - return is_concrete_type(type) || type == Type::Void; +bool BinaryReader::IsBlockType(Type type) { + if (IsConcreteType(type) || type == Type::Void) { + return true; + } + + if (!(options_->features.multi_value_enabled() && IsTypeIndex(type))) { + return false; + } + + return GetTypeIndex(type) < num_signatures_; } Index BinaryReader::NumTotalFuncs() { @@ -523,7 +532,7 @@ Result BinaryReader::ReadGlobalHeader(Type* out_type, bool* out_mutable) { Type global_type = Type::Void; uint8_t mutable_ = 0; CHECK_RESULT(ReadType(&global_type, "global type")); - ERROR_UNLESS(is_concrete_type(global_type), "invalid global type: %#x", + ERROR_UNLESS(IsConcreteType(global_type), "invalid global type: %#x", static_cast<int>(global_type)); CHECK_RESULT(ReadU8(&mutable_, "global mutability")); @@ -549,33 +558,30 @@ Result BinaryReader::ReadFunctionBody(Offset end_offset) { case Opcode::Block: { Type sig_type; CHECK_RESULT(ReadType(&sig_type, "block signature type")); - ERROR_UNLESS(is_inline_sig_type(sig_type), + ERROR_UNLESS(IsBlockType(sig_type), "expected valid block signature type"); - Index num_types = sig_type == Type::Void ? 0 : 1; - CALLBACK(OnBlockExpr, num_types, &sig_type); - CALLBACK(OnOpcodeBlockSig, num_types, &sig_type); + CALLBACK(OnBlockExpr, sig_type); + CALLBACK(OnOpcodeBlockSig, sig_type); break; } case Opcode::Loop: { Type sig_type; CHECK_RESULT(ReadType(&sig_type, "loop signature type")); - ERROR_UNLESS(is_inline_sig_type(sig_type), + ERROR_UNLESS(IsBlockType(sig_type), "expected valid block signature type"); - Index num_types = sig_type == Type::Void ? 0 : 1; - CALLBACK(OnLoopExpr, num_types, &sig_type); - CALLBACK(OnOpcodeBlockSig, num_types, &sig_type); + CALLBACK(OnLoopExpr, sig_type); + CALLBACK(OnOpcodeBlockSig, sig_type); break; } case Opcode::If: { Type sig_type; CHECK_RESULT(ReadType(&sig_type, "if signature type")); - ERROR_UNLESS(is_inline_sig_type(sig_type), + ERROR_UNLESS(IsBlockType(sig_type), "expected valid block signature type"); - Index num_types = sig_type == Type::Void ? 0 : 1; - CALLBACK(OnIfExpr, num_types, &sig_type); - CALLBACK(OnOpcodeBlockSig, num_types, &sig_type); + CALLBACK(OnIfExpr, sig_type); + CALLBACK(OnOpcodeBlockSig, sig_type); break; } @@ -1124,11 +1130,10 @@ Result BinaryReader::ReadFunctionBody(Offset end_offset) { ERROR_UNLESS_OPCODE_ENABLED(opcode); Type sig_type; CHECK_RESULT(ReadType(&sig_type, "try signature type")); - ERROR_UNLESS(is_inline_sig_type(sig_type), + ERROR_UNLESS(IsBlockType(sig_type), "expected valid block signature type"); - Index num_types = sig_type == Type::Void ? 0 : 1; - CALLBACK(OnTryExpr, num_types, &sig_type); - CALLBACK(OnOpcodeBlockSig, num_types, &sig_type); + CALLBACK(OnTryExpr, sig_type); + CALLBACK(OnOpcodeBlockSig, sig_type); break; } @@ -1159,12 +1164,11 @@ Result BinaryReader::ReadFunctionBody(Offset end_offset) { ERROR_UNLESS_OPCODE_ENABLED(opcode); Type sig_type; CHECK_RESULT(ReadType(&sig_type, "if signature type")); - ERROR_UNLESS(is_inline_sig_type(sig_type), + ERROR_UNLESS(IsBlockType(sig_type), "expected valid block signature type"); - Index num_types = sig_type == Type::Void ? 0 : 1; Index except_index; CHECK_RESULT(ReadIndex(&except_index, "exception index")); - CALLBACK(OnIfExceptExpr, num_types, &sig_type, except_index); + CALLBACK(OnIfExceptExpr, sig_type, except_index); break; } @@ -1577,7 +1581,7 @@ Result BinaryReader::ReadExceptionType(TypeVector& sig) { for (Index j = 0; j < num_values; ++j) { Type value_type; CHECK_RESULT(ReadType(&value_type, "exception value type")); - ERROR_UNLESS(is_concrete_type(value_type), + ERROR_UNLESS(IsConcreteType(value_type), "excepted valid exception value type (got %d)", static_cast<int>(value_type)); sig[j] = value_type; @@ -1634,8 +1638,9 @@ Result BinaryReader::ReadTypeSection(Offset section_size) { for (Index i = 0; i < num_signatures_; ++i) { Type form; CHECK_RESULT(ReadType(&form, "type form")); - ERROR_UNLESS(form == Type::Func, "unexpected type form: %d", - static_cast<int>(form)); + ERROR_UNLESS(form == Type::Func, + "unexpected type form (got " PRItypecode ")", + WABT_PRINTF_TYPE_CODE(form)); Index num_params; CHECK_RESULT(ReadCount(&num_params, "function param count")); @@ -1645,27 +1650,32 @@ Result BinaryReader::ReadTypeSection(Offset section_size) { for (Index j = 0; j < num_params; ++j) { Type param_type; CHECK_RESULT(ReadType(¶m_type, "function param type")); - ERROR_UNLESS(is_concrete_type(param_type), - "expected valid param type (got %#x)", - static_cast<int>(param_type)); + ERROR_UNLESS(IsConcreteType(param_type), + "expected valid param type (got " PRItypecode ")", + WABT_PRINTF_TYPE_CODE(param_type)); param_types_[j] = param_type; } Index num_results; CHECK_RESULT(ReadCount(&num_results, "function result count")); - ERROR_UNLESS(num_results <= 1, "result count must be 0 or 1"); + ERROR_UNLESS(num_results <= 1 || options_->features.multi_value_enabled(), + "result count must be 0 or 1"); + + result_types_.resize(num_results); - Type result_type = Type::Void; - if (num_results) { + for (Index j = 0; j < num_results; ++j) { + Type result_type; CHECK_RESULT(ReadType(&result_type, "function result type")); - ERROR_UNLESS(is_concrete_type(result_type), - "expected valid result type: %#x", - static_cast<int>(result_type)); + ERROR_UNLESS(IsConcreteType(result_type), + "expected valid result type (got " PRItypecode ")", + WABT_PRINTF_TYPE_CODE(result_type)); + result_types_[j] = result_type; } Type* param_types = num_params ? param_types_.data() : nullptr; + Type* result_types = num_results ? result_types_.data() : nullptr; - CALLBACK(OnType, i, num_params, param_types, num_results, &result_type); + CALLBACK(OnType, i, num_params, param_types, num_results, result_types); } CALLBACK0(EndTypeSection); return Result::Ok; @@ -1924,7 +1934,7 @@ Result BinaryReader::ReadCodeSection(Offset section_size) { ERROR_UNLESS(num_local_types > 0, "local count must be > 0"); Type local_type; CHECK_RESULT(ReadType(&local_type, "local type")); - ERROR_UNLESS(is_concrete_type(local_type), "expected valid local type"); + ERROR_UNLESS(IsConcreteType(local_type), "expected valid local type"); CALLBACK(OnLocalDecl, k, num_local_types, local_type); } diff --git a/src/binary-reader.h b/src/binary-reader.h index cf09ddba..c64b490e 100644 --- a/src/binary-reader.h +++ b/src/binary-reader.h @@ -182,7 +182,7 @@ class BinaryReaderDelegate { virtual Result OnOpcodeF32(uint32_t value) = 0; virtual Result OnOpcodeF64(uint64_t value) = 0; virtual Result OnOpcodeV128(v128 value) = 0; - virtual Result OnOpcodeBlockSig(Index num_types, Type* sig_types) = 0; + virtual Result OnOpcodeBlockSig(Type sig_type) = 0; virtual Result OnAtomicLoadExpr(Opcode opcode, uint32_t alignment_log2, Address offset) = 0; @@ -202,7 +202,7 @@ class BinaryReaderDelegate { uint32_t alignment_log2, Address offset) = 0; virtual Result OnBinaryExpr(Opcode opcode) = 0; - virtual Result OnBlockExpr(Index num_types, Type* sig_types) = 0; + virtual Result OnBlockExpr(Type sig_type) = 0; virtual Result OnBrExpr(Index depth) = 0; virtual Result OnBrIfExpr(Index depth) = 0; virtual Result OnBrTableExpr(Index num_targets, @@ -224,14 +224,12 @@ class BinaryReaderDelegate { virtual Result OnGetLocalExpr(Index local_index) = 0; virtual Result OnI32ConstExpr(uint32_t value) = 0; virtual Result OnI64ConstExpr(uint64_t value) = 0; - virtual Result OnIfExpr(Index num_types, Type* sig_types) = 0; - virtual Result OnIfExceptExpr(Index num_types, - Type* sig_types, - Index except_index) = 0; + virtual Result OnIfExpr(Type sig_type) = 0; + virtual Result OnIfExceptExpr(Type sig_type, Index except_index) = 0; virtual Result OnLoadExpr(Opcode opcode, uint32_t alignment_log2, Address offset) = 0; - virtual Result OnLoopExpr(Index num_types, Type* sig_types) = 0; + virtual Result OnLoopExpr(Type sig_type) = 0; virtual Result OnMemoryGrowExpr() = 0; virtual Result OnMemorySizeExpr() = 0; virtual Result OnNopExpr() = 0; @@ -245,7 +243,7 @@ class BinaryReaderDelegate { Address offset) = 0; virtual Result OnTeeLocalExpr(Index local_index) = 0; virtual Result OnThrowExpr(Index except_index) = 0; - virtual Result OnTryExpr(Index num_types, Type* sig_types) = 0; + virtual Result OnTryExpr(Type sig_type) = 0; virtual Result OnUnaryExpr(Opcode opcode) = 0; virtual Result OnTernaryExpr(Opcode opcode) = 0; diff --git a/src/binary-writer.cc b/src/binary-writer.cc index 2408c062..24543da2 100644 --- a/src/binary-writer.cc +++ b/src/binary-writer.cc @@ -55,7 +55,7 @@ void WriteOpcode(Stream* stream, Opcode opcode) { } void WriteType(Stream* stream, Type type) { - stream->WriteU8Enum(type, GetTypeName(type)); + WriteS32Leb128(stream, type, GetTypeName(type)); } void WriteLimits(Stream* stream, const Limits* limits) { @@ -129,6 +129,7 @@ class BinaryWriter { Index GetLocalIndex(const Func* func, const Var& var); Index GetSymbolIndex(RelocType reloc_type, Index index); void AddReloc(RelocType reloc_type, Index index); + void WriteBlockDecl(const BlockDeclaration& decl); void WriteU32Leb128WithReloc(Index index, const char* desc, RelocType reloc_type); @@ -224,16 +225,20 @@ Offset BinaryWriter::WriteFixupU32Leb128Size(Offset offset, } } -static void write_inline_signature_type(Stream* stream, - const BlockSignature& sig) { - if (sig.size() == 0) { - WriteType(stream, Type::Void); - } else if (sig.size() == 1) { - WriteType(stream, sig[0]); - } else { - /* this is currently unrepresentable */ - stream->WriteU8(0xff, "INVALID INLINE SIGNATURE"); +void BinaryWriter::WriteBlockDecl(const BlockDeclaration& decl) { + if (decl.sig.GetNumParams() == 0 && decl.sig.GetNumResults() <= 1) { + if (decl.sig.GetNumResults() == 0) { + WriteType(stream_, Type::Void); + } else if (decl.sig.GetNumResults() == 1) { + WriteType(stream_, decl.sig.GetResultType(0)); + } + return; } + + Index index = decl.has_func_type ? module_->GetFuncTypeIndex(decl.type_var) + : module_->GetFuncTypeIndex(decl.sig); + assert(index != kInvalidIndex); + WriteS32Leb128(stream_, index, "block type function index"); } void BinaryWriter::WriteSectionHeader(const char* desc, @@ -400,7 +405,7 @@ void BinaryWriter::WriteExpr(const Func* func, const Expr* expr) { break; case ExprType::Block: WriteOpcode(stream_, Opcode::Block); - write_inline_signature_type(stream_, cast<BlockExpr>(expr)->block.sig); + WriteBlockDecl(cast<BlockExpr>(expr)->block.decl); WriteExprList(func, cast<BlockExpr>(expr)->block.exprs); WriteOpcode(stream_, Opcode::End); break; @@ -495,7 +500,7 @@ void BinaryWriter::WriteExpr(const Func* func, const Expr* expr) { case ExprType::If: { auto* if_expr = cast<IfExpr>(expr); WriteOpcode(stream_, Opcode::If); - write_inline_signature_type(stream_, if_expr->true_.sig); + WriteBlockDecl(if_expr->true_.decl); WriteExprList(func, if_expr->true_.exprs); if (!if_expr->false_.empty()) { WriteOpcode(stream_, Opcode::Else); @@ -507,7 +512,7 @@ void BinaryWriter::WriteExpr(const Func* func, const Expr* expr) { case ExprType::IfExcept: { auto* if_except_expr = cast<IfExceptExpr>(expr); WriteOpcode(stream_, Opcode::IfExcept); - write_inline_signature_type(stream_, if_except_expr->true_.sig); + WriteBlockDecl(if_except_expr->true_.decl); Index index = module_->GetExceptIndex(if_except_expr->except_var); WriteU32Leb128(stream_, index, "exception index"); WriteExprList(func, if_except_expr->true_.exprs); @@ -523,7 +528,7 @@ void BinaryWriter::WriteExpr(const Func* func, const Expr* expr) { break; case ExprType::Loop: WriteOpcode(stream_, Opcode::Loop); - write_inline_signature_type(stream_, cast<LoopExpr>(expr)->block.sig); + WriteBlockDecl(cast<LoopExpr>(expr)->block.decl); WriteExprList(func, cast<LoopExpr>(expr)->block.exprs); WriteOpcode(stream_, Opcode::End); break; @@ -576,7 +581,7 @@ void BinaryWriter::WriteExpr(const Func* func, const Expr* expr) { case ExprType::Try: { auto* try_expr = cast<TryExpr>(expr); WriteOpcode(stream_, Opcode::Try); - write_inline_signature_type(stream_, try_expr->block.sig); + WriteBlockDecl(try_expr->block.decl); WriteExprList(func, try_expr->block.exprs); WriteOpcode(stream_, Opcode::Catch); WriteExprList(func, try_expr->catch_); diff --git a/src/c-writer.cc b/src/c-writer.cc index 4039e6f9..0c969d52 100644 --- a/src/c-writer.cc +++ b/src/c-writer.cc @@ -39,7 +39,7 @@ namespace { struct Label { Label(LabelType label_type, const std::string& name, - const BlockSignature& sig, + const TypeVector& sig, size_t type_stack_size, bool used = false) : label_type(label_type), @@ -54,7 +54,7 @@ struct Label { LabelType label_type; const std::string& name; - const BlockSignature& sig; + const TypeVector& sig; size_t type_stack_size; bool used = false; }; @@ -152,7 +152,7 @@ class CWriter { void PushLabel(LabelType, const std::string& name, - const BlockSignature&, + const FuncSignature&, bool used = false); const Label* FindLabel(const Var& var); bool IsTopLabelUsed() const; @@ -424,9 +424,16 @@ void CWriter::DropTypes(size_t count) { void CWriter::PushLabel(LabelType label_type, const std::string& name, - const BlockSignature& sig, + const FuncSignature& sig, bool used) { - label_stack_.emplace_back(label_type, name, sig, type_stack_.size(), used); + // TODO(binji): Add multi-value support. + if ((label_type != LabelType::Func && sig.GetNumParams() != 0) || + sig.GetNumResults() > 1) { + UNIMPLEMENTED("multi value support"); + } + + label_stack_.emplace_back(label_type, name, sig.result_types, + type_stack_.size(), used); } const Label* CWriter::FindLabel(const Var& var) { @@ -1284,7 +1291,7 @@ void CWriter::Write(const Func& func) { std::string label = DefineLocalScopeName(kImplicitFuncLabel); ResetTypeStack(0); std::string empty; // Must not be temporary, since address is taken by Label. - PushLabel(LabelType::Func, empty, func.decl.sig.result_types); + PushLabel(LabelType::Func, empty, func.decl.sig); Write(func.exprs, LabelDecl(label)); PopLabel(); ResetTypeStack(0); @@ -1400,11 +1407,11 @@ void CWriter::Write(const ExprList& exprs) { const Block& block = cast<BlockExpr>(&expr)->block; std::string label = DefineLocalScopeName(block.label); size_t mark = MarkTypeStack(); - PushLabel(LabelType::Block, block.label, block.sig); + PushLabel(LabelType::Block, block.label, block.decl.sig); Write(block.exprs, LabelDecl(label)); ResetTypeStack(mark); PopLabel(); - PushTypes(block.sig); + PushTypes(block.decl.sig.result_types); break; } @@ -1525,7 +1532,7 @@ void CWriter::Write(const ExprList& exprs) { DropTypes(1); std::string label = DefineLocalScopeName(if_.true_.label); size_t mark = MarkTypeStack(); - PushLabel(LabelType::If, if_.true_.label, if_.true_.sig); + PushLabel(LabelType::If, if_.true_.label, if_.true_.decl.sig); Write(if_.true_.exprs, CloseBrace()); if (!if_.false_.empty()) { ResetTypeStack(mark); @@ -1534,7 +1541,7 @@ void CWriter::Write(const ExprList& exprs) { ResetTypeStack(mark); Write(Newline(), LabelDecl(label)); PopLabel(); - PushTypes(if_.true_.sig); + PushTypes(if_.true_.decl.sig.result_types); break; } @@ -1548,11 +1555,11 @@ void CWriter::Write(const ExprList& exprs) { Write(DefineLocalScopeName(block.label), ": "); Indent(); size_t mark = MarkTypeStack(); - PushLabel(LabelType::Loop, block.label, block.sig); + PushLabel(LabelType::Loop, block.label, block.decl.sig); Write(Newline(), block.exprs); ResetTypeStack(mark); PopLabel(); - PushTypes(block.sig); + PushTypes(block.decl.sig.result_types); Dedent(); } break; diff --git a/src/common.h b/src/common.h index f4c9f5ef..a77b7afd 100644 --- a/src/common.h +++ b/src/common.h @@ -52,6 +52,10 @@ #define WABT_PRINTF_STRING_VIEW_ARG(x) \ static_cast<int>((x).length()), (x).data() +#define PRItypecode "%s%#x" +#define WABT_PRINTF_TYPE_CODE(x) \ + (static_cast<int32_t>(x) < 0 ? "-" : ""), std::abs(static_cast<int32_t>(x)) + #define WABT_DEFAULT_SNPRINTF_ALLOCA_BUFSIZE 128 #define WABT_SNPRINTF_ALLOCA(buffer, len, format) \ va_list args; \ @@ -200,19 +204,19 @@ struct Location { }; }; -/* matches binary format, do not change */ -enum class Type { - I32 = 0x7F, - I64 = 0x7E, - F32 = 0x7D, - F64 = 0x7C, - V128 = 0x7B, - Anyfunc = 0x70, - Func = 0x60, - Void = 0x40, - ExceptRef = 0x3f, - ___ = Void, /* convenient for the opcode table in opcode.h */ - Any = 0, /* Not actually specified, but useful for type-checking */ +// Matches binary format, do not change. +enum class Type : int32_t { + I32 = -0x01, // 0x7f + I64 = -0x02, // 0x7e + F32 = -0x03, // 0x7d + F64 = -0x04, // 0x7c + V128 = -0x05, // 0x7b + Anyfunc = -0x10, // 0x70 + ExceptRef = -0x18, // 0x68 + Func = -0x20, // 0x60 + Void = -0x40, // 0x40 + ___ = Void, // Convenient for the opcode table in opcode.h + Any = 0, // Not actually specified, but useful for type-checking }; typedef std::vector<Type> TypeVector; @@ -355,10 +359,39 @@ static WABT_INLINE const char* GetTypeName(Type type) { return "void"; case Type::Any: return "any"; + default: + return "<type index>"; } WABT_UNREACHABLE; } +static WABT_INLINE bool IsTypeIndex(Type type) { + return static_cast<int32_t>(type) >= 0; +} + +static WABT_INLINE Index GetTypeIndex(Type type) { + assert(IsTypeIndex(type)); + return static_cast<Index>(type); +} + +static WABT_INLINE TypeVector GetInlineTypeVector(Type type) { + assert(!IsTypeIndex(type)); + switch (type) { + case Type::Void: + return TypeVector(); + + case Type::I32: + case Type::I64: + case Type::F32: + case Type::F64: + case Type::V128: + return TypeVector(&type, &type + 1); + + default: + WABT_UNREACHABLE; + } +} + /* error level */ static WABT_INLINE const char* GetErrorLevelName(ErrorLevel error_level) { diff --git a/src/feature.def b/src/feature.def index a74918e1..0e21fadc 100644 --- a/src/feature.def +++ b/src/feature.def @@ -28,3 +28,4 @@ WABT_FEATURE(sat_float_to_int, "saturating-float-to-int", "Saturating float-to-i WABT_FEATURE(sign_extension, "sign-extension", "Sign-extension operators") WABT_FEATURE(simd, "simd", "SIMD support") WABT_FEATURE(threads, "threads", "Threading support") +WABT_FEATURE(multi_value, "multi-value", "Multi-value") diff --git a/src/interp.cc b/src/interp.cc index 1125247c..bca8de7a 100644 --- a/src/interp.cc +++ b/src/interp.cc @@ -647,10 +647,10 @@ inline Opcode ReadOpcode(const uint8_t** pc) { inline void read_table_entry_at(const uint8_t* pc, IstreamOffset* out_offset, uint32_t* out_drop, - uint8_t* out_keep) { + uint32_t* out_keep) { *out_offset = ReadU32At(pc + WABT_TABLE_ENTRY_OFFSET_OFFSET); *out_drop = ReadU32At(pc + WABT_TABLE_ENTRY_DROP_OFFSET); - *out_keep = ReadU8At(pc + WABT_TABLE_ENTRY_KEEP_OFFSET); + *out_keep = ReadU32At(pc + WABT_TABLE_ENTRY_KEEP_OFFSET); } Memory* Thread::ReadMemory(const uint8_t** pc) { @@ -728,10 +728,9 @@ ValueTypeRep<T> Thread::PopRep() { return GetValue<T>(Pop()); } -void Thread::DropKeep(uint32_t drop_count, uint8_t keep_count) { - assert(keep_count <= 1); - if (keep_count == 1) { - Pick(drop_count + 1) = Top(); +void Thread::DropKeep(uint32_t drop_count, uint32_t keep_count) { + for (uint32_t i = 0; i < keep_count; ++i) { + Pick(drop_count + i + 1) = Pick(i + 1); } value_stack_top_ -= drop_count; } @@ -1474,7 +1473,7 @@ Result Thread::Run(int num_instructions) { const uint8_t* entry = istream + table_offset + key_offset; IstreamOffset new_pc; uint32_t drop_count; - uint8_t keep_count; + uint32_t keep_count; read_table_entry_at(entry, &new_pc, &drop_count, &keep_count); DropKeep(drop_count, keep_count); GOTO(new_pc); @@ -2389,7 +2388,7 @@ Result Thread::Run(int num_instructions) { case Opcode::InterpDropKeep: { uint32_t drop_count = ReadU32(&pc); - uint8_t keep_count = *pc++; + uint32_t keep_count = ReadU32(&pc); DropKeep(drop_count, keep_count); break; } @@ -3610,7 +3609,7 @@ void Thread::Trace(Stream* stream) { case Opcode::InterpDropKeep: stream->Writef("%s $%u $%u\n", opcode.GetName(), ReadU32At(pc), - *(pc + 4)); + ReadU32At(pc + 4)); break; case Opcode::V128Const: { @@ -4366,7 +4365,7 @@ void Environment::Disassemble(Stream* stream, case Opcode::InterpDropKeep: { uint32_t drop = ReadU32(&pc); - uint8_t keep = *pc++; + uint32_t keep = ReadU32(&pc); stream->Writef("%s $%u $%u\n", opcode.GetName(), drop, keep); break; } @@ -4382,7 +4381,7 @@ void Environment::Disassemble(Stream* stream, stream->Writef("%4" PRIzd "| ", pc - istream); IstreamOffset offset; uint32_t drop; - uint8_t keep; + uint32_t keep; read_table_entry_at(pc, &offset, &drop, &keep); stream->Writef(" entry %" PRIindex ": offset: %u drop: %u keep: %u\n", diff --git a/src/interp.h b/src/interp.h index 48863deb..dcbf9385 100644 --- a/src/interp.h +++ b/src/interp.h @@ -85,10 +85,10 @@ static const IstreamOffset kInvalidIstreamOffset = ~0; // struct { // IstreamOffset offset; // uint32_t drop_count; -// uint8_t keep_count; +// uint32_t keep_count; // }; #define WABT_TABLE_ENTRY_SIZE \ - (sizeof(IstreamOffset) + sizeof(uint32_t) + sizeof(uint8_t)) + (sizeof(IstreamOffset) + sizeof(uint32_t) + sizeof(uint32_t)) #define WABT_TABLE_ENTRY_OFFSET_OFFSET 0 #define WABT_TABLE_ENTRY_DROP_OFFSET sizeof(IstreamOffset) #define WABT_TABLE_ENTRY_KEEP_OFFSET (sizeof(IstreamOffset) + sizeof(uint32_t)) @@ -522,7 +522,7 @@ class Thread { template <typename T> ValueTypeRep<T> PopRep(); - void DropKeep(uint32_t drop_count, uint8_t keep_count); + void DropKeep(uint32_t drop_count, uint32_t keep_count); Result PushCall(const uint8_t* pc) WABT_WARN_UNUSED; IstreamOffset PopCall(); @@ -203,17 +203,17 @@ enum class ExprType { const char* GetExprTypeName(ExprType type); -typedef TypeVector BlockSignature; - class Expr; typedef intrusive_list<Expr> ExprList; +typedef FuncDeclaration BlockDeclaration; + struct Block { Block() = default; explicit Block(ExprList exprs) : exprs(std::move(exprs)) {} std::string label; - BlockSignature sig; + BlockDeclaration decl; ExprList exprs; Location end_loc; }; diff --git a/src/type-checker.cc b/src/type-checker.cc index ac9b79ed..a1e0c28f 100644 --- a/src/type-checker.cc +++ b/src/type-checker.cc @@ -21,10 +21,12 @@ namespace wabt { TypeChecker::Label::Label(LabelType label_type, - const TypeVector& sig, + const TypeVector& param_types, + const TypeVector& result_types, size_t limit) : label_type(label_type), - sig(sig), + param_types(param_types), + result_types(result_types), type_stack_limit(limit), unreachable(false) {} @@ -74,8 +76,11 @@ Result TypeChecker::SetUnreachable() { return Result::Ok; } -void TypeChecker::PushLabel(LabelType label_type, const TypeVector& sig) { - label_stack_.emplace_back(label_type, sig, type_stack_.size()); +void TypeChecker::PushLabel(LabelType label_type, + const TypeVector& param_types, + const TypeVector& result_types) { + label_stack_.emplace_back(label_type, param_types, result_types, + type_stack_.size()); } Result TypeChecker::PopLabel() { @@ -109,11 +114,8 @@ Result TypeChecker::DropTypes(size_t drop_count) { Label* label; CHECK_RESULT(TopLabel(&label)); if (label->type_stack_limit + drop_count > type_stack_.size()) { - if (label->unreachable) { - ResetTypeStackToLabel(label); - return Result::Ok; - } - return Result::Error; + ResetTypeStackToLabel(label); + return label->unreachable ? Result::Ok : Result::Error; } type_stack_.erase(type_stack_.end() - drop_count, type_stack_.end()); return Result::Ok; @@ -147,18 +149,18 @@ Result TypeChecker::CheckType(Type actual, Type expected) { : Result::Error; } -Result TypeChecker::CheckSignature(const TypeVector& sig) { +Result TypeChecker::CheckSignature(const TypeVector& sig, const char* desc) { Result result = Result::Ok; for (size_t i = 0; i < sig.size(); ++i) { result |= PeekAndCheckType(sig.size() - i - 1, sig[i]); } + PrintStackIfFailed(result, desc, sig); return result; } Result TypeChecker::PopAndCheckSignature(const TypeVector& sig, const char* desc) { - Result result = CheckSignature(sig); - PrintStackIfFailed(result, desc, sig); + Result result = CheckSignature(sig, desc); result |= DropTypes(sig.size()); return result; } @@ -166,8 +168,7 @@ Result TypeChecker::PopAndCheckSignature(const TypeVector& sig, Result TypeChecker::PopAndCheckCall(const TypeVector& param_types, const TypeVector& result_types, const char* desc) { - Result result = CheckSignature(param_types); - PrintStackIfFailed(result, desc, param_types); + Result result = CheckSignature(param_types, desc); result |= DropTypes(param_types.size()); PushTypes(result_types); return result; @@ -291,10 +292,10 @@ void TypeChecker::PrintStackIfFailed(Result result, PrintError("%s", message.c_str()); } -Result TypeChecker::BeginFunction(const TypeVector* sig) { +Result TypeChecker::BeginFunction(const TypeVector& sig) { type_stack_.clear(); label_stack_.clear(); - PushLabel(LabelType::Func, *sig); + PushLabel(LabelType::Func, TypeVector(), sig); return Result::Ok; } @@ -326,19 +327,19 @@ Result TypeChecker::OnBinary(Opcode opcode) { return CheckOpcode2(opcode); } -Result TypeChecker::OnBlock(const TypeVector* sig) { - PushLabel(LabelType::Block, *sig); - return Result::Ok; +Result TypeChecker::OnBlock(const TypeVector& param_types, + const TypeVector& result_types) { + Result result = PopAndCheckSignature(param_types, "block"); + PushLabel(LabelType::Block, param_types, result_types); + PushTypes(param_types); + return result; } Result TypeChecker::OnBr(Index depth) { Result result = Result::Ok; Label* label; CHECK_RESULT(GetLabel(depth, &label)); - if (label->label_type != LabelType::Loop) { - result |= CheckSignature(label->sig); - } - PrintStackIfFailed(result, "br", label->sig); + result |= CheckSignature(label->br_types(), "br"); CHECK_RESULT(SetUnreachable()); return result; } @@ -347,15 +348,13 @@ Result TypeChecker::OnBrIf(Index depth) { Result result = PopAndCheck1Type(Type::I32, "br_if"); Label* label; CHECK_RESULT(GetLabel(depth, &label)); - if (label->label_type != LabelType::Loop) { - result |= PopAndCheckSignature(label->sig, "br_if"); - PushTypes(label->sig); - } + result |= PopAndCheckSignature(label->br_types(), "br_if"); + PushTypes(label->br_types()); return result; } Result TypeChecker::BeginBrTable() { - br_table_sig_ = Type::Any; + br_table_sig_ = nullptr; return PopAndCheck1Type(Type::I32, "br_table"); } @@ -363,25 +362,20 @@ Result TypeChecker::OnBrTableTarget(Index depth) { Result result = Result::Ok; Label* label; CHECK_RESULT(GetLabel(depth, &label)); - Type label_sig; - if (label->label_type == LabelType::Loop) { - label_sig = Type::Void; - } else { - assert(label->sig.size() <= 1); - label_sig = label->sig.size() == 0 ? Type::Void : label->sig[0]; - - result |= CheckSignature(label->sig); - PrintStackIfFailed(result, "br_table", label_sig); - } + TypeVector& label_sig = label->br_types(); + result |= CheckSignature(label_sig, "br_table"); // Make sure this label's signature is consistent with the previous labels' // signatures. - if (Failed(CheckType(br_table_sig_, label_sig))) { + if (br_table_sig_ == nullptr) { + br_table_sig_ = &label_sig; + } + if (*br_table_sig_ != label_sig) { result |= Result::Error; PrintError("br_table labels have inconsistent types: expected %s, got %s", - GetTypeName(br_table_sig_), GetTypeName(label_sig)); + TypesToString(*br_table_sig_).c_str(), + TypesToString(label_sig).c_str()); } - br_table_sig_ = label_sig; return result; } @@ -390,15 +384,15 @@ Result TypeChecker::EndBrTable() { return SetUnreachable(); } -Result TypeChecker::OnCall(const TypeVector* param_types, - const TypeVector* result_types) { - return PopAndCheckCall(*param_types, *result_types, "call"); +Result TypeChecker::OnCall(const TypeVector& param_types, + const TypeVector& result_types) { + return PopAndCheckCall(param_types, result_types, "call"); } -Result TypeChecker::OnCallIndirect(const TypeVector* param_types, - const TypeVector* result_types) { +Result TypeChecker::OnCallIndirect(const TypeVector& param_types, + const TypeVector& result_types) { Result result = PopAndCheck1Type(Type::I32, "call_indirect"); - result |= PopAndCheckCall(*param_types, *result_types, "call_indirect"); + result |= PopAndCheckCall(param_types, result_types, "call_indirect"); return result; } @@ -411,7 +405,7 @@ Result TypeChecker::OnCatch() { Label* label; CHECK_RESULT(TopLabel(&label)); result |= CheckLabelType(label, LabelType::Try); - result |= PopAndCheckSignature(label->sig, "try block"); + result |= PopAndCheckSignature(label->result_types, "try block"); result |= CheckTypeStackEnd("try block"); ResetTypeStackToLabel(label); label->label_type = LabelType::Catch; @@ -441,9 +435,10 @@ Result TypeChecker::OnElse() { Label* label; CHECK_RESULT(TopLabel(&label)); result |= CheckLabelType(label, LabelType::If); - result |= PopAndCheckSignature(label->sig, "if true branch"); + result |= PopAndCheckSignature(label->result_types, "if true branch"); result |= CheckTypeStackEnd("if true branch"); ResetTypeStackToLabel(label); + PushTypes(label->param_types); label->label_type = LabelType::Else; label->unreachable = false; return result; @@ -453,10 +448,10 @@ Result TypeChecker::OnEnd(Label* label, const char* sig_desc, const char* end_desc) { Result result = Result::Ok; - result |= PopAndCheckSignature(label->sig, sig_desc); + result |= PopAndCheckSignature(label->result_types, sig_desc); result |= CheckTypeStackEnd(end_desc); ResetTypeStackToLabel(label); - PushTypes(label->sig); + PushTypes(label->result_types); PopLabel(); return result; } @@ -478,8 +473,8 @@ Result TypeChecker::OnEnd() { assert(static_cast<int>(label->label_type) < kLabelTypeCount); if (label->label_type == LabelType::If || label->label_type == LabelType::IfExcept) { - if (label->sig.size() != 0) { - PrintError("if without else cannot have type signature."); + if (label->result_types.size() != 0) { + PrintError("if without else cannot have results."); result = Result::Error; } } @@ -488,17 +483,25 @@ Result TypeChecker::OnEnd() { return result; } -Result TypeChecker::OnIf(const TypeVector* sig) { +Result TypeChecker::OnIf(const TypeVector& param_types, + const TypeVector& result_types) { Result result = PopAndCheck1Type(Type::I32, "if"); - PushLabel(LabelType::If, *sig); + result |= PopAndCheckSignature(param_types, "if"); + PushLabel(LabelType::If, param_types, result_types); + PushTypes(param_types); return result; } -Result TypeChecker::OnIfExcept(const TypeVector* sig, - const TypeVector* except_sig) { +Result TypeChecker::OnIfExcept(const TypeVector& param_types, + const TypeVector& result_types, + const TypeVector& except_sig) { Result result = PopAndCheck1Type(Type::ExceptRef, "if_except"); - PushLabel(LabelType::IfExcept, *sig); - PushTypes(*except_sig); + result |= PopAndCheckSignature(param_types, "if_except"); + PushLabel(LabelType::IfExcept, param_types, result_types); + // TODO(binji): Not quite sure how multi-value and exception proposals are + // meant to interact here. + PushTypes(param_types); + PushTypes(except_sig); return result; } @@ -516,9 +519,12 @@ Result TypeChecker::OnLoad(Opcode opcode) { return CheckOpcode1(opcode); } -Result TypeChecker::OnLoop(const TypeVector* sig) { - PushLabel(LabelType::Loop, *sig); - return Result::Ok; +Result TypeChecker::OnLoop(const TypeVector& param_types, + const TypeVector& result_types) { + Result result = PopAndCheckSignature(param_types, "loop"); + PushLabel(LabelType::Loop, param_types, result_types); + PushTypes(param_types); + return result; } Result TypeChecker::OnMemoryGrow() { @@ -536,9 +542,9 @@ Result TypeChecker::OnRethrow() { return result; } -Result TypeChecker::OnThrow(const TypeVector* sig) { +Result TypeChecker::OnThrow(const TypeVector& sig) { Result result = Result::Ok; - result |= PopAndCheckSignature(*sig, "throw"); + result |= PopAndCheckSignature(sig, "throw"); CHECK_RESULT(SetUnreachable()); return result; } @@ -547,7 +553,7 @@ Result TypeChecker::OnReturn() { Result result = Result::Ok; Label* func_label; CHECK_RESULT(GetLabel(label_stack_.size() - 1, &func_label)); - result |= PopAndCheckSignature(func_label->sig, "return"); + result |= PopAndCheckSignature(func_label->result_types, "return"); CHECK_RESULT(SetUnreachable()); return result; } @@ -576,9 +582,12 @@ Result TypeChecker::OnStore(Opcode opcode) { return CheckOpcode2(opcode); } -Result TypeChecker::OnTry(const TypeVector* sig) { - PushLabel(LabelType::Try, *sig); - return Result::Ok; +Result TypeChecker::OnTry(const TypeVector& param_types, + const TypeVector& result_types) { + Result result = PopAndCheckSignature(param_types, "try"); + PushLabel(LabelType::Try, param_types, result_types); + PushTypes(param_types); + return result; } Result TypeChecker::OnTeeLocal(Type type) { diff --git a/src/type-checker.h b/src/type-checker.h index edd45d07..e142ce1c 100644 --- a/src/type-checker.h +++ b/src/type-checker.h @@ -30,10 +30,18 @@ class TypeChecker { typedef std::function<void(const char* msg)> ErrorCallback; struct Label { - Label(LabelType, const TypeVector& sig, size_t limit); + Label(LabelType, + const TypeVector& param_types, + const TypeVector& result_types, + size_t limit); + + TypeVector& br_types() { + return label_type == LabelType::Loop ? param_types : result_types; + } LabelType label_type; - TypeVector sig; + TypeVector param_types; + TypeVector result_types; size_t type_stack_limit; bool unreachable; }; @@ -50,7 +58,7 @@ class TypeChecker { bool IsUnreachable(); Result GetLabel(Index depth, Label** out_label); - Result BeginFunction(const TypeVector* sig); + Result BeginFunction(const TypeVector& sig); Result OnAtomicLoad(Opcode); Result OnAtomicStore(Opcode); Result OnAtomicRmw(Opcode); @@ -58,15 +66,15 @@ class TypeChecker { Result OnAtomicWait(Opcode); Result OnAtomicWake(Opcode); Result OnBinary(Opcode); - Result OnBlock(const TypeVector* sig); + Result OnBlock(const TypeVector& param_types, const TypeVector& result_types); Result OnBr(Index depth); Result OnBrIf(Index depth); Result BeginBrTable(); Result OnBrTableTarget(Index depth); Result EndBrTable(); - Result OnCall(const TypeVector* param_types, const TypeVector* result_types); - Result OnCallIndirect(const TypeVector* param_types, - const TypeVector* result_types); + Result OnCall(const TypeVector& param_types, const TypeVector& result_types); + Result OnCallIndirect(const TypeVector& param_types, + const TypeVector& result_types); Result OnCatch(); Result OnCompare(Opcode); Result OnConst(Type); @@ -76,10 +84,12 @@ class TypeChecker { Result OnEnd(); Result OnGetGlobal(Type); Result OnGetLocal(Type); - Result OnIf(const TypeVector* sig); - Result OnIfExcept(const TypeVector* sig, const TypeVector* except_sig); + Result OnIf(const TypeVector& param_types, const TypeVector& result_types); + Result OnIfExcept(const TypeVector& param_types, + const TypeVector& result_types, + const TypeVector& except_sig); Result OnLoad(Opcode); - Result OnLoop(const TypeVector* sig); + Result OnLoop(const TypeVector& param_types, const TypeVector& result_types); Result OnMemoryGrow(); Result OnMemorySize(); Result OnRethrow(); @@ -92,8 +102,8 @@ class TypeChecker { Result OnStore(Opcode); Result OnTeeLocal(Type); Result OnTernary(Opcode); - Result OnThrow(const TypeVector* sig); - Result OnTry(const TypeVector* sig); + Result OnThrow(const TypeVector& sig); + Result OnTry(const TypeVector& param_types, const TypeVector& result_types); Result OnUnary(Opcode); Result OnUnreachable(); Result EndFunction(); @@ -103,7 +113,9 @@ class TypeChecker { Result TopLabel(Label** out_label); void ResetTypeStackToLabel(Label* label); Result SetUnreachable(); - void PushLabel(LabelType label_type, const TypeVector& sig); + void PushLabel(LabelType label_type, + const TypeVector& param_types, + const TypeVector& result_types); Result PopLabel(); Result CheckLabelType(Label* label, LabelType label_type); Result PeekType(Index depth, Type* out_type); @@ -113,7 +125,7 @@ class TypeChecker { void PushTypes(const TypeVector& types); Result CheckTypeStackEnd(const char* desc); Result CheckType(Type actual, Type expected); - Result CheckSignature(const TypeVector& sig); + Result CheckSignature(const TypeVector& sig, const char* desc); Result PopAndCheckSignature(const TypeVector& sig, const char* desc); Result PopAndCheckCall(const TypeVector& param_types, const TypeVector& result_types, @@ -143,9 +155,9 @@ class TypeChecker { ErrorCallback error_callback_; TypeVector type_stack_; std::vector<Label> label_stack_; - // TODO(binji): This will need to be complete signature when signatures with - // multiple types are allowed. - Type br_table_sig_ = Type::Void; + // Cache the expected br_table signature. It will be initialized to `nullptr` + // to represent "any". + TypeVector* br_table_sig_ = nullptr; }; } // namespace wabt diff --git a/src/validator.cc b/src/validator.cc index e505855c..880caca9 100644 --- a/src/validator.cc +++ b/src/validator.cc @@ -163,9 +163,9 @@ class Validator : public ExprVisitor::Delegate { void CheckExprList(const Location* loc, const ExprList& exprs); bool CheckHasMemory(const Location* loc, Opcode opcode); void CheckHasSharedMemory(const Location* loc, Opcode opcode); - void CheckBlockSig(const Location* loc, - Opcode opcode, - const BlockSignature* sig); + void CheckBlockDeclaration(const Location* loc, + Opcode opcode, + const BlockDeclaration* decl); template <typename T> void CheckAtomicExpr(const T* expr, Result (TypeChecker::*func)(Opcode)); void CheckFuncSignature(const Location* loc, const FuncDeclaration& decl); @@ -488,14 +488,27 @@ void Validator::CheckHasSharedMemory(const Location* loc, Opcode opcode) { } } -void Validator::CheckBlockSig(const Location* loc, - Opcode opcode, - const BlockSignature* sig) { - if (sig->size() > 1) { - PrintError(loc, - "multiple %s signature result types not currently supported.", +void Validator::CheckBlockDeclaration(const Location* loc, + Opcode opcode, + const BlockDeclaration* decl) { + if (decl->sig.GetNumParams() > 0 && + !options_->features.multi_value_enabled()) { + PrintError(loc, "%s params not currently supported.", opcode.GetName()); + } + if (decl->sig.GetNumResults() > 1 && + !options_->features.multi_value_enabled()) { + PrintError(loc, "multiple %s results not currently supported.", opcode.GetName()); } + if (decl->has_func_type) { + const FuncType* func_type; + if (Succeeded(CheckFuncTypeVar(&decl->type_var, &func_type))) { + CheckTypes(loc, decl->sig.result_types, func_type->sig.result_types, + opcode.GetName(), "result"); + CheckTypes(loc, decl->sig.param_types, func_type->sig.param_types, + opcode.GetName(), "argument"); + } + } } template <typename T> @@ -515,8 +528,9 @@ Result Validator::OnBinaryExpr(BinaryExpr* expr) { Result Validator::BeginBlockExpr(BlockExpr* expr) { expr_loc_ = &expr->loc; - CheckBlockSig(&expr->loc, Opcode::Block, &expr->block.sig); - typechecker_.OnBlock(&expr->block.sig); + CheckBlockDeclaration(&expr->loc, Opcode::Block, &expr->block.decl); + typechecker_.OnBlock(expr->block.decl.sig.param_types, + expr->block.decl.sig.result_types); return Result::Ok; } @@ -553,8 +567,8 @@ Result Validator::OnCallExpr(CallExpr* expr) { expr_loc_ = &expr->loc; const Func* callee; if (Succeeded(CheckFuncVar(&expr->var, &callee))) { - typechecker_.OnCall(&callee->decl.sig.param_types, - &callee->decl.sig.result_types); + typechecker_.OnCall(callee->decl.sig.param_types, + callee->decl.sig.result_types); } return Result::Ok; } @@ -568,8 +582,8 @@ Result Validator::OnCallIndirectExpr(CallIndirectExpr* expr) { const FuncType* func_type; CheckFuncTypeVar(&expr->decl.type_var, &func_type); } - typechecker_.OnCallIndirect(&expr->decl.sig.param_types, - &expr->decl.sig.result_types); + typechecker_.OnCallIndirect(expr->decl.sig.param_types, + expr->decl.sig.result_types); return Result::Ok; } @@ -611,8 +625,9 @@ Result Validator::OnGetLocalExpr(GetLocalExpr* expr) { Result Validator::BeginIfExpr(IfExpr* expr) { expr_loc_ = &expr->loc; - CheckBlockSig(&expr->loc, Opcode::If, &expr->true_.sig); - typechecker_.OnIf(&expr->true_.sig); + CheckBlockDeclaration(&expr->loc, Opcode::If, &expr->true_.decl); + typechecker_.OnIf(expr->true_.decl.sig.param_types, + expr->true_.decl.sig.result_types); return Result::Ok; } @@ -632,13 +647,14 @@ Result Validator::EndIfExpr(IfExpr* expr) { Result Validator::BeginIfExceptExpr(IfExceptExpr* expr) { expr_loc_ = &expr->loc; - CheckBlockSig(&expr->loc, Opcode::IfExcept, &expr->true_.sig); + CheckBlockDeclaration(&expr->loc, Opcode::IfExcept, &expr->true_.decl); const Exception* except; TypeVector except_sig; if (Succeeded(CheckExceptVar(&expr->except_var, &except))) { except_sig = except->sig; } - typechecker_.OnIfExcept(&expr->true_.sig, &except_sig); + typechecker_.OnIfExcept(expr->true_.decl.sig.param_types, + expr->true_.decl.sig.result_types, except_sig); return Result::Ok; } @@ -667,8 +683,9 @@ Result Validator::OnLoadExpr(LoadExpr* expr) { Result Validator::BeginLoopExpr(LoopExpr* expr) { expr_loc_ = &expr->loc; - CheckBlockSig(&expr->loc, Opcode::Loop, &expr->block.sig); - typechecker_.OnLoop(&expr->block.sig); + CheckBlockDeclaration(&expr->loc, Opcode::Loop, &expr->block.decl); + typechecker_.OnLoop(expr->block.decl.sig.param_types, + expr->block.decl.sig.result_types); return Result::Ok; } @@ -750,8 +767,9 @@ Result Validator::OnUnreachableExpr(UnreachableExpr* expr) { Result Validator::BeginTryExpr(TryExpr* expr) { expr_loc_ = &expr->loc; - CheckBlockSig(&expr->loc, Opcode::Try, &expr->block.sig); - typechecker_.OnTry(&expr->block.sig); + CheckBlockDeclaration(&expr->loc, Opcode::Try, &expr->block.decl); + typechecker_.OnTry(expr->block.decl.sig.param_types, + expr->block.decl.sig.result_types); return Result::Ok; } @@ -770,7 +788,7 @@ Result Validator::OnThrowExpr(ThrowExpr* expr) { expr_loc_ = &expr->loc; const Exception* except; if (Succeeded(CheckExceptVar(&expr->var, &except))) { - typechecker_.OnThrow(&except->sig); + typechecker_.OnThrow(except->sig); } return Result::Ok; } @@ -851,14 +869,14 @@ void Validator::CheckFuncSignature(const Location* loc, void Validator::CheckFunc(const Location* loc, const Func* func) { current_func_ = func; CheckFuncSignature(loc, func->decl); - if (func->GetNumResults() > 1) { + if (!options_->features.multi_value_enabled() && func->GetNumResults() > 1) { PrintError(loc, "multiple result values not currently supported."); // Don't run any other checks, the won't test the result_type properly. return; } expr_loc_ = loc; - typechecker_.BeginFunction(&func->decl.sig.result_types); + typechecker_.BeginFunction(func->decl.sig.result_types); CheckExprList(loc, func->exprs); typechecker_.EndFunction(); current_func_ = nullptr; diff --git a/src/wast-parser.cc b/src/wast-parser.cc index 6464e657..2e1d1f1d 100644 --- a/src/wast-parser.cc +++ b/src/wast-parser.cc @@ -288,6 +288,37 @@ class ResolveFuncTypesExprVisitorDelegate : public ExprVisitor::DelegateNop { explicit ResolveFuncTypesExprVisitorDelegate(Module* module) : module_(module) {} + void ResolveBlockDeclaration(const Location& loc, BlockDeclaration* decl) { + if (decl->GetNumParams() != 0 || decl->GetNumResults() > 1) { + ResolveFuncType(loc, module_, decl); + } + } + + Result BeginBlockExpr(BlockExpr* expr) override { + ResolveBlockDeclaration(expr->loc, &expr->block.decl); + return Result::Ok; + } + + Result BeginIfExpr(IfExpr* expr) override { + ResolveBlockDeclaration(expr->loc, &expr->true_.decl); + return Result::Ok; + } + + Result BeginIfExceptExpr(IfExceptExpr* expr) override { + ResolveBlockDeclaration(expr->loc, &expr->true_.decl); + return Result::Ok; + } + + Result BeginLoopExpr(LoopExpr* expr) override { + ResolveBlockDeclaration(expr->loc, &expr->block.decl); + return Result::Ok; + } + + Result BeginTryExpr(TryExpr* expr) override { + ResolveBlockDeclaration(expr->loc, &expr->block.decl); + return Result::Ok; + } + Result OnCallIndirectExpr(CallIndirectExpr* expr) override { ResolveFuncType(expr->loc, module_, &expr->decl); return Result::Ok; @@ -1784,9 +1815,20 @@ Result WastParser::ParseEndLabelOpt(const std::string& begin_label) { return Result::Ok; } +Result WastParser::ParseBlockDeclaration(BlockDeclaration* decl) { + WABT_TRACE(ParseBlockDeclaration); + FuncDeclaration func_decl; + CHECK_RESULT(ParseTypeUseOpt(&func_decl)); + CHECK_RESULT(ParseUnboundFuncSignature(&func_decl.sig)); + decl->has_func_type = func_decl.has_func_type; + decl->type_var = func_decl.type_var; + decl->sig = func_decl.sig; + return Result::Ok; +} + Result WastParser::ParseBlock(Block* block) { WABT_TRACE(ParseBlock); - CHECK_RESULT(ParseResultList(&block->sig)); + CHECK_RESULT(ParseBlockDeclaration(&block->decl)); CHECK_RESULT(ParseInstrList(&block->exprs)); block->end_loc = GetLocation(); return Result::Ok; @@ -1805,22 +1847,33 @@ Result WastParser::ParseIfExceptHeader(IfExceptExpr* expr) { // 3. if_except $label $except/<num> ... // 4. if_except (result...) $except/<num> ... // 5. if_except $label (result...) $except/<num> ... + // + // With the multi-value proposal, `block_type` can be (param...) (result...), + // so there are more forms: + // + // 6. if_except (param...) $except/<num> ... + // 7. if_except (param...) (result...) $except/<num> ... + // 8. if_except $label (param...) $except/<num> ... + // 9. if_except $label (param...) (result...) $except/<num> ... + // + // This case is handled by ParseBlockDeclaration, but it means we also need + // to check for the `param` token here. - if (PeekMatchLpar(TokenType::Result)) { - // Case 4. - CHECK_RESULT(ParseResultList(&expr->true_.sig)); + if (PeekMatchLpar(TokenType::Result) || PeekMatchLpar(TokenType::Param)) { + // Cases 4, 6, 7. + CHECK_RESULT(ParseBlockDeclaration(&expr->true_.decl)); CHECK_RESULT(ParseVar(&expr->except_var)); } else if (PeekMatch(TokenType::Nat)) { // Case 1. CHECK_RESULT(ParseVar(&expr->except_var)); } else if (PeekMatch(TokenType::Var)) { - // Cases 2, 3, 5. + // Cases 2, 3, 5, 8, 9. Var var; CHECK_RESULT(ParseVar(&var)); - if (PeekMatchLpar(TokenType::Result)) { - // Case 5. + if (PeekMatchLpar(TokenType::Result) || PeekMatchLpar(TokenType::Param)) { + // Cases 5, 8, 9. expr->true_.label = var.name(); - CHECK_RESULT(ParseResultList(&expr->true_.sig)); + CHECK_RESULT(ParseBlockDeclaration(&expr->true_.decl)); CHECK_RESULT(ParseVar(&expr->except_var)); } else if (ParseVarOpt(&expr->except_var, Var())) { // Case 3. @@ -1893,7 +1946,7 @@ Result WastParser::ParseExpr(ExprList* exprs) { auto expr = MakeUnique<IfExpr>(loc); CHECK_RESULT(ParseLabelOpt(&expr->true_.label)); - CHECK_RESULT(ParseResultList(&expr->true_.sig)); + CHECK_RESULT(ParseBlockDeclaration(&expr->true_.decl)); if (PeekMatchExpr()) { ExprList cond; @@ -1968,7 +2021,7 @@ Result WastParser::ParseExpr(ExprList* exprs) { auto expr = MakeUnique<TryExpr>(loc); CHECK_RESULT(ParseLabelOpt(&expr->block.label)); - CHECK_RESULT(ParseResultList(&expr->block.sig)); + CHECK_RESULT(ParseBlockDeclaration(&expr->block.decl)); CHECK_RESULT(ParseInstrList(&expr->block.exprs)); expr->block.end_loc = GetLocation(); EXPECT(Lpar); diff --git a/src/wast-parser.h b/src/wast-parser.h index bdecdec9..3a9f0413 100644 --- a/src/wast-parser.h +++ b/src/wast-parser.h @@ -162,6 +162,7 @@ class WastParser { Result ParseBlockInstr(std::unique_ptr<Expr>*); Result ParseLabelOpt(std::string*); Result ParseEndLabelOpt(const std::string&); + Result ParseBlockDeclaration(BlockDeclaration*); Result ParseBlock(Block*); Result ParseIfExceptHeader(IfExceptExpr*); Result ParseExprList(ExprList*); diff --git a/src/wat-writer.cc b/src/wat-writer.cc index 2cb38cd8..0987c617 100644 --- a/src/wat-writer.cc +++ b/src/wat-writer.cc @@ -96,12 +96,17 @@ struct ExprTree { struct Label { Label(LabelType label_type, const std::string& name, - const BlockSignature& sig) - : name(name), label_type(label_type), sig(sig) {} + const TypeVector& param_types, + const TypeVector& result_types) + : name(name), + label_type(label_type), + param_types(param_types), + result_types(result_types) {} std::string name; LabelType label_type; - const BlockSignature& sig; // Share with Expr. + TypeVector param_types; + TypeVector result_types; }; class WatWriter { @@ -432,12 +437,14 @@ void WatWriter::WriteBeginBlock(LabelType label_type, if (has_label) { WriteString(block.label, NextChar::Space); } - WriteTypes(block.sig, "result"); + WriteTypes(block.decl.sig.param_types, "param"); + WriteTypes(block.decl.sig.result_types, "result"); if (!has_label) { Writef(" ;; label = @%" PRIindex, GetLabelStackSize()); } WriteNewline(FORCE_NEWLINE); - label_stack_.emplace_back(label_type, block.label, block.sig); + label_stack_.emplace_back(label_type, block.label, block.decl.sig.param_types, + block.decl.sig.result_types); Indent(); } @@ -448,13 +455,16 @@ void WatWriter::WriteBeginIfExceptBlock(const IfExceptExpr* expr) { if (has_label) { WriteString(block.label, NextChar::Space); } - WriteTypes(block.sig, "result"); + WriteTypes(block.decl.sig.param_types, "param"); + WriteTypes(block.decl.sig.result_types, "result"); WriteVar(expr->except_var, NextChar::Space); if (!has_label) { Writef(" ;; label = @%" PRIindex, GetLabelStackSize()); } WriteNewline(FORCE_NEWLINE); - label_stack_.emplace_back(LabelType::IfExcept, block.label, block.sig); + label_stack_.emplace_back(LabelType::IfExcept, block.label, + block.decl.sig.param_types, + block.decl.sig.result_types); Indent(); } @@ -905,7 +915,12 @@ Label* WatWriter::GetLabel(const Var& var) { Index WatWriter::GetLabelArity(const Var& var) { Label* label = GetLabel(var); - return label && label->label_type != LabelType::Loop ? label->sig.size() : 0; + if (!label) { + return 0; + } + + return label->label_type == LabelType::Loop ? label->param_types.size() + : label->result_types.size(); } Index WatWriter::GetFuncParamCount(const Var& var) { @@ -934,7 +949,7 @@ void WatWriter::WriteFoldedExpr(const Expr* expr) { break; case ExprType::Block: - PushExpr(expr, 0, cast<BlockExpr>(expr)->block.sig.size()); + PushExpr(expr, 0, cast<BlockExpr>(expr)->block.decl.sig.GetNumResults()); break; case ExprType::Br: @@ -989,15 +1004,16 @@ void WatWriter::WriteFoldedExpr(const Expr* expr) { break; case ExprType::If: - PushExpr(expr, 1, cast<IfExpr>(expr)->true_.sig.size()); + PushExpr(expr, 1, cast<IfExpr>(expr)->true_.decl.sig.GetNumResults()); break; case ExprType::IfExcept: - PushExpr(expr, 1, cast<IfExceptExpr>(expr)->true_.sig.size()); + PushExpr(expr, 1, + cast<IfExceptExpr>(expr)->true_.decl.sig.GetNumResults()); break; case ExprType::Loop: - PushExpr(expr, 0, cast<LoopExpr>(expr)->block.sig.size()); + PushExpr(expr, 0, cast<LoopExpr>(expr)->block.decl.sig.GetNumResults()); break; case ExprType::Nop: @@ -1029,7 +1045,7 @@ void WatWriter::WriteFoldedExpr(const Expr* expr) { } case ExprType::Try: - PushExpr(expr, 0, cast<TryExpr>(expr)->block.sig.size()); + PushExpr(expr, 0, cast<TryExpr>(expr)->block.decl.sig.GetNumResults()); break; case ExprType::Ternary: @@ -1292,7 +1308,7 @@ void WatWriter::WriteFunc(const Func& func) { } WriteNewline(NO_FORCE_NEWLINE); label_stack_.clear(); - label_stack_.emplace_back(LabelType::Func, std::string(), + label_stack_.emplace_back(LabelType::Func, std::string(), TypeVector(), func.decl.sig.result_types); current_func_ = &func; if (options_->fold_exprs) { diff --git a/test/binary/bad-function-param-type.txt b/test/binary/bad-function-param-type.txt index 6c7b1347..6d907177 100644 --- a/test/binary/bad-function-param-type.txt +++ b/test/binary/bad-function-param-type.txt @@ -6,6 +6,6 @@ section(TYPE) { function params[1] void results[0] } (;; STDERR ;;; -000000e: error: expected valid param type (got 0x40) -000000e: error: expected valid param type (got 0x40) +000000e: error: expected valid param type (got -0x40) +000000e: error: expected valid param type (got -0x40) ;;; STDERR ;;) diff --git a/test/binary/bad-function-result-type.txt b/test/binary/bad-function-result-type.txt index 0e0c0253..66f0e381 100644 --- a/test/binary/bad-function-result-type.txt +++ b/test/binary/bad-function-result-type.txt @@ -6,6 +6,6 @@ section(TYPE) { function params[1] i32 results[1] void } (;; STDERR ;;; -0000010: error: expected valid result type: 0x40 -0000010: error: expected valid result type: 0x40 +0000010: error: expected valid result type (got -0x40) +0000010: error: expected valid result type (got -0x40) ;;; STDERR ;;) diff --git a/test/binary/bad-simd-type.txt b/test/binary/bad-simd-type.txt index 0a67847e..ce79b76f 100644 --- a/test/binary/bad-simd-type.txt +++ b/test/binary/bad-simd-type.txt @@ -5,6 +5,6 @@ section(TYPE) { count[1] function params[1] v128 results[0] } (;; STDERR ;;; -000000e: error: expected valid param type (got 0x7b) -000000e: error: expected valid param type (got 0x7b) +000000e: error: expected valid param type (got -0x5) +000000e: error: expected valid param type (got -0x5) ;;; STDERR ;;) diff --git a/test/binary/bad-type-form.txt b/test/binary/bad-type-form.txt index 2af41b5c..39ba7e34 100644 --- a/test/binary/bad-type-form.txt +++ b/test/binary/bad-type-form.txt @@ -6,6 +6,6 @@ section(TYPE) { 0x20 } (;; STDERR ;;; -000000c: error: unexpected type form: 32 -000000c: error: unexpected type form: 32 +000000c: error: unexpected type form (got 0x20) +000000c: error: unexpected type form (got 0x20) ;;; STDERR ;;) diff --git a/test/dump/block-multi.txt b/test/dump/block-multi.txt new file mode 100644 index 00000000..67ee2ba3 --- /dev/null +++ b/test/dump/block-multi.txt @@ -0,0 +1,93 @@ +;;; TOOL: run-objdump +;;; ARGS0: -v --enable-multi-value +(module + (func + block (result i32 i32) + i32.const 1 + i32.const 2 + end + return) + + (func + i32.const 0 + block (param i32) + drop + end)) +(;; STDOUT ;;; +0000000: 0061 736d ; WASM_BINARY_MAGIC +0000004: 0100 0000 ; WASM_BINARY_VERSION +; section "Type" (1) +0000008: 01 ; section code +0000009: 00 ; section size (guess) +000000a: 03 ; num types +; type 0 +000000b: 60 ; func +000000c: 00 ; num params +000000d: 00 ; num results +; type 1 +000000e: 60 ; func +000000f: 00 ; num params +0000010: 02 ; num results +0000011: 7f ; i32 +0000012: 7f ; i32 +; type 2 +0000013: 60 ; func +0000014: 01 ; num params +0000015: 7f ; i32 +0000016: 00 ; num results +0000009: 0d ; FIXUP section size +; section "Function" (3) +0000017: 03 ; section code +0000018: 00 ; section size (guess) +0000019: 02 ; num functions +000001a: 00 ; function 0 signature index +000001b: 00 ; function 1 signature index +0000018: 03 ; FIXUP section size +; section "Code" (10) +000001c: 0a ; section code +000001d: 00 ; section size (guess) +000001e: 02 ; num functions +; function body 0 +000001f: 00 ; func body size (guess) +0000020: 00 ; local decl count +0000021: 02 ; block +0000022: 01 ; block type function index +0000023: 41 ; i32.const +0000024: 01 ; i32 literal +0000025: 41 ; i32.const +0000026: 02 ; i32 literal +0000027: 0b ; end +0000028: 0f ; return +0000029: 0b ; end +000001f: 0a ; FIXUP func body size +; function body 1 +000002a: 00 ; func body size (guess) +000002b: 00 ; local decl count +000002c: 41 ; i32.const +000002d: 00 ; i32 literal +000002e: 02 ; block +000002f: 02 ; block type function index +0000030: 1a ; drop +0000031: 0b ; end +0000032: 0b ; end +000002a: 08 ; FIXUP func body size +000001d: 15 ; FIXUP section size + +block-multi.wasm: file format wasm 0x1 + +Code Disassembly: + +00001f func[0]: + 000021: 02 01 | block type[1] + 000023: 41 01 | i32.const 1 + 000025: 41 02 | i32.const 2 + 000027: 0b | end + 000028: 0f | return + 000029: 0b | end +00002a func[1]: + 00002c: 41 00 | i32.const 0 + 00002e: 02 02 | block type[2] + 000030: 1a | drop + 000031: 0b | end + 000032: 0b | end +;;; STDOUT ;;) diff --git a/test/dump/func-result-multi.txt b/test/dump/func-result-multi.txt new file mode 100644 index 00000000..ba246b42 --- /dev/null +++ b/test/dump/func-result-multi.txt @@ -0,0 +1,50 @@ +;;; TOOL: run-objdump +;;; ARGS0: -v --enable-multi-value +(module + (func (result i32 i64) + i32.const 0 + i64.const 0)) +(;; STDOUT ;;; +0000000: 0061 736d ; WASM_BINARY_MAGIC +0000004: 0100 0000 ; WASM_BINARY_VERSION +; section "Type" (1) +0000008: 01 ; section code +0000009: 00 ; section size (guess) +000000a: 01 ; num types +; type 0 +000000b: 60 ; func +000000c: 00 ; num params +000000d: 02 ; num results +000000e: 7f ; i32 +000000f: 7e ; i64 +0000009: 06 ; FIXUP section size +; section "Function" (3) +0000010: 03 ; section code +0000011: 00 ; section size (guess) +0000012: 01 ; num functions +0000013: 00 ; function 0 signature index +0000011: 02 ; FIXUP section size +; section "Code" (10) +0000014: 0a ; section code +0000015: 00 ; section size (guess) +0000016: 01 ; num functions +; function body 0 +0000017: 00 ; func body size (guess) +0000018: 00 ; local decl count +0000019: 41 ; i32.const +000001a: 00 ; i32 literal +000001b: 42 ; i64.const +000001c: 00 ; i64 literal +000001d: 0b ; end +0000017: 06 ; FIXUP func body size +0000015: 08 ; FIXUP section size + +func-result-multi.wasm: file format wasm 0x1 + +Code Disassembly: + +000017 func[0]: + 000019: 41 00 | i32.const 0 + 00001b: 42 00 | i64.const 0 + 00001d: 0b | end +;;; STDOUT ;;) diff --git a/test/dump/if-multi.txt b/test/dump/if-multi.txt new file mode 100644 index 00000000..e989039e --- /dev/null +++ b/test/dump/if-multi.txt @@ -0,0 +1,118 @@ +;;; TOOL: run-objdump +;;; ARGS0: -v --enable-multi-value +(module + (func + i32.const 0 + if (result i32 f32) + i32.const 1 + f32.const 2 + else + i32.const 3 + f32.const 4 + end + return) + + (func + f32.const 0 + i32.const 1 + if (param f32) + drop + else + drop + end)) +(;; STDOUT ;;; +0000000: 0061 736d ; WASM_BINARY_MAGIC +0000004: 0100 0000 ; WASM_BINARY_VERSION +; section "Type" (1) +0000008: 01 ; section code +0000009: 00 ; section size (guess) +000000a: 03 ; num types +; type 0 +000000b: 60 ; func +000000c: 00 ; num params +000000d: 00 ; num results +; type 1 +000000e: 60 ; func +000000f: 00 ; num params +0000010: 02 ; num results +0000011: 7f ; i32 +0000012: 7d ; f32 +; type 2 +0000013: 60 ; func +0000014: 01 ; num params +0000015: 7d ; f32 +0000016: 00 ; num results +0000009: 0d ; FIXUP section size +; section "Function" (3) +0000017: 03 ; section code +0000018: 00 ; section size (guess) +0000019: 02 ; num functions +000001a: 00 ; function 0 signature index +000001b: 00 ; function 1 signature index +0000018: 03 ; FIXUP section size +; section "Code" (10) +000001c: 0a ; section code +000001d: 00 ; section size (guess) +000001e: 02 ; num functions +; function body 0 +000001f: 00 ; func body size (guess) +0000020: 00 ; local decl count +0000021: 41 ; i32.const +0000022: 00 ; i32 literal +0000023: 04 ; if +0000024: 01 ; block type function index +0000025: 41 ; i32.const +0000026: 01 ; i32 literal +0000027: 43 ; f32.const +0000028: 0000 0040 ; f32 literal +000002c: 05 ; else +000002d: 41 ; i32.const +000002e: 03 ; i32 literal +000002f: 43 ; f32.const +0000030: 0000 8040 ; f32 literal +0000034: 0b ; end +0000035: 0f ; return +0000036: 0b ; end +000001f: 17 ; FIXUP func body size +; function body 1 +0000037: 00 ; func body size (guess) +0000038: 00 ; local decl count +0000039: 43 ; f32.const +000003a: 0000 0000 ; f32 literal +000003e: 41 ; i32.const +000003f: 01 ; i32 literal +0000040: 04 ; if +0000041: 02 ; block type function index +0000042: 1a ; drop +0000043: 05 ; else +0000044: 1a ; drop +0000045: 0b ; end +0000046: 0b ; end +0000037: 0f ; FIXUP func body size +000001d: 29 ; FIXUP section size + +if-multi.wasm: file format wasm 0x1 + +Code Disassembly: + +00001f func[0]: + 000021: 41 00 | i32.const 0 + 000023: 04 01 | if type[1] + 000025: 41 01 | i32.const 1 + 000027: 43 00 00 00 40 | f32.const 0x1p+1 + 00002c: 05 | else + 00002d: 41 03 | i32.const 3 + 00002f: 43 00 00 80 40 | f32.const 0x1p+2 + 000034: 0b | end + 000035: 0f | return + 000036: 0b | end +000037 func[1]: + 000039: 43 00 00 00 00 | f32.const 0x0p+0 + 00003e: 41 01 | i32.const 1 + 000040: 04 02 | if type[2] + 000042: 1a | drop + 000043: 05 | else + 000044: 1a | drop + 000045: 0b | end + 000046: 0b | end +;;; STDOUT ;;) diff --git a/test/dump/if_except-multi.txt b/test/dump/if_except-multi.txt new file mode 100644 index 00000000..879ce835 --- /dev/null +++ b/test/dump/if_except-multi.txt @@ -0,0 +1,93 @@ +;;; TOOL: run-objdump +;;; ARGS0: -v --enable-multi-value --enable-exceptions +(module + (except $e i32 i64) + + (func + try + nop + catch + if_except (result i32 i64) $e + else + i32.const 1 + i64.const 2 + end + return + end)) +(;; STDOUT ;;; +0000000: 0061 736d ; WASM_BINARY_MAGIC +0000004: 0100 0000 ; WASM_BINARY_VERSION +; section "Type" (1) +0000008: 01 ; section code +0000009: 00 ; section size (guess) +000000a: 02 ; num types +; type 0 +000000b: 60 ; func +000000c: 00 ; num params +000000d: 00 ; num results +; type 1 +000000e: 60 ; func +000000f: 00 ; num params +0000010: 02 ; num results +0000011: 7f ; i32 +0000012: 7e ; i64 +0000009: 09 ; FIXUP section size +; section "Function" (3) +0000013: 03 ; section code +0000014: 00 ; section size (guess) +0000015: 01 ; num functions +0000016: 00 ; function 0 signature index +0000014: 02 ; FIXUP section size +; section "exception" +0000017: 00 ; section code +0000018: 00 ; section size (guess) +0000019: 09 ; string length +000001a: 6578 6365 7074 696f 6e exception ; custom section name +0000023: 01 ; exception count +0000024: 02 ; exception type count +0000025: 7f ; i32 +0000026: 7e ; i64 +0000018: 0e ; FIXUP section size +; section "Code" (10) +0000027: 0a ; section code +0000028: 00 ; section size (guess) +0000029: 01 ; num functions +; function body 0 +000002a: 00 ; func body size (guess) +000002b: 00 ; local decl count +000002c: 06 ; try +000002d: 40 ; void +000002e: 01 ; nop +000002f: 07 ; catch +0000030: 0a ; if_except +0000031: 01 ; block type function index +0000032: 00 ; exception index +0000033: 05 ; else +0000034: 41 ; i32.const +0000035: 01 ; i32 literal +0000036: 42 ; i64.const +0000037: 02 ; i64 literal +0000038: 0b ; end +0000039: 0f ; return +000003a: 0b ; end +000003b: 0b ; end +000002a: 11 ; FIXUP func body size +0000028: 13 ; FIXUP section size + +if_except-multi.wasm: file format wasm 0x1 + +Code Disassembly: + +00002a func[0]: + 00002c: 06 40 | try + 00002e: 01 | nop + 00002f: 07 | catch + 000030: 0a 01 00 | if_except type[1] 0 + 000033: 05 | else + 000034: 41 01 | i32.const 1 + 000036: 42 02 | i64.const 2 + 000038: 0b | end + 000039: 0f | return + 00003a: 0b | end + 00003b: 0b | end +;;; STDOUT ;;) diff --git a/test/dump/loop-multi.txt b/test/dump/loop-multi.txt new file mode 100644 index 00000000..c45b1790 --- /dev/null +++ b/test/dump/loop-multi.txt @@ -0,0 +1,93 @@ +;;; TOOL: run-objdump +;;; ARGS0: -v --enable-multi-value +(module + (func + loop (result i32 i32) + i32.const 1 + i32.const 2 + end + return) + + (func + i32.const 0 + loop (param i32) + drop + end)) +(;; STDOUT ;;; +0000000: 0061 736d ; WASM_BINARY_MAGIC +0000004: 0100 0000 ; WASM_BINARY_VERSION +; section "Type" (1) +0000008: 01 ; section code +0000009: 00 ; section size (guess) +000000a: 03 ; num types +; type 0 +000000b: 60 ; func +000000c: 00 ; num params +000000d: 00 ; num results +; type 1 +000000e: 60 ; func +000000f: 00 ; num params +0000010: 02 ; num results +0000011: 7f ; i32 +0000012: 7f ; i32 +; type 2 +0000013: 60 ; func +0000014: 01 ; num params +0000015: 7f ; i32 +0000016: 00 ; num results +0000009: 0d ; FIXUP section size +; section "Function" (3) +0000017: 03 ; section code +0000018: 00 ; section size (guess) +0000019: 02 ; num functions +000001a: 00 ; function 0 signature index +000001b: 00 ; function 1 signature index +0000018: 03 ; FIXUP section size +; section "Code" (10) +000001c: 0a ; section code +000001d: 00 ; section size (guess) +000001e: 02 ; num functions +; function body 0 +000001f: 00 ; func body size (guess) +0000020: 00 ; local decl count +0000021: 03 ; loop +0000022: 01 ; block type function index +0000023: 41 ; i32.const +0000024: 01 ; i32 literal +0000025: 41 ; i32.const +0000026: 02 ; i32 literal +0000027: 0b ; end +0000028: 0f ; return +0000029: 0b ; end +000001f: 0a ; FIXUP func body size +; function body 1 +000002a: 00 ; func body size (guess) +000002b: 00 ; local decl count +000002c: 41 ; i32.const +000002d: 00 ; i32 literal +000002e: 03 ; loop +000002f: 02 ; block type function index +0000030: 1a ; drop +0000031: 0b ; end +0000032: 0b ; end +000002a: 08 ; FIXUP func body size +000001d: 15 ; FIXUP section size + +loop-multi.wasm: file format wasm 0x1 + +Code Disassembly: + +00001f func[0]: + 000021: 03 01 | loop type[1] + 000023: 41 01 | i32.const 1 + 000025: 41 02 | i32.const 2 + 000027: 0b | end + 000028: 0f | return + 000029: 0b | end +00002a func[1]: + 00002c: 41 00 | i32.const 0 + 00002e: 03 02 | loop type[2] + 000030: 1a | drop + 000031: 0b | end + 000032: 0b | end +;;; STDOUT ;;) diff --git a/test/dump/try-multi.txt b/test/dump/try-multi.txt new file mode 100644 index 00000000..c8a0ce7a --- /dev/null +++ b/test/dump/try-multi.txt @@ -0,0 +1,113 @@ +;;; TOOL: run-objdump +;;; ARGS0: -v --enable-multi-value --enable-exceptions +(module + (func + try (result i32 i32) + i32.const 1 + i32.const 2 + catch + drop + i32.const 3 + i32.const 4 + end + return) + + (func + i32.const 0 + try (param i32) + drop + catch + drop + end)) +(;; STDOUT ;;; +0000000: 0061 736d ; WASM_BINARY_MAGIC +0000004: 0100 0000 ; WASM_BINARY_VERSION +; section "Type" (1) +0000008: 01 ; section code +0000009: 00 ; section size (guess) +000000a: 03 ; num types +; type 0 +000000b: 60 ; func +000000c: 00 ; num params +000000d: 00 ; num results +; type 1 +000000e: 60 ; func +000000f: 00 ; num params +0000010: 02 ; num results +0000011: 7f ; i32 +0000012: 7f ; i32 +; type 2 +0000013: 60 ; func +0000014: 01 ; num params +0000015: 7f ; i32 +0000016: 00 ; num results +0000009: 0d ; FIXUP section size +; section "Function" (3) +0000017: 03 ; section code +0000018: 00 ; section size (guess) +0000019: 02 ; num functions +000001a: 00 ; function 0 signature index +000001b: 00 ; function 1 signature index +0000018: 03 ; FIXUP section size +; section "Code" (10) +000001c: 0a ; section code +000001d: 00 ; section size (guess) +000001e: 02 ; num functions +; function body 0 +000001f: 00 ; func body size (guess) +0000020: 00 ; local decl count +0000021: 06 ; try +0000022: 01 ; block type function index +0000023: 41 ; i32.const +0000024: 01 ; i32 literal +0000025: 41 ; i32.const +0000026: 02 ; i32 literal +0000027: 07 ; catch +0000028: 1a ; drop +0000029: 41 ; i32.const +000002a: 03 ; i32 literal +000002b: 41 ; i32.const +000002c: 04 ; i32 literal +000002d: 0b ; end +000002e: 0f ; return +000002f: 0b ; end +000001f: 10 ; FIXUP func body size +; function body 1 +0000030: 00 ; func body size (guess) +0000031: 00 ; local decl count +0000032: 41 ; i32.const +0000033: 00 ; i32 literal +0000034: 06 ; try +0000035: 02 ; block type function index +0000036: 1a ; drop +0000037: 07 ; catch +0000038: 1a ; drop +0000039: 0b ; end +000003a: 0b ; end +0000030: 0a ; FIXUP func body size +000001d: 1d ; FIXUP section size + +try-multi.wasm: file format wasm 0x1 + +Code Disassembly: + +00001f func[0]: + 000021: 06 01 | try type[1] + 000023: 41 01 | i32.const 1 + 000025: 41 02 | i32.const 2 + 000027: 07 | catch + 000028: 1a | drop + 000029: 41 03 | i32.const 3 + 00002b: 41 04 | i32.const 4 + 00002d: 0b | end + 00002e: 0f | return + 00002f: 0b | end +000030 func[1]: + 000032: 41 00 | i32.const 0 + 000034: 06 02 | try type[2] + 000036: 1a | drop + 000037: 07 | catch + 000038: 1a | drop + 000039: 0b | end + 00003a: 0b | end +;;; STDOUT ;;) diff --git a/test/help/spectest-interp.txt b/test/help/spectest-interp.txt index 1a4e2dc4..99c032cc 100644 --- a/test/help/spectest-interp.txt +++ b/test/help/spectest-interp.txt @@ -18,6 +18,7 @@ options: --enable-sign-extension Sign-extension operators --enable-simd SIMD support --enable-threads Threading support + --enable-multi-value Multi-value -V, --value-stack-size=SIZE Size in elements of the value stack -C, --call-stack-size=SIZE Size in elements of the call stack -t, --trace Trace execution diff --git a/test/help/wasm-interp.txt b/test/help/wasm-interp.txt index 576c94de..68f51a4c 100644 --- a/test/help/wasm-interp.txt +++ b/test/help/wasm-interp.txt @@ -29,6 +29,7 @@ options: --enable-sign-extension Sign-extension operators --enable-simd SIMD support --enable-threads Threading support + --enable-multi-value Multi-value -V, --value-stack-size=SIZE Size in elements of the value stack -C, --call-stack-size=SIZE Size in elements of the call stack -t, --trace Trace execution diff --git a/test/help/wasm-validate.txt b/test/help/wasm-validate.txt index 0542f976..4b08c2cb 100644 --- a/test/help/wasm-validate.txt +++ b/test/help/wasm-validate.txt @@ -18,6 +18,7 @@ options: --enable-sign-extension Sign-extension operators --enable-simd SIMD support --enable-threads Threading support + --enable-multi-value Multi-value --no-debug-names Ignore debug names in the binary file --ignore-custom-section-errors Ignore errors in custom sections ;;; STDOUT ;;) diff --git a/test/help/wasm2wat.txt b/test/help/wasm2wat.txt index b7308cb0..682f8a74 100644 --- a/test/help/wasm2wat.txt +++ b/test/help/wasm2wat.txt @@ -24,6 +24,7 @@ options: --enable-sign-extension Sign-extension operators --enable-simd SIMD support --enable-threads Threading support + --enable-multi-value Multi-value --inline-exports Write all exports inline --inline-imports Write all imports inline --no-debug-names Ignore debug names in the binary file diff --git a/test/help/wast2json.txt b/test/help/wast2json.txt index a32c9bbd..12992963 100644 --- a/test/help/wast2json.txt +++ b/test/help/wast2json.txt @@ -21,6 +21,7 @@ options: --enable-sign-extension Sign-extension operators --enable-simd SIMD support --enable-threads Threading support + --enable-multi-value Multi-value -o, --output=FILE output wasm binary file -r, --relocatable Create a relocatable wasm binary (suitable for linking with e.g. lld) --no-canonicalize-leb128s Write all LEB128 sizes as 5-bytes instead of their minimal size diff --git a/test/help/wat-desugar.txt b/test/help/wat-desugar.txt index 6a352b0c..6028de9d 100644 --- a/test/help/wat-desugar.txt +++ b/test/help/wat-desugar.txt @@ -26,5 +26,6 @@ options: --enable-sign-extension Sign-extension operators --enable-simd SIMD support --enable-threads Threading support + --enable-multi-value Multi-value --generate-names Give auto-generated names to non-named functions, types, etc. ;;; STDOUT ;;) diff --git a/test/help/wat2wasm.txt b/test/help/wat2wasm.txt index 2f8a6f2f..9c0a6a03 100644 --- a/test/help/wat2wasm.txt +++ b/test/help/wat2wasm.txt @@ -28,6 +28,7 @@ options: --enable-sign-extension Sign-extension operators --enable-simd SIMD support --enable-threads Threading support + --enable-multi-value Multi-value -o, --output=FILE output wasm binary file -r, --relocatable Create a relocatable wasm binary (suitable for linking with e.g. lld) --no-canonicalize-leb128s Write all LEB128 sizes as 5-bytes instead of their minimal size diff --git a/test/interp/basic-tracing.txt b/test/interp/basic-tracing.txt index aeed99b9..c4a75dba 100644 --- a/test/interp/basic-tracing.txt +++ b/test/interp/basic-tracing.txt @@ -21,8 +21,8 @@ call $fib)) (;; STDOUT ;;; >>> running export "main": -#0. 55: V:0 | i32.const $3 -#0. 60: V:1 | call @0 +#0. 58: V:0 | i32.const $3 +#0. 63: V:1 | call @0 #1. 0: V:1 | get_local $1 #1. 5: V:2 | i32.const $1 #1. 10: V:3 | i32.le_s 3, 1 @@ -46,15 +46,15 @@ #3. 16: V:3 | i32.const $1 #3. 21: V:4 | br @48 #3. 48: V:4 | drop_keep $1 $1 -#3. 54: V:3 | return +#3. 57: V:3 | return #2. 42: V:3 | get_local $2 #2. 47: V:4 | i32.mul 1, 2 #2. 48: V:3 | drop_keep $1 $1 -#2. 54: V:2 | return +#2. 57: V:2 | return #1. 42: V:2 | get_local $2 #1. 47: V:3 | i32.mul 2, 3 #1. 48: V:2 | drop_keep $1 $1 -#1. 54: V:1 | return -#0. 65: V:1 | return +#1. 57: V:1 | return +#0. 68: V:1 | return main() => i32:6 ;;; STDOUT ;;) diff --git a/test/interp/block-multi.txt b/test/interp/block-multi.txt new file mode 100644 index 00000000..6d958473 --- /dev/null +++ b/test/interp/block-multi.txt @@ -0,0 +1,35 @@ +;;; TOOL: run-interp +;;; ARGS*: --enable-multi-value +(module + (func (export "block-multi-result") (result i32) + block (result i32 i32) + i32.const 1 + i32.const 2 + end + i32.add + ) + + (func (export "block-multi-result-br") (result i32) + block $b (result i32 i32) + block + i32.const 15 + i32.const 7 + br $b + end + i32.const -1 + i32.const -2 + end + drop) + + (func (export "block-param") (result f32) + i32.const 2 + block (param i32) (result f32) + f32.convert_s/i32 + end + ) +) +(;; STDOUT ;;; +block-multi-result() => i32:3 +block-multi-result-br() => i32:15 +block-param() => f32:2.000000 +;;; STDOUT ;;) diff --git a/test/interp/call-multi-result.txt b/test/interp/call-multi-result.txt new file mode 100644 index 00000000..07623802 --- /dev/null +++ b/test/interp/call-multi-result.txt @@ -0,0 +1,48 @@ +;;; TOOL: run-interp +;;; ARGS*: --enable-multi-value +(module + (func $i32_i64 (result i32 i64) + i32.const 1 + i64.const 2) + + (func (export "call-multi-result") (result i32) + call $i32_i64 + i32.wrap/i64 + i32.add) + + (func $rot_f32_3 (param f32 f32 f32) (result f32 f32 f32) + get_local 1 + get_local 2 + get_local 0) + + (func (export "call-multi-param-result") (result i32) + block $fail + f32.const 11 + f32.const 22 + f32.const 33 + + ;; updates stack: 11 22 33 -- 22 33 11 + call $rot_f32_3 + + f32.const 11 + f32.ne + br_if $fail + + f32.const 33 + f32.ne + br_if $fail + + f32.const 22 + f32.ne + br_if $fail + + i32.const 1 + return + end + + i32.const 0) +) +(;; STDOUT ;;; +call-multi-result() => i32:3 +call-multi-param-result() => i32:1 +;;; STDOUT ;;) diff --git a/test/interp/if-multi.txt b/test/interp/if-multi.txt new file mode 100644 index 00000000..64881b33 --- /dev/null +++ b/test/interp/if-multi.txt @@ -0,0 +1,28 @@ +;;; TOOL: run-interp +;;; ARGS*: --enable-multi-value +(module + (func (export "if-multi-result") (result i32) + i32.const 1 + if (result i32 f32) + i32.const 2 + f32.const 3 + else + unreachable + end + i32.trunc_s/f32 + i32.add) + + (func (export "if-param") (result f32) + f32.const 3 + i32.const 0 + if (param f32) (result f32) + unreachable + else + f32.const 100 + f32.add + end) +) +(;; STDOUT ;;; +if-multi-result() => i32:5 +if-param() => f32:103.000000 +;;; STDOUT ;;) diff --git a/test/interp/logging-all-opcodes.txt b/test/interp/logging-all-opcodes.txt index ac57d6f7..9006a5a7 100644 --- a/test/interp/logging-all-opcodes.txt +++ b/test/interp/logging-all-opcodes.txt @@ -9112,7 +9112,7 @@ BeginModule(version: 1) EndFunctionBody(175) BeginFunctionBody(176) OnLocalDeclCount(0) - OnBlockExpr(sig: [i32]) + OnBlockExpr(sig: i32) OnI32ConstExpr(1 (0x1)) OnI32ConstExpr(2 (0x2)) OnBrExpr(depth: 0) @@ -10569,1780 +10569,1780 @@ EndModule 8| return 9| i32.const $1 14| br_table %[-1], $#0, table:$28 - 23| data $9 - 28| entry 0: offset: 37 drop: 0 keep: 0 - 37| return - 38| return - 39| return - 40| call @0 - 45| return - 46| i32.const $1 - 51| call_indirect $0:0, %[-1] - 60| return - 61| i32.const $1 - 66| drop - 67| return - 68| i32.const $1 - 73| i32.const $2 - 78| i32.const $3 - 83| select %[-3], %[-2], %[-1] - 84| drop - 85| return - 86| alloca $1 - 91| get_local $1 - 96| drop - 97| drop - 98| return - 99| alloca $1 - 104| i32.const $1 - 109| set_local $1, %[-1] - 114| drop - 115| return - 116| alloca $1 - 121| i32.const $1 - 126| tee_local $2, %[-1] - 131| drop - 132| drop - 133| return - 134| get_global $0 - 139| drop - 140| return - 141| i32.const $1 - 146| set_global $0, %[-1] - 151| return - 152| i32.const $1 - 157| i32.load $0:%[-1]+$2 - 166| drop - 167| return - 168| i32.const $1 - 173| i64.load $0:%[-1]+$2 - 182| drop - 183| return - 184| i32.const $1 - 189| f32.load $0:%[-1]+$2 - 198| drop - 199| return - 200| i32.const $1 - 205| f64.load $0:%[-1]+$2 - 214| drop - 215| return - 216| i32.const $1 - 221| i32.load8_s $0:%[-1]+$2 - 230| drop - 231| return - 232| i32.const $1 - 237| i32.load8_u $0:%[-1]+$2 - 246| drop - 247| return - 248| i32.const $1 - 253| i32.load16_s $0:%[-1]+$2 - 262| drop - 263| return - 264| i32.const $1 - 269| i32.load16_u $0:%[-1]+$2 - 278| drop - 279| return - 280| i32.const $1 - 285| i64.load8_s $0:%[-1]+$2 - 294| drop - 295| return - 296| i32.const $1 - 301| i64.load8_u $0:%[-1]+$2 - 310| drop - 311| return - 312| i32.const $1 - 317| i64.load16_s $0:%[-1]+$2 - 326| drop - 327| return - 328| i32.const $1 - 333| i64.load16_u $0:%[-1]+$2 - 342| drop - 343| return - 344| i32.const $1 - 349| i64.load32_s $0:%[-1]+$2 - 358| drop - 359| return - 360| i32.const $1 - 365| i64.load32_u $0:%[-1]+$2 - 374| drop - 375| return - 376| i32.const $1 - 381| i32.const $2 - 386| i32.store $0:%[-2]+$2, %[-1] - 395| return - 396| i32.const $1 - 401| i64.const $2 - 410| i64.store $0:%[-2]+$2, %[-1] - 419| return - 420| i32.const $1 - 425| f32.const $2 - 430| f32.store $0:%[-2]+$2, %[-1] - 439| return - 440| i32.const $1 - 445| f64.const $2 - 454| f64.store $0:%[-2]+$2, %[-1] - 463| return - 464| i32.const $1 - 469| i32.const $2 - 474| i32.store8 $0:%[-2]+$2, %[-1] - 483| return - 484| i32.const $1 - 489| i32.const $2 - 494| i32.store16 $0:%[-2]+$2, %[-1] - 503| return - 504| i32.const $1 - 509| i64.const $2 - 518| i64.store8 $0:%[-2]+$2, %[-1] - 527| return - 528| i32.const $1 - 533| i64.const $2 - 542| i64.store16 $0:%[-2]+$2, %[-1] - 551| return - 552| i32.const $1 - 557| i64.const $2 - 566| i64.store32 $0:%[-2]+$2, %[-1] - 575| return - 576| memory.size $0 - 581| drop - 582| return - 583| i32.const $1 - 588| memory.grow $0:%[-1] - 593| drop - 594| return - 595| i32.const $1 - 600| drop - 601| return - 602| i64.const $1 - 611| drop - 612| return - 613| f32.const $1 - 618| drop - 619| return - 620| f64.const $1 - 629| drop - 630| return - 631| i32.const $1 - 636| i32.eqz %[-1] - 637| drop - 638| return - 639| i32.const $1 - 644| i32.const $2 - 649| i32.eq %[-2], %[-1] - 650| drop - 651| return - 652| i32.const $1 - 657| i32.const $2 - 662| i32.ne %[-2], %[-1] - 663| drop - 664| return - 665| i32.const $1 - 670| i32.const $2 - 675| i32.lt_s %[-2], %[-1] - 676| drop - 677| return - 678| i32.const $1 - 683| i32.const $2 - 688| i32.lt_u %[-2], %[-1] - 689| drop - 690| return - 691| i32.const $1 - 696| i32.const $2 - 701| i32.gt_s %[-2], %[-1] - 702| drop - 703| return - 704| i32.const $1 - 709| i32.const $2 - 714| i32.gt_u %[-2], %[-1] - 715| drop - 716| return - 717| i32.const $1 - 722| i32.const $2 - 727| i32.le_s %[-2], %[-1] - 728| drop - 729| return - 730| i32.const $1 - 735| i32.const $2 - 740| i32.le_u %[-2], %[-1] - 741| drop - 742| return - 743| i32.const $1 - 748| i32.const $2 - 753| i32.ge_s %[-2], %[-1] - 754| drop - 755| return - 756| i32.const $1 - 761| i32.const $2 - 766| i32.ge_u %[-2], %[-1] - 767| drop - 768| return - 769| i64.const $1 - 778| i64.eqz %[-1] - 779| drop - 780| return - 781| i64.const $1 - 790| i64.const $2 - 799| i64.eq %[-2], %[-1] - 800| drop - 801| return - 802| i64.const $1 - 811| i64.const $2 - 820| i64.ne %[-2], %[-1] - 821| drop - 822| return - 823| i64.const $1 - 832| i64.const $2 - 841| i64.lt_s %[-2], %[-1] - 842| drop - 843| return - 844| i64.const $1 - 853| i64.const $2 - 862| i64.lt_u %[-2], %[-1] - 863| drop - 864| return - 865| i64.const $1 - 874| i64.const $2 - 883| i64.gt_s %[-2], %[-1] - 884| drop - 885| return - 886| i64.const $1 - 895| i64.const $2 - 904| i64.gt_u %[-2], %[-1] - 905| drop - 906| return - 907| i64.const $1 - 916| i64.const $2 - 925| i64.le_s %[-2], %[-1] - 926| drop - 927| return - 928| i64.const $1 - 937| i64.const $2 - 946| i64.le_u %[-2], %[-1] - 947| drop - 948| return - 949| i64.const $1 - 958| i64.const $2 - 967| i64.ge_s %[-2], %[-1] - 968| drop - 969| return - 970| i64.const $1 - 979| i64.const $2 - 988| i64.ge_u %[-2], %[-1] - 989| drop - 990| return - 991| f32.const $1 - 996| f32.const $2 -1001| f32.eq %[-2], %[-1] -1002| drop -1003| return -1004| f32.const $1 -1009| f32.const $2 -1014| f32.ne %[-2], %[-1] -1015| drop -1016| return -1017| f32.const $1 -1022| f32.const $2 -1027| f32.lt %[-2], %[-1] -1028| drop -1029| return -1030| f32.const $1 -1035| f32.const $2 -1040| f32.gt %[-2], %[-1] -1041| drop -1042| return -1043| f32.const $1 -1048| f32.const $2 -1053| f32.le %[-2], %[-1] -1054| drop -1055| return -1056| f32.const $1 -1061| f32.const $2 -1066| f32.ge %[-2], %[-1] -1067| drop -1068| return -1069| f64.const $1 -1078| f64.const $2 -1087| f64.eq %[-2], %[-1] -1088| drop -1089| return -1090| f64.const $1 -1099| f64.const $2 -1108| f64.ne %[-2], %[-1] -1109| drop -1110| return -1111| f64.const $1 -1120| f64.const $2 -1129| f64.lt %[-2], %[-1] -1130| drop -1131| return -1132| f64.const $1 -1141| f64.const $2 -1150| f64.gt %[-2], %[-1] -1151| drop -1152| return -1153| f64.const $1 -1162| f64.const $2 -1171| f64.le %[-2], %[-1] -1172| drop -1173| return -1174| f64.const $1 -1183| f64.const $2 -1192| f64.ge %[-2], %[-1] -1193| drop -1194| return -1195| i32.const $1 -1200| i32.clz %[-1] -1201| drop -1202| return -1203| i32.const $1 -1208| i32.ctz %[-1] -1209| drop -1210| return -1211| i32.const $1 -1216| i32.popcnt %[-1] -1217| drop -1218| return -1219| i32.const $1 -1224| i32.const $2 -1229| i32.add %[-2], %[-1] -1230| drop -1231| return -1232| i32.const $1 -1237| i32.const $2 -1242| i32.sub %[-2], %[-1] -1243| drop -1244| return -1245| i32.const $1 -1250| i32.const $2 -1255| i32.mul %[-2], %[-1] -1256| drop -1257| return -1258| i32.const $1 -1263| i32.const $2 -1268| i32.div_s %[-2], %[-1] -1269| drop -1270| return -1271| i32.const $1 -1276| i32.const $2 -1281| i32.div_u %[-2], %[-1] -1282| drop -1283| return -1284| i32.const $1 -1289| i32.const $2 -1294| i32.rem_s %[-2], %[-1] -1295| drop -1296| return -1297| i32.const $1 -1302| i32.const $2 -1307| i32.rem_u %[-2], %[-1] -1308| drop -1309| return -1310| i32.const $1 -1315| i32.const $2 -1320| i32.and %[-2], %[-1] -1321| drop -1322| return -1323| i32.const $1 -1328| i32.const $2 -1333| i32.or %[-2], %[-1] -1334| drop -1335| return -1336| i32.const $1 -1341| i32.const $2 -1346| i32.xor %[-2], %[-1] -1347| drop -1348| return -1349| i32.const $1 -1354| i32.const $2 -1359| i32.shl %[-2], %[-1] -1360| drop -1361| return -1362| i32.const $1 -1367| i32.const $2 -1372| i32.shr_s %[-2], %[-1] -1373| drop -1374| return -1375| i32.const $1 -1380| i32.const $2 -1385| i32.shr_u %[-2], %[-1] -1386| drop -1387| return -1388| i32.const $1 -1393| i32.const $2 -1398| i32.rotl %[-2], %[-1] -1399| drop -1400| return -1401| i32.const $1 -1406| i32.const $2 -1411| i32.rotr %[-2], %[-1] -1412| drop -1413| return -1414| i64.const $1 -1423| i64.clz %[-1] -1424| drop -1425| return -1426| i64.const $1 -1435| i64.ctz %[-1] -1436| drop -1437| return -1438| i64.const $1 -1447| i64.popcnt %[-1] -1448| drop -1449| return -1450| i64.const $1 -1459| i64.const $2 -1468| i64.add %[-2], %[-1] -1469| drop -1470| return -1471| i64.const $1 -1480| i64.const $2 -1489| i64.sub %[-2], %[-1] -1490| drop -1491| return -1492| i64.const $1 -1501| i64.const $2 -1510| i64.mul %[-2], %[-1] -1511| drop -1512| return -1513| i64.const $1 -1522| i64.const $2 -1531| i64.div_s %[-2], %[-1] -1532| drop -1533| return -1534| i64.const $1 -1543| i64.const $2 -1552| i64.div_u %[-2], %[-1] -1553| drop -1554| return -1555| i64.const $1 -1564| i64.const $2 -1573| i64.rem_s %[-2], %[-1] -1574| drop -1575| return -1576| i64.const $1 -1585| i64.const $2 -1594| i64.rem_u %[-2], %[-1] -1595| drop -1596| return -1597| i64.const $1 -1606| i64.const $2 -1615| i64.and %[-2], %[-1] -1616| drop -1617| return -1618| i64.const $1 -1627| i64.const $2 -1636| i64.or %[-2], %[-1] -1637| drop -1638| return -1639| i64.const $1 -1648| i64.const $2 -1657| i64.xor %[-2], %[-1] -1658| drop -1659| return -1660| i64.const $1 -1669| i64.const $2 -1678| i64.shl %[-2], %[-1] -1679| drop -1680| return -1681| i64.const $1 -1690| i64.const $2 -1699| i64.shr_s %[-2], %[-1] -1700| drop -1701| return -1702| i64.const $1 -1711| i64.const $2 -1720| i64.shr_u %[-2], %[-1] -1721| drop -1722| return -1723| i64.const $1 -1732| i64.const $2 -1741| i64.rotl %[-2], %[-1] -1742| drop -1743| return -1744| i64.const $1 -1753| i64.const $2 -1762| i64.rotr %[-2], %[-1] -1763| drop -1764| return -1765| f32.const $1 -1770| f32.abs %[-1] -1771| drop -1772| return -1773| f32.const $1 -1778| f32.neg %[-1] -1779| drop -1780| return -1781| f32.const $1 -1786| f32.ceil %[-1] -1787| drop -1788| return -1789| f32.const $1 -1794| f32.floor %[-1] -1795| drop -1796| return -1797| f32.const $1 -1802| f32.trunc %[-1] -1803| drop -1804| return -1805| f32.const $1 -1810| f32.nearest %[-1] -1811| drop -1812| return -1813| f32.const $1 -1818| f32.sqrt %[-1] -1819| drop -1820| return -1821| f32.const $1 -1826| f32.const $2 -1831| f32.add %[-2], %[-1] -1832| drop -1833| return -1834| f32.const $1 -1839| f32.const $2 -1844| f32.sub %[-2], %[-1] -1845| drop -1846| return -1847| f32.const $1 -1852| f32.const $2 -1857| f32.mul %[-2], %[-1] -1858| drop -1859| return -1860| f32.const $1 -1865| f32.const $2 -1870| f32.div %[-2], %[-1] -1871| drop -1872| return -1873| f32.const $1 -1878| f32.const $2 -1883| f32.min %[-2], %[-1] -1884| drop -1885| return -1886| f32.const $1 -1891| f32.const $2 -1896| f32.max %[-2], %[-1] -1897| drop -1898| return -1899| f32.const $1 -1904| f32.const $2 -1909| f32.copysign %[-2], %[-1] -1910| drop -1911| return -1912| f64.const $1 -1921| f64.abs %[-1] -1922| drop -1923| return -1924| f64.const $1 -1933| f64.neg %[-1] -1934| drop -1935| return -1936| f64.const $1 -1945| f64.ceil %[-1] -1946| drop -1947| return -1948| f64.const $1 -1957| f64.floor %[-1] -1958| drop -1959| return -1960| f64.const $1 -1969| f64.trunc %[-1] -1970| drop -1971| return -1972| f64.const $1 -1981| f64.nearest %[-1] -1982| drop -1983| return -1984| f64.const $1 -1993| f64.sqrt %[-1] -1994| drop -1995| return -1996| f64.const $1 -2005| f64.const $2 -2014| f64.add %[-2], %[-1] -2015| drop -2016| return -2017| f64.const $1 -2026| f64.const $2 -2035| f64.sub %[-2], %[-1] -2036| drop -2037| return -2038| f64.const $1 -2047| f64.const $2 -2056| f64.mul %[-2], %[-1] -2057| drop -2058| return -2059| f64.const $1 -2068| f64.const $2 -2077| f64.div %[-2], %[-1] -2078| drop -2079| return -2080| f64.const $1 -2089| f64.const $2 -2098| f64.min %[-2], %[-1] -2099| drop -2100| return -2101| f64.const $1 -2110| f64.const $2 -2119| f64.max %[-2], %[-1] -2120| drop -2121| return -2122| f64.const $1 -2131| f64.const $2 -2140| f64.copysign %[-2], %[-1] -2141| drop -2142| return -2143| i64.const $1 -2152| i32.wrap/i64 %[-1] -2153| drop -2154| return -2155| f32.const $1 -2160| i32.trunc_s/f32 %[-1] -2161| drop -2162| return -2163| f32.const $1 -2168| i32.trunc_u/f32 %[-1] -2169| drop -2170| return -2171| f64.const $1 -2180| i32.trunc_s/f64 %[-1] -2181| drop -2182| return -2183| f64.const $1 -2192| i32.trunc_u/f64 %[-1] -2193| drop -2194| return -2195| i32.const $1 -2200| i64.extend_s/i32 %[-1] -2201| drop -2202| return -2203| i32.const $1 -2208| i64.extend_u/i32 %[-1] -2209| drop -2210| return -2211| f32.const $1 -2216| i64.trunc_s/f32 %[-1] -2217| drop -2218| return -2219| f32.const $1 -2224| i64.trunc_u/f32 %[-1] -2225| drop -2226| return -2227| f64.const $1 -2236| i64.trunc_s/f64 %[-1] -2237| drop -2238| return -2239| f64.const $1 -2248| i64.trunc_u/f64 %[-1] -2249| drop -2250| return -2251| i32.const $1 -2256| f32.convert_s/i32 %[-1] -2257| drop -2258| return -2259| i32.const $1 -2264| f32.convert_u/i32 %[-1] -2265| drop -2266| return -2267| i64.const $1 -2276| f32.convert_s/i64 %[-1] -2277| drop -2278| return -2279| i64.const $1 -2288| f32.convert_u/i64 %[-1] -2289| drop -2290| return -2291| f64.const $1 -2300| f32.demote/f64 %[-1] -2301| drop -2302| return -2303| i32.const $1 -2308| f64.convert_s/i32 %[-1] -2309| drop -2310| return -2311| i32.const $1 -2316| f64.convert_u/i32 %[-1] -2317| drop -2318| return -2319| i64.const $1 -2328| f64.convert_s/i64 %[-1] -2329| drop -2330| return -2331| i64.const $1 -2340| f64.convert_u/i64 %[-1] -2341| drop -2342| return -2343| f32.const $1 -2348| f64.promote/f32 %[-1] -2349| drop -2350| return -2351| i32.const $1 -2356| f32.reinterpret/i32 %[-1] -2357| drop -2358| return -2359| f32.const $1 -2364| i32.reinterpret/f32 %[-1] -2365| drop -2366| return -2367| i64.const $1 -2376| f64.reinterpret/i64 %[-1] -2377| drop -2378| return -2379| f64.const $1 -2388| i64.reinterpret/f64 %[-1] -2389| drop -2390| return -2391| i32.const $1 -2396| i32.extend8_s %[-1] -2397| drop -2398| return -2399| i32.const $1 -2404| i32.extend16_s %[-1] -2405| drop -2406| return -2407| i64.const $1 -2416| i64.extend8_s %[-1] -2417| drop -2418| return -2419| i64.const $1 -2428| i64.extend16_s %[-1] -2429| drop -2430| return -2431| i64.const $1 -2440| i64.extend32_s %[-1] -2441| drop -2442| return -2443| alloca $1 -2448| drop -2449| return -2450| i32.const $1 -2455| br_unless @2465, %[-1] -2460| br @2465 -2465| return -2466| i32.const $1 -2471| call_host $0 -2476| return -2477| i32.const $1 -2482| br_table %[-1], $#0, table:$2496 -2491| data $9 -2496| entry 0: offset: 2505 drop: 0 keep: 0 -2505| return -2506| i32.const $1 -2511| i32.const $2 -2516| drop_keep $1 $1 -2522| br @2527 -2527| drop -2528| return -2529| f32.const $1 -2534| i32.trunc_s:sat/f32 %[-1] + 23| data $12 + 28| entry 0: offset: 40 drop: 0 keep: 0 + 40| return + 41| return + 42| return + 43| call @0 + 48| return + 49| i32.const $1 + 54| call_indirect $0:0, %[-1] + 63| return + 64| i32.const $1 + 69| drop + 70| return + 71| i32.const $1 + 76| i32.const $2 + 81| i32.const $3 + 86| select %[-3], %[-2], %[-1] + 87| drop + 88| return + 89| alloca $1 + 94| get_local $1 + 99| drop + 100| drop + 101| return + 102| alloca $1 + 107| i32.const $1 + 112| set_local $1, %[-1] + 117| drop + 118| return + 119| alloca $1 + 124| i32.const $1 + 129| tee_local $2, %[-1] + 134| drop + 135| drop + 136| return + 137| get_global $0 + 142| drop + 143| return + 144| i32.const $1 + 149| set_global $0, %[-1] + 154| return + 155| i32.const $1 + 160| i32.load $0:%[-1]+$2 + 169| drop + 170| return + 171| i32.const $1 + 176| i64.load $0:%[-1]+$2 + 185| drop + 186| return + 187| i32.const $1 + 192| f32.load $0:%[-1]+$2 + 201| drop + 202| return + 203| i32.const $1 + 208| f64.load $0:%[-1]+$2 + 217| drop + 218| return + 219| i32.const $1 + 224| i32.load8_s $0:%[-1]+$2 + 233| drop + 234| return + 235| i32.const $1 + 240| i32.load8_u $0:%[-1]+$2 + 249| drop + 250| return + 251| i32.const $1 + 256| i32.load16_s $0:%[-1]+$2 + 265| drop + 266| return + 267| i32.const $1 + 272| i32.load16_u $0:%[-1]+$2 + 281| drop + 282| return + 283| i32.const $1 + 288| i64.load8_s $0:%[-1]+$2 + 297| drop + 298| return + 299| i32.const $1 + 304| i64.load8_u $0:%[-1]+$2 + 313| drop + 314| return + 315| i32.const $1 + 320| i64.load16_s $0:%[-1]+$2 + 329| drop + 330| return + 331| i32.const $1 + 336| i64.load16_u $0:%[-1]+$2 + 345| drop + 346| return + 347| i32.const $1 + 352| i64.load32_s $0:%[-1]+$2 + 361| drop + 362| return + 363| i32.const $1 + 368| i64.load32_u $0:%[-1]+$2 + 377| drop + 378| return + 379| i32.const $1 + 384| i32.const $2 + 389| i32.store $0:%[-2]+$2, %[-1] + 398| return + 399| i32.const $1 + 404| i64.const $2 + 413| i64.store $0:%[-2]+$2, %[-1] + 422| return + 423| i32.const $1 + 428| f32.const $2 + 433| f32.store $0:%[-2]+$2, %[-1] + 442| return + 443| i32.const $1 + 448| f64.const $2 + 457| f64.store $0:%[-2]+$2, %[-1] + 466| return + 467| i32.const $1 + 472| i32.const $2 + 477| i32.store8 $0:%[-2]+$2, %[-1] + 486| return + 487| i32.const $1 + 492| i32.const $2 + 497| i32.store16 $0:%[-2]+$2, %[-1] + 506| return + 507| i32.const $1 + 512| i64.const $2 + 521| i64.store8 $0:%[-2]+$2, %[-1] + 530| return + 531| i32.const $1 + 536| i64.const $2 + 545| i64.store16 $0:%[-2]+$2, %[-1] + 554| return + 555| i32.const $1 + 560| i64.const $2 + 569| i64.store32 $0:%[-2]+$2, %[-1] + 578| return + 579| memory.size $0 + 584| drop + 585| return + 586| i32.const $1 + 591| memory.grow $0:%[-1] + 596| drop + 597| return + 598| i32.const $1 + 603| drop + 604| return + 605| i64.const $1 + 614| drop + 615| return + 616| f32.const $1 + 621| drop + 622| return + 623| f64.const $1 + 632| drop + 633| return + 634| i32.const $1 + 639| i32.eqz %[-1] + 640| drop + 641| return + 642| i32.const $1 + 647| i32.const $2 + 652| i32.eq %[-2], %[-1] + 653| drop + 654| return + 655| i32.const $1 + 660| i32.const $2 + 665| i32.ne %[-2], %[-1] + 666| drop + 667| return + 668| i32.const $1 + 673| i32.const $2 + 678| i32.lt_s %[-2], %[-1] + 679| drop + 680| return + 681| i32.const $1 + 686| i32.const $2 + 691| i32.lt_u %[-2], %[-1] + 692| drop + 693| return + 694| i32.const $1 + 699| i32.const $2 + 704| i32.gt_s %[-2], %[-1] + 705| drop + 706| return + 707| i32.const $1 + 712| i32.const $2 + 717| i32.gt_u %[-2], %[-1] + 718| drop + 719| return + 720| i32.const $1 + 725| i32.const $2 + 730| i32.le_s %[-2], %[-1] + 731| drop + 732| return + 733| i32.const $1 + 738| i32.const $2 + 743| i32.le_u %[-2], %[-1] + 744| drop + 745| return + 746| i32.const $1 + 751| i32.const $2 + 756| i32.ge_s %[-2], %[-1] + 757| drop + 758| return + 759| i32.const $1 + 764| i32.const $2 + 769| i32.ge_u %[-2], %[-1] + 770| drop + 771| return + 772| i64.const $1 + 781| i64.eqz %[-1] + 782| drop + 783| return + 784| i64.const $1 + 793| i64.const $2 + 802| i64.eq %[-2], %[-1] + 803| drop + 804| return + 805| i64.const $1 + 814| i64.const $2 + 823| i64.ne %[-2], %[-1] + 824| drop + 825| return + 826| i64.const $1 + 835| i64.const $2 + 844| i64.lt_s %[-2], %[-1] + 845| drop + 846| return + 847| i64.const $1 + 856| i64.const $2 + 865| i64.lt_u %[-2], %[-1] + 866| drop + 867| return + 868| i64.const $1 + 877| i64.const $2 + 886| i64.gt_s %[-2], %[-1] + 887| drop + 888| return + 889| i64.const $1 + 898| i64.const $2 + 907| i64.gt_u %[-2], %[-1] + 908| drop + 909| return + 910| i64.const $1 + 919| i64.const $2 + 928| i64.le_s %[-2], %[-1] + 929| drop + 930| return + 931| i64.const $1 + 940| i64.const $2 + 949| i64.le_u %[-2], %[-1] + 950| drop + 951| return + 952| i64.const $1 + 961| i64.const $2 + 970| i64.ge_s %[-2], %[-1] + 971| drop + 972| return + 973| i64.const $1 + 982| i64.const $2 + 991| i64.ge_u %[-2], %[-1] + 992| drop + 993| return + 994| f32.const $1 + 999| f32.const $2 +1004| f32.eq %[-2], %[-1] +1005| drop +1006| return +1007| f32.const $1 +1012| f32.const $2 +1017| f32.ne %[-2], %[-1] +1018| drop +1019| return +1020| f32.const $1 +1025| f32.const $2 +1030| f32.lt %[-2], %[-1] +1031| drop +1032| return +1033| f32.const $1 +1038| f32.const $2 +1043| f32.gt %[-2], %[-1] +1044| drop +1045| return +1046| f32.const $1 +1051| f32.const $2 +1056| f32.le %[-2], %[-1] +1057| drop +1058| return +1059| f32.const $1 +1064| f32.const $2 +1069| f32.ge %[-2], %[-1] +1070| drop +1071| return +1072| f64.const $1 +1081| f64.const $2 +1090| f64.eq %[-2], %[-1] +1091| drop +1092| return +1093| f64.const $1 +1102| f64.const $2 +1111| f64.ne %[-2], %[-1] +1112| drop +1113| return +1114| f64.const $1 +1123| f64.const $2 +1132| f64.lt %[-2], %[-1] +1133| drop +1134| return +1135| f64.const $1 +1144| f64.const $2 +1153| f64.gt %[-2], %[-1] +1154| drop +1155| return +1156| f64.const $1 +1165| f64.const $2 +1174| f64.le %[-2], %[-1] +1175| drop +1176| return +1177| f64.const $1 +1186| f64.const $2 +1195| f64.ge %[-2], %[-1] +1196| drop +1197| return +1198| i32.const $1 +1203| i32.clz %[-1] +1204| drop +1205| return +1206| i32.const $1 +1211| i32.ctz %[-1] +1212| drop +1213| return +1214| i32.const $1 +1219| i32.popcnt %[-1] +1220| drop +1221| return +1222| i32.const $1 +1227| i32.const $2 +1232| i32.add %[-2], %[-1] +1233| drop +1234| return +1235| i32.const $1 +1240| i32.const $2 +1245| i32.sub %[-2], %[-1] +1246| drop +1247| return +1248| i32.const $1 +1253| i32.const $2 +1258| i32.mul %[-2], %[-1] +1259| drop +1260| return +1261| i32.const $1 +1266| i32.const $2 +1271| i32.div_s %[-2], %[-1] +1272| drop +1273| return +1274| i32.const $1 +1279| i32.const $2 +1284| i32.div_u %[-2], %[-1] +1285| drop +1286| return +1287| i32.const $1 +1292| i32.const $2 +1297| i32.rem_s %[-2], %[-1] +1298| drop +1299| return +1300| i32.const $1 +1305| i32.const $2 +1310| i32.rem_u %[-2], %[-1] +1311| drop +1312| return +1313| i32.const $1 +1318| i32.const $2 +1323| i32.and %[-2], %[-1] +1324| drop +1325| return +1326| i32.const $1 +1331| i32.const $2 +1336| i32.or %[-2], %[-1] +1337| drop +1338| return +1339| i32.const $1 +1344| i32.const $2 +1349| i32.xor %[-2], %[-1] +1350| drop +1351| return +1352| i32.const $1 +1357| i32.const $2 +1362| i32.shl %[-2], %[-1] +1363| drop +1364| return +1365| i32.const $1 +1370| i32.const $2 +1375| i32.shr_s %[-2], %[-1] +1376| drop +1377| return +1378| i32.const $1 +1383| i32.const $2 +1388| i32.shr_u %[-2], %[-1] +1389| drop +1390| return +1391| i32.const $1 +1396| i32.const $2 +1401| i32.rotl %[-2], %[-1] +1402| drop +1403| return +1404| i32.const $1 +1409| i32.const $2 +1414| i32.rotr %[-2], %[-1] +1415| drop +1416| return +1417| i64.const $1 +1426| i64.clz %[-1] +1427| drop +1428| return +1429| i64.const $1 +1438| i64.ctz %[-1] +1439| drop +1440| return +1441| i64.const $1 +1450| i64.popcnt %[-1] +1451| drop +1452| return +1453| i64.const $1 +1462| i64.const $2 +1471| i64.add %[-2], %[-1] +1472| drop +1473| return +1474| i64.const $1 +1483| i64.const $2 +1492| i64.sub %[-2], %[-1] +1493| drop +1494| return +1495| i64.const $1 +1504| i64.const $2 +1513| i64.mul %[-2], %[-1] +1514| drop +1515| return +1516| i64.const $1 +1525| i64.const $2 +1534| i64.div_s %[-2], %[-1] +1535| drop +1536| return +1537| i64.const $1 +1546| i64.const $2 +1555| i64.div_u %[-2], %[-1] +1556| drop +1557| return +1558| i64.const $1 +1567| i64.const $2 +1576| i64.rem_s %[-2], %[-1] +1577| drop +1578| return +1579| i64.const $1 +1588| i64.const $2 +1597| i64.rem_u %[-2], %[-1] +1598| drop +1599| return +1600| i64.const $1 +1609| i64.const $2 +1618| i64.and %[-2], %[-1] +1619| drop +1620| return +1621| i64.const $1 +1630| i64.const $2 +1639| i64.or %[-2], %[-1] +1640| drop +1641| return +1642| i64.const $1 +1651| i64.const $2 +1660| i64.xor %[-2], %[-1] +1661| drop +1662| return +1663| i64.const $1 +1672| i64.const $2 +1681| i64.shl %[-2], %[-1] +1682| drop +1683| return +1684| i64.const $1 +1693| i64.const $2 +1702| i64.shr_s %[-2], %[-1] +1703| drop +1704| return +1705| i64.const $1 +1714| i64.const $2 +1723| i64.shr_u %[-2], %[-1] +1724| drop +1725| return +1726| i64.const $1 +1735| i64.const $2 +1744| i64.rotl %[-2], %[-1] +1745| drop +1746| return +1747| i64.const $1 +1756| i64.const $2 +1765| i64.rotr %[-2], %[-1] +1766| drop +1767| return +1768| f32.const $1 +1773| f32.abs %[-1] +1774| drop +1775| return +1776| f32.const $1 +1781| f32.neg %[-1] +1782| drop +1783| return +1784| f32.const $1 +1789| f32.ceil %[-1] +1790| drop +1791| return +1792| f32.const $1 +1797| f32.floor %[-1] +1798| drop +1799| return +1800| f32.const $1 +1805| f32.trunc %[-1] +1806| drop +1807| return +1808| f32.const $1 +1813| f32.nearest %[-1] +1814| drop +1815| return +1816| f32.const $1 +1821| f32.sqrt %[-1] +1822| drop +1823| return +1824| f32.const $1 +1829| f32.const $2 +1834| f32.add %[-2], %[-1] +1835| drop +1836| return +1837| f32.const $1 +1842| f32.const $2 +1847| f32.sub %[-2], %[-1] +1848| drop +1849| return +1850| f32.const $1 +1855| f32.const $2 +1860| f32.mul %[-2], %[-1] +1861| drop +1862| return +1863| f32.const $1 +1868| f32.const $2 +1873| f32.div %[-2], %[-1] +1874| drop +1875| return +1876| f32.const $1 +1881| f32.const $2 +1886| f32.min %[-2], %[-1] +1887| drop +1888| return +1889| f32.const $1 +1894| f32.const $2 +1899| f32.max %[-2], %[-1] +1900| drop +1901| return +1902| f32.const $1 +1907| f32.const $2 +1912| f32.copysign %[-2], %[-1] +1913| drop +1914| return +1915| f64.const $1 +1924| f64.abs %[-1] +1925| drop +1926| return +1927| f64.const $1 +1936| f64.neg %[-1] +1937| drop +1938| return +1939| f64.const $1 +1948| f64.ceil %[-1] +1949| drop +1950| return +1951| f64.const $1 +1960| f64.floor %[-1] +1961| drop +1962| return +1963| f64.const $1 +1972| f64.trunc %[-1] +1973| drop +1974| return +1975| f64.const $1 +1984| f64.nearest %[-1] +1985| drop +1986| return +1987| f64.const $1 +1996| f64.sqrt %[-1] +1997| drop +1998| return +1999| f64.const $1 +2008| f64.const $2 +2017| f64.add %[-2], %[-1] +2018| drop +2019| return +2020| f64.const $1 +2029| f64.const $2 +2038| f64.sub %[-2], %[-1] +2039| drop +2040| return +2041| f64.const $1 +2050| f64.const $2 +2059| f64.mul %[-2], %[-1] +2060| drop +2061| return +2062| f64.const $1 +2071| f64.const $2 +2080| f64.div %[-2], %[-1] +2081| drop +2082| return +2083| f64.const $1 +2092| f64.const $2 +2101| f64.min %[-2], %[-1] +2102| drop +2103| return +2104| f64.const $1 +2113| f64.const $2 +2122| f64.max %[-2], %[-1] +2123| drop +2124| return +2125| f64.const $1 +2134| f64.const $2 +2143| f64.copysign %[-2], %[-1] +2144| drop +2145| return +2146| i64.const $1 +2155| i32.wrap/i64 %[-1] +2156| drop +2157| return +2158| f32.const $1 +2163| i32.trunc_s/f32 %[-1] +2164| drop +2165| return +2166| f32.const $1 +2171| i32.trunc_u/f32 %[-1] +2172| drop +2173| return +2174| f64.const $1 +2183| i32.trunc_s/f64 %[-1] +2184| drop +2185| return +2186| f64.const $1 +2195| i32.trunc_u/f64 %[-1] +2196| drop +2197| return +2198| i32.const $1 +2203| i64.extend_s/i32 %[-1] +2204| drop +2205| return +2206| i32.const $1 +2211| i64.extend_u/i32 %[-1] +2212| drop +2213| return +2214| f32.const $1 +2219| i64.trunc_s/f32 %[-1] +2220| drop +2221| return +2222| f32.const $1 +2227| i64.trunc_u/f32 %[-1] +2228| drop +2229| return +2230| f64.const $1 +2239| i64.trunc_s/f64 %[-1] +2240| drop +2241| return +2242| f64.const $1 +2251| i64.trunc_u/f64 %[-1] +2252| drop +2253| return +2254| i32.const $1 +2259| f32.convert_s/i32 %[-1] +2260| drop +2261| return +2262| i32.const $1 +2267| f32.convert_u/i32 %[-1] +2268| drop +2269| return +2270| i64.const $1 +2279| f32.convert_s/i64 %[-1] +2280| drop +2281| return +2282| i64.const $1 +2291| f32.convert_u/i64 %[-1] +2292| drop +2293| return +2294| f64.const $1 +2303| f32.demote/f64 %[-1] +2304| drop +2305| return +2306| i32.const $1 +2311| f64.convert_s/i32 %[-1] +2312| drop +2313| return +2314| i32.const $1 +2319| f64.convert_u/i32 %[-1] +2320| drop +2321| return +2322| i64.const $1 +2331| f64.convert_s/i64 %[-1] +2332| drop +2333| return +2334| i64.const $1 +2343| f64.convert_u/i64 %[-1] +2344| drop +2345| return +2346| f32.const $1 +2351| f64.promote/f32 %[-1] +2352| drop +2353| return +2354| i32.const $1 +2359| f32.reinterpret/i32 %[-1] +2360| drop +2361| return +2362| f32.const $1 +2367| i32.reinterpret/f32 %[-1] +2368| drop +2369| return +2370| i64.const $1 +2379| f64.reinterpret/i64 %[-1] +2380| drop +2381| return +2382| f64.const $1 +2391| i64.reinterpret/f64 %[-1] +2392| drop +2393| return +2394| i32.const $1 +2399| i32.extend8_s %[-1] +2400| drop +2401| return +2402| i32.const $1 +2407| i32.extend16_s %[-1] +2408| drop +2409| return +2410| i64.const $1 +2419| i64.extend8_s %[-1] +2420| drop +2421| return +2422| i64.const $1 +2431| i64.extend16_s %[-1] +2432| drop +2433| return +2434| i64.const $1 +2443| i64.extend32_s %[-1] +2444| drop +2445| return +2446| alloca $1 +2451| drop +2452| return +2453| i32.const $1 +2458| br_unless @2468, %[-1] +2463| br @2468 +2468| return +2469| i32.const $1 +2474| call_host $0 +2479| return +2480| i32.const $1 +2485| br_table %[-1], $#0, table:$2499 +2494| data $12 +2499| entry 0: offset: 2511 drop: 0 keep: 0 +2511| return +2512| i32.const $1 +2517| i32.const $2 +2522| drop_keep $1 $1 +2531| br @2536 2536| drop 2537| return 2538| f32.const $1 -2543| i32.trunc_u:sat/f32 %[-1] +2543| i32.trunc_s:sat/f32 %[-1] 2545| drop 2546| return -2547| f64.const $1 -2556| i32.trunc_s:sat/f64 %[-1] -2558| drop -2559| return -2560| f64.const $1 -2569| i32.trunc_u:sat/f64 %[-1] -2571| drop -2572| return -2573| f32.const $1 -2578| i64.trunc_s:sat/f32 %[-1] +2547| f32.const $1 +2552| i32.trunc_u:sat/f32 %[-1] +2554| drop +2555| return +2556| f64.const $1 +2565| i32.trunc_s:sat/f64 %[-1] +2567| drop +2568| return +2569| f64.const $1 +2578| i32.trunc_u:sat/f64 %[-1] 2580| drop 2581| return 2582| f32.const $1 -2587| i64.trunc_u:sat/f32 %[-1] +2587| i64.trunc_s:sat/f32 %[-1] 2589| drop 2590| return -2591| f64.const $1 -2600| i64.trunc_s:sat/f64 %[-1] -2602| drop -2603| return -2604| f64.const $1 -2613| i64.trunc_u:sat/f64 %[-1] -2615| drop -2616| return -2617| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -2635| drop -2636| return -2637| i32.const $1 -2642| v128.load $0:%[-1]+$3 -2652| drop -2653| return -2654| i32.const $1 -2659| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -2677| v128.store $0:%[-2]+$3, %[-1] -2687| return -2688| i32.const $1 -2693| i8x16.splat %[-1] -2695| drop +2591| f32.const $1 +2596| i64.trunc_u:sat/f32 %[-1] +2598| drop +2599| return +2600| f64.const $1 +2609| i64.trunc_s:sat/f64 %[-1] +2611| drop +2612| return +2613| f64.const $1 +2622| i64.trunc_u:sat/f64 %[-1] +2624| drop +2625| return +2626| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +2644| drop +2645| return +2646| i32.const $1 +2651| v128.load $0:%[-1]+$3 +2661| drop +2662| return +2663| i32.const $1 +2668| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +2686| v128.store $0:%[-2]+$3, %[-1] 2696| return 2697| i32.const $1 -2702| i16x8.splat %[-1] +2702| i8x16.splat %[-1] 2704| drop 2705| return 2706| i32.const $1 -2711| i32x4.splat %[-1] +2711| i16x8.splat %[-1] 2713| drop 2714| return -2715| i64.const $1 -2724| i64x2.splat %[-1] -2726| drop -2727| return -2728| f32.const $1 -2733| f32x4.splat %[-1] +2715| i32.const $1 +2720| i32x4.splat %[-1] +2722| drop +2723| return +2724| i64.const $1 +2733| i64x2.splat %[-1] 2735| drop 2736| return -2737| f64.const $1 -2746| f64x2.splat %[-1] -2748| drop -2749| return -2750| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -2768| i8x16.extract_lane_s %[-1] : (Lane imm: 15) -2771| drop -2772| return -2773| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -2791| i8x16.extract_lane_u %[-1] : (Lane imm: 15) -2794| drop -2795| return -2796| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -2814| i16x8.extract_lane_s %[-1] : (Lane imm: 7) -2817| drop -2818| return -2819| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -2837| i16x8.extract_lane_u %[-1] : (Lane imm: 7) -2840| drop -2841| return -2842| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -2860| i32x4.extract_lane %[-1] : (Lane imm: 3) -2863| drop -2864| return -2865| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -2883| i64x2.extract_lane %[-1] : (Lane imm: 1) -2886| drop -2887| return -2888| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -2906| f32x4.extract_lane %[-1] : (Lane imm: 3) -2909| drop -2910| return -2911| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -2929| f64x2.extract_lane %[-1] : (Lane imm: 1) -2932| drop -2933| return -2934| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -2952| i32.const $0 -2957| i8x16.replace_lane %[-1], %[-2] : (Lane imm: 15) -2960| drop -2961| return -2962| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -2980| i32.const $0 -2985| i16x8.replace_lane %[-1], %[-2] : (Lane imm: 7) -2988| drop -2989| return -2990| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3008| i32.const $0 -3013| i32x4.replace_lane %[-1], %[-2] : (Lane imm: 3) -3016| drop -3017| return -3018| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3036| i64.const $0 -3045| i64x2.replace_lane %[-1], %[-2] : (Lane imm: 1) -3048| drop -3049| return -3050| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3068| f32.const $0 -3073| f32x4.replace_lane %[-1], %[-2] : (Lane imm: 3) -3076| drop -3077| return -3078| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3096| f64.const $0 -3105| f64x2.replace_lane %[-1], %[-2] : (Lane imm: 1) -3108| drop -3109| return -3110| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3128| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -3146| v8x16.shuffle %[-2], %[-1] : (Lane imm: $0x00000001 0x00000001 0x00000001 0x00000001 ) -3164| drop -3165| return -3166| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3184| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -3202| i8x16.add %[-2], %[-1] -3204| drop -3205| return -3206| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3224| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -3242| i16x8.add %[-2], %[-1] -3244| drop -3245| return -3246| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3264| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -3282| i32x4.add %[-2], %[-1] -3284| drop -3285| return -3286| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3304| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -3322| i64x2.add %[-2], %[-1] -3324| drop -3325| return -3326| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3344| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -3362| i8x16.sub %[-2], %[-1] -3364| drop -3365| return -3366| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3384| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -3402| i16x8.sub %[-2], %[-1] -3404| drop -3405| return -3406| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3424| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -3442| i32x4.sub %[-2], %[-1] -3444| drop -3445| return -3446| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3464| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -3482| i64x2.sub %[-2], %[-1] -3484| drop -3485| return -3486| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3504| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -3522| i8x16.mul %[-2], %[-1] -3524| drop -3525| return -3526| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3544| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -3562| i16x8.mul %[-2], %[-1] -3564| drop -3565| return -3566| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3584| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -3602| i32x4.mul %[-2], %[-1] -3604| drop -3605| return -3606| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3624| i8x16.neg %[-1] -3626| drop -3627| return -3628| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3646| i16x8.neg %[-1] -3648| drop -3649| return -3650| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3668| i32x4.neg %[-1] -3670| drop -3671| return -3672| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3690| i64x2.neg %[-1] -3692| drop -3693| return -3694| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3712| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -3730| i8x16.add_saturate_s %[-2], %[-1] -3732| drop -3733| return -3734| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3752| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -3770| i8x16.add_saturate_u %[-2], %[-1] -3772| drop -3773| return -3774| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3792| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -3810| i16x8.add_saturate_s %[-2], %[-1] -3812| drop -3813| return -3814| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3832| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -3850| i16x8.add_saturate_u %[-2], %[-1] -3852| drop -3853| return -3854| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3872| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -3890| i8x16.sub_saturate_s %[-2], %[-1] -3892| drop -3893| return -3894| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3912| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -3930| i8x16.sub_saturate_u %[-2], %[-1] -3932| drop -3933| return -3934| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3952| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -3970| i16x8.sub_saturate_s %[-2], %[-1] -3972| drop -3973| return -3974| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -3992| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -4010| i16x8.sub_saturate_u %[-2], %[-1] -4012| drop -4013| return -4014| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4032| i32.const $0 -4037| i8x16.shl %[-2], %[-1] -4039| drop -4040| return -4041| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4059| i32.const $0 -4064| i16x8.shl %[-2], %[-1] -4066| drop -4067| return -4068| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4086| i32.const $0 -4091| i32x4.shl %[-2], %[-1] -4093| drop -4094| return -4095| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4113| i32.const $0 -4118| i64x2.shl %[-2], %[-1] -4120| drop -4121| return -4122| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4140| i32.const $0 -4145| i8x16.shr_s %[-2], %[-1] -4147| drop -4148| return -4149| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4167| i32.const $0 -4172| i8x16.shr_u %[-2], %[-1] -4174| drop -4175| return -4176| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4194| i32.const $0 -4199| i16x8.shr_s %[-2], %[-1] -4201| drop -4202| return -4203| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4221| i32.const $0 -4226| i16x8.shr_u %[-2], %[-1] -4228| drop -4229| return -4230| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4248| i32.const $0 -4253| i32x4.shr_s %[-2], %[-1] -4255| drop -4256| return -4257| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4275| i32.const $0 -4280| i32x4.shr_u %[-2], %[-1] -4282| drop -4283| return -4284| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4302| i32.const $0 -4307| i64x2.shr_s %[-2], %[-1] -4309| drop -4310| return -4311| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4329| i32.const $0 -4334| i64x2.shr_u %[-2], %[-1] -4336| drop -4337| return -4338| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4356| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -4374| v128.and %[-2], %[-1] -4376| drop -4377| return -4378| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4396| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -4414| v128.or %[-2], %[-1] -4416| drop -4417| return -4418| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4436| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -4454| v128.xor %[-2], %[-1] -4456| drop -4457| return -4458| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4476| v128.not %[-1] -4478| drop -4479| return -4480| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4498| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -4516| v128.const $0x00000003 0x00000003 0x00000003 0x00000003 -4534| v128.bitselect %[-3], %[-2], %[-1] -4536| drop -4537| return -4538| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4556| i8x16.any_true %[-1] -4558| drop -4559| return -4560| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4578| i16x8.any_true %[-1] -4580| drop -4581| return -4582| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4600| i32x4.any_true %[-1] -4602| drop -4603| return -4604| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4622| i64x2.any_true %[-1] -4624| drop -4625| return -4626| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4644| i8x16.all_true %[-1] -4646| drop -4647| return -4648| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4666| i16x8.all_true %[-1] -4668| drop -4669| return -4670| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4688| i32x4.all_true %[-1] -4690| drop -4691| return -4692| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4710| i64x2.all_true %[-1] -4712| drop -4713| return -4714| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4732| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -4750| i8x16.eq %[-2], %[-1] -4752| drop -4753| return -4754| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4772| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -4790| i16x8.eq %[-2], %[-1] -4792| drop -4793| return -4794| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4812| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -4830| i32x4.eq %[-2], %[-1] -4832| drop -4833| return -4834| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4852| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -4870| f32x4.eq %[-2], %[-1] -4872| drop -4873| return -4874| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4892| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -4910| f64x2.eq %[-2], %[-1] -4912| drop -4913| return -4914| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4932| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -4950| i8x16.ne %[-2], %[-1] -4952| drop -4953| return -4954| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -4972| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -4990| i16x8.ne %[-2], %[-1] -4992| drop -4993| return -4994| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5012| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5030| i32x4.ne %[-2], %[-1] -5032| drop -5033| return -5034| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5052| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5070| f32x4.ne %[-2], %[-1] -5072| drop -5073| return -5074| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5092| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5110| f64x2.ne %[-2], %[-1] -5112| drop -5113| return -5114| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5132| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5150| i8x16.lt_s %[-2], %[-1] -5152| drop -5153| return -5154| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5172| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5190| i8x16.lt_u %[-2], %[-1] -5192| drop -5193| return -5194| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5212| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5230| i16x8.lt_s %[-2], %[-1] -5232| drop -5233| return -5234| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5252| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5270| i16x8.lt_u %[-2], %[-1] -5272| drop -5273| return -5274| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5292| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5310| i32x4.lt_s %[-2], %[-1] -5312| drop -5313| return -5314| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5332| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5350| i32x4.lt_u %[-2], %[-1] -5352| drop -5353| return -5354| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5372| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5390| f32x4.lt %[-2], %[-1] -5392| drop -5393| return -5394| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5412| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5430| f64x2.lt %[-2], %[-1] -5432| drop -5433| return -5434| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5452| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5470| i8x16.le_s %[-2], %[-1] -5472| drop -5473| return -5474| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5492| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5510| i8x16.le_u %[-2], %[-1] -5512| drop -5513| return -5514| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5532| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5550| i16x8.le_s %[-2], %[-1] -5552| drop -5553| return -5554| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5572| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5590| i16x8.le_u %[-2], %[-1] -5592| drop -5593| return -5594| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5612| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5630| i32x4.le_s %[-2], %[-1] -5632| drop -5633| return -5634| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5652| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5670| i32x4.le_u %[-2], %[-1] -5672| drop -5673| return -5674| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5692| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5710| f32x4.le %[-2], %[-1] -5712| drop -5713| return -5714| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5732| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5750| f64x2.le %[-2], %[-1] -5752| drop -5753| return -5754| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5772| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5790| i8x16.gt_s %[-2], %[-1] -5792| drop -5793| return -5794| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5812| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5830| i8x16.gt_u %[-2], %[-1] -5832| drop -5833| return -5834| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5852| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5870| i16x8.gt_s %[-2], %[-1] -5872| drop -5873| return -5874| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5892| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5910| i16x8.gt_u %[-2], %[-1] -5912| drop -5913| return -5914| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5932| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5950| i32x4.gt_s %[-2], %[-1] -5952| drop -5953| return -5954| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -5972| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -5990| i32x4.gt_u %[-2], %[-1] -5992| drop -5993| return -5994| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6012| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -6030| f32x4.gt %[-2], %[-1] -6032| drop -6033| return -6034| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6052| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -6070| f64x2.gt %[-2], %[-1] -6072| drop -6073| return -6074| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6092| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -6110| i8x16.ge_s %[-2], %[-1] -6112| drop -6113| return -6114| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6132| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -6150| i8x16.ge_u %[-2], %[-1] -6152| drop -6153| return -6154| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6172| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -6190| i16x8.ge_s %[-2], %[-1] -6192| drop -6193| return -6194| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6212| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -6230| i16x8.ge_u %[-2], %[-1] -6232| drop -6233| return -6234| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6252| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -6270| i32x4.ge_s %[-2], %[-1] -6272| drop -6273| return -6274| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6292| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -6310| i32x4.ge_u %[-2], %[-1] -6312| drop -6313| return -6314| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6332| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -6350| f32x4.ge %[-2], %[-1] -6352| drop -6353| return -6354| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6372| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -6390| f64x2.ge %[-2], %[-1] -6392| drop -6393| return -6394| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6412| f32x4.neg %[-1] -6414| drop -6415| return -6416| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6434| f64x2.neg %[-1] -6436| drop -6437| return -6438| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6456| f32x4.abs %[-1] -6458| drop -6459| return -6460| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6478| f64x2.abs %[-1] -6480| drop -6481| return -6482| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6500| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -6518| f32x4.min %[-2], %[-1] -6520| drop -6521| return -6522| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6540| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -6558| f64x2.min %[-2], %[-1] -6560| drop -6561| return -6562| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6580| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -6598| f32x4.max %[-2], %[-1] -6600| drop -6601| return -6602| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6620| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -6638| f64x2.max %[-2], %[-1] -6640| drop -6641| return -6642| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6660| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -6678| f32x4.add %[-2], %[-1] -6680| drop -6681| return -6682| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6700| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -6718| f64x2.add %[-2], %[-1] -6720| drop -6721| return -6722| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6740| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -6758| f32x4.sub %[-2], %[-1] -6760| drop -6761| return -6762| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6780| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -6798| f64x2.sub %[-2], %[-1] -6800| drop -6801| return -6802| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6820| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -6838| f32x4.div %[-2], %[-1] -6840| drop -6841| return -6842| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6860| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -6878| f64x2.div %[-2], %[-1] -6880| drop -6881| return -6882| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6900| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -6918| f32x4.mul %[-2], %[-1] -6920| drop -6921| return -6922| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6940| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -6958| f64x2.mul %[-2], %[-1] -6960| drop -6961| return -6962| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -6980| f32x4.sqrt %[-1] -6982| drop -6983| return -6984| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -7002| f64x2.sqrt %[-1] -7004| drop -7005| return -7006| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -7024| f32x4.convert_s/i32x4 %[-1] -7026| drop -7027| return -7028| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -7046| f32x4.convert_u/i32x4 %[-1] -7048| drop -7049| return -7050| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -7068| f64x2.convert_s/i64x2 %[-1] -7070| drop -7071| return -7072| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -7090| f64x2.convert_u/i64x2 %[-1] -7092| drop -7093| return -7094| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -7112| i32x4.trunc_s/f32x4:sat %[-1] -7114| drop -7115| return -7116| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -7134| i32x4.trunc_u/f32x4:sat %[-1] -7136| drop -7137| return -7138| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -7156| i64x2.trunc_s/f64x2:sat %[-1] -7158| drop -7159| return -7160| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -7178| i64x2.trunc_u/f64x2:sat %[-1] -7180| drop -7181| return -7182| i32.const $1 -7187| i32.const $2 -7192| atomic.wake $0:%[-2]+$3, %[-1] -7202| drop -7203| return -7204| i32.const $1 -7209| i32.const $2 -7214| i64.const $3 -7223| i32.atomic.wait $0:%[-3]+$3, %[-2], %[-1] -7233| drop -7234| return -7235| i32.const $1 -7240| i64.const $2 -7249| i64.const $3 -7258| i64.atomic.wait $0:%[-3]+$3, %[-2], %[-1] -7268| drop -7269| return -7270| i32.const $1 -7275| i32.atomic.load $0:%[-1]+$3 -7285| drop -7286| return -7287| i32.const $1 -7292| i64.atomic.load $0:%[-1]+$7 -7302| drop -7303| return -7304| i32.const $1 -7309| i32.atomic.load8_u $0:%[-1]+$3 -7319| drop -7320| return -7321| i32.const $1 -7326| i32.atomic.load16_u $0:%[-1]+$3 -7336| drop -7337| return -7338| i32.const $1 -7343| i64.atomic.load8_u $0:%[-1]+$3 -7353| drop -7354| return -7355| i32.const $1 -7360| i64.atomic.load16_u $0:%[-1]+$3 -7370| drop -7371| return -7372| i32.const $1 -7377| i64.atomic.load32_u $0:%[-1]+$3 -7387| drop -7388| return -7389| i32.const $1 -7394| i32.const $2 -7399| i32.atomic.store $0:%[-2]+$3, %[-1] -7409| return -7410| i32.const $1 -7415| i64.const $2 -7424| i64.atomic.store $0:%[-2]+$7, %[-1] -7434| return -7435| i32.const $1 -7440| i32.const $2 -7445| i32.atomic.store8 $0:%[-2]+$3, %[-1] -7455| return -7456| i32.const $1 -7461| i32.const $2 -7466| i32.atomic.store16 $0:%[-2]+$3, %[-1] -7476| return -7477| i32.const $1 -7482| i64.const $2 -7491| i64.atomic.store8 $0:%[-2]+$3, %[-1] -7501| return -7502| i32.const $1 -7507| i64.const $2 -7516| i64.atomic.store16 $0:%[-2]+$3, %[-1] -7526| return -7527| i32.const $1 -7532| i64.const $2 -7541| i64.atomic.store32 $0:%[-2]+$3, %[-1] -7551| return -7552| i32.const $1 -7557| i32.const $2 -7562| i32.atomic.rmw.add $0:%[-2]+$3, %[-1] -7572| drop -7573| return -7574| i32.const $1 -7579| i64.const $2 -7588| i64.atomic.rmw.add $0:%[-2]+$7, %[-1] -7598| drop -7599| return -7600| i32.const $1 -7605| i32.const $2 -7610| i32.atomic.rmw8_u.add $0:%[-2]+$3, %[-1] -7620| drop -7621| return -7622| i32.const $1 -7627| i32.const $2 -7632| i32.atomic.rmw16_u.add $0:%[-2]+$3, %[-1] -7642| drop -7643| return -7644| i32.const $1 -7649| i64.const $2 -7658| i64.atomic.rmw8_u.add $0:%[-2]+$3, %[-1] -7668| drop -7669| return -7670| i32.const $1 -7675| i64.const $2 -7684| i64.atomic.rmw16_u.add $0:%[-2]+$3, %[-1] -7694| drop -7695| return -7696| i32.const $1 -7701| i64.const $2 -7710| i64.atomic.rmw32_u.add $0:%[-2]+$3, %[-1] -7720| drop -7721| return -7722| i32.const $1 -7727| i32.const $2 -7732| i32.atomic.rmw.sub $0:%[-2]+$3, %[-1] -7742| drop -7743| return -7744| i32.const $1 -7749| i64.const $2 -7758| i64.atomic.rmw.sub $0:%[-2]+$7, %[-1] -7768| drop -7769| return -7770| i32.const $1 -7775| i32.const $2 -7780| i32.atomic.rmw8_u.sub $0:%[-2]+$3, %[-1] -7790| drop -7791| return -7792| i32.const $1 -7797| i32.const $2 -7802| i32.atomic.rmw16_u.sub $0:%[-2]+$3, %[-1] -7812| drop -7813| return -7814| i32.const $1 -7819| i64.const $2 -7828| i64.atomic.rmw8_u.sub $0:%[-2]+$3, %[-1] -7838| drop -7839| return -7840| i32.const $1 -7845| i64.const $2 -7854| i64.atomic.rmw16_u.sub $0:%[-2]+$3, %[-1] -7864| drop -7865| return -7866| i32.const $1 -7871| i64.const $2 -7880| i64.atomic.rmw32_u.sub $0:%[-2]+$3, %[-1] -7890| drop -7891| return -7892| i32.const $1 -7897| i32.const $2 -7902| i32.atomic.rmw.and $0:%[-2]+$3, %[-1] -7912| drop -7913| return -7914| i32.const $1 -7919| i64.const $2 -7928| i64.atomic.rmw.and $0:%[-2]+$7, %[-1] -7938| drop -7939| return -7940| i32.const $1 -7945| i32.const $2 -7950| i32.atomic.rmw8_u.and $0:%[-2]+$3, %[-1] -7960| drop -7961| return -7962| i32.const $1 -7967| i32.const $2 -7972| i32.atomic.rmw16_u.and $0:%[-2]+$3, %[-1] -7982| drop -7983| return -7984| i32.const $1 -7989| i64.const $2 -7998| i64.atomic.rmw8_u.and $0:%[-2]+$3, %[-1] -8008| drop -8009| return -8010| i32.const $1 -8015| i64.const $2 -8024| i64.atomic.rmw16_u.and $0:%[-2]+$3, %[-1] -8034| drop -8035| return -8036| i32.const $1 -8041| i64.const $2 -8050| i64.atomic.rmw32_u.and $0:%[-2]+$3, %[-1] -8060| drop -8061| return -8062| i32.const $1 -8067| i32.const $2 -8072| i32.atomic.rmw.or $0:%[-2]+$3, %[-1] -8082| drop -8083| return -8084| i32.const $1 -8089| i64.const $2 -8098| i64.atomic.rmw.or $0:%[-2]+$7, %[-1] -8108| drop -8109| return -8110| i32.const $1 -8115| i32.const $2 -8120| i32.atomic.rmw8_u.or $0:%[-2]+$3, %[-1] -8130| drop -8131| return -8132| i32.const $1 -8137| i32.const $2 -8142| i32.atomic.rmw16_u.or $0:%[-2]+$3, %[-1] -8152| drop -8153| return -8154| i32.const $1 -8159| i64.const $2 -8168| i64.atomic.rmw8_u.or $0:%[-2]+$3, %[-1] -8178| drop -8179| return -8180| i32.const $1 -8185| i64.const $2 -8194| i64.atomic.rmw16_u.or $0:%[-2]+$3, %[-1] -8204| drop -8205| return -8206| i32.const $1 -8211| i64.const $2 -8220| i64.atomic.rmw32_u.or $0:%[-2]+$3, %[-1] -8230| drop -8231| return -8232| i32.const $1 -8237| i32.const $2 -8242| i32.atomic.rmw.xor $0:%[-2]+$3, %[-1] -8252| drop -8253| return -8254| i32.const $1 -8259| i64.const $2 -8268| i64.atomic.rmw.xor $0:%[-2]+$7, %[-1] -8278| drop -8279| return -8280| i32.const $1 -8285| i32.const $2 -8290| i32.atomic.rmw8_u.xor $0:%[-2]+$3, %[-1] -8300| drop -8301| return -8302| i32.const $1 -8307| i32.const $2 -8312| i32.atomic.rmw16_u.xor $0:%[-2]+$3, %[-1] -8322| drop -8323| return -8324| i32.const $1 -8329| i64.const $2 -8338| i64.atomic.rmw8_u.xor $0:%[-2]+$3, %[-1] -8348| drop -8349| return -8350| i32.const $1 -8355| i64.const $2 -8364| i64.atomic.rmw16_u.xor $0:%[-2]+$3, %[-1] -8374| drop -8375| return -8376| i32.const $1 -8381| i64.const $2 -8390| i64.atomic.rmw32_u.xor $0:%[-2]+$3, %[-1] -8400| drop -8401| return -8402| i32.const $1 -8407| i32.const $2 -8412| i32.atomic.rmw.xchg $0:%[-2]+$3, %[-1] -8422| drop -8423| return -8424| i32.const $1 -8429| i64.const $2 -8438| i64.atomic.rmw.xchg $0:%[-2]+$7, %[-1] -8448| drop -8449| return -8450| i32.const $1 -8455| i32.const $2 -8460| i32.atomic.rmw8_u.xchg $0:%[-2]+$3, %[-1] -8470| drop -8471| return -8472| i32.const $1 -8477| i32.const $2 -8482| i32.atomic.rmw16_u.xchg $0:%[-2]+$3, %[-1] -8492| drop -8493| return -8494| i32.const $1 -8499| i64.const $2 -8508| i64.atomic.rmw8_u.xchg $0:%[-2]+$3, %[-1] -8518| drop -8519| return -8520| i32.const $1 -8525| i64.const $2 -8534| i64.atomic.rmw16_u.xchg $0:%[-2]+$3, %[-1] -8544| drop -8545| return -8546| i32.const $1 -8551| i64.const $2 -8560| i64.atomic.rmw32_u.xchg $0:%[-2]+$3, %[-1] -8570| drop -8571| return -8572| i32.const $1 -8577| i32.const $2 -8582| i32.const $3 -8587| i32.atomic.rmw.cmpxchg $0:%[-3]+$3, %[-2], %[-1] -8597| drop -8598| return -8599| i32.const $1 -8604| i64.const $2 -8613| i64.const $3 -8622| i64.atomic.rmw.cmpxchg $0:%[-3]+$7, %[-2], %[-1] -8632| drop -8633| return -8634| i32.const $1 -8639| i32.const $2 -8644| i32.const $3 -8649| i32.atomic.rmw8_u.cmpxchg $0:%[-3]+$3, %[-2], %[-1] -8659| drop -8660| return -8661| i32.const $1 -8666| i32.const $2 -8671| i32.const $3 -8676| i32.atomic.rmw16_u.cmpxchg $0:%[-3]+$3, %[-2], %[-1] -8686| drop -8687| return -8688| i32.const $1 -8693| i64.const $2 -8702| i64.const $3 -8711| i64.atomic.rmw8_u.cmpxchg $0:%[-3]+$3, %[-2], %[-1] -8721| drop -8722| return -8723| i32.const $1 -8728| i64.const $2 -8737| i64.const $3 -8746| i64.atomic.rmw16_u.cmpxchg $0:%[-3]+$3, %[-2], %[-1] -8756| drop -8757| return -8758| i32.const $1 -8763| i64.const $2 -8772| i64.const $3 -8781| i64.atomic.rmw32_u.cmpxchg $0:%[-3]+$3, %[-2], %[-1] -8791| drop -8792| return +2737| f32.const $1 +2742| f32x4.splat %[-1] +2744| drop +2745| return +2746| f64.const $1 +2755| f64x2.splat %[-1] +2757| drop +2758| return +2759| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +2777| i8x16.extract_lane_s %[-1] : (Lane imm: 15) +2780| drop +2781| return +2782| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +2800| i8x16.extract_lane_u %[-1] : (Lane imm: 15) +2803| drop +2804| return +2805| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +2823| i16x8.extract_lane_s %[-1] : (Lane imm: 7) +2826| drop +2827| return +2828| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +2846| i16x8.extract_lane_u %[-1] : (Lane imm: 7) +2849| drop +2850| return +2851| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +2869| i32x4.extract_lane %[-1] : (Lane imm: 3) +2872| drop +2873| return +2874| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +2892| i64x2.extract_lane %[-1] : (Lane imm: 1) +2895| drop +2896| return +2897| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +2915| f32x4.extract_lane %[-1] : (Lane imm: 3) +2918| drop +2919| return +2920| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +2938| f64x2.extract_lane %[-1] : (Lane imm: 1) +2941| drop +2942| return +2943| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +2961| i32.const $0 +2966| i8x16.replace_lane %[-1], %[-2] : (Lane imm: 15) +2969| drop +2970| return +2971| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +2989| i32.const $0 +2994| i16x8.replace_lane %[-1], %[-2] : (Lane imm: 7) +2997| drop +2998| return +2999| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3017| i32.const $0 +3022| i32x4.replace_lane %[-1], %[-2] : (Lane imm: 3) +3025| drop +3026| return +3027| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3045| i64.const $0 +3054| i64x2.replace_lane %[-1], %[-2] : (Lane imm: 1) +3057| drop +3058| return +3059| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3077| f32.const $0 +3082| f32x4.replace_lane %[-1], %[-2] : (Lane imm: 3) +3085| drop +3086| return +3087| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3105| f64.const $0 +3114| f64x2.replace_lane %[-1], %[-2] : (Lane imm: 1) +3117| drop +3118| return +3119| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3137| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +3155| v8x16.shuffle %[-2], %[-1] : (Lane imm: $0x00000001 0x00000001 0x00000001 0x00000001 ) +3173| drop +3174| return +3175| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3193| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +3211| i8x16.add %[-2], %[-1] +3213| drop +3214| return +3215| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3233| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +3251| i16x8.add %[-2], %[-1] +3253| drop +3254| return +3255| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3273| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +3291| i32x4.add %[-2], %[-1] +3293| drop +3294| return +3295| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3313| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +3331| i64x2.add %[-2], %[-1] +3333| drop +3334| return +3335| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3353| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +3371| i8x16.sub %[-2], %[-1] +3373| drop +3374| return +3375| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3393| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +3411| i16x8.sub %[-2], %[-1] +3413| drop +3414| return +3415| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3433| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +3451| i32x4.sub %[-2], %[-1] +3453| drop +3454| return +3455| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3473| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +3491| i64x2.sub %[-2], %[-1] +3493| drop +3494| return +3495| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3513| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +3531| i8x16.mul %[-2], %[-1] +3533| drop +3534| return +3535| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3553| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +3571| i16x8.mul %[-2], %[-1] +3573| drop +3574| return +3575| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3593| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +3611| i32x4.mul %[-2], %[-1] +3613| drop +3614| return +3615| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3633| i8x16.neg %[-1] +3635| drop +3636| return +3637| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3655| i16x8.neg %[-1] +3657| drop +3658| return +3659| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3677| i32x4.neg %[-1] +3679| drop +3680| return +3681| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3699| i64x2.neg %[-1] +3701| drop +3702| return +3703| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3721| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +3739| i8x16.add_saturate_s %[-2], %[-1] +3741| drop +3742| return +3743| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3761| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +3779| i8x16.add_saturate_u %[-2], %[-1] +3781| drop +3782| return +3783| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3801| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +3819| i16x8.add_saturate_s %[-2], %[-1] +3821| drop +3822| return +3823| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3841| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +3859| i16x8.add_saturate_u %[-2], %[-1] +3861| drop +3862| return +3863| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3881| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +3899| i8x16.sub_saturate_s %[-2], %[-1] +3901| drop +3902| return +3903| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3921| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +3939| i8x16.sub_saturate_u %[-2], %[-1] +3941| drop +3942| return +3943| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +3961| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +3979| i16x8.sub_saturate_s %[-2], %[-1] +3981| drop +3982| return +3983| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4001| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +4019| i16x8.sub_saturate_u %[-2], %[-1] +4021| drop +4022| return +4023| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4041| i32.const $0 +4046| i8x16.shl %[-2], %[-1] +4048| drop +4049| return +4050| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4068| i32.const $0 +4073| i16x8.shl %[-2], %[-1] +4075| drop +4076| return +4077| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4095| i32.const $0 +4100| i32x4.shl %[-2], %[-1] +4102| drop +4103| return +4104| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4122| i32.const $0 +4127| i64x2.shl %[-2], %[-1] +4129| drop +4130| return +4131| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4149| i32.const $0 +4154| i8x16.shr_s %[-2], %[-1] +4156| drop +4157| return +4158| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4176| i32.const $0 +4181| i8x16.shr_u %[-2], %[-1] +4183| drop +4184| return +4185| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4203| i32.const $0 +4208| i16x8.shr_s %[-2], %[-1] +4210| drop +4211| return +4212| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4230| i32.const $0 +4235| i16x8.shr_u %[-2], %[-1] +4237| drop +4238| return +4239| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4257| i32.const $0 +4262| i32x4.shr_s %[-2], %[-1] +4264| drop +4265| return +4266| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4284| i32.const $0 +4289| i32x4.shr_u %[-2], %[-1] +4291| drop +4292| return +4293| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4311| i32.const $0 +4316| i64x2.shr_s %[-2], %[-1] +4318| drop +4319| return +4320| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4338| i32.const $0 +4343| i64x2.shr_u %[-2], %[-1] +4345| drop +4346| return +4347| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4365| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +4383| v128.and %[-2], %[-1] +4385| drop +4386| return +4387| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4405| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +4423| v128.or %[-2], %[-1] +4425| drop +4426| return +4427| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4445| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +4463| v128.xor %[-2], %[-1] +4465| drop +4466| return +4467| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4485| v128.not %[-1] +4487| drop +4488| return +4489| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4507| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +4525| v128.const $0x00000003 0x00000003 0x00000003 0x00000003 +4543| v128.bitselect %[-3], %[-2], %[-1] +4545| drop +4546| return +4547| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4565| i8x16.any_true %[-1] +4567| drop +4568| return +4569| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4587| i16x8.any_true %[-1] +4589| drop +4590| return +4591| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4609| i32x4.any_true %[-1] +4611| drop +4612| return +4613| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4631| i64x2.any_true %[-1] +4633| drop +4634| return +4635| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4653| i8x16.all_true %[-1] +4655| drop +4656| return +4657| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4675| i16x8.all_true %[-1] +4677| drop +4678| return +4679| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4697| i32x4.all_true %[-1] +4699| drop +4700| return +4701| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4719| i64x2.all_true %[-1] +4721| drop +4722| return +4723| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4741| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +4759| i8x16.eq %[-2], %[-1] +4761| drop +4762| return +4763| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4781| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +4799| i16x8.eq %[-2], %[-1] +4801| drop +4802| return +4803| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4821| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +4839| i32x4.eq %[-2], %[-1] +4841| drop +4842| return +4843| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4861| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +4879| f32x4.eq %[-2], %[-1] +4881| drop +4882| return +4883| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4901| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +4919| f64x2.eq %[-2], %[-1] +4921| drop +4922| return +4923| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4941| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +4959| i8x16.ne %[-2], %[-1] +4961| drop +4962| return +4963| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +4981| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +4999| i16x8.ne %[-2], %[-1] +5001| drop +5002| return +5003| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5021| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5039| i32x4.ne %[-2], %[-1] +5041| drop +5042| return +5043| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5061| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5079| f32x4.ne %[-2], %[-1] +5081| drop +5082| return +5083| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5101| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5119| f64x2.ne %[-2], %[-1] +5121| drop +5122| return +5123| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5141| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5159| i8x16.lt_s %[-2], %[-1] +5161| drop +5162| return +5163| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5181| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5199| i8x16.lt_u %[-2], %[-1] +5201| drop +5202| return +5203| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5221| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5239| i16x8.lt_s %[-2], %[-1] +5241| drop +5242| return +5243| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5261| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5279| i16x8.lt_u %[-2], %[-1] +5281| drop +5282| return +5283| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5301| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5319| i32x4.lt_s %[-2], %[-1] +5321| drop +5322| return +5323| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5341| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5359| i32x4.lt_u %[-2], %[-1] +5361| drop +5362| return +5363| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5381| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5399| f32x4.lt %[-2], %[-1] +5401| drop +5402| return +5403| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5421| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5439| f64x2.lt %[-2], %[-1] +5441| drop +5442| return +5443| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5461| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5479| i8x16.le_s %[-2], %[-1] +5481| drop +5482| return +5483| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5501| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5519| i8x16.le_u %[-2], %[-1] +5521| drop +5522| return +5523| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5541| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5559| i16x8.le_s %[-2], %[-1] +5561| drop +5562| return +5563| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5581| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5599| i16x8.le_u %[-2], %[-1] +5601| drop +5602| return +5603| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5621| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5639| i32x4.le_s %[-2], %[-1] +5641| drop +5642| return +5643| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5661| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5679| i32x4.le_u %[-2], %[-1] +5681| drop +5682| return +5683| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5701| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5719| f32x4.le %[-2], %[-1] +5721| drop +5722| return +5723| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5741| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5759| f64x2.le %[-2], %[-1] +5761| drop +5762| return +5763| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5781| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5799| i8x16.gt_s %[-2], %[-1] +5801| drop +5802| return +5803| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5821| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5839| i8x16.gt_u %[-2], %[-1] +5841| drop +5842| return +5843| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5861| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5879| i16x8.gt_s %[-2], %[-1] +5881| drop +5882| return +5883| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5901| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5919| i16x8.gt_u %[-2], %[-1] +5921| drop +5922| return +5923| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5941| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5959| i32x4.gt_s %[-2], %[-1] +5961| drop +5962| return +5963| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +5981| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +5999| i32x4.gt_u %[-2], %[-1] +6001| drop +6002| return +6003| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6021| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +6039| f32x4.gt %[-2], %[-1] +6041| drop +6042| return +6043| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6061| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +6079| f64x2.gt %[-2], %[-1] +6081| drop +6082| return +6083| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6101| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +6119| i8x16.ge_s %[-2], %[-1] +6121| drop +6122| return +6123| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6141| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +6159| i8x16.ge_u %[-2], %[-1] +6161| drop +6162| return +6163| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6181| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +6199| i16x8.ge_s %[-2], %[-1] +6201| drop +6202| return +6203| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6221| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +6239| i16x8.ge_u %[-2], %[-1] +6241| drop +6242| return +6243| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6261| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +6279| i32x4.ge_s %[-2], %[-1] +6281| drop +6282| return +6283| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6301| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +6319| i32x4.ge_u %[-2], %[-1] +6321| drop +6322| return +6323| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6341| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +6359| f32x4.ge %[-2], %[-1] +6361| drop +6362| return +6363| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6381| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +6399| f64x2.ge %[-2], %[-1] +6401| drop +6402| return +6403| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6421| f32x4.neg %[-1] +6423| drop +6424| return +6425| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6443| f64x2.neg %[-1] +6445| drop +6446| return +6447| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6465| f32x4.abs %[-1] +6467| drop +6468| return +6469| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6487| f64x2.abs %[-1] +6489| drop +6490| return +6491| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6509| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +6527| f32x4.min %[-2], %[-1] +6529| drop +6530| return +6531| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6549| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +6567| f64x2.min %[-2], %[-1] +6569| drop +6570| return +6571| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6589| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +6607| f32x4.max %[-2], %[-1] +6609| drop +6610| return +6611| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6629| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +6647| f64x2.max %[-2], %[-1] +6649| drop +6650| return +6651| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6669| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +6687| f32x4.add %[-2], %[-1] +6689| drop +6690| return +6691| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6709| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +6727| f64x2.add %[-2], %[-1] +6729| drop +6730| return +6731| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6749| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +6767| f32x4.sub %[-2], %[-1] +6769| drop +6770| return +6771| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6789| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +6807| f64x2.sub %[-2], %[-1] +6809| drop +6810| return +6811| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6829| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +6847| f32x4.div %[-2], %[-1] +6849| drop +6850| return +6851| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6869| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +6887| f64x2.div %[-2], %[-1] +6889| drop +6890| return +6891| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6909| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +6927| f32x4.mul %[-2], %[-1] +6929| drop +6930| return +6931| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6949| v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +6967| f64x2.mul %[-2], %[-1] +6969| drop +6970| return +6971| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +6989| f32x4.sqrt %[-1] +6991| drop +6992| return +6993| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +7011| f64x2.sqrt %[-1] +7013| drop +7014| return +7015| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +7033| f32x4.convert_s/i32x4 %[-1] +7035| drop +7036| return +7037| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +7055| f32x4.convert_u/i32x4 %[-1] +7057| drop +7058| return +7059| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +7077| f64x2.convert_s/i64x2 %[-1] +7079| drop +7080| return +7081| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +7099| f64x2.convert_u/i64x2 %[-1] +7101| drop +7102| return +7103| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +7121| i32x4.trunc_s/f32x4:sat %[-1] +7123| drop +7124| return +7125| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +7143| i32x4.trunc_u/f32x4:sat %[-1] +7145| drop +7146| return +7147| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +7165| i64x2.trunc_s/f64x2:sat %[-1] +7167| drop +7168| return +7169| v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +7187| i64x2.trunc_u/f64x2:sat %[-1] +7189| drop +7190| return +7191| i32.const $1 +7196| i32.const $2 +7201| atomic.wake $0:%[-2]+$3, %[-1] +7211| drop +7212| return +7213| i32.const $1 +7218| i32.const $2 +7223| i64.const $3 +7232| i32.atomic.wait $0:%[-3]+$3, %[-2], %[-1] +7242| drop +7243| return +7244| i32.const $1 +7249| i64.const $2 +7258| i64.const $3 +7267| i64.atomic.wait $0:%[-3]+$3, %[-2], %[-1] +7277| drop +7278| return +7279| i32.const $1 +7284| i32.atomic.load $0:%[-1]+$3 +7294| drop +7295| return +7296| i32.const $1 +7301| i64.atomic.load $0:%[-1]+$7 +7311| drop +7312| return +7313| i32.const $1 +7318| i32.atomic.load8_u $0:%[-1]+$3 +7328| drop +7329| return +7330| i32.const $1 +7335| i32.atomic.load16_u $0:%[-1]+$3 +7345| drop +7346| return +7347| i32.const $1 +7352| i64.atomic.load8_u $0:%[-1]+$3 +7362| drop +7363| return +7364| i32.const $1 +7369| i64.atomic.load16_u $0:%[-1]+$3 +7379| drop +7380| return +7381| i32.const $1 +7386| i64.atomic.load32_u $0:%[-1]+$3 +7396| drop +7397| return +7398| i32.const $1 +7403| i32.const $2 +7408| i32.atomic.store $0:%[-2]+$3, %[-1] +7418| return +7419| i32.const $1 +7424| i64.const $2 +7433| i64.atomic.store $0:%[-2]+$7, %[-1] +7443| return +7444| i32.const $1 +7449| i32.const $2 +7454| i32.atomic.store8 $0:%[-2]+$3, %[-1] +7464| return +7465| i32.const $1 +7470| i32.const $2 +7475| i32.atomic.store16 $0:%[-2]+$3, %[-1] +7485| return +7486| i32.const $1 +7491| i64.const $2 +7500| i64.atomic.store8 $0:%[-2]+$3, %[-1] +7510| return +7511| i32.const $1 +7516| i64.const $2 +7525| i64.atomic.store16 $0:%[-2]+$3, %[-1] +7535| return +7536| i32.const $1 +7541| i64.const $2 +7550| i64.atomic.store32 $0:%[-2]+$3, %[-1] +7560| return +7561| i32.const $1 +7566| i32.const $2 +7571| i32.atomic.rmw.add $0:%[-2]+$3, %[-1] +7581| drop +7582| return +7583| i32.const $1 +7588| i64.const $2 +7597| i64.atomic.rmw.add $0:%[-2]+$7, %[-1] +7607| drop +7608| return +7609| i32.const $1 +7614| i32.const $2 +7619| i32.atomic.rmw8_u.add $0:%[-2]+$3, %[-1] +7629| drop +7630| return +7631| i32.const $1 +7636| i32.const $2 +7641| i32.atomic.rmw16_u.add $0:%[-2]+$3, %[-1] +7651| drop +7652| return +7653| i32.const $1 +7658| i64.const $2 +7667| i64.atomic.rmw8_u.add $0:%[-2]+$3, %[-1] +7677| drop +7678| return +7679| i32.const $1 +7684| i64.const $2 +7693| i64.atomic.rmw16_u.add $0:%[-2]+$3, %[-1] +7703| drop +7704| return +7705| i32.const $1 +7710| i64.const $2 +7719| i64.atomic.rmw32_u.add $0:%[-2]+$3, %[-1] +7729| drop +7730| return +7731| i32.const $1 +7736| i32.const $2 +7741| i32.atomic.rmw.sub $0:%[-2]+$3, %[-1] +7751| drop +7752| return +7753| i32.const $1 +7758| i64.const $2 +7767| i64.atomic.rmw.sub $0:%[-2]+$7, %[-1] +7777| drop +7778| return +7779| i32.const $1 +7784| i32.const $2 +7789| i32.atomic.rmw8_u.sub $0:%[-2]+$3, %[-1] +7799| drop +7800| return +7801| i32.const $1 +7806| i32.const $2 +7811| i32.atomic.rmw16_u.sub $0:%[-2]+$3, %[-1] +7821| drop +7822| return +7823| i32.const $1 +7828| i64.const $2 +7837| i64.atomic.rmw8_u.sub $0:%[-2]+$3, %[-1] +7847| drop +7848| return +7849| i32.const $1 +7854| i64.const $2 +7863| i64.atomic.rmw16_u.sub $0:%[-2]+$3, %[-1] +7873| drop +7874| return +7875| i32.const $1 +7880| i64.const $2 +7889| i64.atomic.rmw32_u.sub $0:%[-2]+$3, %[-1] +7899| drop +7900| return +7901| i32.const $1 +7906| i32.const $2 +7911| i32.atomic.rmw.and $0:%[-2]+$3, %[-1] +7921| drop +7922| return +7923| i32.const $1 +7928| i64.const $2 +7937| i64.atomic.rmw.and $0:%[-2]+$7, %[-1] +7947| drop +7948| return +7949| i32.const $1 +7954| i32.const $2 +7959| i32.atomic.rmw8_u.and $0:%[-2]+$3, %[-1] +7969| drop +7970| return +7971| i32.const $1 +7976| i32.const $2 +7981| i32.atomic.rmw16_u.and $0:%[-2]+$3, %[-1] +7991| drop +7992| return +7993| i32.const $1 +7998| i64.const $2 +8007| i64.atomic.rmw8_u.and $0:%[-2]+$3, %[-1] +8017| drop +8018| return +8019| i32.const $1 +8024| i64.const $2 +8033| i64.atomic.rmw16_u.and $0:%[-2]+$3, %[-1] +8043| drop +8044| return +8045| i32.const $1 +8050| i64.const $2 +8059| i64.atomic.rmw32_u.and $0:%[-2]+$3, %[-1] +8069| drop +8070| return +8071| i32.const $1 +8076| i32.const $2 +8081| i32.atomic.rmw.or $0:%[-2]+$3, %[-1] +8091| drop +8092| return +8093| i32.const $1 +8098| i64.const $2 +8107| i64.atomic.rmw.or $0:%[-2]+$7, %[-1] +8117| drop +8118| return +8119| i32.const $1 +8124| i32.const $2 +8129| i32.atomic.rmw8_u.or $0:%[-2]+$3, %[-1] +8139| drop +8140| return +8141| i32.const $1 +8146| i32.const $2 +8151| i32.atomic.rmw16_u.or $0:%[-2]+$3, %[-1] +8161| drop +8162| return +8163| i32.const $1 +8168| i64.const $2 +8177| i64.atomic.rmw8_u.or $0:%[-2]+$3, %[-1] +8187| drop +8188| return +8189| i32.const $1 +8194| i64.const $2 +8203| i64.atomic.rmw16_u.or $0:%[-2]+$3, %[-1] +8213| drop +8214| return +8215| i32.const $1 +8220| i64.const $2 +8229| i64.atomic.rmw32_u.or $0:%[-2]+$3, %[-1] +8239| drop +8240| return +8241| i32.const $1 +8246| i32.const $2 +8251| i32.atomic.rmw.xor $0:%[-2]+$3, %[-1] +8261| drop +8262| return +8263| i32.const $1 +8268| i64.const $2 +8277| i64.atomic.rmw.xor $0:%[-2]+$7, %[-1] +8287| drop +8288| return +8289| i32.const $1 +8294| i32.const $2 +8299| i32.atomic.rmw8_u.xor $0:%[-2]+$3, %[-1] +8309| drop +8310| return +8311| i32.const $1 +8316| i32.const $2 +8321| i32.atomic.rmw16_u.xor $0:%[-2]+$3, %[-1] +8331| drop +8332| return +8333| i32.const $1 +8338| i64.const $2 +8347| i64.atomic.rmw8_u.xor $0:%[-2]+$3, %[-1] +8357| drop +8358| return +8359| i32.const $1 +8364| i64.const $2 +8373| i64.atomic.rmw16_u.xor $0:%[-2]+$3, %[-1] +8383| drop +8384| return +8385| i32.const $1 +8390| i64.const $2 +8399| i64.atomic.rmw32_u.xor $0:%[-2]+$3, %[-1] +8409| drop +8410| return +8411| i32.const $1 +8416| i32.const $2 +8421| i32.atomic.rmw.xchg $0:%[-2]+$3, %[-1] +8431| drop +8432| return +8433| i32.const $1 +8438| i64.const $2 +8447| i64.atomic.rmw.xchg $0:%[-2]+$7, %[-1] +8457| drop +8458| return +8459| i32.const $1 +8464| i32.const $2 +8469| i32.atomic.rmw8_u.xchg $0:%[-2]+$3, %[-1] +8479| drop +8480| return +8481| i32.const $1 +8486| i32.const $2 +8491| i32.atomic.rmw16_u.xchg $0:%[-2]+$3, %[-1] +8501| drop +8502| return +8503| i32.const $1 +8508| i64.const $2 +8517| i64.atomic.rmw8_u.xchg $0:%[-2]+$3, %[-1] +8527| drop +8528| return +8529| i32.const $1 +8534| i64.const $2 +8543| i64.atomic.rmw16_u.xchg $0:%[-2]+$3, %[-1] +8553| drop +8554| return +8555| i32.const $1 +8560| i64.const $2 +8569| i64.atomic.rmw32_u.xchg $0:%[-2]+$3, %[-1] +8579| drop +8580| return +8581| i32.const $1 +8586| i32.const $2 +8591| i32.const $3 +8596| i32.atomic.rmw.cmpxchg $0:%[-3]+$3, %[-2], %[-1] +8606| drop +8607| return +8608| i32.const $1 +8613| i64.const $2 +8622| i64.const $3 +8631| i64.atomic.rmw.cmpxchg $0:%[-3]+$7, %[-2], %[-1] +8641| drop +8642| return +8643| i32.const $1 +8648| i32.const $2 +8653| i32.const $3 +8658| i32.atomic.rmw8_u.cmpxchg $0:%[-3]+$3, %[-2], %[-1] +8668| drop +8669| return +8670| i32.const $1 +8675| i32.const $2 +8680| i32.const $3 +8685| i32.atomic.rmw16_u.cmpxchg $0:%[-3]+$3, %[-2], %[-1] +8695| drop +8696| return +8697| i32.const $1 +8702| i64.const $2 +8711| i64.const $3 +8720| i64.atomic.rmw8_u.cmpxchg $0:%[-3]+$3, %[-2], %[-1] +8730| drop +8731| return +8732| i32.const $1 +8737| i64.const $2 +8746| i64.const $3 +8755| i64.atomic.rmw16_u.cmpxchg $0:%[-3]+$3, %[-2], %[-1] +8765| drop +8766| return +8767| i32.const $1 +8772| i64.const $2 +8781| i64.const $3 +8790| i64.atomic.rmw32_u.cmpxchg $0:%[-3]+$3, %[-2], %[-1] +8800| drop +8801| return unreachable() => error: unreachable executed br() => br_table() => diff --git a/test/interp/loop-multi.txt b/test/interp/loop-multi.txt new file mode 100644 index 00000000..b3ad23bc --- /dev/null +++ b/test/interp/loop-multi.txt @@ -0,0 +1,30 @@ +;;; TOOL: run-interp +;;; ARGS*: --enable-multi-value +(module + (func (export "loop-multi-result") (result i32) + loop (result i32 i32) + i32.const 1 + i32.const 2 + end + i32.add) + + (func (export "loop-param-brif") (result i32) + (local $l i32) + i32.const 0 + loop $again (param i32) (result i32) + i32.const 3 + i32.add ;; +3 to TOS (loop param) + + tee_local $l + get_local $l ;; dup TOS + + i32.const 10 + i32.lt_s + br_if $again ;; loop if < 10 + end + ) +) +(;; STDOUT ;;; +loop-multi-result() => i32:3 +loop-param-brif() => i32:12 +;;; STDOUT ;;) diff --git a/test/interp/tracing-all-opcodes.txt b/test/interp/tracing-all-opcodes.txt index f0886bad..9c7a306b 100644 --- a/test/interp/tracing-all-opcodes.txt +++ b/test/interp/tracing-all-opcodes.txt @@ -435,2538 +435,2538 @@ br() => >>> running export "br_table": #0. 9: V:0 | i32.const $1 #0. 14: V:1 | br_table 1, $#0, table:$28 -#0. 37: V:0 | return +#0. 40: V:0 | return br_table() => >>> running export "return": -#0. 38: V:0 | return +#0. 41: V:0 | return return() => >>> running export "call": -#0. 40: V:0 | call @0 +#0. 43: V:0 | call @0 #1. 0: V:0 | return -#0. 45: V:0 | return +#0. 48: V:0 | return call() => >>> running export "call_indirect": -#0. 46: V:0 | i32.const $1 -#0. 51: V:1 | call_indirect $0, 1 +#0. 49: V:0 | i32.const $1 +#0. 54: V:1 | call_indirect $0, 1 #1. 0: V:0 | return -#0. 60: V:0 | return +#0. 63: V:0 | return call_indirect() => >>> running export "drop": -#0. 61: V:0 | i32.const $1 -#0. 66: V:1 | drop -#0. 67: V:0 | return +#0. 64: V:0 | i32.const $1 +#0. 69: V:1 | drop +#0. 70: V:0 | return drop() => >>> running export "select": -#0. 68: V:0 | i32.const $1 -#0. 73: V:1 | i32.const $2 -#0. 78: V:2 | i32.const $3 -#0. 83: V:3 | select 1, %[-2], %[-1] -#0. 84: V:1 | drop -#0. 85: V:0 | return +#0. 71: V:0 | i32.const $1 +#0. 76: V:1 | i32.const $2 +#0. 81: V:2 | i32.const $3 +#0. 86: V:3 | select 1, %[-2], %[-1] +#0. 87: V:1 | drop +#0. 88: V:0 | return select() => >>> running export "get_local": -#0. 86: V:0 | alloca $1 -#0. 91: V:1 | get_local $1 -#0. 96: V:2 | drop -#0. 97: V:1 | drop -#0. 98: V:0 | return +#0. 89: V:0 | alloca $1 +#0. 94: V:1 | get_local $1 +#0. 99: V:2 | drop +#0. 100: V:1 | drop +#0. 101: V:0 | return get_local() => >>> running export "set_local": -#0. 99: V:0 | alloca $1 -#0. 104: V:1 | i32.const $1 -#0. 109: V:2 | set_local $1, 1 -#0. 114: V:1 | drop -#0. 115: V:0 | return +#0. 102: V:0 | alloca $1 +#0. 107: V:1 | i32.const $1 +#0. 112: V:2 | set_local $1, 1 +#0. 117: V:1 | drop +#0. 118: V:0 | return set_local() => >>> running export "tee_local": -#0. 116: V:0 | alloca $1 -#0. 121: V:1 | i32.const $1 -#0. 126: V:2 | tee_local $2, 1 -#0. 131: V:2 | drop -#0. 132: V:1 | drop -#0. 133: V:0 | return +#0. 119: V:0 | alloca $1 +#0. 124: V:1 | i32.const $1 +#0. 129: V:2 | tee_local $2, 1 +#0. 134: V:2 | drop +#0. 135: V:1 | drop +#0. 136: V:0 | return tee_local() => >>> running export "get_global": -#0. 134: V:0 | get_global $0 -#0. 139: V:1 | drop -#0. 140: V:0 | return +#0. 137: V:0 | get_global $0 +#0. 142: V:1 | drop +#0. 143: V:0 | return get_global() => >>> running export "set_global": -#0. 141: V:0 | i32.const $1 -#0. 146: V:1 | set_global $0, 1 -#0. 151: V:0 | return +#0. 144: V:0 | i32.const $1 +#0. 149: V:1 | set_global $0, 1 +#0. 154: V:0 | return set_global() => >>> running export "i32.load": -#0. 152: V:0 | i32.const $1 -#0. 157: V:1 | i32.load $0:1+$2 -#0. 166: V:1 | drop -#0. 167: V:0 | return +#0. 155: V:0 | i32.const $1 +#0. 160: V:1 | i32.load $0:1+$2 +#0. 169: V:1 | drop +#0. 170: V:0 | return i32.load() => >>> running export "i64.load": -#0. 168: V:0 | i32.const $1 -#0. 173: V:1 | i64.load $0:1+$2 -#0. 182: V:1 | drop -#0. 183: V:0 | return +#0. 171: V:0 | i32.const $1 +#0. 176: V:1 | i64.load $0:1+$2 +#0. 185: V:1 | drop +#0. 186: V:0 | return i64.load() => >>> running export "f32.load": -#0. 184: V:0 | i32.const $1 -#0. 189: V:1 | f32.load $0:1+$2 -#0. 198: V:1 | drop -#0. 199: V:0 | return +#0. 187: V:0 | i32.const $1 +#0. 192: V:1 | f32.load $0:1+$2 +#0. 201: V:1 | drop +#0. 202: V:0 | return f32.load() => >>> running export "f64.load": -#0. 200: V:0 | i32.const $1 -#0. 205: V:1 | f64.load $0:1+$2 -#0. 214: V:1 | drop -#0. 215: V:0 | return +#0. 203: V:0 | i32.const $1 +#0. 208: V:1 | f64.load $0:1+$2 +#0. 217: V:1 | drop +#0. 218: V:0 | return f64.load() => >>> running export "i32.load8_s": -#0. 216: V:0 | i32.const $1 -#0. 221: V:1 | i32.load8_s $0:1+$2 -#0. 230: V:1 | drop -#0. 231: V:0 | return +#0. 219: V:0 | i32.const $1 +#0. 224: V:1 | i32.load8_s $0:1+$2 +#0. 233: V:1 | drop +#0. 234: V:0 | return i32.load8_s() => >>> running export "i32.load8_u": -#0. 232: V:0 | i32.const $1 -#0. 237: V:1 | i32.load8_u $0:1+$2 -#0. 246: V:1 | drop -#0. 247: V:0 | return +#0. 235: V:0 | i32.const $1 +#0. 240: V:1 | i32.load8_u $0:1+$2 +#0. 249: V:1 | drop +#0. 250: V:0 | return i32.load8_u() => >>> running export "i32.load16_s": -#0. 248: V:0 | i32.const $1 -#0. 253: V:1 | i32.load16_s $0:1+$2 -#0. 262: V:1 | drop -#0. 263: V:0 | return +#0. 251: V:0 | i32.const $1 +#0. 256: V:1 | i32.load16_s $0:1+$2 +#0. 265: V:1 | drop +#0. 266: V:0 | return i32.load16_s() => >>> running export "i32.load16_u": -#0. 264: V:0 | i32.const $1 -#0. 269: V:1 | i32.load16_u $0:1+$2 -#0. 278: V:1 | drop -#0. 279: V:0 | return +#0. 267: V:0 | i32.const $1 +#0. 272: V:1 | i32.load16_u $0:1+$2 +#0. 281: V:1 | drop +#0. 282: V:0 | return i32.load16_u() => >>> running export "i64.load8_s": -#0. 280: V:0 | i32.const $1 -#0. 285: V:1 | i64.load8_s $0:1+$2 -#0. 294: V:1 | drop -#0. 295: V:0 | return +#0. 283: V:0 | i32.const $1 +#0. 288: V:1 | i64.load8_s $0:1+$2 +#0. 297: V:1 | drop +#0. 298: V:0 | return i64.load8_s() => >>> running export "i64.load8_u": -#0. 296: V:0 | i32.const $1 -#0. 301: V:1 | i64.load8_u $0:1+$2 -#0. 310: V:1 | drop -#0. 311: V:0 | return +#0. 299: V:0 | i32.const $1 +#0. 304: V:1 | i64.load8_u $0:1+$2 +#0. 313: V:1 | drop +#0. 314: V:0 | return i64.load8_u() => >>> running export "i64.load16_s": -#0. 312: V:0 | i32.const $1 -#0. 317: V:1 | i64.load16_s $0:1+$2 -#0. 326: V:1 | drop -#0. 327: V:0 | return +#0. 315: V:0 | i32.const $1 +#0. 320: V:1 | i64.load16_s $0:1+$2 +#0. 329: V:1 | drop +#0. 330: V:0 | return i64.load16_s() => >>> running export "i64.load16_u": -#0. 328: V:0 | i32.const $1 -#0. 333: V:1 | i64.load16_u $0:1+$2 -#0. 342: V:1 | drop -#0. 343: V:0 | return +#0. 331: V:0 | i32.const $1 +#0. 336: V:1 | i64.load16_u $0:1+$2 +#0. 345: V:1 | drop +#0. 346: V:0 | return i64.load16_u() => >>> running export "i64.load32_s": -#0. 344: V:0 | i32.const $1 -#0. 349: V:1 | i64.load32_s $0:1+$2 -#0. 358: V:1 | drop -#0. 359: V:0 | return +#0. 347: V:0 | i32.const $1 +#0. 352: V:1 | i64.load32_s $0:1+$2 +#0. 361: V:1 | drop +#0. 362: V:0 | return i64.load32_s() => >>> running export "i64.load32_u": -#0. 360: V:0 | i32.const $1 -#0. 365: V:1 | i64.load32_u $0:1+$2 -#0. 374: V:1 | drop -#0. 375: V:0 | return +#0. 363: V:0 | i32.const $1 +#0. 368: V:1 | i64.load32_u $0:1+$2 +#0. 377: V:1 | drop +#0. 378: V:0 | return i64.load32_u() => >>> running export "i32.store": -#0. 376: V:0 | i32.const $1 -#0. 381: V:1 | i32.const $2 -#0. 386: V:2 | i32.store $0:1+$2, 2 -#0. 395: V:0 | return +#0. 379: V:0 | i32.const $1 +#0. 384: V:1 | i32.const $2 +#0. 389: V:2 | i32.store $0:1+$2, 2 +#0. 398: V:0 | return i32.store() => >>> running export "i64.store": -#0. 396: V:0 | i32.const $1 -#0. 401: V:1 | i64.const $2 -#0. 410: V:2 | i64.store $0:1+$2, 2 -#0. 419: V:0 | return +#0. 399: V:0 | i32.const $1 +#0. 404: V:1 | i64.const $2 +#0. 413: V:2 | i64.store $0:1+$2, 2 +#0. 422: V:0 | return i64.store() => >>> running export "f32.store": -#0. 420: V:0 | i32.const $1 -#0. 425: V:1 | f32.const $2 -#0. 430: V:2 | f32.store $0:1+$2, 2 -#0. 439: V:0 | return +#0. 423: V:0 | i32.const $1 +#0. 428: V:1 | f32.const $2 +#0. 433: V:2 | f32.store $0:1+$2, 2 +#0. 442: V:0 | return f32.store() => >>> running export "f64.store": -#0. 440: V:0 | i32.const $1 -#0. 445: V:1 | f64.const $2 -#0. 454: V:2 | f64.store $0:1+$2, 2 -#0. 463: V:0 | return +#0. 443: V:0 | i32.const $1 +#0. 448: V:1 | f64.const $2 +#0. 457: V:2 | f64.store $0:1+$2, 2 +#0. 466: V:0 | return f64.store() => >>> running export "i32.store8": -#0. 464: V:0 | i32.const $1 -#0. 469: V:1 | i32.const $2 -#0. 474: V:2 | i32.store8 $0:1+$2, 2 -#0. 483: V:0 | return +#0. 467: V:0 | i32.const $1 +#0. 472: V:1 | i32.const $2 +#0. 477: V:2 | i32.store8 $0:1+$2, 2 +#0. 486: V:0 | return i32.store8() => >>> running export "i32.store16": -#0. 484: V:0 | i32.const $1 -#0. 489: V:1 | i32.const $2 -#0. 494: V:2 | i32.store16 $0:1+$2, 2 -#0. 503: V:0 | return +#0. 487: V:0 | i32.const $1 +#0. 492: V:1 | i32.const $2 +#0. 497: V:2 | i32.store16 $0:1+$2, 2 +#0. 506: V:0 | return i32.store16() => >>> running export "i64.store8": -#0. 504: V:0 | i32.const $1 -#0. 509: V:1 | i64.const $2 -#0. 518: V:2 | i64.store8 $0:1+$2, 2 -#0. 527: V:0 | return +#0. 507: V:0 | i32.const $1 +#0. 512: V:1 | i64.const $2 +#0. 521: V:2 | i64.store8 $0:1+$2, 2 +#0. 530: V:0 | return i64.store8() => >>> running export "i64.store16": -#0. 528: V:0 | i32.const $1 -#0. 533: V:1 | i64.const $2 -#0. 542: V:2 | i64.store16 $0:1+$2, 2 -#0. 551: V:0 | return +#0. 531: V:0 | i32.const $1 +#0. 536: V:1 | i64.const $2 +#0. 545: V:2 | i64.store16 $0:1+$2, 2 +#0. 554: V:0 | return i64.store16() => >>> running export "i64.store32": -#0. 552: V:0 | i32.const $1 -#0. 557: V:1 | i64.const $2 -#0. 566: V:2 | i64.store32 $0:1+$2, 2 -#0. 575: V:0 | return +#0. 555: V:0 | i32.const $1 +#0. 560: V:1 | i64.const $2 +#0. 569: V:2 | i64.store32 $0:1+$2, 2 +#0. 578: V:0 | return i64.store32() => >>> running export "current_memory": -#0. 576: V:0 | memory.size $0 -#0. 581: V:1 | drop -#0. 582: V:0 | return +#0. 579: V:0 | memory.size $0 +#0. 584: V:1 | drop +#0. 585: V:0 | return current_memory() => >>> running export "grow_memory": -#0. 583: V:0 | i32.const $1 -#0. 588: V:1 | memory.grow $0:1 -#0. 593: V:1 | drop -#0. 594: V:0 | return +#0. 586: V:0 | i32.const $1 +#0. 591: V:1 | memory.grow $0:1 +#0. 596: V:1 | drop +#0. 597: V:0 | return grow_memory() => >>> running export "i32.const": -#0. 595: V:0 | i32.const $1 -#0. 600: V:1 | drop -#0. 601: V:0 | return +#0. 598: V:0 | i32.const $1 +#0. 603: V:1 | drop +#0. 604: V:0 | return i32.const() => >>> running export "i64.const": -#0. 602: V:0 | i64.const $1 -#0. 611: V:1 | drop -#0. 612: V:0 | return +#0. 605: V:0 | i64.const $1 +#0. 614: V:1 | drop +#0. 615: V:0 | return i64.const() => >>> running export "f32.const": -#0. 613: V:0 | f32.const $1 -#0. 618: V:1 | drop -#0. 619: V:0 | return +#0. 616: V:0 | f32.const $1 +#0. 621: V:1 | drop +#0. 622: V:0 | return f32.const() => >>> running export "f64.const": -#0. 620: V:0 | f64.const $1 -#0. 629: V:1 | drop -#0. 630: V:0 | return +#0. 623: V:0 | f64.const $1 +#0. 632: V:1 | drop +#0. 633: V:0 | return f64.const() => >>> running export "i32.eqz": -#0. 631: V:0 | i32.const $1 -#0. 636: V:1 | i32.eqz 1 -#0. 637: V:1 | drop -#0. 638: V:0 | return +#0. 634: V:0 | i32.const $1 +#0. 639: V:1 | i32.eqz 1 +#0. 640: V:1 | drop +#0. 641: V:0 | return i32.eqz() => >>> running export "i32.eq": -#0. 639: V:0 | i32.const $1 -#0. 644: V:1 | i32.const $2 -#0. 649: V:2 | i32.eq 1, 2 -#0. 650: V:1 | drop -#0. 651: V:0 | return +#0. 642: V:0 | i32.const $1 +#0. 647: V:1 | i32.const $2 +#0. 652: V:2 | i32.eq 1, 2 +#0. 653: V:1 | drop +#0. 654: V:0 | return i32.eq() => >>> running export "i32.ne": -#0. 652: V:0 | i32.const $1 -#0. 657: V:1 | i32.const $2 -#0. 662: V:2 | i32.ne 1, 2 -#0. 663: V:1 | drop -#0. 664: V:0 | return +#0. 655: V:0 | i32.const $1 +#0. 660: V:1 | i32.const $2 +#0. 665: V:2 | i32.ne 1, 2 +#0. 666: V:1 | drop +#0. 667: V:0 | return i32.ne() => >>> running export "i32.lt_s": -#0. 665: V:0 | i32.const $1 -#0. 670: V:1 | i32.const $2 -#0. 675: V:2 | i32.lt_s 1, 2 -#0. 676: V:1 | drop -#0. 677: V:0 | return +#0. 668: V:0 | i32.const $1 +#0. 673: V:1 | i32.const $2 +#0. 678: V:2 | i32.lt_s 1, 2 +#0. 679: V:1 | drop +#0. 680: V:0 | return i32.lt_s() => >>> running export "i32.lt_u": -#0. 678: V:0 | i32.const $1 -#0. 683: V:1 | i32.const $2 -#0. 688: V:2 | i32.lt_u 1, 2 -#0. 689: V:1 | drop -#0. 690: V:0 | return +#0. 681: V:0 | i32.const $1 +#0. 686: V:1 | i32.const $2 +#0. 691: V:2 | i32.lt_u 1, 2 +#0. 692: V:1 | drop +#0. 693: V:0 | return i32.lt_u() => >>> running export "i32.gt_s": -#0. 691: V:0 | i32.const $1 -#0. 696: V:1 | i32.const $2 -#0. 701: V:2 | i32.gt_s 1, 2 -#0. 702: V:1 | drop -#0. 703: V:0 | return +#0. 694: V:0 | i32.const $1 +#0. 699: V:1 | i32.const $2 +#0. 704: V:2 | i32.gt_s 1, 2 +#0. 705: V:1 | drop +#0. 706: V:0 | return i32.gt_s() => >>> running export "i32.gt_u": -#0. 704: V:0 | i32.const $1 -#0. 709: V:1 | i32.const $2 -#0. 714: V:2 | i32.gt_u 1, 2 -#0. 715: V:1 | drop -#0. 716: V:0 | return +#0. 707: V:0 | i32.const $1 +#0. 712: V:1 | i32.const $2 +#0. 717: V:2 | i32.gt_u 1, 2 +#0. 718: V:1 | drop +#0. 719: V:0 | return i32.gt_u() => >>> running export "i32.le_s": -#0. 717: V:0 | i32.const $1 -#0. 722: V:1 | i32.const $2 -#0. 727: V:2 | i32.le_s 1, 2 -#0. 728: V:1 | drop -#0. 729: V:0 | return +#0. 720: V:0 | i32.const $1 +#0. 725: V:1 | i32.const $2 +#0. 730: V:2 | i32.le_s 1, 2 +#0. 731: V:1 | drop +#0. 732: V:0 | return i32.le_s() => >>> running export "i32.le_u": -#0. 730: V:0 | i32.const $1 -#0. 735: V:1 | i32.const $2 -#0. 740: V:2 | i32.le_u 1, 2 -#0. 741: V:1 | drop -#0. 742: V:0 | return +#0. 733: V:0 | i32.const $1 +#0. 738: V:1 | i32.const $2 +#0. 743: V:2 | i32.le_u 1, 2 +#0. 744: V:1 | drop +#0. 745: V:0 | return i32.le_u() => >>> running export "i32.ge_s": -#0. 743: V:0 | i32.const $1 -#0. 748: V:1 | i32.const $2 -#0. 753: V:2 | i32.ge_s 1, 2 -#0. 754: V:1 | drop -#0. 755: V:0 | return +#0. 746: V:0 | i32.const $1 +#0. 751: V:1 | i32.const $2 +#0. 756: V:2 | i32.ge_s 1, 2 +#0. 757: V:1 | drop +#0. 758: V:0 | return i32.ge_s() => >>> running export "i32.ge_u": -#0. 756: V:0 | i32.const $1 -#0. 761: V:1 | i32.const $2 -#0. 766: V:2 | i32.ge_u 1, 2 -#0. 767: V:1 | drop -#0. 768: V:0 | return +#0. 759: V:0 | i32.const $1 +#0. 764: V:1 | i32.const $2 +#0. 769: V:2 | i32.ge_u 1, 2 +#0. 770: V:1 | drop +#0. 771: V:0 | return i32.ge_u() => >>> running export "i64.eqz": -#0. 769: V:0 | i64.const $1 -#0. 778: V:1 | i64.eqz 1 -#0. 779: V:1 | drop -#0. 780: V:0 | return +#0. 772: V:0 | i64.const $1 +#0. 781: V:1 | i64.eqz 1 +#0. 782: V:1 | drop +#0. 783: V:0 | return i64.eqz() => >>> running export "i64.eq": -#0. 781: V:0 | i64.const $1 -#0. 790: V:1 | i64.const $2 -#0. 799: V:2 | i64.eq 1, 2 -#0. 800: V:1 | drop -#0. 801: V:0 | return +#0. 784: V:0 | i64.const $1 +#0. 793: V:1 | i64.const $2 +#0. 802: V:2 | i64.eq 1, 2 +#0. 803: V:1 | drop +#0. 804: V:0 | return i64.eq() => >>> running export "i64.ne": -#0. 802: V:0 | i64.const $1 -#0. 811: V:1 | i64.const $2 -#0. 820: V:2 | i64.ne 1, 2 -#0. 821: V:1 | drop -#0. 822: V:0 | return +#0. 805: V:0 | i64.const $1 +#0. 814: V:1 | i64.const $2 +#0. 823: V:2 | i64.ne 1, 2 +#0. 824: V:1 | drop +#0. 825: V:0 | return i64.ne() => >>> running export "i64.lt_s": -#0. 823: V:0 | i64.const $1 -#0. 832: V:1 | i64.const $2 -#0. 841: V:2 | i64.lt_s 1, 2 -#0. 842: V:1 | drop -#0. 843: V:0 | return +#0. 826: V:0 | i64.const $1 +#0. 835: V:1 | i64.const $2 +#0. 844: V:2 | i64.lt_s 1, 2 +#0. 845: V:1 | drop +#0. 846: V:0 | return i64.lt_s() => >>> running export "i64.lt_u": -#0. 844: V:0 | i64.const $1 -#0. 853: V:1 | i64.const $2 -#0. 862: V:2 | i64.lt_u 1, 2 -#0. 863: V:1 | drop -#0. 864: V:0 | return +#0. 847: V:0 | i64.const $1 +#0. 856: V:1 | i64.const $2 +#0. 865: V:2 | i64.lt_u 1, 2 +#0. 866: V:1 | drop +#0. 867: V:0 | return i64.lt_u() => >>> running export "i64.gt_s": -#0. 865: V:0 | i64.const $1 -#0. 874: V:1 | i64.const $2 -#0. 883: V:2 | i64.gt_s 1, 2 -#0. 884: V:1 | drop -#0. 885: V:0 | return +#0. 868: V:0 | i64.const $1 +#0. 877: V:1 | i64.const $2 +#0. 886: V:2 | i64.gt_s 1, 2 +#0. 887: V:1 | drop +#0. 888: V:0 | return i64.gt_s() => >>> running export "i64.gt_u": -#0. 886: V:0 | i64.const $1 -#0. 895: V:1 | i64.const $2 -#0. 904: V:2 | i64.gt_u 1, 2 -#0. 905: V:1 | drop -#0. 906: V:0 | return +#0. 889: V:0 | i64.const $1 +#0. 898: V:1 | i64.const $2 +#0. 907: V:2 | i64.gt_u 1, 2 +#0. 908: V:1 | drop +#0. 909: V:0 | return i64.gt_u() => >>> running export "i64.le_s": -#0. 907: V:0 | i64.const $1 -#0. 916: V:1 | i64.const $2 -#0. 925: V:2 | i64.le_s 1, 2 -#0. 926: V:1 | drop -#0. 927: V:0 | return +#0. 910: V:0 | i64.const $1 +#0. 919: V:1 | i64.const $2 +#0. 928: V:2 | i64.le_s 1, 2 +#0. 929: V:1 | drop +#0. 930: V:0 | return i64.le_s() => >>> running export "i64.le_u": -#0. 928: V:0 | i64.const $1 -#0. 937: V:1 | i64.const $2 -#0. 946: V:2 | i64.le_u 1, 2 -#0. 947: V:1 | drop -#0. 948: V:0 | return +#0. 931: V:0 | i64.const $1 +#0. 940: V:1 | i64.const $2 +#0. 949: V:2 | i64.le_u 1, 2 +#0. 950: V:1 | drop +#0. 951: V:0 | return i64.le_u() => >>> running export "i64.ge_s": -#0. 949: V:0 | i64.const $1 -#0. 958: V:1 | i64.const $2 -#0. 967: V:2 | i64.ge_s 1, 2 -#0. 968: V:1 | drop -#0. 969: V:0 | return +#0. 952: V:0 | i64.const $1 +#0. 961: V:1 | i64.const $2 +#0. 970: V:2 | i64.ge_s 1, 2 +#0. 971: V:1 | drop +#0. 972: V:0 | return i64.ge_s() => >>> running export "i64.ge_u": -#0. 970: V:0 | i64.const $1 -#0. 979: V:1 | i64.const $2 -#0. 988: V:2 | i64.ge_u 1, 2 -#0. 989: V:1 | drop -#0. 990: V:0 | return +#0. 973: V:0 | i64.const $1 +#0. 982: V:1 | i64.const $2 +#0. 991: V:2 | i64.ge_u 1, 2 +#0. 992: V:1 | drop +#0. 993: V:0 | return i64.ge_u() => >>> running export "f32.eq": -#0. 991: V:0 | f32.const $1 -#0. 996: V:1 | f32.const $2 -#0. 1001: V:2 | f32.eq 1, 2 -#0. 1002: V:1 | drop -#0. 1003: V:0 | return +#0. 994: V:0 | f32.const $1 +#0. 999: V:1 | f32.const $2 +#0. 1004: V:2 | f32.eq 1, 2 +#0. 1005: V:1 | drop +#0. 1006: V:0 | return f32.eq() => >>> running export "f32.ne": -#0. 1004: V:0 | f32.const $1 -#0. 1009: V:1 | f32.const $2 -#0. 1014: V:2 | f32.ne 1, 2 -#0. 1015: V:1 | drop -#0. 1016: V:0 | return +#0. 1007: V:0 | f32.const $1 +#0. 1012: V:1 | f32.const $2 +#0. 1017: V:2 | f32.ne 1, 2 +#0. 1018: V:1 | drop +#0. 1019: V:0 | return f32.ne() => >>> running export "f32.lt": -#0. 1017: V:0 | f32.const $1 -#0. 1022: V:1 | f32.const $2 -#0. 1027: V:2 | f32.lt 1, 2 -#0. 1028: V:1 | drop -#0. 1029: V:0 | return +#0. 1020: V:0 | f32.const $1 +#0. 1025: V:1 | f32.const $2 +#0. 1030: V:2 | f32.lt 1, 2 +#0. 1031: V:1 | drop +#0. 1032: V:0 | return f32.lt() => >>> running export "f32.gt": -#0. 1030: V:0 | f32.const $1 -#0. 1035: V:1 | f32.const $2 -#0. 1040: V:2 | f32.gt 1, 2 -#0. 1041: V:1 | drop -#0. 1042: V:0 | return +#0. 1033: V:0 | f32.const $1 +#0. 1038: V:1 | f32.const $2 +#0. 1043: V:2 | f32.gt 1, 2 +#0. 1044: V:1 | drop +#0. 1045: V:0 | return f32.gt() => >>> running export "f32.le": -#0. 1043: V:0 | f32.const $1 -#0. 1048: V:1 | f32.const $2 -#0. 1053: V:2 | f32.le 1, 2 -#0. 1054: V:1 | drop -#0. 1055: V:0 | return +#0. 1046: V:0 | f32.const $1 +#0. 1051: V:1 | f32.const $2 +#0. 1056: V:2 | f32.le 1, 2 +#0. 1057: V:1 | drop +#0. 1058: V:0 | return f32.le() => >>> running export "f32.ge": -#0. 1056: V:0 | f32.const $1 -#0. 1061: V:1 | f32.const $2 -#0. 1066: V:2 | f32.ge 1, 2 -#0. 1067: V:1 | drop -#0. 1068: V:0 | return +#0. 1059: V:0 | f32.const $1 +#0. 1064: V:1 | f32.const $2 +#0. 1069: V:2 | f32.ge 1, 2 +#0. 1070: V:1 | drop +#0. 1071: V:0 | return f32.ge() => >>> running export "f64.eq": -#0. 1069: V:0 | f64.const $1 -#0. 1078: V:1 | f64.const $2 -#0. 1087: V:2 | f64.eq 1, 2 -#0. 1088: V:1 | drop -#0. 1089: V:0 | return +#0. 1072: V:0 | f64.const $1 +#0. 1081: V:1 | f64.const $2 +#0. 1090: V:2 | f64.eq 1, 2 +#0. 1091: V:1 | drop +#0. 1092: V:0 | return f64.eq() => >>> running export "f64.ne": -#0. 1090: V:0 | f64.const $1 -#0. 1099: V:1 | f64.const $2 -#0. 1108: V:2 | f64.ne 1, 2 -#0. 1109: V:1 | drop -#0. 1110: V:0 | return +#0. 1093: V:0 | f64.const $1 +#0. 1102: V:1 | f64.const $2 +#0. 1111: V:2 | f64.ne 1, 2 +#0. 1112: V:1 | drop +#0. 1113: V:0 | return f64.ne() => >>> running export "f64.lt": -#0. 1111: V:0 | f64.const $1 -#0. 1120: V:1 | f64.const $2 -#0. 1129: V:2 | f64.lt 1, 2 -#0. 1130: V:1 | drop -#0. 1131: V:0 | return +#0. 1114: V:0 | f64.const $1 +#0. 1123: V:1 | f64.const $2 +#0. 1132: V:2 | f64.lt 1, 2 +#0. 1133: V:1 | drop +#0. 1134: V:0 | return f64.lt() => >>> running export "f64.gt": -#0. 1132: V:0 | f64.const $1 -#0. 1141: V:1 | f64.const $2 -#0. 1150: V:2 | f64.gt 1, 2 -#0. 1151: V:1 | drop -#0. 1152: V:0 | return +#0. 1135: V:0 | f64.const $1 +#0. 1144: V:1 | f64.const $2 +#0. 1153: V:2 | f64.gt 1, 2 +#0. 1154: V:1 | drop +#0. 1155: V:0 | return f64.gt() => >>> running export "f64.le": -#0. 1153: V:0 | f64.const $1 -#0. 1162: V:1 | f64.const $2 -#0. 1171: V:2 | f64.le 1, 2 -#0. 1172: V:1 | drop -#0. 1173: V:0 | return +#0. 1156: V:0 | f64.const $1 +#0. 1165: V:1 | f64.const $2 +#0. 1174: V:2 | f64.le 1, 2 +#0. 1175: V:1 | drop +#0. 1176: V:0 | return f64.le() => >>> running export "f64.ge": -#0. 1174: V:0 | f64.const $1 -#0. 1183: V:1 | f64.const $2 -#0. 1192: V:2 | f64.ge 1, 2 -#0. 1193: V:1 | drop -#0. 1194: V:0 | return +#0. 1177: V:0 | f64.const $1 +#0. 1186: V:1 | f64.const $2 +#0. 1195: V:2 | f64.ge 1, 2 +#0. 1196: V:1 | drop +#0. 1197: V:0 | return f64.ge() => >>> running export "i32.clz": -#0. 1195: V:0 | i32.const $1 -#0. 1200: V:1 | i32.clz 1 -#0. 1201: V:1 | drop -#0. 1202: V:0 | return +#0. 1198: V:0 | i32.const $1 +#0. 1203: V:1 | i32.clz 1 +#0. 1204: V:1 | drop +#0. 1205: V:0 | return i32.clz() => >>> running export "i32.ctz": -#0. 1203: V:0 | i32.const $1 -#0. 1208: V:1 | i32.ctz 1 -#0. 1209: V:1 | drop -#0. 1210: V:0 | return +#0. 1206: V:0 | i32.const $1 +#0. 1211: V:1 | i32.ctz 1 +#0. 1212: V:1 | drop +#0. 1213: V:0 | return i32.ctz() => >>> running export "i32.popcnt": -#0. 1211: V:0 | i32.const $1 -#0. 1216: V:1 | i32.popcnt 1 -#0. 1217: V:1 | drop -#0. 1218: V:0 | return +#0. 1214: V:0 | i32.const $1 +#0. 1219: V:1 | i32.popcnt 1 +#0. 1220: V:1 | drop +#0. 1221: V:0 | return i32.popcnt() => >>> running export "i32.add": -#0. 1219: V:0 | i32.const $1 -#0. 1224: V:1 | i32.const $2 -#0. 1229: V:2 | i32.add 1, 2 -#0. 1230: V:1 | drop -#0. 1231: V:0 | return +#0. 1222: V:0 | i32.const $1 +#0. 1227: V:1 | i32.const $2 +#0. 1232: V:2 | i32.add 1, 2 +#0. 1233: V:1 | drop +#0. 1234: V:0 | return i32.add() => >>> running export "i32.sub": -#0. 1232: V:0 | i32.const $1 -#0. 1237: V:1 | i32.const $2 -#0. 1242: V:2 | i32.sub 1, 2 -#0. 1243: V:1 | drop -#0. 1244: V:0 | return +#0. 1235: V:0 | i32.const $1 +#0. 1240: V:1 | i32.const $2 +#0. 1245: V:2 | i32.sub 1, 2 +#0. 1246: V:1 | drop +#0. 1247: V:0 | return i32.sub() => >>> running export "i32.mul": -#0. 1245: V:0 | i32.const $1 -#0. 1250: V:1 | i32.const $2 -#0. 1255: V:2 | i32.mul 1, 2 -#0. 1256: V:1 | drop -#0. 1257: V:0 | return +#0. 1248: V:0 | i32.const $1 +#0. 1253: V:1 | i32.const $2 +#0. 1258: V:2 | i32.mul 1, 2 +#0. 1259: V:1 | drop +#0. 1260: V:0 | return i32.mul() => >>> running export "i32.div_s": -#0. 1258: V:0 | i32.const $1 -#0. 1263: V:1 | i32.const $2 -#0. 1268: V:2 | i32.div_s 1, 2 -#0. 1269: V:1 | drop -#0. 1270: V:0 | return +#0. 1261: V:0 | i32.const $1 +#0. 1266: V:1 | i32.const $2 +#0. 1271: V:2 | i32.div_s 1, 2 +#0. 1272: V:1 | drop +#0. 1273: V:0 | return i32.div_s() => >>> running export "i32.div_u": -#0. 1271: V:0 | i32.const $1 -#0. 1276: V:1 | i32.const $2 -#0. 1281: V:2 | i32.div_u 1, 2 -#0. 1282: V:1 | drop -#0. 1283: V:0 | return +#0. 1274: V:0 | i32.const $1 +#0. 1279: V:1 | i32.const $2 +#0. 1284: V:2 | i32.div_u 1, 2 +#0. 1285: V:1 | drop +#0. 1286: V:0 | return i32.div_u() => >>> running export "i32.rem_s": -#0. 1284: V:0 | i32.const $1 -#0. 1289: V:1 | i32.const $2 -#0. 1294: V:2 | i32.rem_s 1, 2 -#0. 1295: V:1 | drop -#0. 1296: V:0 | return +#0. 1287: V:0 | i32.const $1 +#0. 1292: V:1 | i32.const $2 +#0. 1297: V:2 | i32.rem_s 1, 2 +#0. 1298: V:1 | drop +#0. 1299: V:0 | return i32.rem_s() => >>> running export "i32.rem_u": -#0. 1297: V:0 | i32.const $1 -#0. 1302: V:1 | i32.const $2 -#0. 1307: V:2 | i32.rem_u 1, 2 -#0. 1308: V:1 | drop -#0. 1309: V:0 | return +#0. 1300: V:0 | i32.const $1 +#0. 1305: V:1 | i32.const $2 +#0. 1310: V:2 | i32.rem_u 1, 2 +#0. 1311: V:1 | drop +#0. 1312: V:0 | return i32.rem_u() => >>> running export "i32.and": -#0. 1310: V:0 | i32.const $1 -#0. 1315: V:1 | i32.const $2 -#0. 1320: V:2 | i32.and 1, 2 -#0. 1321: V:1 | drop -#0. 1322: V:0 | return +#0. 1313: V:0 | i32.const $1 +#0. 1318: V:1 | i32.const $2 +#0. 1323: V:2 | i32.and 1, 2 +#0. 1324: V:1 | drop +#0. 1325: V:0 | return i32.and() => >>> running export "i32.or": -#0. 1323: V:0 | i32.const $1 -#0. 1328: V:1 | i32.const $2 -#0. 1333: V:2 | i32.or 1, 2 -#0. 1334: V:1 | drop -#0. 1335: V:0 | return +#0. 1326: V:0 | i32.const $1 +#0. 1331: V:1 | i32.const $2 +#0. 1336: V:2 | i32.or 1, 2 +#0. 1337: V:1 | drop +#0. 1338: V:0 | return i32.or() => >>> running export "i32.xor": -#0. 1336: V:0 | i32.const $1 -#0. 1341: V:1 | i32.const $2 -#0. 1346: V:2 | i32.xor 1, 2 -#0. 1347: V:1 | drop -#0. 1348: V:0 | return +#0. 1339: V:0 | i32.const $1 +#0. 1344: V:1 | i32.const $2 +#0. 1349: V:2 | i32.xor 1, 2 +#0. 1350: V:1 | drop +#0. 1351: V:0 | return i32.xor() => >>> running export "i32.shl": -#0. 1349: V:0 | i32.const $1 -#0. 1354: V:1 | i32.const $2 -#0. 1359: V:2 | i32.shl 1, 2 -#0. 1360: V:1 | drop -#0. 1361: V:0 | return +#0. 1352: V:0 | i32.const $1 +#0. 1357: V:1 | i32.const $2 +#0. 1362: V:2 | i32.shl 1, 2 +#0. 1363: V:1 | drop +#0. 1364: V:0 | return i32.shl() => >>> running export "i32.shr_s": -#0. 1362: V:0 | i32.const $1 -#0. 1367: V:1 | i32.const $2 -#0. 1372: V:2 | i32.shr_s 1, 2 -#0. 1373: V:1 | drop -#0. 1374: V:0 | return +#0. 1365: V:0 | i32.const $1 +#0. 1370: V:1 | i32.const $2 +#0. 1375: V:2 | i32.shr_s 1, 2 +#0. 1376: V:1 | drop +#0. 1377: V:0 | return i32.shr_s() => >>> running export "i32.shr_u": -#0. 1375: V:0 | i32.const $1 -#0. 1380: V:1 | i32.const $2 -#0. 1385: V:2 | i32.shr_u 1, 2 -#0. 1386: V:1 | drop -#0. 1387: V:0 | return +#0. 1378: V:0 | i32.const $1 +#0. 1383: V:1 | i32.const $2 +#0. 1388: V:2 | i32.shr_u 1, 2 +#0. 1389: V:1 | drop +#0. 1390: V:0 | return i32.shr_u() => >>> running export "i32.rotl": -#0. 1388: V:0 | i32.const $1 -#0. 1393: V:1 | i32.const $2 -#0. 1398: V:2 | i32.rotl 1, 2 -#0. 1399: V:1 | drop -#0. 1400: V:0 | return +#0. 1391: V:0 | i32.const $1 +#0. 1396: V:1 | i32.const $2 +#0. 1401: V:2 | i32.rotl 1, 2 +#0. 1402: V:1 | drop +#0. 1403: V:0 | return i32.rotl() => >>> running export "i32.rotr": -#0. 1401: V:0 | i32.const $1 -#0. 1406: V:1 | i32.const $2 -#0. 1411: V:2 | i32.rotr 1, 2 -#0. 1412: V:1 | drop -#0. 1413: V:0 | return +#0. 1404: V:0 | i32.const $1 +#0. 1409: V:1 | i32.const $2 +#0. 1414: V:2 | i32.rotr 1, 2 +#0. 1415: V:1 | drop +#0. 1416: V:0 | return i32.rotr() => >>> running export "i64.clz": -#0. 1414: V:0 | i64.const $1 -#0. 1423: V:1 | i64.clz 1 -#0. 1424: V:1 | drop -#0. 1425: V:0 | return +#0. 1417: V:0 | i64.const $1 +#0. 1426: V:1 | i64.clz 1 +#0. 1427: V:1 | drop +#0. 1428: V:0 | return i64.clz() => >>> running export "i64.ctz": -#0. 1426: V:0 | i64.const $1 -#0. 1435: V:1 | i64.ctz 1 -#0. 1436: V:1 | drop -#0. 1437: V:0 | return +#0. 1429: V:0 | i64.const $1 +#0. 1438: V:1 | i64.ctz 1 +#0. 1439: V:1 | drop +#0. 1440: V:0 | return i64.ctz() => >>> running export "i64.popcnt": -#0. 1438: V:0 | i64.const $1 -#0. 1447: V:1 | i64.popcnt 1 -#0. 1448: V:1 | drop -#0. 1449: V:0 | return +#0. 1441: V:0 | i64.const $1 +#0. 1450: V:1 | i64.popcnt 1 +#0. 1451: V:1 | drop +#0. 1452: V:0 | return i64.popcnt() => >>> running export "i64.add": -#0. 1450: V:0 | i64.const $1 -#0. 1459: V:1 | i64.const $2 -#0. 1468: V:2 | i64.add 1, 2 -#0. 1469: V:1 | drop -#0. 1470: V:0 | return +#0. 1453: V:0 | i64.const $1 +#0. 1462: V:1 | i64.const $2 +#0. 1471: V:2 | i64.add 1, 2 +#0. 1472: V:1 | drop +#0. 1473: V:0 | return i64.add() => >>> running export "i64.sub": -#0. 1471: V:0 | i64.const $1 -#0. 1480: V:1 | i64.const $2 -#0. 1489: V:2 | i64.sub 1, 2 -#0. 1490: V:1 | drop -#0. 1491: V:0 | return +#0. 1474: V:0 | i64.const $1 +#0. 1483: V:1 | i64.const $2 +#0. 1492: V:2 | i64.sub 1, 2 +#0. 1493: V:1 | drop +#0. 1494: V:0 | return i64.sub() => >>> running export "i64.mul": -#0. 1492: V:0 | i64.const $1 -#0. 1501: V:1 | i64.const $2 -#0. 1510: V:2 | i64.mul 1, 2 -#0. 1511: V:1 | drop -#0. 1512: V:0 | return +#0. 1495: V:0 | i64.const $1 +#0. 1504: V:1 | i64.const $2 +#0. 1513: V:2 | i64.mul 1, 2 +#0. 1514: V:1 | drop +#0. 1515: V:0 | return i64.mul() => >>> running export "i64.div_s": -#0. 1513: V:0 | i64.const $1 -#0. 1522: V:1 | i64.const $2 -#0. 1531: V:2 | i64.div_s 1, 2 -#0. 1532: V:1 | drop -#0. 1533: V:0 | return +#0. 1516: V:0 | i64.const $1 +#0. 1525: V:1 | i64.const $2 +#0. 1534: V:2 | i64.div_s 1, 2 +#0. 1535: V:1 | drop +#0. 1536: V:0 | return i64.div_s() => >>> running export "i64.div_u": -#0. 1534: V:0 | i64.const $1 -#0. 1543: V:1 | i64.const $2 -#0. 1552: V:2 | i64.div_u 1, 2 -#0. 1553: V:1 | drop -#0. 1554: V:0 | return +#0. 1537: V:0 | i64.const $1 +#0. 1546: V:1 | i64.const $2 +#0. 1555: V:2 | i64.div_u 1, 2 +#0. 1556: V:1 | drop +#0. 1557: V:0 | return i64.div_u() => >>> running export "i64.rem_s": -#0. 1555: V:0 | i64.const $1 -#0. 1564: V:1 | i64.const $2 -#0. 1573: V:2 | i64.rem_s 1, 2 -#0. 1574: V:1 | drop -#0. 1575: V:0 | return +#0. 1558: V:0 | i64.const $1 +#0. 1567: V:1 | i64.const $2 +#0. 1576: V:2 | i64.rem_s 1, 2 +#0. 1577: V:1 | drop +#0. 1578: V:0 | return i64.rem_s() => >>> running export "i64.rem_u": -#0. 1576: V:0 | i64.const $1 -#0. 1585: V:1 | i64.const $2 -#0. 1594: V:2 | i64.rem_u 1, 2 -#0. 1595: V:1 | drop -#0. 1596: V:0 | return +#0. 1579: V:0 | i64.const $1 +#0. 1588: V:1 | i64.const $2 +#0. 1597: V:2 | i64.rem_u 1, 2 +#0. 1598: V:1 | drop +#0. 1599: V:0 | return i64.rem_u() => >>> running export "i64.and": -#0. 1597: V:0 | i64.const $1 -#0. 1606: V:1 | i64.const $2 -#0. 1615: V:2 | i64.and 1, 2 -#0. 1616: V:1 | drop -#0. 1617: V:0 | return +#0. 1600: V:0 | i64.const $1 +#0. 1609: V:1 | i64.const $2 +#0. 1618: V:2 | i64.and 1, 2 +#0. 1619: V:1 | drop +#0. 1620: V:0 | return i64.and() => >>> running export "i64.or": -#0. 1618: V:0 | i64.const $1 -#0. 1627: V:1 | i64.const $2 -#0. 1636: V:2 | i64.or 1, 2 -#0. 1637: V:1 | drop -#0. 1638: V:0 | return +#0. 1621: V:0 | i64.const $1 +#0. 1630: V:1 | i64.const $2 +#0. 1639: V:2 | i64.or 1, 2 +#0. 1640: V:1 | drop +#0. 1641: V:0 | return i64.or() => >>> running export "i64.xor": -#0. 1639: V:0 | i64.const $1 -#0. 1648: V:1 | i64.const $2 -#0. 1657: V:2 | i64.xor 1, 2 -#0. 1658: V:1 | drop -#0. 1659: V:0 | return +#0. 1642: V:0 | i64.const $1 +#0. 1651: V:1 | i64.const $2 +#0. 1660: V:2 | i64.xor 1, 2 +#0. 1661: V:1 | drop +#0. 1662: V:0 | return i64.xor() => >>> running export "i64.shl": -#0. 1660: V:0 | i64.const $1 -#0. 1669: V:1 | i64.const $2 -#0. 1678: V:2 | i64.shl 1, 2 -#0. 1679: V:1 | drop -#0. 1680: V:0 | return +#0. 1663: V:0 | i64.const $1 +#0. 1672: V:1 | i64.const $2 +#0. 1681: V:2 | i64.shl 1, 2 +#0. 1682: V:1 | drop +#0. 1683: V:0 | return i64.shl() => >>> running export "i64.shr_s": -#0. 1681: V:0 | i64.const $1 -#0. 1690: V:1 | i64.const $2 -#0. 1699: V:2 | i64.shr_s 1, 2 -#0. 1700: V:1 | drop -#0. 1701: V:0 | return +#0. 1684: V:0 | i64.const $1 +#0. 1693: V:1 | i64.const $2 +#0. 1702: V:2 | i64.shr_s 1, 2 +#0. 1703: V:1 | drop +#0. 1704: V:0 | return i64.shr_s() => >>> running export "i64.shr_u": -#0. 1702: V:0 | i64.const $1 -#0. 1711: V:1 | i64.const $2 -#0. 1720: V:2 | i64.shr_u 1, 2 -#0. 1721: V:1 | drop -#0. 1722: V:0 | return +#0. 1705: V:0 | i64.const $1 +#0. 1714: V:1 | i64.const $2 +#0. 1723: V:2 | i64.shr_u 1, 2 +#0. 1724: V:1 | drop +#0. 1725: V:0 | return i64.shr_u() => >>> running export "i64.rotl": -#0. 1723: V:0 | i64.const $1 -#0. 1732: V:1 | i64.const $2 -#0. 1741: V:2 | i64.rotl 1, 2 -#0. 1742: V:1 | drop -#0. 1743: V:0 | return +#0. 1726: V:0 | i64.const $1 +#0. 1735: V:1 | i64.const $2 +#0. 1744: V:2 | i64.rotl 1, 2 +#0. 1745: V:1 | drop +#0. 1746: V:0 | return i64.rotl() => >>> running export "i64.rotr": -#0. 1744: V:0 | i64.const $1 -#0. 1753: V:1 | i64.const $2 -#0. 1762: V:2 | i64.rotr 1, 2 -#0. 1763: V:1 | drop -#0. 1764: V:0 | return +#0. 1747: V:0 | i64.const $1 +#0. 1756: V:1 | i64.const $2 +#0. 1765: V:2 | i64.rotr 1, 2 +#0. 1766: V:1 | drop +#0. 1767: V:0 | return i64.rotr() => >>> running export "f32.abs": -#0. 1765: V:0 | f32.const $1 -#0. 1770: V:1 | f32.abs 1 -#0. 1771: V:1 | drop -#0. 1772: V:0 | return +#0. 1768: V:0 | f32.const $1 +#0. 1773: V:1 | f32.abs 1 +#0. 1774: V:1 | drop +#0. 1775: V:0 | return f32.abs() => >>> running export "f32.neg": -#0. 1773: V:0 | f32.const $1 -#0. 1778: V:1 | f32.neg 1 -#0. 1779: V:1 | drop -#0. 1780: V:0 | return +#0. 1776: V:0 | f32.const $1 +#0. 1781: V:1 | f32.neg 1 +#0. 1782: V:1 | drop +#0. 1783: V:0 | return f32.neg() => >>> running export "f32.ceil": -#0. 1781: V:0 | f32.const $1 -#0. 1786: V:1 | f32.ceil 1 -#0. 1787: V:1 | drop -#0. 1788: V:0 | return +#0. 1784: V:0 | f32.const $1 +#0. 1789: V:1 | f32.ceil 1 +#0. 1790: V:1 | drop +#0. 1791: V:0 | return f32.ceil() => >>> running export "f32.floor": -#0. 1789: V:0 | f32.const $1 -#0. 1794: V:1 | f32.floor 1 -#0. 1795: V:1 | drop -#0. 1796: V:0 | return +#0. 1792: V:0 | f32.const $1 +#0. 1797: V:1 | f32.floor 1 +#0. 1798: V:1 | drop +#0. 1799: V:0 | return f32.floor() => >>> running export "f32.trunc": -#0. 1797: V:0 | f32.const $1 -#0. 1802: V:1 | f32.trunc 1 -#0. 1803: V:1 | drop -#0. 1804: V:0 | return +#0. 1800: V:0 | f32.const $1 +#0. 1805: V:1 | f32.trunc 1 +#0. 1806: V:1 | drop +#0. 1807: V:0 | return f32.trunc() => >>> running export "f32.nearest": -#0. 1805: V:0 | f32.const $1 -#0. 1810: V:1 | f32.nearest 1 -#0. 1811: V:1 | drop -#0. 1812: V:0 | return +#0. 1808: V:0 | f32.const $1 +#0. 1813: V:1 | f32.nearest 1 +#0. 1814: V:1 | drop +#0. 1815: V:0 | return f32.nearest() => >>> running export "f32.sqrt": -#0. 1813: V:0 | f32.const $1 -#0. 1818: V:1 | f32.sqrt 1 -#0. 1819: V:1 | drop -#0. 1820: V:0 | return +#0. 1816: V:0 | f32.const $1 +#0. 1821: V:1 | f32.sqrt 1 +#0. 1822: V:1 | drop +#0. 1823: V:0 | return f32.sqrt() => >>> running export "f32.add": -#0. 1821: V:0 | f32.const $1 -#0. 1826: V:1 | f32.const $2 -#0. 1831: V:2 | f32.add 1, 2 -#0. 1832: V:1 | drop -#0. 1833: V:0 | return +#0. 1824: V:0 | f32.const $1 +#0. 1829: V:1 | f32.const $2 +#0. 1834: V:2 | f32.add 1, 2 +#0. 1835: V:1 | drop +#0. 1836: V:0 | return f32.add() => >>> running export "f32.sub": -#0. 1834: V:0 | f32.const $1 -#0. 1839: V:1 | f32.const $2 -#0. 1844: V:2 | f32.sub 1, 2 -#0. 1845: V:1 | drop -#0. 1846: V:0 | return +#0. 1837: V:0 | f32.const $1 +#0. 1842: V:1 | f32.const $2 +#0. 1847: V:2 | f32.sub 1, 2 +#0. 1848: V:1 | drop +#0. 1849: V:0 | return f32.sub() => >>> running export "f32.mul": -#0. 1847: V:0 | f32.const $1 -#0. 1852: V:1 | f32.const $2 -#0. 1857: V:2 | f32.mul 1, 2 -#0. 1858: V:1 | drop -#0. 1859: V:0 | return +#0. 1850: V:0 | f32.const $1 +#0. 1855: V:1 | f32.const $2 +#0. 1860: V:2 | f32.mul 1, 2 +#0. 1861: V:1 | drop +#0. 1862: V:0 | return f32.mul() => >>> running export "f32.div": -#0. 1860: V:0 | f32.const $1 -#0. 1865: V:1 | f32.const $2 -#0. 1870: V:2 | f32.div 1, 2 -#0. 1871: V:1 | drop -#0. 1872: V:0 | return +#0. 1863: V:0 | f32.const $1 +#0. 1868: V:1 | f32.const $2 +#0. 1873: V:2 | f32.div 1, 2 +#0. 1874: V:1 | drop +#0. 1875: V:0 | return f32.div() => >>> running export "f32.min": -#0. 1873: V:0 | f32.const $1 -#0. 1878: V:1 | f32.const $2 -#0. 1883: V:2 | f32.min 1, 2 -#0. 1884: V:1 | drop -#0. 1885: V:0 | return +#0. 1876: V:0 | f32.const $1 +#0. 1881: V:1 | f32.const $2 +#0. 1886: V:2 | f32.min 1, 2 +#0. 1887: V:1 | drop +#0. 1888: V:0 | return f32.min() => >>> running export "f32.max": -#0. 1886: V:0 | f32.const $1 -#0. 1891: V:1 | f32.const $2 -#0. 1896: V:2 | f32.max 1, 2 -#0. 1897: V:1 | drop -#0. 1898: V:0 | return +#0. 1889: V:0 | f32.const $1 +#0. 1894: V:1 | f32.const $2 +#0. 1899: V:2 | f32.max 1, 2 +#0. 1900: V:1 | drop +#0. 1901: V:0 | return f32.max() => >>> running export "f32.copysign": -#0. 1899: V:0 | f32.const $1 -#0. 1904: V:1 | f32.const $2 -#0. 1909: V:2 | f32.copysign 1, 2 -#0. 1910: V:1 | drop -#0. 1911: V:0 | return +#0. 1902: V:0 | f32.const $1 +#0. 1907: V:1 | f32.const $2 +#0. 1912: V:2 | f32.copysign 1, 2 +#0. 1913: V:1 | drop +#0. 1914: V:0 | return f32.copysign() => >>> running export "f64.abs": -#0. 1912: V:0 | f64.const $1 -#0. 1921: V:1 | f64.abs 1 -#0. 1922: V:1 | drop -#0. 1923: V:0 | return +#0. 1915: V:0 | f64.const $1 +#0. 1924: V:1 | f64.abs 1 +#0. 1925: V:1 | drop +#0. 1926: V:0 | return f64.abs() => >>> running export "f64.neg": -#0. 1924: V:0 | f64.const $1 -#0. 1933: V:1 | f64.neg 1 -#0. 1934: V:1 | drop -#0. 1935: V:0 | return +#0. 1927: V:0 | f64.const $1 +#0. 1936: V:1 | f64.neg 1 +#0. 1937: V:1 | drop +#0. 1938: V:0 | return f64.neg() => >>> running export "f64.ceil": -#0. 1936: V:0 | f64.const $1 -#0. 1945: V:1 | f64.ceil 1 -#0. 1946: V:1 | drop -#0. 1947: V:0 | return +#0. 1939: V:0 | f64.const $1 +#0. 1948: V:1 | f64.ceil 1 +#0. 1949: V:1 | drop +#0. 1950: V:0 | return f64.ceil() => >>> running export "f64.floor": -#0. 1948: V:0 | f64.const $1 -#0. 1957: V:1 | f64.floor 1 -#0. 1958: V:1 | drop -#0. 1959: V:0 | return +#0. 1951: V:0 | f64.const $1 +#0. 1960: V:1 | f64.floor 1 +#0. 1961: V:1 | drop +#0. 1962: V:0 | return f64.floor() => >>> running export "f64.trunc": -#0. 1960: V:0 | f64.const $1 -#0. 1969: V:1 | f64.trunc 1 -#0. 1970: V:1 | drop -#0. 1971: V:0 | return +#0. 1963: V:0 | f64.const $1 +#0. 1972: V:1 | f64.trunc 1 +#0. 1973: V:1 | drop +#0. 1974: V:0 | return f64.trunc() => >>> running export "f64.nearest": -#0. 1972: V:0 | f64.const $1 -#0. 1981: V:1 | f64.nearest 1 -#0. 1982: V:1 | drop -#0. 1983: V:0 | return +#0. 1975: V:0 | f64.const $1 +#0. 1984: V:1 | f64.nearest 1 +#0. 1985: V:1 | drop +#0. 1986: V:0 | return f64.nearest() => >>> running export "f64.sqrt": -#0. 1984: V:0 | f64.const $1 -#0. 1993: V:1 | f64.sqrt 1 -#0. 1994: V:1 | drop -#0. 1995: V:0 | return +#0. 1987: V:0 | f64.const $1 +#0. 1996: V:1 | f64.sqrt 1 +#0. 1997: V:1 | drop +#0. 1998: V:0 | return f64.sqrt() => >>> running export "f64.add": -#0. 1996: V:0 | f64.const $1 -#0. 2005: V:1 | f64.const $2 -#0. 2014: V:2 | f64.add 1, 2 -#0. 2015: V:1 | drop -#0. 2016: V:0 | return +#0. 1999: V:0 | f64.const $1 +#0. 2008: V:1 | f64.const $2 +#0. 2017: V:2 | f64.add 1, 2 +#0. 2018: V:1 | drop +#0. 2019: V:0 | return f64.add() => >>> running export "f64.sub": -#0. 2017: V:0 | f64.const $1 -#0. 2026: V:1 | f64.const $2 -#0. 2035: V:2 | f64.sub 1, 2 -#0. 2036: V:1 | drop -#0. 2037: V:0 | return +#0. 2020: V:0 | f64.const $1 +#0. 2029: V:1 | f64.const $2 +#0. 2038: V:2 | f64.sub 1, 2 +#0. 2039: V:1 | drop +#0. 2040: V:0 | return f64.sub() => >>> running export "f64.mul": -#0. 2038: V:0 | f64.const $1 -#0. 2047: V:1 | f64.const $2 -#0. 2056: V:2 | f64.mul 1, 2 -#0. 2057: V:1 | drop -#0. 2058: V:0 | return +#0. 2041: V:0 | f64.const $1 +#0. 2050: V:1 | f64.const $2 +#0. 2059: V:2 | f64.mul 1, 2 +#0. 2060: V:1 | drop +#0. 2061: V:0 | return f64.mul() => >>> running export "f64.div": -#0. 2059: V:0 | f64.const $1 -#0. 2068: V:1 | f64.const $2 -#0. 2077: V:2 | f64.div 1, 2 -#0. 2078: V:1 | drop -#0. 2079: V:0 | return +#0. 2062: V:0 | f64.const $1 +#0. 2071: V:1 | f64.const $2 +#0. 2080: V:2 | f64.div 1, 2 +#0. 2081: V:1 | drop +#0. 2082: V:0 | return f64.div() => >>> running export "f64.min": -#0. 2080: V:0 | f64.const $1 -#0. 2089: V:1 | f64.const $2 -#0. 2098: V:2 | f64.min 1, 2 -#0. 2099: V:1 | drop -#0. 2100: V:0 | return +#0. 2083: V:0 | f64.const $1 +#0. 2092: V:1 | f64.const $2 +#0. 2101: V:2 | f64.min 1, 2 +#0. 2102: V:1 | drop +#0. 2103: V:0 | return f64.min() => >>> running export "f64.max": -#0. 2101: V:0 | f64.const $1 -#0. 2110: V:1 | f64.const $2 -#0. 2119: V:2 | f64.max 1, 2 -#0. 2120: V:1 | drop -#0. 2121: V:0 | return +#0. 2104: V:0 | f64.const $1 +#0. 2113: V:1 | f64.const $2 +#0. 2122: V:2 | f64.max 1, 2 +#0. 2123: V:1 | drop +#0. 2124: V:0 | return f64.max() => >>> running export "f64.copysign": -#0. 2122: V:0 | f64.const $1 -#0. 2131: V:1 | f64.const $2 -#0. 2140: V:2 | f64.copysign 1, 2 -#0. 2141: V:1 | drop -#0. 2142: V:0 | return +#0. 2125: V:0 | f64.const $1 +#0. 2134: V:1 | f64.const $2 +#0. 2143: V:2 | f64.copysign 1, 2 +#0. 2144: V:1 | drop +#0. 2145: V:0 | return f64.copysign() => >>> running export "i32.wrap/i64": -#0. 2143: V:0 | i64.const $1 -#0. 2152: V:1 | i32.wrap/i64 1 -#0. 2153: V:1 | drop -#0. 2154: V:0 | return +#0. 2146: V:0 | i64.const $1 +#0. 2155: V:1 | i32.wrap/i64 1 +#0. 2156: V:1 | drop +#0. 2157: V:0 | return i32.wrap/i64() => >>> running export "i32.trunc_s/f32": -#0. 2155: V:0 | f32.const $1 -#0. 2160: V:1 | i32.trunc_s/f32 1 -#0. 2161: V:1 | drop -#0. 2162: V:0 | return +#0. 2158: V:0 | f32.const $1 +#0. 2163: V:1 | i32.trunc_s/f32 1 +#0. 2164: V:1 | drop +#0. 2165: V:0 | return i32.trunc_s/f32() => >>> running export "i32.trunc_u/f32": -#0. 2163: V:0 | f32.const $1 -#0. 2168: V:1 | i32.trunc_u/f32 1 -#0. 2169: V:1 | drop -#0. 2170: V:0 | return +#0. 2166: V:0 | f32.const $1 +#0. 2171: V:1 | i32.trunc_u/f32 1 +#0. 2172: V:1 | drop +#0. 2173: V:0 | return i32.trunc_u/f32() => >>> running export "i32.trunc_s/f64": -#0. 2171: V:0 | f64.const $1 -#0. 2180: V:1 | i32.trunc_s/f64 1 -#0. 2181: V:1 | drop -#0. 2182: V:0 | return +#0. 2174: V:0 | f64.const $1 +#0. 2183: V:1 | i32.trunc_s/f64 1 +#0. 2184: V:1 | drop +#0. 2185: V:0 | return i32.trunc_s/f64() => >>> running export "i32.trunc_u/f64": -#0. 2183: V:0 | f64.const $1 -#0. 2192: V:1 | i32.trunc_u/f64 1 -#0. 2193: V:1 | drop -#0. 2194: V:0 | return +#0. 2186: V:0 | f64.const $1 +#0. 2195: V:1 | i32.trunc_u/f64 1 +#0. 2196: V:1 | drop +#0. 2197: V:0 | return i32.trunc_u/f64() => >>> running export "i64.extend_s/i32": -#0. 2195: V:0 | i32.const $1 -#0. 2200: V:1 | i64.extend_s/i32 1 -#0. 2201: V:1 | drop -#0. 2202: V:0 | return +#0. 2198: V:0 | i32.const $1 +#0. 2203: V:1 | i64.extend_s/i32 1 +#0. 2204: V:1 | drop +#0. 2205: V:0 | return i64.extend_s/i32() => >>> running export "i64.extend_u/i32": -#0. 2203: V:0 | i32.const $1 -#0. 2208: V:1 | i64.extend_u/i32 1 -#0. 2209: V:1 | drop -#0. 2210: V:0 | return +#0. 2206: V:0 | i32.const $1 +#0. 2211: V:1 | i64.extend_u/i32 1 +#0. 2212: V:1 | drop +#0. 2213: V:0 | return i64.extend_u/i32() => >>> running export "i64.trunc_s/f32": -#0. 2211: V:0 | f32.const $1 -#0. 2216: V:1 | i64.trunc_s/f32 1 -#0. 2217: V:1 | drop -#0. 2218: V:0 | return +#0. 2214: V:0 | f32.const $1 +#0. 2219: V:1 | i64.trunc_s/f32 1 +#0. 2220: V:1 | drop +#0. 2221: V:0 | return i64.trunc_s/f32() => >>> running export "i64.trunc_u/f32": -#0. 2219: V:0 | f32.const $1 -#0. 2224: V:1 | i64.trunc_u/f32 1 -#0. 2225: V:1 | drop -#0. 2226: V:0 | return +#0. 2222: V:0 | f32.const $1 +#0. 2227: V:1 | i64.trunc_u/f32 1 +#0. 2228: V:1 | drop +#0. 2229: V:0 | return i64.trunc_u/f32() => >>> running export "i64.trunc_s/f64": -#0. 2227: V:0 | f64.const $1 -#0. 2236: V:1 | i64.trunc_s/f64 1 -#0. 2237: V:1 | drop -#0. 2238: V:0 | return +#0. 2230: V:0 | f64.const $1 +#0. 2239: V:1 | i64.trunc_s/f64 1 +#0. 2240: V:1 | drop +#0. 2241: V:0 | return i64.trunc_s/f64() => >>> running export "i64.trunc_u/f64": -#0. 2239: V:0 | f64.const $1 -#0. 2248: V:1 | i64.trunc_u/f64 1 -#0. 2249: V:1 | drop -#0. 2250: V:0 | return +#0. 2242: V:0 | f64.const $1 +#0. 2251: V:1 | i64.trunc_u/f64 1 +#0. 2252: V:1 | drop +#0. 2253: V:0 | return i64.trunc_u/f64() => >>> running export "f32.convert_s/i32": -#0. 2251: V:0 | i32.const $1 -#0. 2256: V:1 | f32.convert_s/i32 1 -#0. 2257: V:1 | drop -#0. 2258: V:0 | return +#0. 2254: V:0 | i32.const $1 +#0. 2259: V:1 | f32.convert_s/i32 1 +#0. 2260: V:1 | drop +#0. 2261: V:0 | return f32.convert_s/i32() => >>> running export "f32.convert_u/i32": -#0. 2259: V:0 | i32.const $1 -#0. 2264: V:1 | f32.convert_u/i32 1 -#0. 2265: V:1 | drop -#0. 2266: V:0 | return +#0. 2262: V:0 | i32.const $1 +#0. 2267: V:1 | f32.convert_u/i32 1 +#0. 2268: V:1 | drop +#0. 2269: V:0 | return f32.convert_u/i32() => >>> running export "f32.convert_s/i64": -#0. 2267: V:0 | i64.const $1 -#0. 2276: V:1 | f32.convert_s/i64 1 -#0. 2277: V:1 | drop -#0. 2278: V:0 | return +#0. 2270: V:0 | i64.const $1 +#0. 2279: V:1 | f32.convert_s/i64 1 +#0. 2280: V:1 | drop +#0. 2281: V:0 | return f32.convert_s/i64() => >>> running export "f32.convert_u/i64": -#0. 2279: V:0 | i64.const $1 -#0. 2288: V:1 | f32.convert_u/i64 1 -#0. 2289: V:1 | drop -#0. 2290: V:0 | return +#0. 2282: V:0 | i64.const $1 +#0. 2291: V:1 | f32.convert_u/i64 1 +#0. 2292: V:1 | drop +#0. 2293: V:0 | return f32.convert_u/i64() => >>> running export "f32.demote/f64": -#0. 2291: V:0 | f64.const $1 -#0. 2300: V:1 | f32.demote/f64 1 -#0. 2301: V:1 | drop -#0. 2302: V:0 | return +#0. 2294: V:0 | f64.const $1 +#0. 2303: V:1 | f32.demote/f64 1 +#0. 2304: V:1 | drop +#0. 2305: V:0 | return f32.demote/f64() => >>> running export "f64.convert_s/i32": -#0. 2303: V:0 | i32.const $1 -#0. 2308: V:1 | f64.convert_s/i32 1 -#0. 2309: V:1 | drop -#0. 2310: V:0 | return +#0. 2306: V:0 | i32.const $1 +#0. 2311: V:1 | f64.convert_s/i32 1 +#0. 2312: V:1 | drop +#0. 2313: V:0 | return f64.convert_s/i32() => >>> running export "f64.convert_u/i32": -#0. 2311: V:0 | i32.const $1 -#0. 2316: V:1 | f64.convert_u/i32 1 -#0. 2317: V:1 | drop -#0. 2318: V:0 | return +#0. 2314: V:0 | i32.const $1 +#0. 2319: V:1 | f64.convert_u/i32 1 +#0. 2320: V:1 | drop +#0. 2321: V:0 | return f64.convert_u/i32() => >>> running export "f64.convert_s/i64": -#0. 2319: V:0 | i64.const $1 -#0. 2328: V:1 | f64.convert_s/i64 1 -#0. 2329: V:1 | drop -#0. 2330: V:0 | return +#0. 2322: V:0 | i64.const $1 +#0. 2331: V:1 | f64.convert_s/i64 1 +#0. 2332: V:1 | drop +#0. 2333: V:0 | return f64.convert_s/i64() => >>> running export "f64.convert_u/i64": -#0. 2331: V:0 | i64.const $1 -#0. 2340: V:1 | f64.convert_u/i64 1 -#0. 2341: V:1 | drop -#0. 2342: V:0 | return +#0. 2334: V:0 | i64.const $1 +#0. 2343: V:1 | f64.convert_u/i64 1 +#0. 2344: V:1 | drop +#0. 2345: V:0 | return f64.convert_u/i64() => >>> running export "f64.promote/f32": -#0. 2343: V:0 | f32.const $1 -#0. 2348: V:1 | f64.promote/f32 1 -#0. 2349: V:1 | drop -#0. 2350: V:0 | return +#0. 2346: V:0 | f32.const $1 +#0. 2351: V:1 | f64.promote/f32 1 +#0. 2352: V:1 | drop +#0. 2353: V:0 | return f64.promote/f32() => >>> running export "i32.reinterpret/f32": -#0. 2351: V:0 | i32.const $1 -#0. 2356: V:1 | f32.reinterpret/i32 1 -#0. 2357: V:1 | drop -#0. 2358: V:0 | return +#0. 2354: V:0 | i32.const $1 +#0. 2359: V:1 | f32.reinterpret/i32 1 +#0. 2360: V:1 | drop +#0. 2361: V:0 | return i32.reinterpret/f32() => >>> running export "f32.reinterpret/i32": -#0. 2359: V:0 | f32.const $1 -#0. 2364: V:1 | i32.reinterpret/f32 1 -#0. 2365: V:1 | drop -#0. 2366: V:0 | return +#0. 2362: V:0 | f32.const $1 +#0. 2367: V:1 | i32.reinterpret/f32 1 +#0. 2368: V:1 | drop +#0. 2369: V:0 | return f32.reinterpret/i32() => >>> running export "i64.reinterpret/f64": -#0. 2367: V:0 | i64.const $1 -#0. 2376: V:1 | f64.reinterpret/i64 1 -#0. 2377: V:1 | drop -#0. 2378: V:0 | return +#0. 2370: V:0 | i64.const $1 +#0. 2379: V:1 | f64.reinterpret/i64 1 +#0. 2380: V:1 | drop +#0. 2381: V:0 | return i64.reinterpret/f64() => >>> running export "f64.reinterpret/i64": -#0. 2379: V:0 | f64.const $1 -#0. 2388: V:1 | i64.reinterpret/f64 1 -#0. 2389: V:1 | drop -#0. 2390: V:0 | return +#0. 2382: V:0 | f64.const $1 +#0. 2391: V:1 | i64.reinterpret/f64 1 +#0. 2392: V:1 | drop +#0. 2393: V:0 | return f64.reinterpret/i64() => >>> running export "i32.extend8_s": -#0. 2391: V:0 | i32.const $1 -#0. 2396: V:1 | i32.extend8_s 1 -#0. 2397: V:1 | drop -#0. 2398: V:0 | return +#0. 2394: V:0 | i32.const $1 +#0. 2399: V:1 | i32.extend8_s 1 +#0. 2400: V:1 | drop +#0. 2401: V:0 | return i32.extend8_s() => >>> running export "i32.extend16_s": -#0. 2399: V:0 | i32.const $1 -#0. 2404: V:1 | i32.extend16_s 1 -#0. 2405: V:1 | drop -#0. 2406: V:0 | return +#0. 2402: V:0 | i32.const $1 +#0. 2407: V:1 | i32.extend16_s 1 +#0. 2408: V:1 | drop +#0. 2409: V:0 | return i32.extend16_s() => >>> running export "i64.extend8_s": -#0. 2407: V:0 | i64.const $1 -#0. 2416: V:1 | i64.extend8_s 1 -#0. 2417: V:1 | drop -#0. 2418: V:0 | return +#0. 2410: V:0 | i64.const $1 +#0. 2419: V:1 | i64.extend8_s 1 +#0. 2420: V:1 | drop +#0. 2421: V:0 | return i64.extend8_s() => >>> running export "i64.extend16_s": -#0. 2419: V:0 | i64.const $1 -#0. 2428: V:1 | i64.extend16_s 1 -#0. 2429: V:1 | drop -#0. 2430: V:0 | return +#0. 2422: V:0 | i64.const $1 +#0. 2431: V:1 | i64.extend16_s 1 +#0. 2432: V:1 | drop +#0. 2433: V:0 | return i64.extend16_s() => >>> running export "i64.extend32_s": -#0. 2431: V:0 | i64.const $1 -#0. 2440: V:1 | i64.extend32_s 1 -#0. 2441: V:1 | drop -#0. 2442: V:0 | return +#0. 2434: V:0 | i64.const $1 +#0. 2443: V:1 | i64.extend32_s 1 +#0. 2444: V:1 | drop +#0. 2445: V:0 | return i64.extend32_s() => >>> running export "alloca": -#0. 2443: V:0 | alloca $1 -#0. 2448: V:1 | drop -#0. 2449: V:0 | return +#0. 2446: V:0 | alloca $1 +#0. 2451: V:1 | drop +#0. 2452: V:0 | return alloca() => >>> running export "br_unless": -#0. 2450: V:0 | i32.const $1 -#0. 2455: V:1 | br_unless @2465, 1 -#0. 2460: V:0 | br @2465 -#0. 2465: V:0 | return +#0. 2453: V:0 | i32.const $1 +#0. 2458: V:1 | br_unless @2468, 1 +#0. 2463: V:0 | br @2468 +#0. 2468: V:0 | return br_unless() => >>> running export "call_host": -#0. 2466: V:0 | i32.const $1 -#0. 2471: V:1 | call_host $0 +#0. 2469: V:0 | i32.const $1 +#0. 2474: V:1 | call_host $0 called host host.print(i32:1) => -#0. 2476: V:0 | return +#0. 2479: V:0 | return call_host() => >>> running export "drop_keep": -#0. 2477: V:0 | i32.const $1 -#0. 2482: V:1 | i32.const $2 -#0. 2487: V:2 | drop_keep $1 $1 -#0. 2493: V:1 | br @2498 -#0. 2498: V:1 | drop -#0. 2499: V:0 | return +#0. 2480: V:0 | i32.const $1 +#0. 2485: V:1 | i32.const $2 +#0. 2490: V:2 | drop_keep $1 $1 +#0. 2499: V:1 | br @2504 +#0. 2504: V:1 | drop +#0. 2505: V:0 | return drop_keep() => >>> running export "i32.trunc_s:sat/f32": -#0. 2500: V:0 | f32.const $1 -#0. 2505: V:1 | i32.trunc_s:sat/f32 1 -#0. 2507: V:1 | drop -#0. 2508: V:0 | return +#0. 2506: V:0 | f32.const $1 +#0. 2511: V:1 | i32.trunc_s:sat/f32 1 +#0. 2513: V:1 | drop +#0. 2514: V:0 | return i32.trunc_s:sat/f32() => >>> running export "i32.trunc_u:sat/f32": -#0. 2509: V:0 | f32.const $1 -#0. 2514: V:1 | i32.trunc_u:sat/f32 1 -#0. 2516: V:1 | drop -#0. 2517: V:0 | return +#0. 2515: V:0 | f32.const $1 +#0. 2520: V:1 | i32.trunc_u:sat/f32 1 +#0. 2522: V:1 | drop +#0. 2523: V:0 | return i32.trunc_u:sat/f32() => >>> running export "i32.trunc_s:sat/f64": -#0. 2518: V:0 | f64.const $1 -#0. 2527: V:1 | i32.trunc_s:sat/f64 1 -#0. 2529: V:1 | drop -#0. 2530: V:0 | return +#0. 2524: V:0 | f64.const $1 +#0. 2533: V:1 | i32.trunc_s:sat/f64 1 +#0. 2535: V:1 | drop +#0. 2536: V:0 | return i32.trunc_s:sat/f64() => >>> running export "i32.trunc_u:sat/f64": -#0. 2531: V:0 | f64.const $1 -#0. 2540: V:1 | i32.trunc_u:sat/f64 1 -#0. 2542: V:1 | drop -#0. 2543: V:0 | return +#0. 2537: V:0 | f64.const $1 +#0. 2546: V:1 | i32.trunc_u:sat/f64 1 +#0. 2548: V:1 | drop +#0. 2549: V:0 | return i32.trunc_u:sat/f64() => >>> running export "i64.trunc_s:sat/f32": -#0. 2544: V:0 | f32.const $1 -#0. 2549: V:1 | i64.trunc_s:sat/f32 1 -#0. 2551: V:1 | drop -#0. 2552: V:0 | return +#0. 2550: V:0 | f32.const $1 +#0. 2555: V:1 | i64.trunc_s:sat/f32 1 +#0. 2557: V:1 | drop +#0. 2558: V:0 | return i64.trunc_s:sat/f32() => >>> running export "i64.trunc_u:sat/f32": -#0. 2553: V:0 | f32.const $1 -#0. 2558: V:1 | i64.trunc_u:sat/f32 1 -#0. 2560: V:1 | drop -#0. 2561: V:0 | return +#0. 2559: V:0 | f32.const $1 +#0. 2564: V:1 | i64.trunc_u:sat/f32 1 +#0. 2566: V:1 | drop +#0. 2567: V:0 | return i64.trunc_u:sat/f32() => >>> running export "i64.trunc_s:sat/f64": -#0. 2562: V:0 | f64.const $1 -#0. 2571: V:1 | i64.trunc_s:sat/f64 1 -#0. 2573: V:1 | drop -#0. 2574: V:0 | return +#0. 2568: V:0 | f64.const $1 +#0. 2577: V:1 | i64.trunc_s:sat/f64 1 +#0. 2579: V:1 | drop +#0. 2580: V:0 | return i64.trunc_s:sat/f64() => >>> running export "i64.trunc_u:sat/f64": -#0. 2575: V:0 | f64.const $1 -#0. 2584: V:1 | i64.trunc_u:sat/f64 1 -#0. 2586: V:1 | drop -#0. 2587: V:0 | return +#0. 2581: V:0 | f64.const $1 +#0. 2590: V:1 | i64.trunc_u:sat/f64 1 +#0. 2592: V:1 | drop +#0. 2593: V:0 | return i64.trunc_u:sat/f64() => >>> running export "v128.const": -#0. 2588: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2606: V:1 | drop -#0. 2607: V:0 | return +#0. 2594: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2612: V:1 | drop +#0. 2613: V:0 | return v128.const() => >>> running export "v128.load": -#0. 2608: V:0 | i32.const $1 -#0. 2613: V:1 | v128.load $0:1+$3 -#0. 2623: V:1 | drop -#0. 2624: V:0 | return +#0. 2614: V:0 | i32.const $1 +#0. 2619: V:1 | v128.load $0:1+$3 +#0. 2629: V:1 | drop +#0. 2630: V:0 | return v128.load() => >>> running export "v128.store": -#0. 2625: V:0 | i32.const $1 -#0. 2630: V:1 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2648: V:2 | v128.store $0:1+$3, $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2658: V:0 | return +#0. 2631: V:0 | i32.const $1 +#0. 2636: V:1 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2654: V:2 | v128.store $0:1+$3, $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2664: V:0 | return v128.store() => >>> running export "i8x16.splat": -#0. 2659: V:0 | i32.const $1 -#0. 2664: V:1 | i8x16.splat 1 -#0. 2666: V:1 | drop -#0. 2667: V:0 | return +#0. 2665: V:0 | i32.const $1 +#0. 2670: V:1 | i8x16.splat 1 +#0. 2672: V:1 | drop +#0. 2673: V:0 | return i8x16.splat() => >>> running export "i16x8.splat": -#0. 2668: V:0 | i32.const $1 -#0. 2673: V:1 | i16x8.splat 1 -#0. 2675: V:1 | drop -#0. 2676: V:0 | return +#0. 2674: V:0 | i32.const $1 +#0. 2679: V:1 | i16x8.splat 1 +#0. 2681: V:1 | drop +#0. 2682: V:0 | return i16x8.splat() => >>> running export "i32x4.splat": -#0. 2677: V:0 | i32.const $1 -#0. 2682: V:1 | i32x4.splat 1 -#0. 2684: V:1 | drop -#0. 2685: V:0 | return +#0. 2683: V:0 | i32.const $1 +#0. 2688: V:1 | i32x4.splat 1 +#0. 2690: V:1 | drop +#0. 2691: V:0 | return i32x4.splat() => >>> running export "i64x2.splat": -#0. 2686: V:0 | i64.const $1 -#0. 2695: V:1 | i64x2.splat 1 -#0. 2697: V:1 | drop -#0. 2698: V:0 | return +#0. 2692: V:0 | i64.const $1 +#0. 2701: V:1 | i64x2.splat 1 +#0. 2703: V:1 | drop +#0. 2704: V:0 | return i64x2.splat() => >>> running export "f32x4.splat": -#0. 2699: V:0 | f32.const $1 -#0. 2704: V:1 | f32x4.splat 1 -#0. 2706: V:1 | drop -#0. 2707: V:0 | return +#0. 2705: V:0 | f32.const $1 +#0. 2710: V:1 | f32x4.splat 1 +#0. 2712: V:1 | drop +#0. 2713: V:0 | return f32x4.splat() => >>> running export "f64x2.splat": -#0. 2708: V:0 | f64.const $1 -#0. 2717: V:1 | f64x2.splat 1 -#0. 2719: V:1 | drop -#0. 2720: V:0 | return +#0. 2714: V:0 | f64.const $1 +#0. 2723: V:1 | f64x2.splat 1 +#0. 2725: V:1 | drop +#0. 2726: V:0 | return f64x2.splat() => >>> running export "i8x16.extract_lane_s": -#0. 2721: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2739: V:1 | i8x16.extract_lane_s : LaneIdx 15 From $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2742: V:1 | drop -#0. 2743: V:0 | return +#0. 2727: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2745: V:1 | i8x16.extract_lane_s : LaneIdx 15 From $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2748: V:1 | drop +#0. 2749: V:0 | return i8x16.extract_lane_s() => >>> running export "i8x16.extract_lane_u": -#0. 2744: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2762: V:1 | i8x16.extract_lane_u : LaneIdx 15 From $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2765: V:1 | drop -#0. 2766: V:0 | return +#0. 2750: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2768: V:1 | i8x16.extract_lane_u : LaneIdx 15 From $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2771: V:1 | drop +#0. 2772: V:0 | return i8x16.extract_lane_u() => >>> running export "i16x8.extract_lane_s": -#0. 2767: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2785: V:1 | i16x8.extract_lane_s : LaneIdx 7 From $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2788: V:1 | drop -#0. 2789: V:0 | return +#0. 2773: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2791: V:1 | i16x8.extract_lane_s : LaneIdx 7 From $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2794: V:1 | drop +#0. 2795: V:0 | return i16x8.extract_lane_s() => >>> running export "i16x8.extract_lane_u": -#0. 2790: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2808: V:1 | i16x8.extract_lane_u : LaneIdx 7 From $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2811: V:1 | drop -#0. 2812: V:0 | return +#0. 2796: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2814: V:1 | i16x8.extract_lane_u : LaneIdx 7 From $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2817: V:1 | drop +#0. 2818: V:0 | return i16x8.extract_lane_u() => >>> running export "i32x4.extract_lane": -#0. 2813: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2831: V:1 | i32x4.extract_lane : LaneIdx 3 From $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2834: V:1 | drop -#0. 2835: V:0 | return +#0. 2819: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2837: V:1 | i32x4.extract_lane : LaneIdx 3 From $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2840: V:1 | drop +#0. 2841: V:0 | return i32x4.extract_lane() => >>> running export "i64x2.extract_lane": -#0. 2836: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2854: V:1 | i64x2.extract_lane : LaneIdx 1 From $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2857: V:1 | drop -#0. 2858: V:0 | return +#0. 2842: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2860: V:1 | i64x2.extract_lane : LaneIdx 1 From $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2863: V:1 | drop +#0. 2864: V:0 | return i64x2.extract_lane() => >>> running export "f32x4.extract_lane": -#0. 2859: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2877: V:1 | f32x4.extract_lane : LaneIdx 3 From $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2880: V:1 | drop -#0. 2881: V:0 | return +#0. 2865: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2883: V:1 | f32x4.extract_lane : LaneIdx 3 From $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2886: V:1 | drop +#0. 2887: V:0 | return f32x4.extract_lane() => >>> running export "f64x2.extract_lane": -#0. 2882: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2900: V:1 | f64x2.extract_lane : LaneIdx 1 From $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2903: V:1 | drop -#0. 2904: V:0 | return +#0. 2888: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2906: V:1 | f64x2.extract_lane : LaneIdx 1 From $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2909: V:1 | drop +#0. 2910: V:0 | return f64x2.extract_lane() => >>> running export "i8x16.replace_lane": -#0. 2905: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2923: V:1 | i32.const $0 -#0. 2928: V:2 | i8x16.replace_lane : Set 0 to LaneIdx 15 In $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2931: V:1 | drop -#0. 2932: V:0 | return +#0. 2911: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2929: V:1 | i32.const $0 +#0. 2934: V:2 | i8x16.replace_lane : Set 0 to LaneIdx 15 In $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2937: V:1 | drop +#0. 2938: V:0 | return i8x16.replace_lane() => >>> running export "i16x8.replace_lane": -#0. 2933: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2951: V:1 | i32.const $0 -#0. 2956: V:2 | i16x8.replace_lane : Set 0 to LaneIdx 7 In $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2959: V:1 | drop -#0. 2960: V:0 | return +#0. 2939: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2957: V:1 | i32.const $0 +#0. 2962: V:2 | i16x8.replace_lane : Set 0 to LaneIdx 7 In $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2965: V:1 | drop +#0. 2966: V:0 | return i16x8.replace_lane() => >>> running export "i32x4.replace_lane": -#0. 2961: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2979: V:1 | i32.const $0 -#0. 2984: V:2 | i32x4.replace_lane : Set 0 to LaneIdx 3 In $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 2987: V:1 | drop -#0. 2988: V:0 | return +#0. 2967: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2985: V:1 | i32.const $0 +#0. 2990: V:2 | i32x4.replace_lane : Set 0 to LaneIdx 3 In $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 2993: V:1 | drop +#0. 2994: V:0 | return i32x4.replace_lane() => >>> running export "i64x2.replace_lane": -#0. 2989: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3007: V:1 | i64.const $0 -#0. 3016: V:2 | i64x2.replace_lane : Set 0 to LaneIdx 1 In $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3019: V:1 | drop -#0. 3020: V:0 | return +#0. 2995: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3013: V:1 | i64.const $0 +#0. 3022: V:2 | i64x2.replace_lane : Set 0 to LaneIdx 1 In $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3025: V:1 | drop +#0. 3026: V:0 | return i64x2.replace_lane() => >>> running export "f32x4.replace_lane": -#0. 3021: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3039: V:1 | f32.const $0 -#0. 3044: V:2 | f32x4.replace_lane : Set 0 to LaneIdx 3 In $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3047: V:1 | drop -#0. 3048: V:0 | return +#0. 3027: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3045: V:1 | f32.const $0 +#0. 3050: V:2 | f32x4.replace_lane : Set 0 to LaneIdx 3 In $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3053: V:1 | drop +#0. 3054: V:0 | return f32x4.replace_lane() => >>> running export "f64x2.replace_lane": -#0. 3049: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3067: V:1 | f64.const $0 -#0. 3076: V:2 | f64x2.replace_lane : Set 0 to LaneIdx 1 In $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3079: V:1 | drop -#0. 3080: V:0 | return +#0. 3055: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3073: V:1 | f64.const $0 +#0. 3082: V:2 | f64x2.replace_lane : Set 0 to LaneIdx 1 In $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3085: V:1 | drop +#0. 3086: V:0 | return f64x2.replace_lane() => >>> running export "v8x16.shuffle": -#0. 3081: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3099: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 3117: V:2 | v8x16.shuffle $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 : with lane imm: $0x00000001 00000001 00000001 00000001 -#0. 3135: V:1 | drop -#0. 3136: V:0 | return +#0. 3087: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3105: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 3123: V:2 | v8x16.shuffle $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 : with lane imm: $0x00000001 00000001 00000001 00000001 +#0. 3141: V:1 | drop +#0. 3142: V:0 | return v8x16.shuffle() => >>> running export "i8x16.add": -#0. 3137: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3155: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 3173: V:2 | i8x16.add $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 3175: V:1 | drop -#0. 3176: V:0 | return +#0. 3143: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3161: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 3179: V:2 | i8x16.add $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 3181: V:1 | drop +#0. 3182: V:0 | return i8x16.add() => >>> running export "i16x8.add": -#0. 3177: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3195: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 3213: V:2 | i16x8.add $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 3215: V:1 | drop -#0. 3216: V:0 | return +#0. 3183: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3201: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 3219: V:2 | i16x8.add $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 3221: V:1 | drop +#0. 3222: V:0 | return i16x8.add() => >>> running export "i32x4.add": -#0. 3217: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3235: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 3253: V:2 | i32x4.add $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 3255: V:1 | drop -#0. 3256: V:0 | return +#0. 3223: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3241: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 3259: V:2 | i32x4.add $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 3261: V:1 | drop +#0. 3262: V:0 | return i32x4.add() => >>> running export "i64x2.add": -#0. 3257: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3275: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 3293: V:2 | i64x2.add $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 3295: V:1 | drop -#0. 3296: V:0 | return +#0. 3263: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3281: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 3299: V:2 | i64x2.add $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 3301: V:1 | drop +#0. 3302: V:0 | return i64x2.add() => >>> running export "i8x16.sub": -#0. 3297: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3315: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 3333: V:2 | i8x16.sub $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 3335: V:1 | drop -#0. 3336: V:0 | return +#0. 3303: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3321: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 3339: V:2 | i8x16.sub $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 3341: V:1 | drop +#0. 3342: V:0 | return i8x16.sub() => >>> running export "i16x8.sub": -#0. 3337: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3355: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 3373: V:2 | i16x8.sub $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 3375: V:1 | drop -#0. 3376: V:0 | return +#0. 3343: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3361: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 3379: V:2 | i16x8.sub $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 3381: V:1 | drop +#0. 3382: V:0 | return i16x8.sub() => >>> running export "i32x4.sub": -#0. 3377: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3395: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 3413: V:2 | i32x4.sub $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 3415: V:1 | drop -#0. 3416: V:0 | return +#0. 3383: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3401: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 3419: V:2 | i32x4.sub $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 3421: V:1 | drop +#0. 3422: V:0 | return i32x4.sub() => >>> running export "i64x2.sub": -#0. 3417: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3435: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 3453: V:2 | i64x2.sub $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 3455: V:1 | drop -#0. 3456: V:0 | return +#0. 3423: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3441: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 3459: V:2 | i64x2.sub $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 3461: V:1 | drop +#0. 3462: V:0 | return i64x2.sub() => >>> running export "i8x16.mul": -#0. 3457: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3475: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 3493: V:2 | i8x16.mul $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 3495: V:1 | drop -#0. 3496: V:0 | return +#0. 3463: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3481: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 3499: V:2 | i8x16.mul $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 3501: V:1 | drop +#0. 3502: V:0 | return i8x16.mul() => >>> running export "i16x8.mul": -#0. 3497: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3515: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 3533: V:2 | i16x8.mul $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 3535: V:1 | drop -#0. 3536: V:0 | return +#0. 3503: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3521: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 3539: V:2 | i16x8.mul $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 3541: V:1 | drop +#0. 3542: V:0 | return i16x8.mul() => >>> running export "i32x4.mul": -#0. 3537: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3555: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 3573: V:2 | i32x4.mul $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 3575: V:1 | drop -#0. 3576: V:0 | return +#0. 3543: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3561: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 3579: V:2 | i32x4.mul $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 3581: V:1 | drop +#0. 3582: V:0 | return i32x4.mul() => >>> running export "i8x16.neg": -#0. 3577: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3595: V:1 | i8x16.neg $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3597: V:1 | drop -#0. 3598: V:0 | return +#0. 3583: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3601: V:1 | i8x16.neg $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3603: V:1 | drop +#0. 3604: V:0 | return i8x16.neg() => >>> running export "i16x8.neg": -#0. 3599: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3617: V:1 | i16x8.neg $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3619: V:1 | drop -#0. 3620: V:0 | return +#0. 3605: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3623: V:1 | i16x8.neg $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3625: V:1 | drop +#0. 3626: V:0 | return i16x8.neg() => >>> running export "i32x4.neg": -#0. 3621: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3639: V:1 | i32x4.neg $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3641: V:1 | drop -#0. 3642: V:0 | return +#0. 3627: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3645: V:1 | i32x4.neg $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3647: V:1 | drop +#0. 3648: V:0 | return i32x4.neg() => >>> running export "i64x2.neg": -#0. 3643: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3661: V:1 | i64x2.neg $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3663: V:1 | drop -#0. 3664: V:0 | return +#0. 3649: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3667: V:1 | i64x2.neg $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3669: V:1 | drop +#0. 3670: V:0 | return i64x2.neg() => >>> running export "i8x16.add_saturate_s": -#0. 3665: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3683: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 3701: V:2 | i8x16.add_saturate_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 3703: V:1 | drop -#0. 3704: V:0 | return +#0. 3671: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3689: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 3707: V:2 | i8x16.add_saturate_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 3709: V:1 | drop +#0. 3710: V:0 | return i8x16.add_saturate_s() => >>> running export "i8x16.add_saturate_u": -#0. 3705: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3723: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 3741: V:2 | i8x16.add_saturate_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 3743: V:1 | drop -#0. 3744: V:0 | return +#0. 3711: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3729: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 3747: V:2 | i8x16.add_saturate_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 3749: V:1 | drop +#0. 3750: V:0 | return i8x16.add_saturate_u() => >>> running export "i16x8.add_saturate_s": -#0. 3745: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3763: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 3781: V:2 | i16x8.add_saturate_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 3783: V:1 | drop -#0. 3784: V:0 | return +#0. 3751: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3769: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 3787: V:2 | i16x8.add_saturate_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 3789: V:1 | drop +#0. 3790: V:0 | return i16x8.add_saturate_s() => >>> running export "i16x8.add_saturate_u": -#0. 3785: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3803: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 3821: V:2 | i16x8.add_saturate_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 3823: V:1 | drop -#0. 3824: V:0 | return +#0. 3791: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3809: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 3827: V:2 | i16x8.add_saturate_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 3829: V:1 | drop +#0. 3830: V:0 | return i16x8.add_saturate_u() => >>> running export "i8x16.sub_saturate_s": -#0. 3825: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3843: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 3861: V:2 | i8x16.sub_saturate_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 3863: V:1 | drop -#0. 3864: V:0 | return +#0. 3831: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3849: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 3867: V:2 | i8x16.sub_saturate_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 3869: V:1 | drop +#0. 3870: V:0 | return i8x16.sub_saturate_s() => >>> running export "i8x16.sub_saturate_u": -#0. 3865: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3883: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 3901: V:2 | i8x16.sub_saturate_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 3903: V:1 | drop -#0. 3904: V:0 | return +#0. 3871: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3889: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 3907: V:2 | i8x16.sub_saturate_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 3909: V:1 | drop +#0. 3910: V:0 | return i8x16.sub_saturate_u() => >>> running export "i16x8.sub_saturate_s": -#0. 3905: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3923: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 3941: V:2 | i16x8.sub_saturate_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 3943: V:1 | drop -#0. 3944: V:0 | return +#0. 3911: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3929: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 3947: V:2 | i16x8.sub_saturate_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 3949: V:1 | drop +#0. 3950: V:0 | return i16x8.sub_saturate_s() => >>> running export "i16x8.sub_saturate_u": -#0. 3945: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 3963: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 3981: V:2 | i16x8.sub_saturate_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 3983: V:1 | drop -#0. 3984: V:0 | return +#0. 3951: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 3969: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 3987: V:2 | i16x8.sub_saturate_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 3989: V:1 | drop +#0. 3990: V:0 | return i16x8.sub_saturate_u() => >>> running export "i8x16.shl": -#0. 3985: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4003: V:1 | i32.const $0 -#0. 4008: V:2 | i8x16.shl $0x00000001 00000001 00000001 00000001 $0x00000000 -#0. 4010: V:1 | drop -#0. 4011: V:0 | return +#0. 3991: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4009: V:1 | i32.const $0 +#0. 4014: V:2 | i8x16.shl $0x00000001 00000001 00000001 00000001 $0x00000000 +#0. 4016: V:1 | drop +#0. 4017: V:0 | return i8x16.shl() => >>> running export "i16x8.shl": -#0. 4012: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4030: V:1 | i32.const $0 -#0. 4035: V:2 | i16x8.shl $0x00000001 00000001 00000001 00000001 $0x00000000 -#0. 4037: V:1 | drop -#0. 4038: V:0 | return +#0. 4018: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4036: V:1 | i32.const $0 +#0. 4041: V:2 | i16x8.shl $0x00000001 00000001 00000001 00000001 $0x00000000 +#0. 4043: V:1 | drop +#0. 4044: V:0 | return i16x8.shl() => >>> running export "i32x4.shl": -#0. 4039: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4057: V:1 | i32.const $0 -#0. 4062: V:2 | i32x4.shl $0x00000001 00000001 00000001 00000001 $0x00000000 -#0. 4064: V:1 | drop -#0. 4065: V:0 | return +#0. 4045: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4063: V:1 | i32.const $0 +#0. 4068: V:2 | i32x4.shl $0x00000001 00000001 00000001 00000001 $0x00000000 +#0. 4070: V:1 | drop +#0. 4071: V:0 | return i32x4.shl() => >>> running export "i64x2.shl": -#0. 4066: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4084: V:1 | i32.const $0 -#0. 4089: V:2 | i64x2.shl $0x00000001 00000001 00000001 00000001 $0x00000000 -#0. 4091: V:1 | drop -#0. 4092: V:0 | return +#0. 4072: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4090: V:1 | i32.const $0 +#0. 4095: V:2 | i64x2.shl $0x00000001 00000001 00000001 00000001 $0x00000000 +#0. 4097: V:1 | drop +#0. 4098: V:0 | return i64x2.shl() => >>> running export "i8x16.shr_s": -#0. 4093: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4111: V:1 | i32.const $0 -#0. 4116: V:2 | i8x16.shr_s $0x00000001 00000001 00000001 00000001 $0x00000000 -#0. 4118: V:1 | drop -#0. 4119: V:0 | return +#0. 4099: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4117: V:1 | i32.const $0 +#0. 4122: V:2 | i8x16.shr_s $0x00000001 00000001 00000001 00000001 $0x00000000 +#0. 4124: V:1 | drop +#0. 4125: V:0 | return i8x16.shr_s() => >>> running export "i8x16.shr_u": -#0. 4120: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4138: V:1 | i32.const $0 -#0. 4143: V:2 | i8x16.shr_u $0x00000001 00000001 00000001 00000001 $0x00000000 -#0. 4145: V:1 | drop -#0. 4146: V:0 | return +#0. 4126: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4144: V:1 | i32.const $0 +#0. 4149: V:2 | i8x16.shr_u $0x00000001 00000001 00000001 00000001 $0x00000000 +#0. 4151: V:1 | drop +#0. 4152: V:0 | return i8x16.shr_u() => >>> running export "i16x8.shr_s": -#0. 4147: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4165: V:1 | i32.const $0 -#0. 4170: V:2 | i16x8.shr_s $0x00000001 00000001 00000001 00000001 $0x00000000 -#0. 4172: V:1 | drop -#0. 4173: V:0 | return +#0. 4153: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4171: V:1 | i32.const $0 +#0. 4176: V:2 | i16x8.shr_s $0x00000001 00000001 00000001 00000001 $0x00000000 +#0. 4178: V:1 | drop +#0. 4179: V:0 | return i16x8.shr_s() => >>> running export "i16x8.shr_u": -#0. 4174: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4192: V:1 | i32.const $0 -#0. 4197: V:2 | i16x8.shr_u $0x00000001 00000001 00000001 00000001 $0x00000000 -#0. 4199: V:1 | drop -#0. 4200: V:0 | return +#0. 4180: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4198: V:1 | i32.const $0 +#0. 4203: V:2 | i16x8.shr_u $0x00000001 00000001 00000001 00000001 $0x00000000 +#0. 4205: V:1 | drop +#0. 4206: V:0 | return i16x8.shr_u() => >>> running export "i32x4.shr_s": -#0. 4201: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4219: V:1 | i32.const $0 -#0. 4224: V:2 | i32x4.shr_s $0x00000001 00000001 00000001 00000001 $0x00000000 -#0. 4226: V:1 | drop -#0. 4227: V:0 | return +#0. 4207: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4225: V:1 | i32.const $0 +#0. 4230: V:2 | i32x4.shr_s $0x00000001 00000001 00000001 00000001 $0x00000000 +#0. 4232: V:1 | drop +#0. 4233: V:0 | return i32x4.shr_s() => >>> running export "i32x4.shr_u": -#0. 4228: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4246: V:1 | i32.const $0 -#0. 4251: V:2 | i32x4.shr_u $0x00000001 00000001 00000001 00000001 $0x00000000 -#0. 4253: V:1 | drop -#0. 4254: V:0 | return +#0. 4234: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4252: V:1 | i32.const $0 +#0. 4257: V:2 | i32x4.shr_u $0x00000001 00000001 00000001 00000001 $0x00000000 +#0. 4259: V:1 | drop +#0. 4260: V:0 | return i32x4.shr_u() => >>> running export "i64x2.shr_s": -#0. 4255: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4273: V:1 | i32.const $0 -#0. 4278: V:2 | i64x2.shr_s $0x00000001 00000001 00000001 00000001 $0x00000000 -#0. 4280: V:1 | drop -#0. 4281: V:0 | return +#0. 4261: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4279: V:1 | i32.const $0 +#0. 4284: V:2 | i64x2.shr_s $0x00000001 00000001 00000001 00000001 $0x00000000 +#0. 4286: V:1 | drop +#0. 4287: V:0 | return i64x2.shr_s() => >>> running export "i64x2.shr_u": -#0. 4282: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4300: V:1 | i32.const $0 -#0. 4305: V:2 | i64x2.shr_u $0x00000001 00000001 00000001 00000001 $0x00000000 -#0. 4307: V:1 | drop -#0. 4308: V:0 | return +#0. 4288: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4306: V:1 | i32.const $0 +#0. 4311: V:2 | i64x2.shr_u $0x00000001 00000001 00000001 00000001 $0x00000000 +#0. 4313: V:1 | drop +#0. 4314: V:0 | return i64x2.shr_u() => >>> running export "v128.and": -#0. 4309: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4327: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 4345: V:2 | v128.and $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 4347: V:1 | drop -#0. 4348: V:0 | return +#0. 4315: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4333: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 4351: V:2 | v128.and $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 4353: V:1 | drop +#0. 4354: V:0 | return v128.and() => >>> running export "v128.or": -#0. 4349: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4367: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 4385: V:2 | v128.or $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 4387: V:1 | drop -#0. 4388: V:0 | return +#0. 4355: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4373: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 4391: V:2 | v128.or $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 4393: V:1 | drop +#0. 4394: V:0 | return v128.or() => >>> running export "v128.xor": -#0. 4389: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4407: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 4425: V:2 | v128.xor $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 4427: V:1 | drop -#0. 4428: V:0 | return +#0. 4395: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4413: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 4431: V:2 | v128.xor $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 4433: V:1 | drop +#0. 4434: V:0 | return v128.xor() => >>> running export "v128.not": -#0. 4429: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4447: V:1 | v128.not $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4449: V:1 | drop -#0. 4450: V:0 | return +#0. 4435: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4453: V:1 | v128.not $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4455: V:1 | drop +#0. 4456: V:0 | return v128.not() => >>> running export "v128.bitselect": -#0. 4451: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4469: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 4487: V:2 | v128.const $0x00000003 0x00000003 0x00000003 0x00000003 -#0. 4505: V:3 | v128.bitselect $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 $0x00000003 00000003 00000003 00000003 -#0. 4507: V:1 | drop -#0. 4508: V:0 | return +#0. 4457: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4475: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 4493: V:2 | v128.const $0x00000003 0x00000003 0x00000003 0x00000003 +#0. 4511: V:3 | v128.bitselect $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 $0x00000003 00000003 00000003 00000003 +#0. 4513: V:1 | drop +#0. 4514: V:0 | return v128.bitselect() => >>> running export "i8x16.any_true": -#0. 4509: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4527: V:1 | i8x16.any_true $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4529: V:1 | drop -#0. 4530: V:0 | return +#0. 4515: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4533: V:1 | i8x16.any_true $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4535: V:1 | drop +#0. 4536: V:0 | return i8x16.any_true() => >>> running export "i16x8.any_true": -#0. 4531: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4549: V:1 | i16x8.any_true $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4551: V:1 | drop -#0. 4552: V:0 | return +#0. 4537: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4555: V:1 | i16x8.any_true $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4557: V:1 | drop +#0. 4558: V:0 | return i16x8.any_true() => >>> running export "i32x4.any_true": -#0. 4553: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4571: V:1 | i32x4.any_true $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4573: V:1 | drop -#0. 4574: V:0 | return +#0. 4559: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4577: V:1 | i32x4.any_true $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4579: V:1 | drop +#0. 4580: V:0 | return i32x4.any_true() => >>> running export "i64x2.any_true": -#0. 4575: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4593: V:1 | i64x2.any_true $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4595: V:1 | drop -#0. 4596: V:0 | return +#0. 4581: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4599: V:1 | i64x2.any_true $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4601: V:1 | drop +#0. 4602: V:0 | return i64x2.any_true() => >>> running export "i8x16.all_true": -#0. 4597: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4615: V:1 | i8x16.all_true $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4617: V:1 | drop -#0. 4618: V:0 | return +#0. 4603: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4621: V:1 | i8x16.all_true $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4623: V:1 | drop +#0. 4624: V:0 | return i8x16.all_true() => >>> running export "i16x8.all_true": -#0. 4619: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4637: V:1 | i16x8.all_true $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4639: V:1 | drop -#0. 4640: V:0 | return +#0. 4625: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4643: V:1 | i16x8.all_true $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4645: V:1 | drop +#0. 4646: V:0 | return i16x8.all_true() => >>> running export "i32x4.all_true": -#0. 4641: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4659: V:1 | i32x4.all_true $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4661: V:1 | drop -#0. 4662: V:0 | return +#0. 4647: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4665: V:1 | i32x4.all_true $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4667: V:1 | drop +#0. 4668: V:0 | return i32x4.all_true() => >>> running export "i64x2.all_true": -#0. 4663: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4681: V:1 | i64x2.all_true $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4683: V:1 | drop -#0. 4684: V:0 | return +#0. 4669: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4687: V:1 | i64x2.all_true $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4689: V:1 | drop +#0. 4690: V:0 | return i64x2.all_true() => >>> running export "i8x16.eq": -#0. 4685: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4703: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 4721: V:2 | i8x16.eq $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 4723: V:1 | drop -#0. 4724: V:0 | return +#0. 4691: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4709: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 4727: V:2 | i8x16.eq $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 4729: V:1 | drop +#0. 4730: V:0 | return i8x16.eq() => >>> running export "i16x8.eq": -#0. 4725: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4743: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 4761: V:2 | i16x8.eq $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 4763: V:1 | drop -#0. 4764: V:0 | return +#0. 4731: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4749: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 4767: V:2 | i16x8.eq $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 4769: V:1 | drop +#0. 4770: V:0 | return i16x8.eq() => >>> running export "i32x4.eq": -#0. 4765: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4783: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 4801: V:2 | i32x4.eq $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 4803: V:1 | drop -#0. 4804: V:0 | return +#0. 4771: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4789: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 4807: V:2 | i32x4.eq $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 4809: V:1 | drop +#0. 4810: V:0 | return i32x4.eq() => >>> running export "f32x4.eq": -#0. 4805: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4823: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 4841: V:2 | f32x4.eq $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 4843: V:1 | drop -#0. 4844: V:0 | return +#0. 4811: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4829: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 4847: V:2 | f32x4.eq $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 4849: V:1 | drop +#0. 4850: V:0 | return f32x4.eq() => >>> running export "f64x2.eq": -#0. 4845: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4863: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 4881: V:2 | f64x2.eq $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 4883: V:1 | drop -#0. 4884: V:0 | return +#0. 4851: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4869: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 4887: V:2 | f64x2.eq $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 4889: V:1 | drop +#0. 4890: V:0 | return f64x2.eq() => >>> running export "i8x16.ne": -#0. 4885: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4903: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 4921: V:2 | i8x16.ne $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 4923: V:1 | drop -#0. 4924: V:0 | return +#0. 4891: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4909: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 4927: V:2 | i8x16.ne $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 4929: V:1 | drop +#0. 4930: V:0 | return i8x16.ne() => >>> running export "i16x8.ne": -#0. 4925: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4943: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 4961: V:2 | i16x8.ne $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 4963: V:1 | drop -#0. 4964: V:0 | return +#0. 4931: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4949: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 4967: V:2 | i16x8.ne $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 4969: V:1 | drop +#0. 4970: V:0 | return i16x8.ne() => >>> running export "i32x4.ne": -#0. 4965: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 4983: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5001: V:2 | i32x4.ne $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5003: V:1 | drop -#0. 5004: V:0 | return +#0. 4971: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 4989: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5007: V:2 | i32x4.ne $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5009: V:1 | drop +#0. 5010: V:0 | return i32x4.ne() => >>> running export "f32x4.ne": -#0. 5005: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5023: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5041: V:2 | f32x4.ne $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5043: V:1 | drop -#0. 5044: V:0 | return +#0. 5011: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5029: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5047: V:2 | f32x4.ne $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5049: V:1 | drop +#0. 5050: V:0 | return f32x4.ne() => >>> running export "f64x2.ne": -#0. 5045: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5063: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5081: V:2 | f64x2.ne $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5083: V:1 | drop -#0. 5084: V:0 | return +#0. 5051: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5069: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5087: V:2 | f64x2.ne $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5089: V:1 | drop +#0. 5090: V:0 | return f64x2.ne() => >>> running export "i8x16.lt_s": -#0. 5085: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5103: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5121: V:2 | i8x16.lt_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5123: V:1 | drop -#0. 5124: V:0 | return +#0. 5091: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5109: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5127: V:2 | i8x16.lt_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5129: V:1 | drop +#0. 5130: V:0 | return i8x16.lt_s() => >>> running export "i8x16.lt_u": -#0. 5125: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5143: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5161: V:2 | i8x16.lt_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5163: V:1 | drop -#0. 5164: V:0 | return +#0. 5131: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5149: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5167: V:2 | i8x16.lt_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5169: V:1 | drop +#0. 5170: V:0 | return i8x16.lt_u() => >>> running export "i16x8.lt_s": -#0. 5165: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5183: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5201: V:2 | i16x8.lt_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5203: V:1 | drop -#0. 5204: V:0 | return +#0. 5171: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5189: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5207: V:2 | i16x8.lt_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5209: V:1 | drop +#0. 5210: V:0 | return i16x8.lt_s() => >>> running export "i16x8.lt_u": -#0. 5205: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5223: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5241: V:2 | i16x8.lt_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5243: V:1 | drop -#0. 5244: V:0 | return +#0. 5211: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5229: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5247: V:2 | i16x8.lt_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5249: V:1 | drop +#0. 5250: V:0 | return i16x8.lt_u() => >>> running export "i32x4.lt_s": -#0. 5245: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5263: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5281: V:2 | i32x4.lt_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5283: V:1 | drop -#0. 5284: V:0 | return +#0. 5251: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5269: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5287: V:2 | i32x4.lt_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5289: V:1 | drop +#0. 5290: V:0 | return i32x4.lt_s() => >>> running export "i32x4.lt_u": -#0. 5285: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5303: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5321: V:2 | i32x4.lt_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5323: V:1 | drop -#0. 5324: V:0 | return +#0. 5291: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5309: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5327: V:2 | i32x4.lt_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5329: V:1 | drop +#0. 5330: V:0 | return i32x4.lt_u() => >>> running export "f32x4.lt": -#0. 5325: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5343: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5361: V:2 | f32x4.lt $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5363: V:1 | drop -#0. 5364: V:0 | return +#0. 5331: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5349: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5367: V:2 | f32x4.lt $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5369: V:1 | drop +#0. 5370: V:0 | return f32x4.lt() => >>> running export "f64x2.lt": -#0. 5365: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5383: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5401: V:2 | f64x2.lt $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5403: V:1 | drop -#0. 5404: V:0 | return +#0. 5371: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5389: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5407: V:2 | f64x2.lt $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5409: V:1 | drop +#0. 5410: V:0 | return f64x2.lt() => >>> running export "i8x16.le_s": -#0. 5405: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5423: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5441: V:2 | i8x16.le_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5443: V:1 | drop -#0. 5444: V:0 | return +#0. 5411: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5429: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5447: V:2 | i8x16.le_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5449: V:1 | drop +#0. 5450: V:0 | return i8x16.le_s() => >>> running export "i8x16.le_u": -#0. 5445: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5463: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5481: V:2 | i8x16.le_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5483: V:1 | drop -#0. 5484: V:0 | return +#0. 5451: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5469: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5487: V:2 | i8x16.le_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5489: V:1 | drop +#0. 5490: V:0 | return i8x16.le_u() => >>> running export "i16x8.le_s": -#0. 5485: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5503: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5521: V:2 | i16x8.le_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5523: V:1 | drop -#0. 5524: V:0 | return +#0. 5491: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5509: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5527: V:2 | i16x8.le_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5529: V:1 | drop +#0. 5530: V:0 | return i16x8.le_s() => >>> running export "i16x8.le_u": -#0. 5525: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5543: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5561: V:2 | i16x8.le_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5563: V:1 | drop -#0. 5564: V:0 | return +#0. 5531: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5549: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5567: V:2 | i16x8.le_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5569: V:1 | drop +#0. 5570: V:0 | return i16x8.le_u() => >>> running export "i32x4.le_s": -#0. 5565: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5583: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5601: V:2 | i32x4.le_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5603: V:1 | drop -#0. 5604: V:0 | return +#0. 5571: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5589: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5607: V:2 | i32x4.le_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5609: V:1 | drop +#0. 5610: V:0 | return i32x4.le_s() => >>> running export "i32x4.le_u": -#0. 5605: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5623: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5641: V:2 | i32x4.le_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5643: V:1 | drop -#0. 5644: V:0 | return +#0. 5611: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5629: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5647: V:2 | i32x4.le_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5649: V:1 | drop +#0. 5650: V:0 | return i32x4.le_u() => >>> running export "f32x4.le": -#0. 5645: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5663: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5681: V:2 | f32x4.le $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5683: V:1 | drop -#0. 5684: V:0 | return +#0. 5651: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5669: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5687: V:2 | f32x4.le $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5689: V:1 | drop +#0. 5690: V:0 | return f32x4.le() => >>> running export "f64x2.le": -#0. 5685: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5703: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5721: V:2 | f64x2.le $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5723: V:1 | drop -#0. 5724: V:0 | return +#0. 5691: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5709: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5727: V:2 | f64x2.le $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5729: V:1 | drop +#0. 5730: V:0 | return f64x2.le() => >>> running export "i8x16.gt_s": -#0. 5725: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5743: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5761: V:2 | i8x16.gt_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5763: V:1 | drop -#0. 5764: V:0 | return +#0. 5731: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5749: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5767: V:2 | i8x16.gt_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5769: V:1 | drop +#0. 5770: V:0 | return i8x16.gt_s() => >>> running export "i8x16.gt_u": -#0. 5765: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5783: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5801: V:2 | i8x16.gt_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5803: V:1 | drop -#0. 5804: V:0 | return +#0. 5771: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5789: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5807: V:2 | i8x16.gt_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5809: V:1 | drop +#0. 5810: V:0 | return i8x16.gt_u() => >>> running export "i16x8.gt_s": -#0. 5805: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5823: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5841: V:2 | i16x8.gt_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5843: V:1 | drop -#0. 5844: V:0 | return +#0. 5811: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5829: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5847: V:2 | i16x8.gt_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5849: V:1 | drop +#0. 5850: V:0 | return i16x8.gt_s() => >>> running export "i16x8.gt_u": -#0. 5845: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5863: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5881: V:2 | i16x8.gt_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5883: V:1 | drop -#0. 5884: V:0 | return +#0. 5851: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5869: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5887: V:2 | i16x8.gt_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5889: V:1 | drop +#0. 5890: V:0 | return i16x8.gt_u() => >>> running export "i32x4.gt_s": -#0. 5885: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5903: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5921: V:2 | i32x4.gt_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5923: V:1 | drop -#0. 5924: V:0 | return +#0. 5891: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5909: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5927: V:2 | i32x4.gt_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5929: V:1 | drop +#0. 5930: V:0 | return i32x4.gt_s() => >>> running export "i32x4.gt_u": -#0. 5925: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5943: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 5961: V:2 | i32x4.gt_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 5963: V:1 | drop -#0. 5964: V:0 | return +#0. 5931: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5949: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 5967: V:2 | i32x4.gt_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 5969: V:1 | drop +#0. 5970: V:0 | return i32x4.gt_u() => >>> running export "f32x4.gt": -#0. 5965: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 5983: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 6001: V:2 | f32x4.gt $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 6003: V:1 | drop -#0. 6004: V:0 | return +#0. 5971: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 5989: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 6007: V:2 | f32x4.gt $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 6009: V:1 | drop +#0. 6010: V:0 | return f32x4.gt() => >>> running export "f64x2.gt": -#0. 6005: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6023: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 6041: V:2 | f64x2.gt $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 6043: V:1 | drop -#0. 6044: V:0 | return +#0. 6011: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6029: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 6047: V:2 | f64x2.gt $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 6049: V:1 | drop +#0. 6050: V:0 | return f64x2.gt() => >>> running export "i8x16.ge_s": -#0. 6045: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6063: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 6081: V:2 | i8x16.ge_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 6083: V:1 | drop -#0. 6084: V:0 | return +#0. 6051: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6069: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 6087: V:2 | i8x16.ge_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 6089: V:1 | drop +#0. 6090: V:0 | return i8x16.ge_s() => >>> running export "i8x16.ge_u": -#0. 6085: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6103: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 6121: V:2 | i8x16.ge_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 6123: V:1 | drop -#0. 6124: V:0 | return +#0. 6091: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6109: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 6127: V:2 | i8x16.ge_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 6129: V:1 | drop +#0. 6130: V:0 | return i8x16.ge_u() => >>> running export "i16x8.ge_s": -#0. 6125: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6143: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 6161: V:2 | i16x8.ge_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 6163: V:1 | drop -#0. 6164: V:0 | return +#0. 6131: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6149: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 6167: V:2 | i16x8.ge_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 6169: V:1 | drop +#0. 6170: V:0 | return i16x8.ge_s() => >>> running export "i16x8.ge_u": -#0. 6165: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6183: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 6201: V:2 | i16x8.ge_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 6203: V:1 | drop -#0. 6204: V:0 | return +#0. 6171: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6189: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 6207: V:2 | i16x8.ge_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 6209: V:1 | drop +#0. 6210: V:0 | return i16x8.ge_u() => >>> running export "i32x4.ge_s": -#0. 6205: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6223: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 6241: V:2 | i32x4.ge_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 6243: V:1 | drop -#0. 6244: V:0 | return +#0. 6211: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6229: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 6247: V:2 | i32x4.ge_s $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 6249: V:1 | drop +#0. 6250: V:0 | return i32x4.ge_s() => >>> running export "i32x4.ge_u": -#0. 6245: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6263: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 6281: V:2 | i32x4.ge_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 6283: V:1 | drop -#0. 6284: V:0 | return +#0. 6251: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6269: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 6287: V:2 | i32x4.ge_u $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 6289: V:1 | drop +#0. 6290: V:0 | return i32x4.ge_u() => >>> running export "f32x4.ge": -#0. 6285: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6303: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 6321: V:2 | f32x4.ge $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 6323: V:1 | drop -#0. 6324: V:0 | return +#0. 6291: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6309: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 6327: V:2 | f32x4.ge $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 6329: V:1 | drop +#0. 6330: V:0 | return f32x4.ge() => >>> running export "f64x2.ge": -#0. 6325: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6343: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 6361: V:2 | f64x2.ge $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 6363: V:1 | drop -#0. 6364: V:0 | return +#0. 6331: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6349: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 6367: V:2 | f64x2.ge $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 6369: V:1 | drop +#0. 6370: V:0 | return f64x2.ge() => >>> running export "f32x4.neg": -#0. 6365: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6383: V:1 | f32x4.neg $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6385: V:1 | drop -#0. 6386: V:0 | return +#0. 6371: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6389: V:1 | f32x4.neg $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6391: V:1 | drop +#0. 6392: V:0 | return f32x4.neg() => >>> running export "f64x2.neg": -#0. 6387: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6405: V:1 | f64x2.neg $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6407: V:1 | drop -#0. 6408: V:0 | return +#0. 6393: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6411: V:1 | f64x2.neg $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6413: V:1 | drop +#0. 6414: V:0 | return f64x2.neg() => >>> running export "f32x4.abs": -#0. 6409: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6427: V:1 | f32x4.abs $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6429: V:1 | drop -#0. 6430: V:0 | return +#0. 6415: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6433: V:1 | f32x4.abs $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6435: V:1 | drop +#0. 6436: V:0 | return f32x4.abs() => >>> running export "f64x2.abs": -#0. 6431: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6449: V:1 | f64x2.abs $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6451: V:1 | drop -#0. 6452: V:0 | return +#0. 6437: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6455: V:1 | f64x2.abs $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6457: V:1 | drop +#0. 6458: V:0 | return f64x2.abs() => >>> running export "f32x4.min": -#0. 6453: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6471: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 6489: V:2 | f32x4.min $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 6491: V:1 | drop -#0. 6492: V:0 | return +#0. 6459: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6477: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 6495: V:2 | f32x4.min $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 6497: V:1 | drop +#0. 6498: V:0 | return f32x4.min() => >>> running export "f64x2.min": -#0. 6493: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6511: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 6529: V:2 | f64x2.min $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 6531: V:1 | drop -#0. 6532: V:0 | return +#0. 6499: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6517: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 6535: V:2 | f64x2.min $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 6537: V:1 | drop +#0. 6538: V:0 | return f64x2.min() => >>> running export "f32x4.max": -#0. 6533: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6551: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 6569: V:2 | f32x4.max $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 6571: V:1 | drop -#0. 6572: V:0 | return +#0. 6539: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6557: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 6575: V:2 | f32x4.max $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 6577: V:1 | drop +#0. 6578: V:0 | return f32x4.max() => >>> running export "f64x2.max": -#0. 6573: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6591: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 6609: V:2 | f64x2.max $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 6611: V:1 | drop -#0. 6612: V:0 | return +#0. 6579: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6597: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 6615: V:2 | f64x2.max $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 6617: V:1 | drop +#0. 6618: V:0 | return f64x2.max() => >>> running export "f32x4.add": -#0. 6613: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6631: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 6649: V:2 | f32x4.add $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 6651: V:1 | drop -#0. 6652: V:0 | return +#0. 6619: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6637: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 6655: V:2 | f32x4.add $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 6657: V:1 | drop +#0. 6658: V:0 | return f32x4.add() => >>> running export "f64x2.add": -#0. 6653: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6671: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 6689: V:2 | f64x2.add $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 6691: V:1 | drop -#0. 6692: V:0 | return +#0. 6659: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6677: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 6695: V:2 | f64x2.add $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 6697: V:1 | drop +#0. 6698: V:0 | return f64x2.add() => >>> running export "f32x4.sub": -#0. 6693: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6711: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 6729: V:2 | f32x4.sub $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 6731: V:1 | drop -#0. 6732: V:0 | return +#0. 6699: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6717: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 6735: V:2 | f32x4.sub $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 6737: V:1 | drop +#0. 6738: V:0 | return f32x4.sub() => >>> running export "f64x2.sub": -#0. 6733: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6751: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 6769: V:2 | f64x2.sub $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 6771: V:1 | drop -#0. 6772: V:0 | return +#0. 6739: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6757: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 6775: V:2 | f64x2.sub $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 6777: V:1 | drop +#0. 6778: V:0 | return f64x2.sub() => >>> running export "f32x4.div": -#0. 6773: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6791: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 6809: V:2 | f32x4.div $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 6811: V:1 | drop -#0. 6812: V:0 | return +#0. 6779: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6797: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 6815: V:2 | f32x4.div $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 6817: V:1 | drop +#0. 6818: V:0 | return f32x4.div() => >>> running export "f64x2.div": -#0. 6813: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6831: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 6849: V:2 | f64x2.div $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 6851: V:1 | drop -#0. 6852: V:0 | return +#0. 6819: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6837: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 6855: V:2 | f64x2.div $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 6857: V:1 | drop +#0. 6858: V:0 | return f64x2.div() => >>> running export "f32x4.mul": -#0. 6853: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6871: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 6889: V:2 | f32x4.mul $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 6891: V:1 | drop -#0. 6892: V:0 | return +#0. 6859: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6877: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 6895: V:2 | f32x4.mul $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 6897: V:1 | drop +#0. 6898: V:0 | return f32x4.mul() => >>> running export "f64x2.mul": -#0. 6893: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6911: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 -#0. 6929: V:2 | f64x2.mul $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 -#0. 6931: V:1 | drop -#0. 6932: V:0 | return +#0. 6899: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6917: V:1 | v128.const $0x00000002 0x00000002 0x00000002 0x00000002 +#0. 6935: V:2 | f64x2.mul $0x00000001 00000001 00000001 00000001 $0x00000002 00000002 00000002 00000002 +#0. 6937: V:1 | drop +#0. 6938: V:0 | return f64x2.mul() => >>> running export "f32x4.sqrt": -#0. 6933: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6951: V:1 | f32x4.sqrt $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6953: V:1 | drop -#0. 6954: V:0 | return +#0. 6939: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6957: V:1 | f32x4.sqrt $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6959: V:1 | drop +#0. 6960: V:0 | return f32x4.sqrt() => >>> running export "f64x2.sqrt": -#0. 6955: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6973: V:1 | f64x2.sqrt $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6975: V:1 | drop -#0. 6976: V:0 | return +#0. 6961: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6979: V:1 | f64x2.sqrt $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 6981: V:1 | drop +#0. 6982: V:0 | return f64x2.sqrt() => >>> running export "f32x4.convert_s/i32x4": -#0. 6977: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6995: V:1 | f32x4.convert_s/i32x4 $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 6997: V:1 | drop -#0. 6998: V:0 | return +#0. 6983: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 7001: V:1 | f32x4.convert_s/i32x4 $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 7003: V:1 | drop +#0. 7004: V:0 | return f32x4.convert_s/i32x4() => >>> running export "f32x4.convert_u/i32x4": -#0. 6999: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 7017: V:1 | f32x4.convert_u/i32x4 $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 7019: V:1 | drop -#0. 7020: V:0 | return +#0. 7005: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 7023: V:1 | f32x4.convert_u/i32x4 $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 7025: V:1 | drop +#0. 7026: V:0 | return f32x4.convert_u/i32x4() => >>> running export "f64x2.convert_s/i64x2": -#0. 7021: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 7039: V:1 | f64x2.convert_s/i64x2 $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 7041: V:1 | drop -#0. 7042: V:0 | return +#0. 7027: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 7045: V:1 | f64x2.convert_s/i64x2 $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 7047: V:1 | drop +#0. 7048: V:0 | return f64x2.convert_s/i64x2() => >>> running export "f64x2.convert_u/i64x2": -#0. 7043: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 7061: V:1 | f64x2.convert_u/i64x2 $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 7063: V:1 | drop -#0. 7064: V:0 | return +#0. 7049: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 7067: V:1 | f64x2.convert_u/i64x2 $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 7069: V:1 | drop +#0. 7070: V:0 | return f64x2.convert_u/i64x2() => >>> running export "i32x4.trunc_s/f32x4:sat": -#0. 7065: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 7083: V:1 | i32x4.trunc_s/f32x4:sat $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 7085: V:1 | drop -#0. 7086: V:0 | return +#0. 7071: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 7089: V:1 | i32x4.trunc_s/f32x4:sat $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 7091: V:1 | drop +#0. 7092: V:0 | return i32x4.trunc_s/f32x4:sat() => >>> running export "i32x4.trunc_u/f32x4:sat": -#0. 7087: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 7105: V:1 | i32x4.trunc_u/f32x4:sat $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 7107: V:1 | drop -#0. 7108: V:0 | return +#0. 7093: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 7111: V:1 | i32x4.trunc_u/f32x4:sat $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 7113: V:1 | drop +#0. 7114: V:0 | return i32x4.trunc_u/f32x4:sat() => >>> running export "i64x2.trunc_s/f64x2:sat": -#0. 7109: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 7127: V:1 | i64x2.trunc_s/f64x2:sat $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 7129: V:1 | drop -#0. 7130: V:0 | return +#0. 7115: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 7133: V:1 | i64x2.trunc_s/f64x2:sat $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 7135: V:1 | drop +#0. 7136: V:0 | return i64x2.trunc_s/f64x2:sat() => >>> running export "i64x2.trunc_u/f64x2:sat": -#0. 7131: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 7149: V:1 | i64x2.trunc_u/f64x2:sat $0x00000001 0x00000001 0x00000001 0x00000001 -#0. 7151: V:1 | drop -#0. 7152: V:0 | return +#0. 7137: V:0 | v128.const $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 7155: V:1 | i64x2.trunc_u/f64x2:sat $0x00000001 0x00000001 0x00000001 0x00000001 +#0. 7157: V:1 | drop +#0. 7158: V:0 | return i64x2.trunc_u/f64x2:sat() => >>> running export "atomic.wake": -#0. 7153: V:0 | i32.const $1 -#0. 7158: V:1 | i32.const $2 -#0. 7163: V:2 | atomic.wake $0:1+$3, 2 +#0. 7159: V:0 | i32.const $1 +#0. 7164: V:1 | i32.const $2 +#0. 7169: V:2 | atomic.wake $0:1+$3, 2 atomic.wake() => error: unreachable executed >>> running export "i32.atomic.wait": -#0. 7175: V:0 | i32.const $1 -#0. 7180: V:1 | i32.const $2 -#0. 7185: V:2 | i64.const $3 -#0. 7194: V:3 | i32.atomic.wait $0:1+$3, 2, 3 +#0. 7181: V:0 | i32.const $1 +#0. 7186: V:1 | i32.const $2 +#0. 7191: V:2 | i64.const $3 +#0. 7200: V:3 | i32.atomic.wait $0:1+$3, 2, 3 i32.atomic.wait() => error: unreachable executed >>> running export "i64.atomic.wait": -#0. 7206: V:0 | i32.const $1 -#0. 7211: V:1 | i64.const $2 -#0. 7220: V:2 | i64.const $3 -#0. 7229: V:3 | i64.atomic.wait $0:1+$3, 2, 3 +#0. 7212: V:0 | i32.const $1 +#0. 7217: V:1 | i64.const $2 +#0. 7226: V:2 | i64.const $3 +#0. 7235: V:3 | i64.atomic.wait $0:1+$3, 2, 3 i64.atomic.wait() => error: unreachable executed >>> running export "i32.atomic.load": -#0. 7241: V:0 | i32.const $1 -#0. 7246: V:1 | i32.atomic.load $0:1+$3 -#0. 7256: V:1 | drop -#0. 7257: V:0 | return +#0. 7247: V:0 | i32.const $1 +#0. 7252: V:1 | i32.atomic.load $0:1+$3 +#0. 7262: V:1 | drop +#0. 7263: V:0 | return i32.atomic.load() => >>> running export "i64.atomic.load": -#0. 7258: V:0 | i32.const $1 -#0. 7263: V:1 | i64.atomic.load $0:1+$7 -#0. 7273: V:1 | drop -#0. 7274: V:0 | return +#0. 7264: V:0 | i32.const $1 +#0. 7269: V:1 | i64.atomic.load $0:1+$7 +#0. 7279: V:1 | drop +#0. 7280: V:0 | return i64.atomic.load() => >>> running export "i32.atomic.load8_u": -#0. 7275: V:0 | i32.const $1 -#0. 7280: V:1 | i32.atomic.load8_u $0:1+$3 -#0. 7290: V:1 | drop -#0. 7291: V:0 | return +#0. 7281: V:0 | i32.const $1 +#0. 7286: V:1 | i32.atomic.load8_u $0:1+$3 +#0. 7296: V:1 | drop +#0. 7297: V:0 | return i32.atomic.load8_u() => >>> running export "i32.atomic.load16_u": -#0. 7292: V:0 | i32.const $1 -#0. 7297: V:1 | i32.atomic.load16_u $0:1+$3 -#0. 7307: V:1 | drop -#0. 7308: V:0 | return +#0. 7298: V:0 | i32.const $1 +#0. 7303: V:1 | i32.atomic.load16_u $0:1+$3 +#0. 7313: V:1 | drop +#0. 7314: V:0 | return i32.atomic.load16_u() => >>> running export "i64.atomic.load8_u": -#0. 7309: V:0 | i32.const $1 -#0. 7314: V:1 | i64.atomic.load8_u $0:1+$3 -#0. 7324: V:1 | drop -#0. 7325: V:0 | return +#0. 7315: V:0 | i32.const $1 +#0. 7320: V:1 | i64.atomic.load8_u $0:1+$3 +#0. 7330: V:1 | drop +#0. 7331: V:0 | return i64.atomic.load8_u() => >>> running export "i64.atomic.load16_u": -#0. 7326: V:0 | i32.const $1 -#0. 7331: V:1 | i64.atomic.load16_u $0:1+$3 -#0. 7341: V:1 | drop -#0. 7342: V:0 | return +#0. 7332: V:0 | i32.const $1 +#0. 7337: V:1 | i64.atomic.load16_u $0:1+$3 +#0. 7347: V:1 | drop +#0. 7348: V:0 | return i64.atomic.load16_u() => >>> running export "i64.atomic.load32_u": -#0. 7343: V:0 | i32.const $1 -#0. 7348: V:1 | i64.atomic.load32_u $0:1+$3 -#0. 7358: V:1 | drop -#0. 7359: V:0 | return +#0. 7349: V:0 | i32.const $1 +#0. 7354: V:1 | i64.atomic.load32_u $0:1+$3 +#0. 7364: V:1 | drop +#0. 7365: V:0 | return i64.atomic.load32_u() => >>> running export "i32.atomic.store": -#0. 7360: V:0 | i32.const $1 -#0. 7365: V:1 | i32.const $2 -#0. 7370: V:2 | i32.atomic.store $0:1+$3, 2 -#0. 7380: V:0 | return +#0. 7366: V:0 | i32.const $1 +#0. 7371: V:1 | i32.const $2 +#0. 7376: V:2 | i32.atomic.store $0:1+$3, 2 +#0. 7386: V:0 | return i32.atomic.store() => >>> running export "i64.atomic.store": -#0. 7381: V:0 | i32.const $1 -#0. 7386: V:1 | i64.const $2 -#0. 7395: V:2 | i64.atomic.store $0:1+$7, 2 -#0. 7405: V:0 | return +#0. 7387: V:0 | i32.const $1 +#0. 7392: V:1 | i64.const $2 +#0. 7401: V:2 | i64.atomic.store $0:1+$7, 2 +#0. 7411: V:0 | return i64.atomic.store() => >>> running export "i32.atomic.store8": -#0. 7406: V:0 | i32.const $1 -#0. 7411: V:1 | i32.const $2 -#0. 7416: V:2 | i32.atomic.store8 $0:1+$3, 2 -#0. 7426: V:0 | return +#0. 7412: V:0 | i32.const $1 +#0. 7417: V:1 | i32.const $2 +#0. 7422: V:2 | i32.atomic.store8 $0:1+$3, 2 +#0. 7432: V:0 | return i32.atomic.store8() => >>> running export "i32.atomic.store16": -#0. 7427: V:0 | i32.const $1 -#0. 7432: V:1 | i32.const $2 -#0. 7437: V:2 | i32.atomic.store16 $0:1+$3, 2 -#0. 7447: V:0 | return +#0. 7433: V:0 | i32.const $1 +#0. 7438: V:1 | i32.const $2 +#0. 7443: V:2 | i32.atomic.store16 $0:1+$3, 2 +#0. 7453: V:0 | return i32.atomic.store16() => >>> running export "i64.atomic.store8": -#0. 7448: V:0 | i32.const $1 -#0. 7453: V:1 | i64.const $2 -#0. 7462: V:2 | i64.atomic.store8 $0:1+$3, 2 -#0. 7472: V:0 | return +#0. 7454: V:0 | i32.const $1 +#0. 7459: V:1 | i64.const $2 +#0. 7468: V:2 | i64.atomic.store8 $0:1+$3, 2 +#0. 7478: V:0 | return i64.atomic.store8() => >>> running export "i64.atomic.store16": -#0. 7473: V:0 | i32.const $1 -#0. 7478: V:1 | i64.const $2 -#0. 7487: V:2 | i64.atomic.store16 $0:1+$3, 2 -#0. 7497: V:0 | return +#0. 7479: V:0 | i32.const $1 +#0. 7484: V:1 | i64.const $2 +#0. 7493: V:2 | i64.atomic.store16 $0:1+$3, 2 +#0. 7503: V:0 | return i64.atomic.store16() => >>> running export "i64.atomic.store32": -#0. 7498: V:0 | i32.const $1 -#0. 7503: V:1 | i64.const $2 -#0. 7512: V:2 | i64.atomic.store32 $0:1+$3, 2 -#0. 7522: V:0 | return +#0. 7504: V:0 | i32.const $1 +#0. 7509: V:1 | i64.const $2 +#0. 7518: V:2 | i64.atomic.store32 $0:1+$3, 2 +#0. 7528: V:0 | return i64.atomic.store32() => >>> running export "i32.atomic.rmw.add": -#0. 7523: V:0 | i32.const $1 -#0. 7528: V:1 | i32.const $2 -#0. 7533: V:2 | i32.atomic.rmw.add $0:1+$3, 2 -#0. 7543: V:1 | drop -#0. 7544: V:0 | return +#0. 7529: V:0 | i32.const $1 +#0. 7534: V:1 | i32.const $2 +#0. 7539: V:2 | i32.atomic.rmw.add $0:1+$3, 2 +#0. 7549: V:1 | drop +#0. 7550: V:0 | return i32.atomic.rmw.add() => >>> running export "i64.atomic.rmw.add": -#0. 7545: V:0 | i32.const $1 -#0. 7550: V:1 | i64.const $2 -#0. 7559: V:2 | i64.atomic.rmw.add $0:1+$7, 2 -#0. 7569: V:1 | drop -#0. 7570: V:0 | return +#0. 7551: V:0 | i32.const $1 +#0. 7556: V:1 | i64.const $2 +#0. 7565: V:2 | i64.atomic.rmw.add $0:1+$7, 2 +#0. 7575: V:1 | drop +#0. 7576: V:0 | return i64.atomic.rmw.add() => >>> running export "i32.atomic.rmw8_u.add": -#0. 7571: V:0 | i32.const $1 -#0. 7576: V:1 | i32.const $2 -#0. 7581: V:2 | i32.atomic.rmw8_u.add $0:1+$3, 2 -#0. 7591: V:1 | drop -#0. 7592: V:0 | return +#0. 7577: V:0 | i32.const $1 +#0. 7582: V:1 | i32.const $2 +#0. 7587: V:2 | i32.atomic.rmw8_u.add $0:1+$3, 2 +#0. 7597: V:1 | drop +#0. 7598: V:0 | return i32.atomic.rmw8_u.add() => >>> running export "i32.atomic.rmw16_u.add": -#0. 7593: V:0 | i32.const $1 -#0. 7598: V:1 | i32.const $2 -#0. 7603: V:2 | i32.atomic.rmw16_u.add $0:1+$3, 2 -#0. 7613: V:1 | drop -#0. 7614: V:0 | return +#0. 7599: V:0 | i32.const $1 +#0. 7604: V:1 | i32.const $2 +#0. 7609: V:2 | i32.atomic.rmw16_u.add $0:1+$3, 2 +#0. 7619: V:1 | drop +#0. 7620: V:0 | return i32.atomic.rmw16_u.add() => >>> running export "i64.atomic.rmw8_u.add": -#0. 7615: V:0 | i32.const $1 -#0. 7620: V:1 | i64.const $2 -#0. 7629: V:2 | i64.atomic.rmw8_u.add $0:1+$3, 2 -#0. 7639: V:1 | drop -#0. 7640: V:0 | return +#0. 7621: V:0 | i32.const $1 +#0. 7626: V:1 | i64.const $2 +#0. 7635: V:2 | i64.atomic.rmw8_u.add $0:1+$3, 2 +#0. 7645: V:1 | drop +#0. 7646: V:0 | return i64.atomic.rmw8_u.add() => >>> running export "i64.atomic.rmw16_u.add": -#0. 7641: V:0 | i32.const $1 -#0. 7646: V:1 | i64.const $2 -#0. 7655: V:2 | i64.atomic.rmw16_u.add $0:1+$3, 2 -#0. 7665: V:1 | drop -#0. 7666: V:0 | return +#0. 7647: V:0 | i32.const $1 +#0. 7652: V:1 | i64.const $2 +#0. 7661: V:2 | i64.atomic.rmw16_u.add $0:1+$3, 2 +#0. 7671: V:1 | drop +#0. 7672: V:0 | return i64.atomic.rmw16_u.add() => >>> running export "i64.atomic.rmw32_u.add": -#0. 7667: V:0 | i32.const $1 -#0. 7672: V:1 | i64.const $2 -#0. 7681: V:2 | i64.atomic.rmw32_u.add $0:1+$3, 2 -#0. 7691: V:1 | drop -#0. 7692: V:0 | return +#0. 7673: V:0 | i32.const $1 +#0. 7678: V:1 | i64.const $2 +#0. 7687: V:2 | i64.atomic.rmw32_u.add $0:1+$3, 2 +#0. 7697: V:1 | drop +#0. 7698: V:0 | return i64.atomic.rmw32_u.add() => >>> running export "i32.atomic.rmw.sub": -#0. 7693: V:0 | i32.const $1 -#0. 7698: V:1 | i32.const $2 -#0. 7703: V:2 | i32.atomic.rmw.sub $0:1+$3, 2 -#0. 7713: V:1 | drop -#0. 7714: V:0 | return +#0. 7699: V:0 | i32.const $1 +#0. 7704: V:1 | i32.const $2 +#0. 7709: V:2 | i32.atomic.rmw.sub $0:1+$3, 2 +#0. 7719: V:1 | drop +#0. 7720: V:0 | return i32.atomic.rmw.sub() => >>> running export "i64.atomic.rmw.sub": -#0. 7715: V:0 | i32.const $1 -#0. 7720: V:1 | i64.const $2 -#0. 7729: V:2 | i64.atomic.rmw.sub $0:1+$7, 2 -#0. 7739: V:1 | drop -#0. 7740: V:0 | return +#0. 7721: V:0 | i32.const $1 +#0. 7726: V:1 | i64.const $2 +#0. 7735: V:2 | i64.atomic.rmw.sub $0:1+$7, 2 +#0. 7745: V:1 | drop +#0. 7746: V:0 | return i64.atomic.rmw.sub() => >>> running export "i32.atomic.rmw8_u.sub": -#0. 7741: V:0 | i32.const $1 -#0. 7746: V:1 | i32.const $2 -#0. 7751: V:2 | i32.atomic.rmw8_u.sub $0:1+$3, 2 -#0. 7761: V:1 | drop -#0. 7762: V:0 | return +#0. 7747: V:0 | i32.const $1 +#0. 7752: V:1 | i32.const $2 +#0. 7757: V:2 | i32.atomic.rmw8_u.sub $0:1+$3, 2 +#0. 7767: V:1 | drop +#0. 7768: V:0 | return i32.atomic.rmw8_u.sub() => >>> running export "i32.atomic.rmw16_u.sub": -#0. 7763: V:0 | i32.const $1 -#0. 7768: V:1 | i32.const $2 -#0. 7773: V:2 | i32.atomic.rmw16_u.sub $0:1+$3, 2 -#0. 7783: V:1 | drop -#0. 7784: V:0 | return +#0. 7769: V:0 | i32.const $1 +#0. 7774: V:1 | i32.const $2 +#0. 7779: V:2 | i32.atomic.rmw16_u.sub $0:1+$3, 2 +#0. 7789: V:1 | drop +#0. 7790: V:0 | return i32.atomic.rmw16_u.sub() => >>> running export "i64.atomic.rmw8_u.sub": -#0. 7785: V:0 | i32.const $1 -#0. 7790: V:1 | i64.const $2 -#0. 7799: V:2 | i64.atomic.rmw8_u.sub $0:1+$3, 2 -#0. 7809: V:1 | drop -#0. 7810: V:0 | return +#0. 7791: V:0 | i32.const $1 +#0. 7796: V:1 | i64.const $2 +#0. 7805: V:2 | i64.atomic.rmw8_u.sub $0:1+$3, 2 +#0. 7815: V:1 | drop +#0. 7816: V:0 | return i64.atomic.rmw8_u.sub() => >>> running export "i64.atomic.rmw16_u.sub": -#0. 7811: V:0 | i32.const $1 -#0. 7816: V:1 | i64.const $2 -#0. 7825: V:2 | i64.atomic.rmw16_u.sub $0:1+$3, 2 -#0. 7835: V:1 | drop -#0. 7836: V:0 | return +#0. 7817: V:0 | i32.const $1 +#0. 7822: V:1 | i64.const $2 +#0. 7831: V:2 | i64.atomic.rmw16_u.sub $0:1+$3, 2 +#0. 7841: V:1 | drop +#0. 7842: V:0 | return i64.atomic.rmw16_u.sub() => >>> running export "i64.atomic.rmw32_u.sub": -#0. 7837: V:0 | i32.const $1 -#0. 7842: V:1 | i64.const $2 -#0. 7851: V:2 | i64.atomic.rmw32_u.sub $0:1+$3, 2 -#0. 7861: V:1 | drop -#0. 7862: V:0 | return +#0. 7843: V:0 | i32.const $1 +#0. 7848: V:1 | i64.const $2 +#0. 7857: V:2 | i64.atomic.rmw32_u.sub $0:1+$3, 2 +#0. 7867: V:1 | drop +#0. 7868: V:0 | return i64.atomic.rmw32_u.sub() => >>> running export "i32.atomic.rmw.and": -#0. 7863: V:0 | i32.const $1 -#0. 7868: V:1 | i32.const $2 -#0. 7873: V:2 | i32.atomic.rmw.and $0:1+$3, 2 -#0. 7883: V:1 | drop -#0. 7884: V:0 | return +#0. 7869: V:0 | i32.const $1 +#0. 7874: V:1 | i32.const $2 +#0. 7879: V:2 | i32.atomic.rmw.and $0:1+$3, 2 +#0. 7889: V:1 | drop +#0. 7890: V:0 | return i32.atomic.rmw.and() => >>> running export "i64.atomic.rmw.and": -#0. 7885: V:0 | i32.const $1 -#0. 7890: V:1 | i64.const $2 -#0. 7899: V:2 | i64.atomic.rmw.and $0:1+$7, 2 -#0. 7909: V:1 | drop -#0. 7910: V:0 | return +#0. 7891: V:0 | i32.const $1 +#0. 7896: V:1 | i64.const $2 +#0. 7905: V:2 | i64.atomic.rmw.and $0:1+$7, 2 +#0. 7915: V:1 | drop +#0. 7916: V:0 | return i64.atomic.rmw.and() => >>> running export "i32.atomic.rmw8_u.and": -#0. 7911: V:0 | i32.const $1 -#0. 7916: V:1 | i32.const $2 -#0. 7921: V:2 | i32.atomic.rmw8_u.and $0:1+$3, 2 -#0. 7931: V:1 | drop -#0. 7932: V:0 | return +#0. 7917: V:0 | i32.const $1 +#0. 7922: V:1 | i32.const $2 +#0. 7927: V:2 | i32.atomic.rmw8_u.and $0:1+$3, 2 +#0. 7937: V:1 | drop +#0. 7938: V:0 | return i32.atomic.rmw8_u.and() => >>> running export "i32.atomic.rmw16_u.and": -#0. 7933: V:0 | i32.const $1 -#0. 7938: V:1 | i32.const $2 -#0. 7943: V:2 | i32.atomic.rmw16_u.and $0:1+$3, 2 -#0. 7953: V:1 | drop -#0. 7954: V:0 | return +#0. 7939: V:0 | i32.const $1 +#0. 7944: V:1 | i32.const $2 +#0. 7949: V:2 | i32.atomic.rmw16_u.and $0:1+$3, 2 +#0. 7959: V:1 | drop +#0. 7960: V:0 | return i32.atomic.rmw16_u.and() => >>> running export "i64.atomic.rmw8_u.and": -#0. 7955: V:0 | i32.const $1 -#0. 7960: V:1 | i64.const $2 -#0. 7969: V:2 | i64.atomic.rmw8_u.and $0:1+$3, 2 -#0. 7979: V:1 | drop -#0. 7980: V:0 | return +#0. 7961: V:0 | i32.const $1 +#0. 7966: V:1 | i64.const $2 +#0. 7975: V:2 | i64.atomic.rmw8_u.and $0:1+$3, 2 +#0. 7985: V:1 | drop +#0. 7986: V:0 | return i64.atomic.rmw8_u.and() => >>> running export "i64.atomic.rmw16_u.and": -#0. 7981: V:0 | i32.const $1 -#0. 7986: V:1 | i64.const $2 -#0. 7995: V:2 | i64.atomic.rmw16_u.and $0:1+$3, 2 -#0. 8005: V:1 | drop -#0. 8006: V:0 | return +#0. 7987: V:0 | i32.const $1 +#0. 7992: V:1 | i64.const $2 +#0. 8001: V:2 | i64.atomic.rmw16_u.and $0:1+$3, 2 +#0. 8011: V:1 | drop +#0. 8012: V:0 | return i64.atomic.rmw16_u.and() => >>> running export "i64.atomic.rmw32_u.and": -#0. 8007: V:0 | i32.const $1 -#0. 8012: V:1 | i64.const $2 -#0. 8021: V:2 | i64.atomic.rmw32_u.and $0:1+$3, 2 -#0. 8031: V:1 | drop -#0. 8032: V:0 | return +#0. 8013: V:0 | i32.const $1 +#0. 8018: V:1 | i64.const $2 +#0. 8027: V:2 | i64.atomic.rmw32_u.and $0:1+$3, 2 +#0. 8037: V:1 | drop +#0. 8038: V:0 | return i64.atomic.rmw32_u.and() => >>> running export "i32.atomic.rmw.or": -#0. 8033: V:0 | i32.const $1 -#0. 8038: V:1 | i32.const $2 -#0. 8043: V:2 | i32.atomic.rmw.or $0:1+$3, 2 -#0. 8053: V:1 | drop -#0. 8054: V:0 | return +#0. 8039: V:0 | i32.const $1 +#0. 8044: V:1 | i32.const $2 +#0. 8049: V:2 | i32.atomic.rmw.or $0:1+$3, 2 +#0. 8059: V:1 | drop +#0. 8060: V:0 | return i32.atomic.rmw.or() => >>> running export "i64.atomic.rmw.or": -#0. 8055: V:0 | i32.const $1 -#0. 8060: V:1 | i64.const $2 -#0. 8069: V:2 | i64.atomic.rmw.or $0:1+$7, 2 -#0. 8079: V:1 | drop -#0. 8080: V:0 | return +#0. 8061: V:0 | i32.const $1 +#0. 8066: V:1 | i64.const $2 +#0. 8075: V:2 | i64.atomic.rmw.or $0:1+$7, 2 +#0. 8085: V:1 | drop +#0. 8086: V:0 | return i64.atomic.rmw.or() => >>> running export "i32.atomic.rmw8_u.or": -#0. 8081: V:0 | i32.const $1 -#0. 8086: V:1 | i32.const $2 -#0. 8091: V:2 | i32.atomic.rmw8_u.or $0:1+$3, 2 -#0. 8101: V:1 | drop -#0. 8102: V:0 | return +#0. 8087: V:0 | i32.const $1 +#0. 8092: V:1 | i32.const $2 +#0. 8097: V:2 | i32.atomic.rmw8_u.or $0:1+$3, 2 +#0. 8107: V:1 | drop +#0. 8108: V:0 | return i32.atomic.rmw8_u.or() => >>> running export "i32.atomic.rmw16_u.or": -#0. 8103: V:0 | i32.const $1 -#0. 8108: V:1 | i32.const $2 -#0. 8113: V:2 | i32.atomic.rmw16_u.or $0:1+$3, 2 -#0. 8123: V:1 | drop -#0. 8124: V:0 | return +#0. 8109: V:0 | i32.const $1 +#0. 8114: V:1 | i32.const $2 +#0. 8119: V:2 | i32.atomic.rmw16_u.or $0:1+$3, 2 +#0. 8129: V:1 | drop +#0. 8130: V:0 | return i32.atomic.rmw16_u.or() => >>> running export "i64.atomic.rmw8_u.or": -#0. 8125: V:0 | i32.const $1 -#0. 8130: V:1 | i64.const $2 -#0. 8139: V:2 | i64.atomic.rmw8_u.or $0:1+$3, 2 -#0. 8149: V:1 | drop -#0. 8150: V:0 | return +#0. 8131: V:0 | i32.const $1 +#0. 8136: V:1 | i64.const $2 +#0. 8145: V:2 | i64.atomic.rmw8_u.or $0:1+$3, 2 +#0. 8155: V:1 | drop +#0. 8156: V:0 | return i64.atomic.rmw8_u.or() => >>> running export "i64.atomic.rmw16_u.or": -#0. 8151: V:0 | i32.const $1 -#0. 8156: V:1 | i64.const $2 -#0. 8165: V:2 | i64.atomic.rmw16_u.or $0:1+$3, 2 -#0. 8175: V:1 | drop -#0. 8176: V:0 | return +#0. 8157: V:0 | i32.const $1 +#0. 8162: V:1 | i64.const $2 +#0. 8171: V:2 | i64.atomic.rmw16_u.or $0:1+$3, 2 +#0. 8181: V:1 | drop +#0. 8182: V:0 | return i64.atomic.rmw16_u.or() => >>> running export "i64.atomic.rmw32_u.or": -#0. 8177: V:0 | i32.const $1 -#0. 8182: V:1 | i64.const $2 -#0. 8191: V:2 | i64.atomic.rmw32_u.or $0:1+$3, 2 -#0. 8201: V:1 | drop -#0. 8202: V:0 | return +#0. 8183: V:0 | i32.const $1 +#0. 8188: V:1 | i64.const $2 +#0. 8197: V:2 | i64.atomic.rmw32_u.or $0:1+$3, 2 +#0. 8207: V:1 | drop +#0. 8208: V:0 | return i64.atomic.rmw32_u.or() => >>> running export "i32.atomic.rmw.xor": -#0. 8203: V:0 | i32.const $1 -#0. 8208: V:1 | i32.const $2 -#0. 8213: V:2 | i32.atomic.rmw.xor $0:1+$3, 2 -#0. 8223: V:1 | drop -#0. 8224: V:0 | return +#0. 8209: V:0 | i32.const $1 +#0. 8214: V:1 | i32.const $2 +#0. 8219: V:2 | i32.atomic.rmw.xor $0:1+$3, 2 +#0. 8229: V:1 | drop +#0. 8230: V:0 | return i32.atomic.rmw.xor() => >>> running export "i64.atomic.rmw.xor": -#0. 8225: V:0 | i32.const $1 -#0. 8230: V:1 | i64.const $2 -#0. 8239: V:2 | i64.atomic.rmw.xor $0:1+$7, 2 -#0. 8249: V:1 | drop -#0. 8250: V:0 | return +#0. 8231: V:0 | i32.const $1 +#0. 8236: V:1 | i64.const $2 +#0. 8245: V:2 | i64.atomic.rmw.xor $0:1+$7, 2 +#0. 8255: V:1 | drop +#0. 8256: V:0 | return i64.atomic.rmw.xor() => >>> running export "i32.atomic.rmw8_u.xor": -#0. 8251: V:0 | i32.const $1 -#0. 8256: V:1 | i32.const $2 -#0. 8261: V:2 | i32.atomic.rmw8_u.xor $0:1+$3, 2 -#0. 8271: V:1 | drop -#0. 8272: V:0 | return +#0. 8257: V:0 | i32.const $1 +#0. 8262: V:1 | i32.const $2 +#0. 8267: V:2 | i32.atomic.rmw8_u.xor $0:1+$3, 2 +#0. 8277: V:1 | drop +#0. 8278: V:0 | return i32.atomic.rmw8_u.xor() => >>> running export "i32.atomic.rmw16_u.xor": -#0. 8273: V:0 | i32.const $1 -#0. 8278: V:1 | i32.const $2 -#0. 8283: V:2 | i32.atomic.rmw16_u.xor $0:1+$3, 2 -#0. 8293: V:1 | drop -#0. 8294: V:0 | return +#0. 8279: V:0 | i32.const $1 +#0. 8284: V:1 | i32.const $2 +#0. 8289: V:2 | i32.atomic.rmw16_u.xor $0:1+$3, 2 +#0. 8299: V:1 | drop +#0. 8300: V:0 | return i32.atomic.rmw16_u.xor() => >>> running export "i64.atomic.rmw8_u.xor": -#0. 8295: V:0 | i32.const $1 -#0. 8300: V:1 | i64.const $2 -#0. 8309: V:2 | i64.atomic.rmw8_u.xor $0:1+$3, 2 -#0. 8319: V:1 | drop -#0. 8320: V:0 | return +#0. 8301: V:0 | i32.const $1 +#0. 8306: V:1 | i64.const $2 +#0. 8315: V:2 | i64.atomic.rmw8_u.xor $0:1+$3, 2 +#0. 8325: V:1 | drop +#0. 8326: V:0 | return i64.atomic.rmw8_u.xor() => >>> running export "i64.atomic.rmw16_u.xor": -#0. 8321: V:0 | i32.const $1 -#0. 8326: V:1 | i64.const $2 -#0. 8335: V:2 | i64.atomic.rmw16_u.xor $0:1+$3, 2 -#0. 8345: V:1 | drop -#0. 8346: V:0 | return +#0. 8327: V:0 | i32.const $1 +#0. 8332: V:1 | i64.const $2 +#0. 8341: V:2 | i64.atomic.rmw16_u.xor $0:1+$3, 2 +#0. 8351: V:1 | drop +#0. 8352: V:0 | return i64.atomic.rmw16_u.xor() => >>> running export "i64.atomic.rmw32_u.xor": -#0. 8347: V:0 | i32.const $1 -#0. 8352: V:1 | i64.const $2 -#0. 8361: V:2 | i64.atomic.rmw32_u.xor $0:1+$3, 2 -#0. 8371: V:1 | drop -#0. 8372: V:0 | return +#0. 8353: V:0 | i32.const $1 +#0. 8358: V:1 | i64.const $2 +#0. 8367: V:2 | i64.atomic.rmw32_u.xor $0:1+$3, 2 +#0. 8377: V:1 | drop +#0. 8378: V:0 | return i64.atomic.rmw32_u.xor() => >>> running export "i32.atomic.rmw.xchg": -#0. 8373: V:0 | i32.const $1 -#0. 8378: V:1 | i32.const $2 -#0. 8383: V:2 | i32.atomic.rmw.xchg $0:1+$3, 2 -#0. 8393: V:1 | drop -#0. 8394: V:0 | return +#0. 8379: V:0 | i32.const $1 +#0. 8384: V:1 | i32.const $2 +#0. 8389: V:2 | i32.atomic.rmw.xchg $0:1+$3, 2 +#0. 8399: V:1 | drop +#0. 8400: V:0 | return i32.atomic.rmw.xchg() => >>> running export "i64.atomic.rmw.xchg": -#0. 8395: V:0 | i32.const $1 -#0. 8400: V:1 | i64.const $2 -#0. 8409: V:2 | i64.atomic.rmw.xchg $0:1+$7, 2 -#0. 8419: V:1 | drop -#0. 8420: V:0 | return +#0. 8401: V:0 | i32.const $1 +#0. 8406: V:1 | i64.const $2 +#0. 8415: V:2 | i64.atomic.rmw.xchg $0:1+$7, 2 +#0. 8425: V:1 | drop +#0. 8426: V:0 | return i64.atomic.rmw.xchg() => >>> running export "i32.atomic.rmw8_u.xchg": -#0. 8421: V:0 | i32.const $1 -#0. 8426: V:1 | i32.const $2 -#0. 8431: V:2 | i32.atomic.rmw8_u.xchg $0:1+$3, 2 -#0. 8441: V:1 | drop -#0. 8442: V:0 | return +#0. 8427: V:0 | i32.const $1 +#0. 8432: V:1 | i32.const $2 +#0. 8437: V:2 | i32.atomic.rmw8_u.xchg $0:1+$3, 2 +#0. 8447: V:1 | drop +#0. 8448: V:0 | return i32.atomic.rmw8_u.xchg() => >>> running export "i32.atomic.rmw16_u.xchg": -#0. 8443: V:0 | i32.const $1 -#0. 8448: V:1 | i32.const $2 -#0. 8453: V:2 | i32.atomic.rmw16_u.xchg $0:1+$3, 2 -#0. 8463: V:1 | drop -#0. 8464: V:0 | return +#0. 8449: V:0 | i32.const $1 +#0. 8454: V:1 | i32.const $2 +#0. 8459: V:2 | i32.atomic.rmw16_u.xchg $0:1+$3, 2 +#0. 8469: V:1 | drop +#0. 8470: V:0 | return i32.atomic.rmw16_u.xchg() => >>> running export "i64.atomic.rmw8_u.xchg": -#0. 8465: V:0 | i32.const $1 -#0. 8470: V:1 | i64.const $2 -#0. 8479: V:2 | i64.atomic.rmw8_u.xchg $0:1+$3, 2 -#0. 8489: V:1 | drop -#0. 8490: V:0 | return +#0. 8471: V:0 | i32.const $1 +#0. 8476: V:1 | i64.const $2 +#0. 8485: V:2 | i64.atomic.rmw8_u.xchg $0:1+$3, 2 +#0. 8495: V:1 | drop +#0. 8496: V:0 | return i64.atomic.rmw8_u.xchg() => >>> running export "i64.atomic.rmw16_u.xchg": -#0. 8491: V:0 | i32.const $1 -#0. 8496: V:1 | i64.const $2 -#0. 8505: V:2 | i64.atomic.rmw16_u.xchg $0:1+$3, 2 -#0. 8515: V:1 | drop -#0. 8516: V:0 | return +#0. 8497: V:0 | i32.const $1 +#0. 8502: V:1 | i64.const $2 +#0. 8511: V:2 | i64.atomic.rmw16_u.xchg $0:1+$3, 2 +#0. 8521: V:1 | drop +#0. 8522: V:0 | return i64.atomic.rmw16_u.xchg() => >>> running export "i64.atomic.rmw32_u.xchg": -#0. 8517: V:0 | i32.const $1 -#0. 8522: V:1 | i64.const $2 -#0. 8531: V:2 | i64.atomic.rmw32_u.xchg $0:1+$3, 2 -#0. 8541: V:1 | drop -#0. 8542: V:0 | return +#0. 8523: V:0 | i32.const $1 +#0. 8528: V:1 | i64.const $2 +#0. 8537: V:2 | i64.atomic.rmw32_u.xchg $0:1+$3, 2 +#0. 8547: V:1 | drop +#0. 8548: V:0 | return i64.atomic.rmw32_u.xchg() => >>> running export "i32.atomic.rmw.cmpxchg": -#0. 8543: V:0 | i32.const $1 -#0. 8548: V:1 | i32.const $2 -#0. 8553: V:2 | i32.const $3 -#0. 8558: V:3 | i32.atomic.rmw.cmpxchg $0:1+$3, 2, 3 -#0. 8568: V:1 | drop -#0. 8569: V:0 | return +#0. 8549: V:0 | i32.const $1 +#0. 8554: V:1 | i32.const $2 +#0. 8559: V:2 | i32.const $3 +#0. 8564: V:3 | i32.atomic.rmw.cmpxchg $0:1+$3, 2, 3 +#0. 8574: V:1 | drop +#0. 8575: V:0 | return i32.atomic.rmw.cmpxchg() => >>> running export "i64.atomic.rmw.cmpxchg": -#0. 8570: V:0 | i32.const $1 -#0. 8575: V:1 | i64.const $2 -#0. 8584: V:2 | i64.const $3 -#0. 8593: V:3 | i64.atomic.rmw.cmpxchg $0:1+$7, 2, 3 -#0. 8603: V:1 | drop -#0. 8604: V:0 | return +#0. 8576: V:0 | i32.const $1 +#0. 8581: V:1 | i64.const $2 +#0. 8590: V:2 | i64.const $3 +#0. 8599: V:3 | i64.atomic.rmw.cmpxchg $0:1+$7, 2, 3 +#0. 8609: V:1 | drop +#0. 8610: V:0 | return i64.atomic.rmw.cmpxchg() => >>> running export "i32.atomic.rmw8_u.cmpxchg": -#0. 8605: V:0 | i32.const $1 -#0. 8610: V:1 | i32.const $2 -#0. 8615: V:2 | i32.const $3 -#0. 8620: V:3 | i32.atomic.rmw8_u.cmpxchg $0:1+$3, 2, 3 -#0. 8630: V:1 | drop -#0. 8631: V:0 | return +#0. 8611: V:0 | i32.const $1 +#0. 8616: V:1 | i32.const $2 +#0. 8621: V:2 | i32.const $3 +#0. 8626: V:3 | i32.atomic.rmw8_u.cmpxchg $0:1+$3, 2, 3 +#0. 8636: V:1 | drop +#0. 8637: V:0 | return i32.atomic.rmw8_u.cmpxchg() => >>> running export "i32.atomic.rmw16_u.cmpxchg": -#0. 8632: V:0 | i32.const $1 -#0. 8637: V:1 | i32.const $2 -#0. 8642: V:2 | i32.const $3 -#0. 8647: V:3 | i32.atomic.rmw16_u.cmpxchg $0:1+$3, 2, 3 -#0. 8657: V:1 | drop -#0. 8658: V:0 | return +#0. 8638: V:0 | i32.const $1 +#0. 8643: V:1 | i32.const $2 +#0. 8648: V:2 | i32.const $3 +#0. 8653: V:3 | i32.atomic.rmw16_u.cmpxchg $0:1+$3, 2, 3 +#0. 8663: V:1 | drop +#0. 8664: V:0 | return i32.atomic.rmw16_u.cmpxchg() => >>> running export "i64.atomic.rmw8_u.cmpxchg": -#0. 8659: V:0 | i32.const $1 -#0. 8664: V:1 | i64.const $2 -#0. 8673: V:2 | i64.const $3 -#0. 8682: V:3 | i64.atomic.rmw8_u.cmpxchg $0:1+$3, 2, 3 -#0. 8692: V:1 | drop -#0. 8693: V:0 | return +#0. 8665: V:0 | i32.const $1 +#0. 8670: V:1 | i64.const $2 +#0. 8679: V:2 | i64.const $3 +#0. 8688: V:3 | i64.atomic.rmw8_u.cmpxchg $0:1+$3, 2, 3 +#0. 8698: V:1 | drop +#0. 8699: V:0 | return i64.atomic.rmw8_u.cmpxchg() => >>> running export "i64.atomic.rmw16_u.cmpxchg": -#0. 8694: V:0 | i32.const $1 -#0. 8699: V:1 | i64.const $2 -#0. 8708: V:2 | i64.const $3 -#0. 8717: V:3 | i64.atomic.rmw16_u.cmpxchg $0:1+$3, 2, 3 -#0. 8727: V:1 | drop -#0. 8728: V:0 | return +#0. 8700: V:0 | i32.const $1 +#0. 8705: V:1 | i64.const $2 +#0. 8714: V:2 | i64.const $3 +#0. 8723: V:3 | i64.atomic.rmw16_u.cmpxchg $0:1+$3, 2, 3 +#0. 8733: V:1 | drop +#0. 8734: V:0 | return i64.atomic.rmw16_u.cmpxchg() => >>> running export "i64.atomic.rmw32_u.cmpxchg": -#0. 8729: V:0 | i32.const $1 -#0. 8734: V:1 | i64.const $2 -#0. 8743: V:2 | i64.const $3 -#0. 8752: V:3 | i64.atomic.rmw32_u.cmpxchg $0:1+$3, 2, 3 -#0. 8762: V:1 | drop -#0. 8763: V:0 | return +#0. 8735: V:0 | i32.const $1 +#0. 8740: V:1 | i64.const $2 +#0. 8749: V:2 | i64.const $3 +#0. 8758: V:3 | i64.atomic.rmw32_u.cmpxchg $0:1+$3, 2, 3 +#0. 8768: V:1 | drop +#0. 8769: V:0 | return i64.atomic.rmw32_u.cmpxchg() => ;;; STDOUT ;;) diff --git a/test/parse/expr/bad-binary-one-expr.txt b/test/parse/expr/bad-binary-one-expr.txt index 28258a73..b7944dfe 100644 --- a/test/parse/expr/bad-binary-one-expr.txt +++ b/test/parse/expr/bad-binary-one-expr.txt @@ -7,7 +7,7 @@ out/test/parse/expr/bad-binary-one-expr.txt:5:4: error: type mismatch in i32.add, expected [i32, i32] but got [i32] i32.add)) ^^^^^^^ -out/test/parse/expr/bad-binary-one-expr.txt:5:4: error: type mismatch in function, expected [] but got [i32, i32] +out/test/parse/expr/bad-binary-one-expr.txt:5:4: error: type mismatch in function, expected [] but got [i32] i32.add)) ^^^^^^^ ;;; STDERR ;;) diff --git a/test/parse/expr/bad-block-sig-multi.txt b/test/parse/expr/bad-block-sig-multi.txt index f00308d3..00e7698f 100644 --- a/test/parse/expr/bad-block-sig-multi.txt +++ b/test/parse/expr/bad-block-sig-multi.txt @@ -7,9 +7,18 @@ i32.const 1 end drop - drop)) + drop) + + (func + i32.const 1 + block (param i32) + drop + end)) (;; STDERR ;;; -out/test/parse/expr/bad-block-sig-multi.txt:5:5: error: multiple block signature result types not currently supported. +out/test/parse/expr/bad-block-sig-multi.txt:5:5: error: multiple block results not currently supported. block (result i32 i32) ^^^^^ +out/test/parse/expr/bad-block-sig-multi.txt:14:5: error: block params not currently supported. + block (param i32) + ^^^^^ ;;; STDERR ;;) diff --git a/test/parse/expr/bad-compare-one-expr.txt b/test/parse/expr/bad-compare-one-expr.txt index 1a6e8b47..dbf1dc2e 100644 --- a/test/parse/expr/bad-compare-one-expr.txt +++ b/test/parse/expr/bad-compare-one-expr.txt @@ -7,7 +7,7 @@ out/test/parse/expr/bad-compare-one-expr.txt:5:11: error: type mismatch in i32.lt_s, expected [i32, i32] but got [i32] i32.lt_s)) ^^^^^^^^ -out/test/parse/expr/bad-compare-one-expr.txt:5:11: error: type mismatch in function, expected [] but got [i32, i32] +out/test/parse/expr/bad-compare-one-expr.txt:5:11: error: type mismatch in function, expected [] but got [i32] i32.lt_s)) ^^^^^^^^ ;;; STDERR ;;) diff --git a/test/parse/expr/bad-if-sig-multi.txt b/test/parse/expr/bad-if-sig-multi.txt index 5f7c25a0..e987c504 100644 --- a/test/parse/expr/bad-if-sig-multi.txt +++ b/test/parse/expr/bad-if-sig-multi.txt @@ -11,9 +11,21 @@ i32.const 4 end drop - drop)) + drop) + + (func + i32.const 1 + i32.const 2 + if (param i32) + drop + else + drop + end)) (;; STDERR ;;; -out/test/parse/expr/bad-if-sig-multi.txt:6:5: error: multiple if signature result types not currently supported. +out/test/parse/expr/bad-if-sig-multi.txt:6:5: error: multiple if results not currently supported. if (result i32 i32) ^^ +out/test/parse/expr/bad-if-sig-multi.txt:19:5: error: if params not currently supported. + if (param i32) + ^^ ;;; STDERR ;;) diff --git a/test/parse/expr/bad-if_except-sig-multi.txt b/test/parse/expr/bad-if_except-sig-multi.txt new file mode 100644 index 00000000..fb2e6370 --- /dev/null +++ b/test/parse/expr/bad-if_except-sig-multi.txt @@ -0,0 +1,23 @@ +;;; TOOL: wat2wasm +;;; ARGS: --enable-exceptions +;;; ERROR: 1 + +(module + (except $e i32 i64) + + (func + try + nop + catch + if_except (result i32 i64) $e + else + i32.const 1 + i64.const 2 + end + return + end)) +(;; STDERR ;;; +out/test/parse/expr/bad-if_except-sig-multi.txt:12:7: error: multiple if_except results not currently supported. + if_except (result i32 i64) $e + ^^^^^^^^^ +;;; STDERR ;;) diff --git a/test/parse/expr/bad-loop-sig-multi.txt b/test/parse/expr/bad-loop-sig-multi.txt index 26bd575e..7763f3d0 100644 --- a/test/parse/expr/bad-loop-sig-multi.txt +++ b/test/parse/expr/bad-loop-sig-multi.txt @@ -7,9 +7,18 @@ i32.const 2 end drop - drop)) + drop) + + (func + i32.const 0 + loop (param i32) + drop + end)) (;; STDERR ;;; -out/test/parse/expr/bad-loop-sig-multi.txt:5:5: error: multiple loop signature result types not currently supported. +out/test/parse/expr/bad-loop-sig-multi.txt:5:5: error: multiple loop results not currently supported. loop (result i32 i32) ^^^^ +out/test/parse/expr/bad-loop-sig-multi.txt:14:5: error: loop params not currently supported. + loop (param i32) + ^^^^ ;;; STDERR ;;) diff --git a/test/parse/expr/bad-try-sig-multi.txt b/test/parse/expr/bad-try-sig-multi.txt new file mode 100644 index 00000000..82f2323f --- /dev/null +++ b/test/parse/expr/bad-try-sig-multi.txt @@ -0,0 +1,31 @@ +;;; TOOL: wat2wasm +;;; ARGS: --enable-exceptions +;;; ERROR: 1 +(module + (func + try (result i32 i32) + i32.const 1 + i32.const 2 + catch + drop ;; drop except_ref + i32.const 3 + i32.const 4 + end + return) + + (func + i32.const 0 + try (param i32) + drop + catch + drop ;; drop except_ref + end + return)) +(;; STDERR ;;; +out/test/parse/expr/bad-try-sig-multi.txt:6:5: error: multiple try results not currently supported. + try (result i32 i32) + ^^^ +out/test/parse/expr/bad-try-sig-multi.txt:18:5: error: try params not currently supported. + try (param i32) + ^^^ +;;; STDERR ;;) diff --git a/test/parse/expr/block-multi.txt b/test/parse/expr/block-multi.txt new file mode 100644 index 00000000..15649dca --- /dev/null +++ b/test/parse/expr/block-multi.txt @@ -0,0 +1,19 @@ +;;; TOOL: wat2wasm +;;; ARGS: --enable-multi-value +(module + ;; block w/ multiple results + (func + block (result i32 i64) + i32.const 0 + i64.const 0 + end + return) + + ;; block w/ params + (func + i32.const 0 + block (param i32) (result i32 i32) + i32.const 1 + end + return) +) diff --git a/test/parse/expr/if-multi.txt b/test/parse/expr/if-multi.txt new file mode 100644 index 00000000..d280c848 --- /dev/null +++ b/test/parse/expr/if-multi.txt @@ -0,0 +1,29 @@ +;;; TOOL: wat2wasm +;;; ARGS: --enable-multi-value +(module + ;; if w/ multiple results + (func + i32.const 0 + if (result i32 f32 f64) + i32.const 0 + f32.const 0 + f64.const 0 + else + i32.const 1 + f32.const 1 + f64.const 1 + end + return) + + ;; if w/ params + (func + i32.const 1 ;; param + i32.const 0 ;; cond + if (param i32) (result i64) + drop + i64.const 1 + else + i64.extend_u/i32 + end + return) +) diff --git a/test/parse/expr/if_except-multi.txt b/test/parse/expr/if_except-multi.txt new file mode 100644 index 00000000..b480efdf --- /dev/null +++ b/test/parse/expr/if_except-multi.txt @@ -0,0 +1,44 @@ +;;; TOOL: wat2wasm +;;; ARGS: --enable-exceptions --enable-multi-value +(module + (except $e i32 i64) + + ;; if_except w/ multiple results + (func + try + nop + catch + if_except (result i32 i64) $e + else + i32.const 1 + i64.const 2 + end + return + end) + + ;; if_except w/ params + ;; TODO(binji): this doesn't currently work since wat2wasm doesn't support + ;; except_ref locals. + (; + + (func + (local $ee except_ref) + try + nop + catch + set_local $ee ;; except_ref -> + + i32.const 0 ;; -> i32 + get_local $ee ;; i32 -> i32 except_ref + + if_except (param i32) $e + drop ;; drop i64 from except + drop ;; drop i32 from except + drop ;; drop param + else + drop ;; drop param + end + end) + + ;) +) diff --git a/test/parse/expr/loop-multi.txt b/test/parse/expr/loop-multi.txt new file mode 100644 index 00000000..fdbbfa87 --- /dev/null +++ b/test/parse/expr/loop-multi.txt @@ -0,0 +1,20 @@ +;;; TOOL: wat2wasm +;;; ARGS: --enable-multi-value +(module + ;; loop w/ multiple results + (func + loop (result i32 i64) + i32.const 0 + i64.const 0 + end + return) + + ;; loop w/ params + (func + i64.const 0 + loop (param i64) (result i32) + drop + i32.const 1 + end + return) +) diff --git a/test/parse/expr/try-multi.txt b/test/parse/expr/try-multi.txt new file mode 100644 index 00000000..7b020c4d --- /dev/null +++ b/test/parse/expr/try-multi.txt @@ -0,0 +1,26 @@ +;;; TOOL: wat2wasm +;;; ARGS: --enable-exceptions --enable-multi-value +(module + ;; try w/ multiple results + (func + try (result f32 f32) + f32.const 0 + f32.const 1 + catch + drop + f32.const 2 + f32.const 3 + end + return) + + ;; try w/ params + (func + i32.const 0 + try (param i32) (result i32) + i32.eqz + catch + drop ;; no i32 param, just except_ref + i32.const 0 + end + return) +) diff --git a/test/parse/func/result-multi.txt b/test/parse/func/result-multi.txt new file mode 100644 index 00000000..c6a97adb --- /dev/null +++ b/test/parse/func/result-multi.txt @@ -0,0 +1,6 @@ +;;; TOOL: wat2wasm +;;; ARGS: --enable-multi-value +(module + (func (result i32 i32) + i32.const 0 + i32.const 1)) diff --git a/test/run-roundtrip.py b/test/run-roundtrip.py index b4c7e0c1..8d8033cb 100755 --- a/test/run-roundtrip.py +++ b/test/run-roundtrip.py @@ -122,6 +122,7 @@ def main(args): parser.add_argument('--enable-simd', action='store_true') parser.add_argument('--enable-sign-extension', action='store_true') parser.add_argument('--enable-mutable-globals', action='store_true') + parser.add_argument('--enable-multi-value', action='store_true') parser.add_argument('--inline-exports', action='store_true') parser.add_argument('--inline-imports', action='store_true') parser.add_argument('file', help='test file.') @@ -133,6 +134,7 @@ def main(args): wat2wasm.AppendOptionalArgs({ '--debug-names': options.debug_names, '--enable-exceptions': options.enable_exceptions, + '--enable-multi-value': options.enable_multi_value, '--enable-mutable-globals': options.enable_mutable_globals, '--enable-saturating-float-to-int': options.enable_saturating_float_to_int, @@ -148,6 +150,7 @@ def main(args): wasm2wat.AppendOptionalArgs({ '--fold-exprs': options.fold_exprs, '--enable-exceptions': options.enable_exceptions, + '--enable-multi-value': options.enable_multi_value, '--enable-mutable-globals': options.enable_mutable_globals, '--enable-saturating-float-to-int': options.enable_saturating_float_to_int, diff --git a/test/spec/br_table.txt b/test/spec/br_table.txt index 361fffe7..92a6cf20 100644 --- a/test/spec/br_table.txt +++ b/test/spec/br_table.txt @@ -11,7 +11,7 @@ out/test/spec/br_table.wast:1426: assert_invalid passed: error: type mismatch in br_table, expected [i32] but got [i64] 0000023: error: OnBrTableExpr callback failed out/test/spec/br_table.wast:1434: assert_invalid passed: - error: br_table labels have inconsistent types: expected f32, got void + error: br_table labels have inconsistent types: expected [f32], got [] 0000026: error: OnBrTableExpr callback failed out/test/spec/br_table.wast:1446: assert_invalid passed: error: type mismatch in br_table, expected [i32] but got [] diff --git a/test/spec/if.txt b/test/spec/if.txt index d7f9118a..db286d16 100644 --- a/test/spec/if.txt +++ b/test/spec/if.txt @@ -41,14 +41,14 @@ out/test/spec/if.wast:242: assert_invalid passed: error: type mismatch in if true branch, expected [i32] but got [] 000001d: error: OnElseExpr callback failed out/test/spec/if.wast:248: assert_invalid passed: - error: if without else cannot have type signature. + error: if without else cannot have results. 000001f: error: OnEndExpr callback failed out/test/spec/if.wast:254: assert_invalid passed: - error: if without else cannot have type signature. + error: if without else cannot have results. error: type mismatch in if, expected [i32] but got [] 000001d: error: OnEndExpr callback failed out/test/spec/if.wast:260: assert_invalid passed: - error: if without else cannot have type signature. + error: if without else cannot have results. 000001f: error: OnEndExpr callback failed out/test/spec/if.wast:267: assert_invalid passed: error: type mismatch in if true branch, expected [i32] but got [] diff --git a/test/spec/unreached-invalid.txt b/test/spec/unreached-invalid.txt index 9807304c..73e0edd6 100644 --- a/test/spec/unreached-invalid.txt +++ b/test/spec/unreached-invalid.txt @@ -222,7 +222,7 @@ out/test/spec/unreached-invalid.wast:433: assert_invalid passed: error: type mismatch in if, expected [] but got [i32] 000001e: error: OnEndExpr callback failed out/test/spec/unreached-invalid.wast:439: assert_invalid passed: - error: if without else cannot have type signature. + error: if without else cannot have results. error: type mismatch in if, expected [i32] but got [f32] 0000022: error: OnEndExpr callback failed out/test/spec/unreached-invalid.wast:445: assert_invalid passed: @@ -262,10 +262,10 @@ out/test/spec/unreached-invalid.wast:521: assert_invalid passed: error: type mismatch in br_table, expected [i32] but got [f32] 0000025: error: OnBrTableExpr callback failed out/test/spec/unreached-invalid.wast:527: assert_invalid passed: - error: br_table labels have inconsistent types: expected f32, got void + error: br_table labels have inconsistent types: expected [f32], got [] 0000023: error: OnBrTableExpr callback failed out/test/spec/unreached-invalid.wast:539: assert_invalid passed: - error: br_table labels have inconsistent types: expected f32, got f64 + error: br_table labels have inconsistent types: expected [f32], got [f64] 0000023: error: OnBrTableExpr callback failed out/test/spec/unreached-invalid.wast:554: assert_invalid passed: error: type mismatch in block, expected [] but got [i32] diff --git a/test/typecheck/bad-block-multi-mismatch.txt b/test/typecheck/bad-block-multi-mismatch.txt new file mode 100644 index 00000000..5c73842c --- /dev/null +++ b/test/typecheck/bad-block-multi-mismatch.txt @@ -0,0 +1,58 @@ +;;; TOOL: wat2wasm +;;; ARGS: --enable-multi-value +;;; ERROR: 1 +(module + ;; too few results + (func + block (result i32 i32) + i32.const 0 + end + return) + + ;; too many results + (func + block (result i32 i32) + i32.const 0 + i32.const 0 + i32.const 0 + end + return) + + ;; result type mismatch + (func + block (result f32 i32) + i32.const 0 + i32.const 1 + end + return) + + ;; too few params + (func + block (param i32) + drop + end) + + ;; param type mismatch + (func + f32.const 0 + block (param i32) + drop + end) +) +(;; STDERR ;;; +out/test/typecheck/bad-block-multi-mismatch.txt:9:5: error: type mismatch in block, expected [i32, i32] but got [i32] + end + ^^^ +out/test/typecheck/bad-block-multi-mismatch.txt:18:5: error: type mismatch in block, expected [] but got [i32] + end + ^^^ +out/test/typecheck/bad-block-multi-mismatch.txt:26:5: error: type mismatch in block, expected [f32, i32] but got [i32, i32] + end + ^^^ +out/test/typecheck/bad-block-multi-mismatch.txt:31:5: error: type mismatch in block, expected [i32] but got [] + block (param i32) + ^^^^^ +out/test/typecheck/bad-block-multi-mismatch.txt:38:5: error: type mismatch in block, expected [i32] but got [f32] + block (param i32) + ^^^^^ +;;; STDERR ;;) diff --git a/test/typecheck/bad-expr-if.txt b/test/typecheck/bad-expr-if.txt index 453c832a..efcf54f3 100644 --- a/test/typecheck/bad-expr-if.txt +++ b/test/typecheck/bad-expr-if.txt @@ -13,7 +13,4 @@ out/test/typecheck/bad-expr-if.txt:11:5: error: type mismatch in i32.add, expected [i32, i32] but got [i32] i32.add)) ^^^^^^^ -out/test/typecheck/bad-expr-if.txt:11:5: error: type mismatch in function, expected [] but got [i32] - i32.add)) - ^^^^^^^ ;;; STDERR ;;) diff --git a/test/typecheck/bad-if-multi-mismatch.txt b/test/typecheck/bad-if-multi-mismatch.txt new file mode 100644 index 00000000..5008f669 --- /dev/null +++ b/test/typecheck/bad-if-multi-mismatch.txt @@ -0,0 +1,85 @@ +;;; TOOL: wat2wasm +;;; ARGS: --enable-multi-value +;;; ERROR: 1 +(module + ;; too many results + (func + i32.const 0 + if (result i32 i64) + i32.const 0 + i32.const 0 + i64.const 0 + else + i32.const 0 + i32.const 0 + i64.const 0 + end + return) + + ;; too few results + (func + i32.const 0 + if (result i32 f64) + f64.const 0 + else + f64.const 0 + end + return) + + ;; result type mismatch + (func + i32.const 0 + if (result i32 f64) + f32.const 0 + f64.const 0 + else + f32.const 0 + f64.const 0 + end + return) + + ;; too few params + (func + i32.const 0 + if (param i32) + drop + else + drop + end) + + ;; param type mismatch + (func + f32.const 0 + i32.const 0 + if (param i32) + drop + else + drop + end) +) +(;; STDERR ;;; +out/test/typecheck/bad-if-multi-mismatch.txt:11:7: error: type mismatch in if true branch, expected [] but got [i32] + i64.const 0 + ^^^^^^^^^ +out/test/typecheck/bad-if-multi-mismatch.txt:16:5: error: type mismatch in if false branch, expected [] but got [i32] + end + ^^^ +out/test/typecheck/bad-if-multi-mismatch.txt:23:7: error: type mismatch in if true branch, expected [i32, f64] but got [f64] + f64.const 0 + ^^^^^^^^^ +out/test/typecheck/bad-if-multi-mismatch.txt:26:5: error: type mismatch in if false branch, expected [i32, f64] but got [f64] + end + ^^^ +out/test/typecheck/bad-if-multi-mismatch.txt:34:7: error: type mismatch in if true branch, expected [i32, f64] but got [f32, f64] + f64.const 0 + ^^^^^^^^^ +out/test/typecheck/bad-if-multi-mismatch.txt:38:5: error: type mismatch in if false branch, expected [i32, f64] but got [f32, f64] + end + ^^^ +out/test/typecheck/bad-if-multi-mismatch.txt:44:5: error: type mismatch in if, expected [i32] but got [] + if (param i32) + ^^ +out/test/typecheck/bad-if-multi-mismatch.txt:54:5: error: type mismatch in if, expected [i32] but got [f32] + if (param i32) + ^^ +;;; STDERR ;;) diff --git a/test/typecheck/bad-loop-multi-mismatch.txt b/test/typecheck/bad-loop-multi-mismatch.txt new file mode 100644 index 00000000..1592aa4c --- /dev/null +++ b/test/typecheck/bad-loop-multi-mismatch.txt @@ -0,0 +1,58 @@ +;;; TOOL: wat2wasm +;;; ARGS: --enable-multi-value +;;; ERROR: 1 +(module + ;; too few results + (func + loop (result i32 i32) + i32.const 0 + end + return) + + ;; too many results + (func + loop (result i32 i32) + i32.const 0 + i32.const 0 + i32.const 0 + end + return) + + ;; result type mismatch + (func + loop (result f32 i32) + i32.const 0 + i32.const 1 + end + return) + + ;; too few params + (func + loop (param i32) + drop + end) + + ;; param type mismatch + (func + f32.const 0 + loop (param i32) + drop + end) +) +(;; STDERR ;;; +out/test/typecheck/bad-loop-multi-mismatch.txt:9:5: error: type mismatch in loop, expected [i32, i32] but got [i32] + end + ^^^ +out/test/typecheck/bad-loop-multi-mismatch.txt:18:5: error: type mismatch in loop, expected [] but got [i32] + end + ^^^ +out/test/typecheck/bad-loop-multi-mismatch.txt:26:5: error: type mismatch in loop, expected [f32, i32] but got [i32, i32] + end + ^^^ +out/test/typecheck/bad-loop-multi-mismatch.txt:31:5: error: type mismatch in loop, expected [i32] but got [] + loop (param i32) + ^^^^ +out/test/typecheck/bad-loop-multi-mismatch.txt:38:5: error: type mismatch in loop, expected [i32] but got [f32] + loop (param i32) + ^^^^ +;;; STDERR ;;) diff --git a/test/typecheck/br-multi.txt b/test/typecheck/br-multi.txt new file mode 100644 index 00000000..9457d9fd --- /dev/null +++ b/test/typecheck/br-multi.txt @@ -0,0 +1,42 @@ +;;; TOOL: wat2wasm +;;; ARGS: --enable-multi-value +(module + ;; block + (func + block (result i32 i64) + i32.const 1 + i64.const 2 + br 0 + end + return) + + ;; loop + (func + loop (result i32 i64) + br 0 + end + return) + + ;; loop w/ param + (func + i32.const 1 + loop (param i32) + drop ;; drop loop param + i32.const 2 ;; push loop param for br + br 0 + end) + + ;; if + (func + i32.const 1 + if (result i32 i64) + i32.const 1 + i64.const 2 + br 0 + else + i32.const 3 + i64.const 4 + br 0 + end + return) +) diff --git a/test/typecheck/brif-multi.txt b/test/typecheck/brif-multi.txt new file mode 100644 index 00000000..afda493e --- /dev/null +++ b/test/typecheck/brif-multi.txt @@ -0,0 +1,50 @@ +;;; TOOL: wat2wasm +;;; ARGS: --enable-multi-value +(module + ;; block + (func + block (result i32 i64) + i32.const 1 + i64.const 2 + i32.const 0 ;; cond + br_if 0 + end + return) + + ;; loop + (func + loop (result i32 i64) + i32.const 0 ;; cond + br_if 0 + i32.const 1 + i64.const 2 + end + return) + + ;; loop w/ param + (func + i32.const 1 + loop (param i32) + drop ;; drop loop param + i32.const 2 ;; push loop param for br + i32.const 0 ;; cond + br_if 0 + drop ;; drop `i32.const 2` + end) + + ;; if + (func + i32.const 1 + if (result i32 i64) + i32.const 1 + i64.const 2 + i32.const 0 ;; cond + br_if 0 + else + i32.const 3 + i64.const 4 + i32.const 0 ;; cond + br_if 0 + end + return) +) diff --git a/test/typecheck/brtable-multi.txt b/test/typecheck/brtable-multi.txt new file mode 100644 index 00000000..9ed7bdd0 --- /dev/null +++ b/test/typecheck/brtable-multi.txt @@ -0,0 +1,52 @@ +;;; TOOL: wat2wasm +;;; ARGS: --enable-multi-value +(module + ;; block + (func + block (result f32 f32) + block + block (result f32 f32) + f32.const 1 + f32.const 2 + i32.const 0 ;; key + br_table 0 2 + end + drop + drop + end + f32.const 3 + f32.const 4 + end + return) + + ;; loop + (func + loop (result f32 f32) + loop + loop (result f32 f32) + i32.const 0 ;; key + br_table 0 2 + end + drop + drop + end + f32.const 3 + f32.const 4 + end + return) + + ;; loop w/ param + (func + i32.const 1 + loop (param i32) + drop ;; loop param + loop + i32.const 2 + loop (param i32) + ;; br param is passed through as loop param + i32.const 0 ;; key + br_table 0 2 + end + end + end) +) |