diff options
| -rw-r--r-- | src/binary-reader-interpreter.cc | 1047 | ||||
| -rw-r--r-- | src/binary-reader-interpreter.h | 13 | ||||
| -rw-r--r-- | src/common.h | 4 | ||||
| -rw-r--r-- | src/interpreter.cc | 1363 | ||||
| -rw-r--r-- | src/interpreter.h | 277 | ||||
| -rw-r--r-- | src/tools/wasm-interp.cc | 607 |
6 files changed, 1633 insertions, 1678 deletions
diff --git a/src/binary-reader-interpreter.cc b/src/binary-reader-interpreter.cc index 0c2396ff..cbac7668 100644 --- a/src/binary-reader-interpreter.cc +++ b/src/binary-reader-interpreter.cc @@ -28,14 +28,16 @@ #include "type-checker.h" #include "writer.h" -#define CHECK_RESULT(expr) \ - do { \ - if (WABT_FAILED(expr)) \ - return Result::Error; \ +#define CHECK_RESULT(expr) \ + do { \ + if (WABT_FAILED(expr)) \ + return wabt::Result::Error; \ } while (0) namespace wabt { +using namespace interpreter; + namespace { typedef std::vector<Index> IndexVector; @@ -71,8 +73,8 @@ struct DataSegmentInfo { class BinaryReaderInterpreter : public BinaryReaderNop { public: - BinaryReaderInterpreter(InterpreterEnvironment* env, - DefinedInterpreterModule* module, + BinaryReaderInterpreter(Environment* env, + DefinedModule* module, IstreamOffset istream_offset, BinaryErrorHandler* error_handler); @@ -82,120 +84,120 @@ class BinaryReaderInterpreter : public BinaryReaderNop { // Implement BinaryReader. bool OnError(const char* message) override; - Result EndModule() override; - - Result OnTypeCount(Index count) override; - Result OnType(Index index, - Index param_count, - Type* param_types, - Index result_count, - Type* result_types) override; - - Result OnImportCount(Index count) override; - Result OnImport(Index index, - StringSlice module_name, - StringSlice field_name) override; - Result OnImportFunc(Index import_index, - StringSlice module_name, - StringSlice field_name, - Index func_index, - Index sig_index) override; - Result OnImportTable(Index import_index, - StringSlice module_name, - StringSlice field_name, - Index table_index, + wabt::Result EndModule() override; + + wabt::Result OnTypeCount(Index count) override; + wabt::Result OnType(Index index, + Index param_count, + Type* param_types, + Index result_count, + Type* result_types) override; + + wabt::Result OnImportCount(Index count) override; + wabt::Result OnImport(Index index, + StringSlice module_name, + StringSlice field_name) override; + wabt::Result OnImportFunc(Index import_index, + StringSlice module_name, + StringSlice field_name, + Index func_index, + Index sig_index) override; + wabt::Result OnImportTable(Index import_index, + StringSlice module_name, + StringSlice field_name, + Index table_index, + Type elem_type, + const Limits* elem_limits) override; + wabt::Result OnImportMemory(Index import_index, + StringSlice module_name, + StringSlice field_name, + Index memory_index, + const Limits* page_limits) override; + wabt::Result OnImportGlobal(Index import_index, + StringSlice module_name, + StringSlice field_name, + Index global_index, + Type type, + bool mutable_) override; + + wabt::Result OnFunctionCount(Index count) override; + wabt::Result OnFunction(Index index, Index sig_index) override; + + wabt::Result OnTable(Index index, Type elem_type, const Limits* elem_limits) override; - Result OnImportMemory(Index import_index, - StringSlice module_name, - StringSlice field_name, - Index memory_index, - const Limits* page_limits) override; - Result OnImportGlobal(Index import_index, - StringSlice module_name, - StringSlice field_name, - Index global_index, - Type type, - bool mutable_) override; - - Result OnFunctionCount(Index count) override; - Result OnFunction(Index index, Index sig_index) override; - - Result OnTable(Index index, - Type elem_type, - const Limits* elem_limits) override; - - Result OnMemory(Index index, const Limits* limits) override; - - Result OnGlobalCount(Index count) override; - Result BeginGlobal(Index index, Type type, bool mutable_) override; - Result EndGlobalInitExpr(Index index) override; - - Result OnExport(Index index, - ExternalKind kind, - Index item_index, - StringSlice name) override; - - Result OnStartFunction(Index func_index) override; - - Result BeginFunctionBody(Index index) override; - Result OnLocalDeclCount(Index count) override; - Result OnLocalDecl(Index decl_index, Index count, Type type) override; - - Result OnBinaryExpr(Opcode opcode) override; - Result OnBlockExpr(Index num_types, Type* sig_types) override; - Result OnBrExpr(Index depth) override; - Result OnBrIfExpr(Index depth) override; - Result OnBrTableExpr(Index num_targets, - Index* target_depths, - Index default_target_depth) override; - Result OnCallExpr(Index func_index) override; - Result OnCallIndirectExpr(Index sig_index) override; - Result OnCompareExpr(Opcode opcode) override; - Result OnConvertExpr(Opcode opcode) override; - Result OnCurrentMemoryExpr() override; - Result OnDropExpr() override; - Result OnElseExpr() override; - Result OnEndExpr() override; - Result OnF32ConstExpr(uint32_t value_bits) override; - Result OnF64ConstExpr(uint64_t value_bits) override; - Result OnGetGlobalExpr(Index global_index) override; - Result OnGetLocalExpr(Index local_index) override; - Result OnGrowMemoryExpr() override; - Result OnI32ConstExpr(uint32_t value) override; - Result OnI64ConstExpr(uint64_t value) override; - Result OnIfExpr(Index num_types, Type* sig_types) override; - Result OnLoadExpr(Opcode opcode, - uint32_t alignment_log2, - Address offset) override; - Result OnLoopExpr(Index num_types, Type* sig_types) override; - Result OnNopExpr() override; - Result OnReturnExpr() override; - Result OnSelectExpr() override; - Result OnSetGlobalExpr(Index global_index) override; - Result OnSetLocalExpr(Index local_index) override; - Result OnStoreExpr(Opcode opcode, - uint32_t alignment_log2, - Address offset) override; - Result OnTeeLocalExpr(Index local_index) override; - Result OnUnaryExpr(Opcode opcode) override; - Result OnUnreachableExpr() override; - Result EndFunctionBody(Index index) override; - - Result EndElemSegmentInitExpr(Index index) override; - Result OnElemSegmentFunctionIndex(Index index, - Index func_index) override; - - Result OnDataSegmentData(Index index, - const void* data, - Address size) override; - - Result OnInitExprF32ConstExpr(Index index, uint32_t value) override; - Result OnInitExprF64ConstExpr(Index index, uint64_t value) override; - Result OnInitExprGetGlobalExpr(Index index, - Index global_index) override; - Result OnInitExprI32ConstExpr(Index index, uint32_t value) override; - Result OnInitExprI64ConstExpr(Index index, uint64_t value) override; + + wabt::Result OnMemory(Index index, const Limits* limits) override; + + wabt::Result OnGlobalCount(Index count) override; + wabt::Result BeginGlobal(Index index, Type type, bool mutable_) override; + wabt::Result EndGlobalInitExpr(Index index) override; + + wabt::Result OnExport(Index index, + ExternalKind kind, + Index item_index, + StringSlice name) override; + + wabt::Result OnStartFunction(Index func_index) override; + + wabt::Result BeginFunctionBody(Index index) override; + wabt::Result OnLocalDeclCount(Index count) override; + wabt::Result OnLocalDecl(Index decl_index, Index count, Type type) override; + + wabt::Result OnBinaryExpr(wabt::Opcode opcode) override; + wabt::Result OnBlockExpr(Index num_types, Type* sig_types) override; + wabt::Result OnBrExpr(Index depth) override; + wabt::Result OnBrIfExpr(Index depth) override; + wabt::Result OnBrTableExpr(Index num_targets, + Index* target_depths, + Index default_target_depth) override; + wabt::Result OnCallExpr(Index func_index) override; + wabt::Result OnCallIndirectExpr(Index sig_index) override; + wabt::Result OnCompareExpr(wabt::Opcode opcode) override; + wabt::Result OnConvertExpr(wabt::Opcode opcode) override; + wabt::Result OnCurrentMemoryExpr() override; + wabt::Result OnDropExpr() override; + wabt::Result OnElseExpr() override; + wabt::Result OnEndExpr() override; + wabt::Result OnF32ConstExpr(uint32_t value_bits) override; + wabt::Result OnF64ConstExpr(uint64_t value_bits) override; + wabt::Result OnGetGlobalExpr(Index global_index) override; + wabt::Result OnGetLocalExpr(Index local_index) override; + wabt::Result OnGrowMemoryExpr() 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 OnLoadExpr(wabt::Opcode opcode, + uint32_t alignment_log2, + Address offset) override; + wabt::Result OnLoopExpr(Index num_types, Type* sig_types) override; + wabt::Result OnNopExpr() override; + wabt::Result OnReturnExpr() override; + wabt::Result OnSelectExpr() override; + wabt::Result OnSetGlobalExpr(Index global_index) override; + wabt::Result OnSetLocalExpr(Index local_index) override; + wabt::Result OnStoreExpr(wabt::Opcode opcode, + uint32_t alignment_log2, + Address offset) override; + wabt::Result OnTeeLocalExpr(Index local_index) override; + wabt::Result OnUnaryExpr(wabt::Opcode opcode) override; + wabt::Result OnUnreachableExpr() override; + wabt::Result EndFunctionBody(Index index) override; + + wabt::Result EndElemSegmentInitExpr(Index index) override; + wabt::Result OnElemSegmentFunctionIndex(Index index, + Index func_index) override; + + wabt::Result OnDataSegmentData(Index index, + const void* data, + Address size) override; + + wabt::Result OnInitExprF32ConstExpr(Index index, uint32_t value) override; + wabt::Result OnInitExprF64ConstExpr(Index index, uint64_t value) override; + wabt::Result OnInitExprGetGlobalExpr(Index index, + Index global_index) override; + wabt::Result OnInitExprI32ConstExpr(Index index, uint32_t value) override; + wabt::Result OnInitExprI64ConstExpr(Index index, uint64_t value) override; private: Label* GetLabel(Index depth); @@ -208,64 +210,65 @@ class BinaryReaderInterpreter : public BinaryReaderNop { static void OnTypecheckerError(const char* msg, void* user_data); Index TranslateSigIndexToEnv(Index sig_index); - InterpreterFuncSignature* GetSignatureByEnvIndex(Index sig_index); - InterpreterFuncSignature* GetSignatureByModuleIndex(Index sig_index); + FuncSignature* GetSignatureByEnvIndex(Index sig_index); + FuncSignature* GetSignatureByModuleIndex(Index sig_index); Index TranslateFuncIndexToEnv(Index func_index); Index TranslateModuleFuncIndexToDefined(Index func_index); - InterpreterFunc* GetFuncByEnvIndex(Index func_index); - InterpreterFunc* GetFuncByModuleIndex(Index func_index); + Func* GetFuncByEnvIndex(Index func_index); + Func* GetFuncByModuleIndex(Index func_index); Index TranslateGlobalIndexToEnv(Index global_index); - InterpreterGlobal* GetGlobalByEnvIndex(Index global_index); - InterpreterGlobal* GetGlobalByModuleIndex(Index global_index); + Global* GetGlobalByEnvIndex(Index global_index); + Global* GetGlobalByModuleIndex(Index global_index); Type GetGlobalTypeByModuleIndex(Index global_index); Index TranslateLocalIndex(Index local_index); - Type GetLocalTypeByIndex(InterpreterFunc* func, Index local_index); + Type GetLocalTypeByIndex(Func* func, Index local_index); IstreamOffset GetIstreamOffset(); - Result EmitDataAt(IstreamOffset offset, - const void* data, - IstreamOffset size); - Result EmitData(const void* data, IstreamOffset size); - Result EmitOpcode(Opcode opcode); - Result EmitOpcode(InterpreterOpcode opcode); - Result EmitI8(uint8_t value); - Result EmitI32(uint32_t value); - Result EmitI64(uint64_t value); - Result EmitI32At(IstreamOffset offset, uint32_t value); - Result EmitDropKeep(uint32_t drop, uint8_t keep); - Result AppendFixup(IstreamOffsetVectorVector* fixups_vector, Index index); - Result EmitBrOffset(Index depth, IstreamOffset offset); - Result GetBrDropKeepCount(Index depth, - Index* out_drop_count, - Index* out_keep_count); - Result GetReturnDropKeepCount(Index* out_drop_count, - Index* out_keep_count); - Result EmitBr(Index depth, Index drop_count, Index keep_count); - Result EmitBrTableOffset(Index depth); - Result FixupTopLabel(); - Result EmitFuncOffset(DefinedInterpreterFunc* func, Index func_index); - - Result CheckLocal(Index local_index); - Result CheckGlobal(Index global_index); - Result CheckImportKind(InterpreterImport* import, ExternalKind expected_kind); - Result CheckImportLimits(const Limits* declared_limits, - const Limits* actual_limits); - Result CheckHasMemory(Opcode opcode); - Result CheckAlign(uint32_t alignment_log2, Address natural_alignment); - - Result AppendExport(InterpreterModule* module, - ExternalKind kind, - Index item_index, - StringSlice name); + wabt::Result EmitDataAt(IstreamOffset offset, + const void* data, + IstreamOffset size); + wabt::Result EmitData(const void* data, IstreamOffset size); + wabt::Result EmitOpcode(wabt::Opcode opcode); + wabt::Result EmitOpcode(interpreter::Opcode opcode); + wabt::Result EmitI8(uint8_t value); + wabt::Result EmitI32(uint32_t value); + wabt::Result EmitI64(uint64_t value); + wabt::Result EmitI32At(IstreamOffset offset, uint32_t value); + wabt::Result EmitDropKeep(uint32_t drop, uint8_t keep); + wabt::Result AppendFixup(IstreamOffsetVectorVector* fixups_vector, + Index index); + wabt::Result EmitBrOffset(Index depth, IstreamOffset offset); + wabt::Result GetBrDropKeepCount(Index depth, + Index* out_drop_count, + Index* out_keep_count); + wabt::Result GetReturnDropKeepCount(Index* out_drop_count, + Index* out_keep_count); + wabt::Result EmitBr(Index depth, Index drop_count, Index keep_count); + wabt::Result EmitBrTableOffset(Index depth); + wabt::Result FixupTopLabel(); + wabt::Result EmitFuncOffset(DefinedFunc* func, Index func_index); + + wabt::Result CheckLocal(Index local_index); + wabt::Result CheckGlobal(Index global_index); + wabt::Result CheckImportKind(Import* import, ExternalKind expected_kind); + wabt::Result CheckImportLimits(const Limits* declared_limits, + const Limits* actual_limits); + wabt::Result CheckHasMemory(wabt::Opcode opcode); + wabt::Result CheckAlign(uint32_t alignment_log2, Address natural_alignment); + + wabt::Result AppendExport(Module* module, + ExternalKind kind, + Index item_index, + StringSlice name); PrintErrorCallback MakePrintErrorCallback(); static void OnHostImportPrintError(const char* msg, void* user_data); BinaryErrorHandler* error_handler = nullptr; - InterpreterEnvironment* env = nullptr; - DefinedInterpreterModule* module = nullptr; - DefinedInterpreterFunc* current_func = nullptr; + Environment* env = nullptr; + DefinedModule* module = nullptr; + DefinedFunc* current_func = nullptr; TypeCheckerErrorHandler tc_error_handler; TypeChecker typechecker; std::vector<Label> label_stack; @@ -289,16 +292,16 @@ class BinaryReaderInterpreter : public BinaryReaderNop { std::vector<DataSegmentInfo> data_segment_infos; /* values cached so they can be shared between callbacks */ - InterpreterTypedValue init_expr_value; + TypedValue init_expr_value; IstreamOffset table_offset = 0; bool is_host_import = false; - HostInterpreterModule* host_import_module = nullptr; + HostModule* host_import_module = nullptr; Index import_env_index = 0; }; BinaryReaderInterpreter::BinaryReaderInterpreter( - InterpreterEnvironment* env, - DefinedInterpreterModule* module, + Environment* env, + DefinedModule* module, IstreamOffset istream_offset, BinaryErrorHandler* error_handler) : error_handler(error_handler), @@ -345,12 +348,12 @@ Index BinaryReaderInterpreter::TranslateSigIndexToEnv(Index sig_index) { return sig_index_mapping[sig_index]; } -InterpreterFuncSignature* BinaryReaderInterpreter::GetSignatureByEnvIndex( +FuncSignature* BinaryReaderInterpreter::GetSignatureByEnvIndex( Index sig_index) { return &env->sigs[sig_index]; } -InterpreterFuncSignature* BinaryReaderInterpreter::GetSignatureByModuleIndex( +FuncSignature* BinaryReaderInterpreter::GetSignatureByModuleIndex( Index sig_index) { return GetSignatureByEnvIndex(TranslateSigIndexToEnv(sig_index)); } @@ -366,13 +369,11 @@ Index BinaryReaderInterpreter::TranslateModuleFuncIndexToDefined( return func_index - num_func_imports; } -InterpreterFunc* BinaryReaderInterpreter::GetFuncByEnvIndex( - Index func_index) { +Func* BinaryReaderInterpreter::GetFuncByEnvIndex(Index func_index) { return env->funcs[func_index].get(); } -InterpreterFunc* BinaryReaderInterpreter::GetFuncByModuleIndex( - Index func_index) { +Func* BinaryReaderInterpreter::GetFuncByModuleIndex(Index func_index) { return GetFuncByEnvIndex(TranslateFuncIndexToEnv(func_index)); } @@ -380,13 +381,11 @@ Index BinaryReaderInterpreter::TranslateGlobalIndexToEnv(Index global_index) { return global_index_mapping[global_index]; } -InterpreterGlobal* BinaryReaderInterpreter::GetGlobalByEnvIndex( - Index global_index) { +Global* BinaryReaderInterpreter::GetGlobalByEnvIndex(Index global_index) { return &env->globals[global_index]; } -InterpreterGlobal* BinaryReaderInterpreter::GetGlobalByModuleIndex( - Index global_index) { +Global* BinaryReaderInterpreter::GetGlobalByModuleIndex(Index global_index) { return GetGlobalByEnvIndex(TranslateGlobalIndexToEnv(global_index)); } @@ -394,7 +393,7 @@ Type BinaryReaderInterpreter::GetGlobalTypeByModuleIndex(Index global_index) { return GetGlobalByModuleIndex(global_index)->typed_value.type; } -Type BinaryReaderInterpreter::GetLocalTypeByIndex(InterpreterFunc* func, +Type BinaryReaderInterpreter::GetLocalTypeByIndex(Func* func, Index local_index) { assert(!func->is_host); return func->as_defined()->param_and_local_types[local_index]; @@ -404,69 +403,71 @@ IstreamOffset BinaryReaderInterpreter::GetIstreamOffset() { return istream_offset; } -Result BinaryReaderInterpreter::EmitDataAt(IstreamOffset offset, - const void* data, - IstreamOffset size) { +wabt::Result BinaryReaderInterpreter::EmitDataAt(IstreamOffset offset, + const void* data, + IstreamOffset size) { return istream_writer.WriteData(offset, data, size); } -Result BinaryReaderInterpreter::EmitData(const void* data, IstreamOffset size) { +wabt::Result BinaryReaderInterpreter::EmitData(const void* data, + IstreamOffset size) { CHECK_RESULT(EmitDataAt(istream_offset, data, size)); istream_offset += size; - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::EmitOpcode(Opcode opcode) { +wabt::Result BinaryReaderInterpreter::EmitOpcode(wabt::Opcode opcode) { return EmitData(&opcode, sizeof(uint8_t)); } -Result BinaryReaderInterpreter::EmitOpcode(InterpreterOpcode opcode) { +wabt::Result BinaryReaderInterpreter::EmitOpcode(interpreter::Opcode opcode) { return EmitData(&opcode, sizeof(uint8_t)); } -Result BinaryReaderInterpreter::EmitI8(uint8_t value) { +wabt::Result BinaryReaderInterpreter::EmitI8(uint8_t value) { return EmitData(&value, sizeof(value)); } -Result BinaryReaderInterpreter::EmitI32(uint32_t value) { +wabt::Result BinaryReaderInterpreter::EmitI32(uint32_t value) { return EmitData(&value, sizeof(value)); } -Result BinaryReaderInterpreter::EmitI64(uint64_t value) { +wabt::Result BinaryReaderInterpreter::EmitI64(uint64_t value) { return EmitData(&value, sizeof(value)); } -Result BinaryReaderInterpreter::EmitI32At(IstreamOffset offset, - uint32_t value) { +wabt::Result BinaryReaderInterpreter::EmitI32At(IstreamOffset offset, + uint32_t value) { return EmitDataAt(offset, &value, sizeof(value)); } -Result BinaryReaderInterpreter::EmitDropKeep(uint32_t drop, uint8_t keep) { +wabt::Result BinaryReaderInterpreter::EmitDropKeep(uint32_t drop, + uint8_t keep) { assert(drop != UINT32_MAX); assert(keep <= 1); if (drop > 0) { if (drop == 1 && keep == 0) { - CHECK_RESULT(EmitOpcode(InterpreterOpcode::Drop)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::Drop)); } else { - CHECK_RESULT(EmitOpcode(InterpreterOpcode::DropKeep)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::DropKeep)); CHECK_RESULT(EmitI32(drop)); CHECK_RESULT(EmitI8(keep)); } } - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::AppendFixup( +wabt::Result BinaryReaderInterpreter::AppendFixup( IstreamOffsetVectorVector* fixups_vector, Index index) { if (index >= fixups_vector->size()) fixups_vector->resize(index + 1); (*fixups_vector)[index].push_back(GetIstreamOffset()); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::EmitBrOffset(Index depth, - IstreamOffset offset) { +wabt::Result BinaryReaderInterpreter::EmitBrOffset(Index depth, + IstreamOffset offset) { if (offset == kInvalidIstreamOffset) { /* depth_fixups stores the depth counting up from zero, where zero is the * top-level function scope. */ @@ -474,12 +475,13 @@ Result BinaryReaderInterpreter::EmitBrOffset(Index depth, CHECK_RESULT(AppendFixup(&depth_fixups, depth)); } CHECK_RESULT(EmitI32(offset)); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::GetBrDropKeepCount(Index depth, - Index* out_drop_count, - Index* out_keep_count) { +wabt::Result BinaryReaderInterpreter::GetBrDropKeepCount( + Index depth, + Index* out_drop_count, + Index* out_keep_count) { TypeCheckerLabel* label; CHECK_RESULT(typechecker_get_label(&typechecker, depth, &label)); *out_keep_count = @@ -491,97 +493,98 @@ Result BinaryReaderInterpreter::GetBrDropKeepCount(Index depth, (typechecker.type_stack.size() - label->type_stack_limit) - *out_keep_count; } - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::GetReturnDropKeepCount(Index* out_drop_count, - Index* out_keep_count) { +wabt::Result BinaryReaderInterpreter::GetReturnDropKeepCount( + Index* out_drop_count, + Index* out_keep_count) { if (WABT_FAILED(GetBrDropKeepCount(label_stack.size() - 1, out_drop_count, out_keep_count))) { - return Result::Error; + return wabt::Result::Error; } *out_drop_count += current_func->param_and_local_types.size(); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::EmitBr(Index depth, - Index drop_count, - Index keep_count) { +wabt::Result BinaryReaderInterpreter::EmitBr(Index depth, + Index drop_count, + Index keep_count) { CHECK_RESULT(EmitDropKeep(drop_count, keep_count)); - CHECK_RESULT(EmitOpcode(InterpreterOpcode::Br)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::Br)); CHECK_RESULT(EmitBrOffset(depth, GetLabel(depth)->offset)); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::EmitBrTableOffset(Index depth) { +wabt::Result BinaryReaderInterpreter::EmitBrTableOffset(Index depth) { Index drop_count, keep_count; 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)); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::FixupTopLabel() { +wabt::Result BinaryReaderInterpreter::FixupTopLabel() { IstreamOffset offset = GetIstreamOffset(); Index top = label_stack.size() - 1; if (top >= depth_fixups.size()) { /* nothing to fixup */ - return Result::Ok; + return wabt::Result::Ok; } IstreamOffsetVector& fixups = depth_fixups[top]; for (IstreamOffset fixup : fixups) CHECK_RESULT(EmitI32At(fixup, offset)); fixups.clear(); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::EmitFuncOffset(DefinedInterpreterFunc* func, - Index func_index) { +wabt::Result BinaryReaderInterpreter::EmitFuncOffset(DefinedFunc* func, + Index func_index) { if (func->offset == kInvalidIstreamOffset) { Index defined_index = TranslateModuleFuncIndexToDefined(func_index); CHECK_RESULT(AppendFixup(&func_fixups, defined_index)); } CHECK_RESULT(EmitI32(func->offset)); - return Result::Ok; + return wabt::Result::Ok; } bool BinaryReaderInterpreter::OnError(const char* message) { return HandleError(state->offset, message); } -Result BinaryReaderInterpreter::OnTypeCount(Index count) { +wabt::Result BinaryReaderInterpreter::OnTypeCount(Index count) { sig_index_mapping.resize(count); for (Index i = 0; i < count; ++i) sig_index_mapping[i] = env->sigs.size() + i; env->sigs.resize(env->sigs.size() + count); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnType(Index index, - Index param_count, - Type* param_types, - Index result_count, - Type* result_types) { - InterpreterFuncSignature* sig = GetSignatureByModuleIndex(index); +wabt::Result BinaryReaderInterpreter::OnType(Index index, + Index param_count, + Type* param_types, + Index result_count, + Type* result_types) { + FuncSignature* sig = GetSignatureByModuleIndex(index); sig->param_types.insert(sig->param_types.end(), param_types, param_types + param_count); sig->result_types.insert(sig->result_types.end(), result_types, result_types + result_count); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnImportCount(Index count) { +wabt::Result BinaryReaderInterpreter::OnImportCount(Index count) { module->imports.resize(count); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnImport(Index index, - StringSlice module_name, - StringSlice field_name) { - InterpreterImport* import = &module->imports[index]; +wabt::Result BinaryReaderInterpreter::OnImport(Index index, + StringSlice module_name, + StringSlice field_name) { + Import* import = &module->imports[index]; import->module_name = dup_string_slice(module_name); import->field_name = dup_string_slice(field_name); int module_index = @@ -589,10 +592,10 @@ Result BinaryReaderInterpreter::OnImport(Index index, if (module_index < 0) { PrintError("unknown import module \"" PRIstringslice "\"", WABT_PRINTF_STRING_SLICE_ARG(import->module_name)); - return Result::Error; + return wabt::Result::Error; } - InterpreterModule* module = env->modules[module_index].get(); + Module* module = env->modules[module_index].get(); if (module->is_host) { /* We don't yet know the kind of a host import module, so just assume it * exists for now. We'll fail later (in on_import_* below) if it doesn't @@ -600,93 +603,94 @@ Result BinaryReaderInterpreter::OnImport(Index index, is_host_import = true; host_import_module = module->as_host(); } else { - InterpreterExport* export_ = - get_interpreter_export_by_name(module, &import->field_name); + Export* export_ = get_export_by_name(module, &import->field_name); if (!export_) { PrintError("unknown module field \"" PRIstringslice "\"", WABT_PRINTF_STRING_SLICE_ARG(import->field_name)); - return Result::Error; + return wabt::Result::Error; } import->kind = export_->kind; is_host_import = false; import_env_index = export_->index; } - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::CheckLocal(Index local_index) { +wabt::Result BinaryReaderInterpreter::CheckLocal(Index local_index) { Index max_local_index = current_func->param_and_local_types.size(); if (local_index >= max_local_index) { PrintError("invalid local_index: %" PRIindex " (max %" PRIindex ")", local_index, max_local_index); - return Result::Error; + return wabt::Result::Error; } - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::CheckGlobal(Index global_index) { +wabt::Result BinaryReaderInterpreter::CheckGlobal(Index global_index) { Index max_global_index = global_index_mapping.size(); if (global_index >= max_global_index) { PrintError("invalid global_index: %" PRIindex " (max %" PRIindex ")", global_index, max_global_index); - return Result::Error; + return wabt::Result::Error; } - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::CheckImportKind(InterpreterImport* import, - ExternalKind expected_kind) { +wabt::Result BinaryReaderInterpreter::CheckImportKind( + Import* import, + ExternalKind expected_kind) { if (import->kind != expected_kind) { PrintError("expected import \"" PRIstringslice "." PRIstringslice "\" to have kind %s, not %s", WABT_PRINTF_STRING_SLICE_ARG(import->module_name), WABT_PRINTF_STRING_SLICE_ARG(import->field_name), get_kind_name(expected_kind), get_kind_name(import->kind)); - return Result::Error; + return wabt::Result::Error; } - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::CheckImportLimits(const Limits* declared_limits, - const Limits* actual_limits) { +wabt::Result BinaryReaderInterpreter::CheckImportLimits( + const Limits* declared_limits, + const Limits* actual_limits) { if (actual_limits->initial < declared_limits->initial) { PrintError("actual size (%" PRIu64 ") smaller than declared (%" PRIu64 ")", actual_limits->initial, declared_limits->initial); - return Result::Error; + return wabt::Result::Error; } if (declared_limits->has_max) { if (!actual_limits->has_max) { PrintError("max size (unspecified) larger than declared (%" PRIu64 ")", declared_limits->max); - return Result::Error; + return wabt::Result::Error; } else if (actual_limits->max > declared_limits->max) { PrintError("max size (%" PRIu64 ") larger than declared (%" PRIu64 ")", actual_limits->max, declared_limits->max); - return Result::Error; + return wabt::Result::Error; } } - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::AppendExport(InterpreterModule* module, - ExternalKind kind, - Index item_index, - StringSlice name) { +wabt::Result BinaryReaderInterpreter::AppendExport(Module* module, + ExternalKind kind, + Index item_index, + StringSlice name) { if (module->export_bindings.find_index(name) != -1) { PrintError("duplicate export \"" PRIstringslice "\"", WABT_PRINTF_STRING_SLICE_ARG(name)); - return Result::Error; + return wabt::Result::Error; } module->exports.emplace_back(dup_string_slice(name), kind, item_index); - InterpreterExport* export_ = &module->exports.back(); + Export* export_ = &module->exports.back(); module->export_bindings.emplace(string_slice_to_string(export_->name), Binding(module->exports.size() - 1)); - return Result::Ok; + return wabt::Result::Ok; } // static @@ -702,24 +706,23 @@ PrintErrorCallback BinaryReaderInterpreter::MakePrintErrorCallback() { return result; } -Result BinaryReaderInterpreter::OnImportFunc(Index import_index, - StringSlice module_name, - StringSlice field_name, - Index func_index, - Index sig_index) { - InterpreterImport* import = &module->imports[import_index]; +wabt::Result BinaryReaderInterpreter::OnImportFunc(Index import_index, + StringSlice module_name, + StringSlice field_name, + Index func_index, + Index sig_index) { + Import* import = &module->imports[import_index]; import->func.sig_index = TranslateSigIndexToEnv(sig_index); Index func_env_index; if (is_host_import) { - HostInterpreterFunc* func = new HostInterpreterFunc( - import->module_name, import->field_name, import->func.sig_index); + HostFunc* func = new HostFunc(import->module_name, import->field_name, + import->func.sig_index); env->funcs.emplace_back(func); - InterpreterHostImportDelegate* host_delegate = - &host_import_module->import_delegate; - InterpreterFuncSignature* sig = &env->sigs[func->sig_index]; + HostImportDelegate* host_delegate = &host_import_module->import_delegate; + FuncSignature* sig = &env->sigs[func->sig_index]; CHECK_RESULT(host_delegate->import_func( import, func, sig, MakePrintErrorCallback(), host_delegate->user_data)); assert(func->callback); @@ -729,39 +732,38 @@ Result BinaryReaderInterpreter::OnImportFunc(Index import_index, import->field_name); } else { CHECK_RESULT(CheckImportKind(import, ExternalKind::Func)); - InterpreterFunc* func = env->funcs[import_env_index].get(); + Func* func = env->funcs[import_env_index].get(); if (!func_signatures_are_equal(env, import->func.sig_index, func->sig_index)) { PrintError("import signature mismatch"); - return Result::Error; + return wabt::Result::Error; } func_env_index = import_env_index; } func_index_mapping.push_back(func_env_index); num_func_imports++; - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnImportTable(Index import_index, - StringSlice module_name, - StringSlice field_name, - Index table_index, - Type elem_type, - const Limits* elem_limits) { +wabt::Result BinaryReaderInterpreter::OnImportTable(Index import_index, + StringSlice module_name, + StringSlice field_name, + Index table_index, + Type elem_type, + const Limits* elem_limits) { if (module->table_index != kInvalidIndex) { PrintError("only one table allowed"); - return Result::Error; + return wabt::Result::Error; } - InterpreterImport* import = &module->imports[import_index]; + Import* import = &module->imports[import_index]; if (is_host_import) { env->tables.emplace_back(*elem_limits); - InterpreterTable* table = &env->tables.back(); + Table* table = &env->tables.back(); - InterpreterHostImportDelegate* host_delegate = - &host_import_module->import_delegate; + HostImportDelegate* host_delegate = &host_import_module->import_delegate; CHECK_RESULT(host_delegate->import_table( import, table, MakePrintErrorCallback(), host_delegate->user_data)); @@ -772,33 +774,33 @@ Result BinaryReaderInterpreter::OnImportTable(Index import_index, import->field_name); } else { CHECK_RESULT(CheckImportKind(import, ExternalKind::Table)); - InterpreterTable* table = &env->tables[import_env_index]; + Table* table = &env->tables[import_env_index]; CHECK_RESULT(CheckImportLimits(elem_limits, &table->limits)); import->table.limits = *elem_limits; module->table_index = import_env_index; } - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnImportMemory(Index import_index, - StringSlice module_name, - StringSlice field_name, - Index memory_index, - const Limits* page_limits) { +wabt::Result BinaryReaderInterpreter::OnImportMemory( + Index import_index, + StringSlice module_name, + StringSlice field_name, + Index memory_index, + const Limits* page_limits) { if (module->memory_index != kInvalidIndex) { PrintError("only one memory allowed"); - return Result::Error; + return wabt::Result::Error; } - InterpreterImport* import = &module->imports[import_index]; + Import* import = &module->imports[import_index]; if (is_host_import) { env->memories.emplace_back(); - InterpreterMemory* memory = &env->memories.back(); + Memory* memory = &env->memories.back(); - InterpreterHostImportDelegate* host_delegate = - &host_import_module->import_delegate; + HostImportDelegate* host_delegate = &host_import_module->import_delegate; CHECK_RESULT(host_delegate->import_memory( import, memory, MakePrintErrorCallback(), host_delegate->user_data)); @@ -809,30 +811,29 @@ Result BinaryReaderInterpreter::OnImportMemory(Index import_index, import->field_name); } else { CHECK_RESULT(CheckImportKind(import, ExternalKind::Memory)); - InterpreterMemory* memory = &env->memories[import_env_index]; + Memory* memory = &env->memories[import_env_index]; CHECK_RESULT(CheckImportLimits(page_limits, &memory->page_limits)); import->memory.limits = *page_limits; module->memory_index = import_env_index; } - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnImportGlobal(Index import_index, - StringSlice module_name, - StringSlice field_name, - Index global_index, - Type type, - bool mutable_) { - InterpreterImport* import = &module->imports[import_index]; +wabt::Result BinaryReaderInterpreter::OnImportGlobal(Index import_index, + StringSlice module_name, + StringSlice field_name, + Index global_index, + Type type, + bool mutable_) { + Import* import = &module->imports[import_index]; Index global_env_index = env->globals.size() - 1; if (is_host_import) { - env->globals.emplace_back(InterpreterTypedValue(type), mutable_); - InterpreterGlobal* global = &env->globals.back(); + env->globals.emplace_back(TypedValue(type), mutable_); + Global* global = &env->globals.back(); - InterpreterHostImportDelegate* host_delegate = - &host_import_module->import_delegate; + HostImportDelegate* host_delegate = &host_import_module->import_delegate; CHECK_RESULT(host_delegate->import_global( import, global, MakePrintErrorCallback(), host_delegate->user_data)); @@ -848,123 +849,125 @@ Result BinaryReaderInterpreter::OnImportGlobal(Index import_index, } global_index_mapping.push_back(global_env_index); num_global_imports++; - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnFunctionCount(Index count) { +wabt::Result BinaryReaderInterpreter::OnFunctionCount(Index count) { for (Index i = 0; i < count; ++i) func_index_mapping.push_back(env->funcs.size() + i); env->funcs.reserve(env->funcs.size() + count); func_fixups.resize(count); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnFunction(Index index, Index sig_index) { - DefinedInterpreterFunc* func = - new DefinedInterpreterFunc(TranslateSigIndexToEnv(sig_index)); +wabt::Result BinaryReaderInterpreter::OnFunction(Index index, Index sig_index) { + DefinedFunc* func = new DefinedFunc(TranslateSigIndexToEnv(sig_index)); env->funcs.emplace_back(func); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnTable(Index index, - Type elem_type, - const Limits* elem_limits) { +wabt::Result BinaryReaderInterpreter::OnTable(Index index, + Type elem_type, + const Limits* elem_limits) { if (module->table_index != kInvalidIndex) { PrintError("only one table allowed"); - return Result::Error; + return wabt::Result::Error; } env->tables.emplace_back(*elem_limits); module->table_index = env->tables.size() - 1; - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnMemory(Index index, - const Limits* page_limits) { +wabt::Result BinaryReaderInterpreter::OnMemory(Index index, + const Limits* page_limits) { if (module->memory_index != kInvalidIndex) { PrintError("only one memory allowed"); - return Result::Error; + return wabt::Result::Error; } env->memories.emplace_back(*page_limits); module->memory_index = env->memories.size() - 1; - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnGlobalCount(Index count) { +wabt::Result BinaryReaderInterpreter::OnGlobalCount(Index count) { for (Index i = 0; i < count; ++i) global_index_mapping.push_back(env->globals.size() + i); env->globals.resize(env->globals.size() + count); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::BeginGlobal(Index index, - Type type, - bool mutable_) { - InterpreterGlobal* global = GetGlobalByModuleIndex(index); +wabt::Result BinaryReaderInterpreter::BeginGlobal(Index index, + Type type, + bool mutable_) { + Global* global = GetGlobalByModuleIndex(index); global->typed_value.type = type; global->mutable_ = mutable_; init_expr_value.type = Type::Void; - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::EndGlobalInitExpr(Index index) { - InterpreterGlobal* global = GetGlobalByModuleIndex(index); +wabt::Result BinaryReaderInterpreter::EndGlobalInitExpr(Index index) { + Global* global = GetGlobalByModuleIndex(index); if (init_expr_value.type != global->typed_value.type) { PrintError("type mismatch in global, expected %s but got %s.", get_type_name(global->typed_value.type), get_type_name(init_expr_value.type)); - return Result::Error; + return wabt::Result::Error; } global->typed_value = init_expr_value; - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnInitExprF32ConstExpr(Index index, - uint32_t value_bits) { +wabt::Result BinaryReaderInterpreter::OnInitExprF32ConstExpr( + Index index, + uint32_t value_bits) { init_expr_value.type = Type::F32; init_expr_value.value.f32_bits = value_bits; - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnInitExprF64ConstExpr(Index index, - uint64_t value_bits) { +wabt::Result BinaryReaderInterpreter::OnInitExprF64ConstExpr( + Index index, + uint64_t value_bits) { init_expr_value.type = Type::F64; init_expr_value.value.f64_bits = value_bits; - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnInitExprGetGlobalExpr(Index index, - Index global_index) { +wabt::Result BinaryReaderInterpreter::OnInitExprGetGlobalExpr( + Index index, + Index global_index) { if (global_index >= num_global_imports) { PrintError("initializer expression can only reference an imported global"); - return Result::Error; + return wabt::Result::Error; } - InterpreterGlobal* ref_global = GetGlobalByModuleIndex(global_index); + Global* ref_global = GetGlobalByModuleIndex(global_index); if (ref_global->mutable_) { PrintError("initializer expression cannot reference a mutable global"); - return Result::Error; + return wabt::Result::Error; } init_expr_value = ref_global->typed_value; - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnInitExprI32ConstExpr(Index index, - uint32_t value) { +wabt::Result BinaryReaderInterpreter::OnInitExprI32ConstExpr(Index index, + uint32_t value) { init_expr_value.type = Type::I32; init_expr_value.value.i32 = value; - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnInitExprI64ConstExpr(Index index, - uint64_t value) { +wabt::Result BinaryReaderInterpreter::OnInitExprI64ConstExpr(Index index, + uint64_t value) { init_expr_value.type = Type::I64; init_expr_value.value.i64 = value; - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnExport(Index index, - ExternalKind kind, - Index item_index, - StringSlice name) { +wabt::Result BinaryReaderInterpreter::OnExport(Index index, + ExternalKind kind, + Index item_index, + StringSlice name) { switch (kind) { case ExternalKind::Func: item_index = TranslateFuncIndexToEnv(item_index); @@ -980,10 +983,10 @@ Result BinaryReaderInterpreter::OnExport(Index index, case ExternalKind::Global: { item_index = TranslateGlobalIndexToEnv(item_index); - InterpreterGlobal* global = &env->globals[item_index]; + Global* global = &env->globals[item_index]; if (global->mutable_) { PrintError("mutable globals cannot be exported"); - return Result::Error; + return wabt::Result::Error; } break; } @@ -991,63 +994,64 @@ Result BinaryReaderInterpreter::OnExport(Index index, return AppendExport(module, kind, item_index, name); } -Result BinaryReaderInterpreter::OnStartFunction(Index func_index) { +wabt::Result BinaryReaderInterpreter::OnStartFunction(Index func_index) { Index start_func_index = TranslateFuncIndexToEnv(func_index); - InterpreterFunc* start_func = GetFuncByEnvIndex(start_func_index); - InterpreterFuncSignature* sig = GetSignatureByEnvIndex(start_func->sig_index); + Func* start_func = GetFuncByEnvIndex(start_func_index); + FuncSignature* sig = GetSignatureByEnvIndex(start_func->sig_index); if (sig->param_types.size() != 0) { PrintError("start function must be nullary"); - return Result::Error; + return wabt::Result::Error; } if (sig->result_types.size() != 0) { PrintError("start function must not return anything"); - return Result::Error; + return wabt::Result::Error; } module->start_func_index = start_func_index; - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::EndElemSegmentInitExpr(Index index) { +wabt::Result BinaryReaderInterpreter::EndElemSegmentInitExpr(Index index) { if (init_expr_value.type != Type::I32) { PrintError("type mismatch in elem segment, expected i32 but got %s", get_type_name(init_expr_value.type)); - return Result::Error; + return wabt::Result::Error; } table_offset = init_expr_value.value.i32; - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnElemSegmentFunctionIndex(Index index, - Index func_index) { +wabt::Result BinaryReaderInterpreter::OnElemSegmentFunctionIndex( + Index index, + Index func_index) { assert(module->table_index != kInvalidIndex); - InterpreterTable* table = &env->tables[module->table_index]; + Table* table = &env->tables[module->table_index]; if (table_offset >= table->func_indexes.size()) { PrintError("elem segment offset is out of bounds: %u >= max value %" PRIzd, table_offset, table->func_indexes.size()); - return Result::Error; + return wabt::Result::Error; } Index max_func_index = func_index_mapping.size(); if (func_index >= max_func_index) { PrintError("invalid func_index: %" PRIindex " (max %" PRIindex ")", func_index, max_func_index); - return Result::Error; + return wabt::Result::Error; } elem_segment_infos.emplace_back(&table->func_indexes[table_offset++], TranslateFuncIndexToEnv(func_index)); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnDataSegmentData(Index index, - const void* src_data, - Address size) { +wabt::Result BinaryReaderInterpreter::OnDataSegmentData(Index index, + const void* src_data, + Address size) { assert(module->memory_index != kInvalidIndex); - InterpreterMemory* memory = &env->memories[module->memory_index]; + Memory* memory = &env->memories[module->memory_index]; if (init_expr_value.type != Type::I32) { PrintError("type mismatch in data segment, expected i32 but got %s", get_type_name(init_expr_value.type)); - return Result::Error; + return wabt::Result::Error; } Address address = init_expr_value.value.i32; uint64_t end_address = @@ -1056,13 +1060,13 @@ Result BinaryReaderInterpreter::OnDataSegmentData(Index index, PrintError("data segment is out of bounds: [%" PRIaddress ", %" PRIu64 ") >= max value %" PRIzd, address, end_address, memory->data.size()); - return Result::Error; + return wabt::Result::Error; } if (size > 0) data_segment_infos.emplace_back(&memory->data[address], src_data, size); - return Result::Ok; + return wabt::Result::Ok; } void BinaryReaderInterpreter::PushLabel(IstreamOffset offset, @@ -1080,9 +1084,9 @@ void BinaryReaderInterpreter::PopLabel() { } } -Result BinaryReaderInterpreter::BeginFunctionBody(Index index) { - DefinedInterpreterFunc* func = GetFuncByModuleIndex(index)->as_defined(); - InterpreterFuncSignature* sig = GetSignatureByEnvIndex(func->sig_index); +wabt::Result BinaryReaderInterpreter::BeginFunctionBody(Index index) { + DefinedFunc* func = GetFuncByModuleIndex(index)->as_defined(); + FuncSignature* sig = GetSignatureByEnvIndex(func->sig_index); func->offset = GetIstreamOffset(); func->local_decl_count = 0; @@ -1106,29 +1110,29 @@ Result BinaryReaderInterpreter::BeginFunctionBody(Index index) { /* push implicit func label (equivalent to return) */ PushLabel(kInvalidIstreamOffset, kInvalidIstreamOffset); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::EndFunctionBody(Index index) { +wabt::Result BinaryReaderInterpreter::EndFunctionBody(Index index) { FixupTopLabel(); Index drop_count, keep_count; CHECK_RESULT(GetReturnDropKeepCount(&drop_count, &keep_count)); CHECK_RESULT(typechecker_end_function(&typechecker)); CHECK_RESULT(EmitDropKeep(drop_count, keep_count)); - CHECK_RESULT(EmitOpcode(InterpreterOpcode::Return)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::Return)); PopLabel(); current_func = nullptr; - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnLocalDeclCount(Index count) { +wabt::Result BinaryReaderInterpreter::OnLocalDeclCount(Index count) { current_func->local_decl_count = count; - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnLocalDecl(Index decl_index, - Index count, - Type type) { +wabt::Result BinaryReaderInterpreter::OnLocalDecl(Index decl_index, + Index count, + Type type) { current_func->local_count += count; for (Index i = 0; i < count; ++i) @@ -1136,79 +1140,82 @@ Result BinaryReaderInterpreter::OnLocalDecl(Index decl_index, if (decl_index == current_func->local_decl_count - 1) { /* last local declaration, allocate space for all locals. */ - CHECK_RESULT(EmitOpcode(InterpreterOpcode::Alloca)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::Alloca)); CHECK_RESULT(EmitI32(current_func->local_count)); } - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::CheckHasMemory(Opcode opcode) { +wabt::Result BinaryReaderInterpreter::CheckHasMemory(wabt::Opcode opcode) { if (module->memory_index == kInvalidIndex) { PrintError("%s requires an imported or defined memory.", get_opcode_name(opcode)); - return Result::Error; + return wabt::Result::Error; } - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::CheckAlign(uint32_t alignment_log2, - Address natural_alignment) { +wabt::Result BinaryReaderInterpreter::CheckAlign(uint32_t alignment_log2, + Address natural_alignment) { if (alignment_log2 >= 32 || (1U << alignment_log2) > natural_alignment) { PrintError("alignment must not be larger than natural alignment (%u)", natural_alignment); - return Result::Error; + return wabt::Result::Error; } - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnUnaryExpr(Opcode opcode) { +wabt::Result BinaryReaderInterpreter::OnUnaryExpr(wabt::Opcode opcode) { CHECK_RESULT(typechecker_on_unary(&typechecker, opcode)); CHECK_RESULT(EmitOpcode(opcode)); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnBinaryExpr(Opcode opcode) { +wabt::Result BinaryReaderInterpreter::OnBinaryExpr(wabt::Opcode opcode) { CHECK_RESULT(typechecker_on_binary(&typechecker, opcode)); CHECK_RESULT(EmitOpcode(opcode)); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnBlockExpr(Index num_types, Type* sig_types) { +wabt::Result BinaryReaderInterpreter::OnBlockExpr(Index num_types, + Type* sig_types) { TypeVector sig(sig_types, sig_types + num_types); CHECK_RESULT(typechecker_on_block(&typechecker, &sig)); PushLabel(kInvalidIstreamOffset, kInvalidIstreamOffset); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnLoopExpr(Index num_types, Type* sig_types) { +wabt::Result BinaryReaderInterpreter::OnLoopExpr(Index num_types, + Type* sig_types) { TypeVector sig(sig_types, sig_types + num_types); CHECK_RESULT(typechecker_on_loop(&typechecker, &sig)); PushLabel(GetIstreamOffset(), kInvalidIstreamOffset); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnIfExpr(Index num_types, Type* sig_types) { +wabt::Result BinaryReaderInterpreter::OnIfExpr(Index num_types, + Type* sig_types) { TypeVector sig(sig_types, sig_types + num_types); CHECK_RESULT(typechecker_on_if(&typechecker, &sig)); - CHECK_RESULT(EmitOpcode(InterpreterOpcode::BrUnless)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::BrUnless)); IstreamOffset fixup_offset = GetIstreamOffset(); CHECK_RESULT(EmitI32(kInvalidIstreamOffset)); PushLabel(kInvalidIstreamOffset, fixup_offset); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnElseExpr() { +wabt::Result BinaryReaderInterpreter::OnElseExpr() { CHECK_RESULT(typechecker_on_else(&typechecker)); Label* label = TopLabel(); IstreamOffset fixup_cond_offset = label->fixup_offset; - CHECK_RESULT(EmitOpcode(InterpreterOpcode::Br)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::Br)); label->fixup_offset = GetIstreamOffset(); CHECK_RESULT(EmitI32(kInvalidIstreamOffset)); CHECK_RESULT(EmitI32At(fixup_cond_offset, GetIstreamOffset())); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnEndExpr() { +wabt::Result BinaryReaderInterpreter::OnEndExpr() { TypeCheckerLabel* label; CHECK_RESULT(typechecker_get_label(&typechecker, 0, &label)); LabelType label_type = label->label_type; @@ -1218,41 +1225,42 @@ Result BinaryReaderInterpreter::OnEndExpr() { } FixupTopLabel(); PopLabel(); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnBrExpr(Index depth) { +wabt::Result BinaryReaderInterpreter::OnBrExpr(Index depth) { Index drop_count, keep_count; CHECK_RESULT(GetBrDropKeepCount(depth, &drop_count, &keep_count)); CHECK_RESULT(typechecker_on_br(&typechecker, depth)); CHECK_RESULT(EmitBr(depth, drop_count, keep_count)); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnBrIfExpr(Index depth) { +wabt::Result BinaryReaderInterpreter::OnBrIfExpr(Index depth) { Index drop_count, keep_count; CHECK_RESULT(typechecker_on_br_if(&typechecker, depth)); CHECK_RESULT(GetBrDropKeepCount(depth, &drop_count, &keep_count)); /* flip the br_if so if <cond> is true it can drop values from the stack */ - CHECK_RESULT(EmitOpcode(InterpreterOpcode::BrUnless)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::BrUnless)); IstreamOffset fixup_br_offset = GetIstreamOffset(); CHECK_RESULT(EmitI32(kInvalidIstreamOffset)); CHECK_RESULT(EmitBr(depth, drop_count, keep_count)); CHECK_RESULT(EmitI32At(fixup_br_offset, GetIstreamOffset())); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnBrTableExpr(Index num_targets, - Index* target_depths, - Index default_target_depth) { +wabt::Result BinaryReaderInterpreter::OnBrTableExpr( + Index num_targets, + Index* target_depths, + Index default_target_depth) { CHECK_RESULT(typechecker_begin_br_table(&typechecker)); - CHECK_RESULT(EmitOpcode(InterpreterOpcode::BrTable)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::BrTable)); CHECK_RESULT(EmitI32(num_targets)); IstreamOffset fixup_table_offset = GetIstreamOffset(); CHECK_RESULT(EmitI32(kInvalidIstreamOffset)); /* not necessary for the interpreter, but it makes it easier to disassemble. * This opcode specifies how many bytes of data follow. */ - CHECK_RESULT(EmitOpcode(InterpreterOpcode::Data)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::Data)); CHECK_RESULT(EmitI32((num_targets + 1) * WABT_TABLE_ENTRY_SIZE)); CHECK_RESULT(EmitI32At(fixup_table_offset, GetIstreamOffset())); @@ -1263,105 +1271,105 @@ Result BinaryReaderInterpreter::OnBrTableExpr(Index num_targets, } CHECK_RESULT(typechecker_end_br_table(&typechecker)); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnCallExpr(Index func_index) { - InterpreterFunc* func = GetFuncByModuleIndex(func_index); - InterpreterFuncSignature* sig = GetSignatureByEnvIndex(func->sig_index); +wabt::Result BinaryReaderInterpreter::OnCallExpr(Index func_index) { + Func* func = GetFuncByModuleIndex(func_index); + FuncSignature* sig = GetSignatureByEnvIndex(func->sig_index); CHECK_RESULT( typechecker_on_call(&typechecker, &sig->param_types, &sig->result_types)); if (func->is_host) { - CHECK_RESULT(EmitOpcode(InterpreterOpcode::CallHost)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::CallHost)); CHECK_RESULT(EmitI32(TranslateFuncIndexToEnv(func_index))); } else { - CHECK_RESULT(EmitOpcode(InterpreterOpcode::Call)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::Call)); CHECK_RESULT(EmitFuncOffset(func->as_defined(), func_index)); } - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnCallIndirectExpr(Index sig_index) { +wabt::Result BinaryReaderInterpreter::OnCallIndirectExpr(Index sig_index) { if (module->table_index == kInvalidIndex) { PrintError("found call_indirect operator, but no table"); - return Result::Error; + return wabt::Result::Error; } - InterpreterFuncSignature* sig = GetSignatureByModuleIndex(sig_index); + FuncSignature* sig = GetSignatureByModuleIndex(sig_index); CHECK_RESULT(typechecker_on_call_indirect(&typechecker, &sig->param_types, &sig->result_types)); - CHECK_RESULT(EmitOpcode(InterpreterOpcode::CallIndirect)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::CallIndirect)); CHECK_RESULT(EmitI32(module->table_index)); CHECK_RESULT(EmitI32(TranslateSigIndexToEnv(sig_index))); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnCompareExpr(Opcode opcode) { +wabt::Result BinaryReaderInterpreter::OnCompareExpr(wabt::Opcode opcode) { return OnBinaryExpr(opcode); } -Result BinaryReaderInterpreter::OnConvertExpr(Opcode opcode) { +wabt::Result BinaryReaderInterpreter::OnConvertExpr(wabt::Opcode opcode) { return OnUnaryExpr(opcode); } -Result BinaryReaderInterpreter::OnDropExpr() { +wabt::Result BinaryReaderInterpreter::OnDropExpr() { CHECK_RESULT(typechecker_on_drop(&typechecker)); - CHECK_RESULT(EmitOpcode(InterpreterOpcode::Drop)); - return Result::Ok; + CHECK_RESULT(EmitOpcode(interpreter::Opcode::Drop)); + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnI32ConstExpr(uint32_t value) { +wabt::Result BinaryReaderInterpreter::OnI32ConstExpr(uint32_t value) { CHECK_RESULT(typechecker_on_const(&typechecker, Type::I32)); - CHECK_RESULT(EmitOpcode(InterpreterOpcode::I32Const)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::I32Const)); CHECK_RESULT(EmitI32(value)); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnI64ConstExpr(uint64_t value) { +wabt::Result BinaryReaderInterpreter::OnI64ConstExpr(uint64_t value) { CHECK_RESULT(typechecker_on_const(&typechecker, Type::I64)); - CHECK_RESULT(EmitOpcode(InterpreterOpcode::I64Const)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::I64Const)); CHECK_RESULT(EmitI64(value)); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnF32ConstExpr(uint32_t value_bits) { +wabt::Result BinaryReaderInterpreter::OnF32ConstExpr(uint32_t value_bits) { CHECK_RESULT(typechecker_on_const(&typechecker, Type::F32)); - CHECK_RESULT(EmitOpcode(InterpreterOpcode::F32Const)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::F32Const)); CHECK_RESULT(EmitI32(value_bits)); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnF64ConstExpr(uint64_t value_bits) { +wabt::Result BinaryReaderInterpreter::OnF64ConstExpr(uint64_t value_bits) { CHECK_RESULT(typechecker_on_const(&typechecker, Type::F64)); - CHECK_RESULT(EmitOpcode(InterpreterOpcode::F64Const)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::F64Const)); CHECK_RESULT(EmitI64(value_bits)); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnGetGlobalExpr(Index global_index) { +wabt::Result BinaryReaderInterpreter::OnGetGlobalExpr(Index global_index) { CHECK_RESULT(CheckGlobal(global_index)); Type type = GetGlobalTypeByModuleIndex(global_index); CHECK_RESULT(typechecker_on_get_global(&typechecker, type)); - CHECK_RESULT(EmitOpcode(InterpreterOpcode::GetGlobal)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::GetGlobal)); CHECK_RESULT(EmitI32(TranslateGlobalIndexToEnv(global_index))); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnSetGlobalExpr(Index global_index) { +wabt::Result BinaryReaderInterpreter::OnSetGlobalExpr(Index global_index) { CHECK_RESULT(CheckGlobal(global_index)); - InterpreterGlobal* global = GetGlobalByModuleIndex(global_index); + Global* global = GetGlobalByModuleIndex(global_index); if (!global->mutable_) { PrintError("can't set_global on immutable global at index %" PRIindex ".", global_index); - return Result::Error; + return wabt::Result::Error; } CHECK_RESULT( typechecker_on_set_global(&typechecker, global->typed_value.type)); - CHECK_RESULT(EmitOpcode(InterpreterOpcode::SetGlobal)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::SetGlobal)); CHECK_RESULT(EmitI32(TranslateGlobalIndexToEnv(global_index))); - return Result::Ok; + return wabt::Result::Ok; } Index BinaryReaderInterpreter::TranslateLocalIndex(Index local_index) { @@ -1369,7 +1377,7 @@ Index BinaryReaderInterpreter::TranslateLocalIndex(Index local_index) { current_func->param_and_local_types.size() - local_index; } -Result BinaryReaderInterpreter::OnGetLocalExpr(Index local_index) { +wabt::Result BinaryReaderInterpreter::OnGetLocalExpr(Index local_index) { CHECK_RESULT(CheckLocal(local_index)); Type type = GetLocalTypeByIndex(current_func, local_index); /* Get the translated index before calling typechecker_on_get_local @@ -1377,130 +1385,129 @@ Result BinaryReaderInterpreter::OnGetLocalExpr(Index local_index) { * relative to the old stack size. */ Index translated_local_index = TranslateLocalIndex(local_index); CHECK_RESULT(typechecker_on_get_local(&typechecker, type)); - CHECK_RESULT(EmitOpcode(InterpreterOpcode::GetLocal)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::GetLocal)); CHECK_RESULT(EmitI32(translated_local_index)); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnSetLocalExpr(Index local_index) { +wabt::Result BinaryReaderInterpreter::OnSetLocalExpr(Index local_index) { CHECK_RESULT(CheckLocal(local_index)); Type type = GetLocalTypeByIndex(current_func, local_index); CHECK_RESULT(typechecker_on_set_local(&typechecker, type)); - CHECK_RESULT(EmitOpcode(InterpreterOpcode::SetLocal)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::SetLocal)); CHECK_RESULT(EmitI32(TranslateLocalIndex(local_index))); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnTeeLocalExpr(Index local_index) { +wabt::Result BinaryReaderInterpreter::OnTeeLocalExpr(Index local_index) { CHECK_RESULT(CheckLocal(local_index)); Type type = GetLocalTypeByIndex(current_func, local_index); CHECK_RESULT(typechecker_on_tee_local(&typechecker, type)); - CHECK_RESULT(EmitOpcode(InterpreterOpcode::TeeLocal)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::TeeLocal)); CHECK_RESULT(EmitI32(TranslateLocalIndex(local_index))); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnGrowMemoryExpr() { - CHECK_RESULT(CheckHasMemory(Opcode::GrowMemory)); +wabt::Result BinaryReaderInterpreter::OnGrowMemoryExpr() { + CHECK_RESULT(CheckHasMemory(wabt::Opcode::GrowMemory)); CHECK_RESULT(typechecker_on_grow_memory(&typechecker)); - CHECK_RESULT(EmitOpcode(InterpreterOpcode::GrowMemory)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::GrowMemory)); CHECK_RESULT(EmitI32(module->memory_index)); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnLoadExpr(Opcode opcode, - uint32_t alignment_log2, - Address offset) { +wabt::Result BinaryReaderInterpreter::OnLoadExpr(wabt::Opcode opcode, + uint32_t alignment_log2, + Address offset) { CHECK_RESULT(CheckHasMemory(opcode)); CHECK_RESULT(CheckAlign(alignment_log2, get_opcode_memory_size(opcode))); CHECK_RESULT(typechecker_on_load(&typechecker, opcode)); CHECK_RESULT(EmitOpcode(opcode)); CHECK_RESULT(EmitI32(module->memory_index)); CHECK_RESULT(EmitI32(offset)); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnStoreExpr(Opcode opcode, - uint32_t alignment_log2, - Address offset) { +wabt::Result BinaryReaderInterpreter::OnStoreExpr(wabt::Opcode opcode, + uint32_t alignment_log2, + Address offset) { CHECK_RESULT(CheckHasMemory(opcode)); CHECK_RESULT(CheckAlign(alignment_log2, get_opcode_memory_size(opcode))); CHECK_RESULT(typechecker_on_store(&typechecker, opcode)); CHECK_RESULT(EmitOpcode(opcode)); CHECK_RESULT(EmitI32(module->memory_index)); CHECK_RESULT(EmitI32(offset)); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnCurrentMemoryExpr() { - CHECK_RESULT(CheckHasMemory(Opcode::CurrentMemory)); +wabt::Result BinaryReaderInterpreter::OnCurrentMemoryExpr() { + CHECK_RESULT(CheckHasMemory(wabt::Opcode::CurrentMemory)); CHECK_RESULT(typechecker_on_current_memory(&typechecker)); - CHECK_RESULT(EmitOpcode(InterpreterOpcode::CurrentMemory)); + CHECK_RESULT(EmitOpcode(interpreter::Opcode::CurrentMemory)); CHECK_RESULT(EmitI32(module->memory_index)); - return Result::Ok; + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnNopExpr() { - return Result::Ok; +wabt::Result BinaryReaderInterpreter::OnNopExpr() { + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnReturnExpr() { +wabt::Result BinaryReaderInterpreter::OnReturnExpr() { Index drop_count, keep_count; CHECK_RESULT(GetReturnDropKeepCount(&drop_count, &keep_count)); CHECK_RESULT(typechecker_on_return(&typechecker)); CHECK_RESULT(EmitDropKeep(drop_count, keep_count)); - CHECK_RESULT(EmitOpcode(InterpreterOpcode::Return)); - return Result::Ok; + CHECK_RESULT(EmitOpcode(interpreter::Opcode::Return)); + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnSelectExpr() { +wabt::Result BinaryReaderInterpreter::OnSelectExpr() { CHECK_RESULT(typechecker_on_select(&typechecker)); - CHECK_RESULT(EmitOpcode(InterpreterOpcode::Select)); - return Result::Ok; + CHECK_RESULT(EmitOpcode(interpreter::Opcode::Select)); + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::OnUnreachableExpr() { +wabt::Result BinaryReaderInterpreter::OnUnreachableExpr() { CHECK_RESULT(typechecker_on_unreachable(&typechecker)); - CHECK_RESULT(EmitOpcode(InterpreterOpcode::Unreachable)); - return Result::Ok; + CHECK_RESULT(EmitOpcode(interpreter::Opcode::Unreachable)); + return wabt::Result::Ok; } -Result BinaryReaderInterpreter::EndModule() { +wabt::Result BinaryReaderInterpreter::EndModule() { for (ElemSegmentInfo& info : elem_segment_infos) { *info.dst = info.func_index; } for (DataSegmentInfo& info : data_segment_infos) { memcpy(info.dst_data, info.src_data, info.size); } - return Result::Ok; + return wabt::Result::Ok; } } // namespace -Result read_binary_interpreter(InterpreterEnvironment* env, - const void* data, - size_t size, - const ReadBinaryOptions* options, - BinaryErrorHandler* error_handler, - DefinedInterpreterModule** out_module) { +wabt::Result read_binary_interpreter(Environment* env, + const void* data, + size_t size, + const ReadBinaryOptions* options, + BinaryErrorHandler* error_handler, + DefinedModule** out_module) { IstreamOffset istream_offset = env->istream->data.size(); - DefinedInterpreterModule* module = - new DefinedInterpreterModule(istream_offset); + DefinedModule* module = new DefinedModule(istream_offset); // Need to mark before constructing the reader since it takes ownership of // env->istream, which makes env->istream == nullptr. - InterpreterEnvironmentMark mark = mark_interpreter_environment(env); + EnvironmentMark mark = mark_environment(env); BinaryReaderInterpreter reader(env, module, istream_offset, error_handler); env->modules.emplace_back(module); - Result result = read_binary(data, size, &reader, options); + wabt::Result result = read_binary(data, size, &reader, options); env->istream = reader.ReleaseOutputBuffer(); if (WABT_SUCCEEDED(result)) { env->istream->data.resize(reader.get_istream_offset()); module->istream_end = env->istream->data.size(); *out_module = module; } else { - reset_interpreter_environment_to_mark(env, mark); + reset_environment_to_mark(env, mark); *out_module = nullptr; } return result; diff --git a/src/binary-reader-interpreter.h b/src/binary-reader-interpreter.h index 60f985ce..a075e631 100644 --- a/src/binary-reader-interpreter.h +++ b/src/binary-reader-interpreter.h @@ -21,17 +21,22 @@ namespace wabt { +namespace interpreter { + +struct DefinedModule; +struct Environment; + +} // namespace interpreter + class BinaryErrorHandler; -struct DefinedInterpreterModule; -struct InterpreterEnvironment; struct ReadBinaryOptions; -Result read_binary_interpreter(InterpreterEnvironment* env, +Result read_binary_interpreter(interpreter::Environment* env, const void* data, size_t size, const ReadBinaryOptions* options, BinaryErrorHandler*, - DefinedInterpreterModule** out_module); + interpreter::DefinedModule** out_module); } // namespace wabt diff --git a/src/common.h b/src/common.h index 9560cd1c..f2278c07 100644 --- a/src/common.h +++ b/src/common.h @@ -102,8 +102,8 @@ enum class Result { Error, }; -#define WABT_SUCCEEDED(x) ((x) == Result::Ok) -#define WABT_FAILED(x) ((x) == Result::Error) +#define WABT_SUCCEEDED(x) ((x) == ::wabt::Result::Ok) +#define WABT_FAILED(x) ((x) == ::wabt::Result::Error) inline std::string WABT_PRINTF_FORMAT(1, 2) string_printf(const char* format, ...) { diff --git a/src/interpreter.cc b/src/interpreter.cc index 30aba1a9..f116eb25 100644 --- a/src/interpreter.cc +++ b/src/interpreter.cc @@ -25,8 +25,9 @@ #include "stream.h" namespace wabt { +namespace interpreter { -static const char* s_interpreter_opcode_name[256] = { +static const char* s_opcode_name[256] = { #define WABT_OPCODE(rtype, type1, type2, mem_size, code, NAME, text) text, #include "interpreter-opcode.def" @@ -40,14 +41,13 @@ static const char* s_interpreter_opcode_name[256] = { return Result::Error; \ } while (0) -static const char* get_interpreter_opcode_name(InterpreterOpcode opcode) { - return s_interpreter_opcode_name[static_cast<int>(opcode)]; +static const char* get_opcode_name(Opcode opcode) { + return s_opcode_name[static_cast<int>(opcode)]; } -InterpreterEnvironment::InterpreterEnvironment() - : istream(new OutputBuffer()) {} +Environment::Environment() : istream(new OutputBuffer()) {} -InterpreterThread::InterpreterThread() +Thread::Thread() : env(nullptr), value_stack_top(nullptr), value_stack_end(nullptr), @@ -55,18 +55,17 @@ InterpreterThread::InterpreterThread() call_stack_end(nullptr), pc(0) {} -InterpreterImport::InterpreterImport() - : kind(ExternalKind::Func) { +Import::Import() : kind(ExternalKind::Func) { WABT_ZERO_MEMORY(module_name); WABT_ZERO_MEMORY(field_name); WABT_ZERO_MEMORY(func.sig_index); } -InterpreterImport::InterpreterImport(InterpreterImport&& other) { +Import::Import(Import&& other) { *this = std::move(other); } -InterpreterImport& InterpreterImport::operator=(InterpreterImport&& other) { +Import& Import::operator=(Import&& other) { kind = other.kind; module_name = other.module_name; WABT_ZERO_MEMORY(other.module_name); @@ -90,20 +89,17 @@ InterpreterImport& InterpreterImport::operator=(InterpreterImport&& other) { return *this; } - -InterpreterImport::~InterpreterImport() { +Import::~Import() { destroy_string_slice(&module_name); destroy_string_slice(&field_name); } -InterpreterExport::InterpreterExport(InterpreterExport&& other) - : name(other.name), - kind(other.kind), - index(other.index) { +Export::Export(Export&& other) + : name(other.name), kind(other.kind), index(other.index) { WABT_ZERO_MEMORY(other.name); } -InterpreterExport& InterpreterExport::operator=(InterpreterExport&& other) { +Export& Export::operator=(Export&& other) { name = other.name; kind = other.kind; index = other.index; @@ -111,39 +107,37 @@ InterpreterExport& InterpreterExport::operator=(InterpreterExport&& other) { return *this; } -InterpreterExport::~InterpreterExport() { +Export::~Export() { destroy_string_slice(&name); } -InterpreterModule::InterpreterModule(bool is_host) +Module::Module(bool is_host) : memory_index(kInvalidIndex), table_index(kInvalidIndex), is_host(is_host) { WABT_ZERO_MEMORY(name); } -InterpreterModule::InterpreterModule(const StringSlice& name, bool is_host) +Module::Module(const StringSlice& name, bool is_host) : name(name), memory_index(kInvalidIndex), table_index(kInvalidIndex), is_host(is_host) {} -InterpreterModule::~InterpreterModule() { +Module::~Module() { destroy_string_slice(&name); } -DefinedInterpreterModule::DefinedInterpreterModule(size_t istream_start) - : InterpreterModule(false), +DefinedModule::DefinedModule(size_t istream_start) + : Module(false), start_func_index(kInvalidIndex), istream_start(istream_start), istream_end(istream_start) {} -HostInterpreterModule::HostInterpreterModule(const StringSlice& name) - : InterpreterModule(name, true) {} +HostModule::HostModule(const StringSlice& name) : Module(name, true) {} -InterpreterEnvironmentMark mark_interpreter_environment( - InterpreterEnvironment* env) { - InterpreterEnvironmentMark mark; +EnvironmentMark mark_environment(Environment* env) { + EnvironmentMark mark; WABT_ZERO_MEMORY(mark); mark.modules_size = env->modules.size(); mark.sigs_size = env->sigs.size(); @@ -155,8 +149,7 @@ InterpreterEnvironmentMark mark_interpreter_environment( return mark; } -void reset_interpreter_environment_to_mark(InterpreterEnvironment* env, - InterpreterEnvironmentMark mark) { +void reset_environment_to_mark(Environment* env, EnvironmentMark mark) { /* Destroy entries in the binding hash. */ for (size_t i = mark.modules_size; i < env->modules.size(); ++i) { const StringSlice* name = &env->modules[i]->name; @@ -187,19 +180,15 @@ void reset_interpreter_environment_to_mark(InterpreterEnvironment* env, env->istream->data.resize(mark.istream_size); } -HostInterpreterModule* append_host_module(InterpreterEnvironment* env, - StringSlice name) { - HostInterpreterModule* module = - new HostInterpreterModule(dup_string_slice(name)); +HostModule* append_host_module(Environment* env, StringSlice name) { + HostModule* module = new HostModule(dup_string_slice(name)); env->modules.emplace_back(module); env->registered_module_bindings.emplace(string_slice_to_string(name), Binding(env->modules.size() - 1)); return module; } -void init_interpreter_thread(InterpreterEnvironment* env, - InterpreterThread* thread, - InterpreterThreadOptions* options) { +void init_thread(Environment* env, Thread* thread, ThreadOptions* options) { thread->value_stack.resize(options->value_stack_size); thread->call_stack.resize(options->call_stack_size); thread->env = env; @@ -212,16 +201,14 @@ void init_interpreter_thread(InterpreterEnvironment* env, thread->pc = options->pc; } -InterpreterResult push_thread_value(InterpreterThread* thread, - InterpreterValue value) { +Result push_thread_value(Thread* thread, Value value) { if (thread->value_stack_top >= thread->value_stack_end) - return InterpreterResult::TrapValueStackExhausted; + return Result::TrapValueStackExhausted; *thread->value_stack_top++ = value; - return InterpreterResult::Ok; + return Result::Ok; } -InterpreterExport* get_interpreter_export_by_name(InterpreterModule* module, - const StringSlice* name) { +Export* get_export_by_name(Module* module, const StringSlice* name) { int field_index = module->export_bindings.find_index(*name); if (field_index < 0) return nullptr; @@ -475,7 +462,7 @@ DEFINE_BITCAST(bitcast_u64_to_f64, uint64_t, double) #define TYPE_FIELD_NAME_F32 f32_bits #define TYPE_FIELD_NAME_F64 f64_bits -#define TRAP(type) return InterpreterResult::Trap##type +#define TRAP(type) return Result::Trap##type #define TRAP_UNLESS(cond, type) TRAP_IF(!(cond), type) #define TRAP_IF(cond, type) \ do { \ @@ -539,7 +526,7 @@ DEFINE_BITCAST(bitcast_u64_to_f64, uint64_t, double) #define GET_MEMORY(var) \ Index memory_index = read_u32(&pc); \ - InterpreterMemory* var = &env->memories[memory_index] + Memory* var = &env->memories[memory_index] #define LOAD(type, mem_type) \ do { \ @@ -751,27 +738,26 @@ static WABT_INLINE void read_table_entry_at(const uint8_t* pc, *out_keep = *(pc + WABT_TABLE_ENTRY_KEEP_OFFSET); } -bool func_signatures_are_equal(InterpreterEnvironment* env, +bool func_signatures_are_equal(Environment* env, Index sig_index_0, Index sig_index_1) { if (sig_index_0 == sig_index_1) return true; - InterpreterFuncSignature* sig_0 = &env->sigs[sig_index_0]; - InterpreterFuncSignature* sig_1 = &env->sigs[sig_index_1]; + FuncSignature* sig_0 = &env->sigs[sig_index_0]; + FuncSignature* sig_1 = &env->sigs[sig_index_1]; return sig_0->param_types == sig_1->param_types && sig_0->result_types == sig_1->result_types; } -InterpreterResult call_host(InterpreterThread* thread, - HostInterpreterFunc* func) { - InterpreterFuncSignature* sig = &thread->env->sigs[func->sig_index]; +Result call_host(Thread* thread, HostFunc* func) { + FuncSignature* sig = &thread->env->sigs[func->sig_index]; size_t num_params = sig->param_types.size(); size_t num_results = sig->result_types.size(); // + 1 is a workaround for using data() below; UBSAN doesn't like calling // data() with an empty vector. - std::vector<InterpreterTypedValue> params(num_params + 1); - std::vector<InterpreterTypedValue> results(num_results + 1); + std::vector<TypedValue> params(num_params + 1); + std::vector<TypedValue> results(num_results + 1); for (size_t i = num_params; i > 0; --i) { params[i - 1].value = POP(); @@ -788,42 +774,42 @@ InterpreterResult call_host(InterpreterThread* thread, PUSH(results[i].value); } - return InterpreterResult::Ok; + return Result::Ok; } -InterpreterResult run_interpreter(InterpreterThread* thread, - int num_instructions, - IstreamOffset* call_stack_return_top) { - InterpreterResult result = InterpreterResult::Ok; +Result run_interpreter(Thread* thread, + int num_instructions, + IstreamOffset* call_stack_return_top) { + Result result = Result::Ok; assert(call_stack_return_top < thread->call_stack_end); - InterpreterEnvironment* env = thread->env; + Environment* env = thread->env; const uint8_t* istream = env->istream->data.data(); const uint8_t* pc = &istream[thread->pc]; for (int i = 0; i < num_instructions; ++i) { - InterpreterOpcode opcode = static_cast<InterpreterOpcode>(*pc++); + Opcode opcode = static_cast<Opcode>(*pc++); switch (opcode) { - case InterpreterOpcode::Select: { + case Opcode::Select: { VALUE_TYPE_I32 cond = POP_I32(); - InterpreterValue false_ = POP(); - InterpreterValue true_ = POP(); + Value false_ = POP(); + Value true_ = POP(); PUSH(cond ? true_ : false_); break; } - case InterpreterOpcode::Br: + case Opcode::Br: GOTO(read_u32(&pc)); break; - case InterpreterOpcode::BrIf: { + case Opcode::BrIf: { IstreamOffset new_pc = read_u32(&pc); if (POP_I32()) GOTO(new_pc); break; } - case InterpreterOpcode::BrTable: { + case Opcode::BrTable: { Index num_targets = read_u32(&pc); IstreamOffset table_offset = read_u32(&pc); VALUE_TYPE_I32 key = POP_I32(); @@ -839,80 +825,80 @@ InterpreterResult run_interpreter(InterpreterThread* thread, break; } - case InterpreterOpcode::Return: + case Opcode::Return: if (thread->call_stack_top == call_stack_return_top) { - result = InterpreterResult::Returned; + result = Result::Returned; goto exit_loop; } GOTO(POP_CALL()); break; - case InterpreterOpcode::Unreachable: + case Opcode::Unreachable: TRAP(Unreachable); break; - case InterpreterOpcode::I32Const: + case Opcode::I32Const: PUSH_I32(read_u32(&pc)); break; - case InterpreterOpcode::I64Const: + case Opcode::I64Const: PUSH_I64(read_u64(&pc)); break; - case InterpreterOpcode::F32Const: + case Opcode::F32Const: PUSH_F32(read_u32(&pc)); break; - case InterpreterOpcode::F64Const: + case Opcode::F64Const: PUSH_F64(read_u64(&pc)); break; - case InterpreterOpcode::GetGlobal: { + case Opcode::GetGlobal: { Index index = read_u32(&pc); assert(index < env->globals.size()); PUSH(env->globals[index].typed_value.value); break; } - case InterpreterOpcode::SetGlobal: { + case Opcode::SetGlobal: { Index index = read_u32(&pc); assert(index < env->globals.size()); env->globals[index].typed_value.value = POP(); break; } - case InterpreterOpcode::GetLocal: { - InterpreterValue value = PICK(read_u32(&pc)); + case Opcode::GetLocal: { + Value value = PICK(read_u32(&pc)); PUSH(value); break; } - case InterpreterOpcode::SetLocal: { - InterpreterValue value = POP(); + case Opcode::SetLocal: { + Value value = POP(); PICK(read_u32(&pc)) = value; break; } - case InterpreterOpcode::TeeLocal: + case Opcode::TeeLocal: PICK(read_u32(&pc)) = TOP(); break; - case InterpreterOpcode::Call: { + case Opcode::Call: { IstreamOffset offset = read_u32(&pc); PUSH_CALL(); GOTO(offset); break; } - case InterpreterOpcode::CallIndirect: { + case Opcode::CallIndirect: { Index table_index = read_u32(&pc); - InterpreterTable* table = &env->tables[table_index]; + Table* table = &env->tables[table_index]; Index sig_index = read_u32(&pc); VALUE_TYPE_I32 entry_index = POP_I32(); TRAP_IF(entry_index >= table->func_indexes.size(), UndefinedTableIndex); Index func_index = table->func_indexes[entry_index]; TRAP_IF(func_index == kInvalidIndex, UninitializedTableElement); - InterpreterFunc* func = env->funcs[func_index].get(); + Func* func = env->funcs[func_index].get(); TRAP_UNLESS(func_signatures_are_equal(env, func->sig_index, sig_index), IndirectCallSignatureMismatch); if (func->is_host) { @@ -924,111 +910,111 @@ InterpreterResult run_interpreter(InterpreterThread* thread, break; } - case InterpreterOpcode::CallHost: { + case Opcode::CallHost: { Index func_index = read_u32(&pc); call_host(thread, env->funcs[func_index]->as_host()); break; } - case InterpreterOpcode::I32Load8S: + case Opcode::I32Load8S: LOAD(I32, I8); break; - case InterpreterOpcode::I32Load8U: + case Opcode::I32Load8U: LOAD(I32, U8); break; - case InterpreterOpcode::I32Load16S: + case Opcode::I32Load16S: LOAD(I32, I16); break; - case InterpreterOpcode::I32Load16U: + case Opcode::I32Load16U: LOAD(I32, U16); break; - case InterpreterOpcode::I64Load8S: + case Opcode::I64Load8S: LOAD(I64, I8); break; - case InterpreterOpcode::I64Load8U: + case Opcode::I64Load8U: LOAD(I64, U8); break; - case InterpreterOpcode::I64Load16S: + case Opcode::I64Load16S: LOAD(I64, I16); break; - case InterpreterOpcode::I64Load16U: + case Opcode::I64Load16U: LOAD(I64, U16); break; - case InterpreterOpcode::I64Load32S: + case Opcode::I64Load32S: LOAD(I64, I32); break; - case InterpreterOpcode::I64Load32U: + case Opcode::I64Load32U: LOAD(I64, U32); break; - case InterpreterOpcode::I32Load: + case Opcode::I32Load: LOAD(I32, U32); break; - case InterpreterOpcode::I64Load: + case Opcode::I64Load: LOAD(I64, U64); break; - case InterpreterOpcode::F32Load: + case Opcode::F32Load: LOAD(F32, F32); break; - case InterpreterOpcode::F64Load: + case Opcode::F64Load: LOAD(F64, F64); break; - case InterpreterOpcode::I32Store8: + case Opcode::I32Store8: STORE(I32, U8); break; - case InterpreterOpcode::I32Store16: + case Opcode::I32Store16: STORE(I32, U16); break; - case InterpreterOpcode::I64Store8: + case Opcode::I64Store8: STORE(I64, U8); break; - case InterpreterOpcode::I64Store16: + case Opcode::I64Store16: STORE(I64, U16); break; - case InterpreterOpcode::I64Store32: + case Opcode::I64Store32: STORE(I64, U32); break; - case InterpreterOpcode::I32Store: + case Opcode::I32Store: STORE(I32, U32); break; - case InterpreterOpcode::I64Store: + case Opcode::I64Store: STORE(I64, U64); break; - case InterpreterOpcode::F32Store: + case Opcode::F32Store: STORE(F32, F32); break; - case InterpreterOpcode::F64Store: + case Opcode::F64Store: STORE(F64, F64); break; - case InterpreterOpcode::CurrentMemory: { + case Opcode::CurrentMemory: { GET_MEMORY(memory); PUSH_I32(memory->page_limits.initial); break; } - case InterpreterOpcode::GrowMemory: { + case Opcode::GrowMemory: { GET_MEMORY(memory); uint32_t old_page_size = memory->page_limits.initial; VALUE_TYPE_I32 grow_pages = POP_I32(); @@ -1045,399 +1031,399 @@ InterpreterResult run_interpreter(InterpreterThread* thread, break; } - case InterpreterOpcode::I32Add: + case Opcode::I32Add: BINOP(I32, I32, +); break; - case InterpreterOpcode::I32Sub: + case Opcode::I32Sub: BINOP(I32, I32, -); break; - case InterpreterOpcode::I32Mul: + case Opcode::I32Mul: BINOP(I32, I32, *); break; - case InterpreterOpcode::I32DivS: + case Opcode::I32DivS: BINOP_DIV_S(I32); break; - case InterpreterOpcode::I32DivU: + case Opcode::I32DivU: BINOP_DIV_REM_U(I32, /); break; - case InterpreterOpcode::I32RemS: + case Opcode::I32RemS: BINOP_REM_S(I32); break; - case InterpreterOpcode::I32RemU: + case Opcode::I32RemU: BINOP_DIV_REM_U(I32, %); break; - case InterpreterOpcode::I32And: + case Opcode::I32And: BINOP(I32, I32, &); break; - case InterpreterOpcode::I32Or: + case Opcode::I32Or: BINOP(I32, I32, |); break; - case InterpreterOpcode::I32Xor: + case Opcode::I32Xor: BINOP(I32, I32, ^); break; - case InterpreterOpcode::I32Shl: + case Opcode::I32Shl: BINOP_SHIFT(I32, <<, UNSIGNED); break; - case InterpreterOpcode::I32ShrU: + case Opcode::I32ShrU: BINOP_SHIFT(I32, >>, UNSIGNED); break; - case InterpreterOpcode::I32ShrS: + case Opcode::I32ShrS: BINOP_SHIFT(I32, >>, SIGNED); break; - case InterpreterOpcode::I32Eq: + case Opcode::I32Eq: BINOP(I32, I32, ==); break; - case InterpreterOpcode::I32Ne: + case Opcode::I32Ne: BINOP(I32, I32, !=); break; - case InterpreterOpcode::I32LtS: + case Opcode::I32LtS: BINOP_SIGNED(I32, I32, <); break; - case InterpreterOpcode::I32LeS: + case Opcode::I32LeS: BINOP_SIGNED(I32, I32, <=); break; - case InterpreterOpcode::I32LtU: + case Opcode::I32LtU: BINOP(I32, I32, <); break; - case InterpreterOpcode::I32LeU: + case Opcode::I32LeU: BINOP(I32, I32, <=); break; - case InterpreterOpcode::I32GtS: + case Opcode::I32GtS: BINOP_SIGNED(I32, I32, >); break; - case InterpreterOpcode::I32GeS: + case Opcode::I32GeS: BINOP_SIGNED(I32, I32, >=); break; - case InterpreterOpcode::I32GtU: + case Opcode::I32GtU: BINOP(I32, I32, >); break; - case InterpreterOpcode::I32GeU: + case Opcode::I32GeU: BINOP(I32, I32, >=); break; - case InterpreterOpcode::I32Clz: { + case Opcode::I32Clz: { VALUE_TYPE_I32 value = POP_I32(); PUSH_I32(value != 0 ? wabt_clz_u32(value) : 32); break; } - case InterpreterOpcode::I32Ctz: { + case Opcode::I32Ctz: { VALUE_TYPE_I32 value = POP_I32(); PUSH_I32(value != 0 ? wabt_ctz_u32(value) : 32); break; } - case InterpreterOpcode::I32Popcnt: { + case Opcode::I32Popcnt: { VALUE_TYPE_I32 value = POP_I32(); PUSH_I32(wabt_popcount_u32(value)); break; } - case InterpreterOpcode::I32Eqz: { + case Opcode::I32Eqz: { VALUE_TYPE_I32 value = POP_I32(); PUSH_I32(value == 0); break; } - case InterpreterOpcode::I64Add: + case Opcode::I64Add: BINOP(I64, I64, +); break; - case InterpreterOpcode::I64Sub: + case Opcode::I64Sub: BINOP(I64, I64, -); break; - case InterpreterOpcode::I64Mul: + case Opcode::I64Mul: BINOP(I64, I64, *); break; - case InterpreterOpcode::I64DivS: + case Opcode::I64DivS: BINOP_DIV_S(I64); break; - case InterpreterOpcode::I64DivU: + case Opcode::I64DivU: BINOP_DIV_REM_U(I64, /); break; - case InterpreterOpcode::I64RemS: + case Opcode::I64RemS: BINOP_REM_S(I64); break; - case InterpreterOpcode::I64RemU: + case Opcode::I64RemU: BINOP_DIV_REM_U(I64, %); break; - case InterpreterOpcode::I64And: + case Opcode::I64And: BINOP(I64, I64, &); break; - case InterpreterOpcode::I64Or: + case Opcode::I64Or: BINOP(I64, I64, |); break; - case InterpreterOpcode::I64Xor: + case Opcode::I64Xor: BINOP(I64, I64, ^); break; - case InterpreterOpcode::I64Shl: + case Opcode::I64Shl: BINOP_SHIFT(I64, <<, UNSIGNED); break; - case InterpreterOpcode::I64ShrU: + case Opcode::I64ShrU: BINOP_SHIFT(I64, >>, UNSIGNED); break; - case InterpreterOpcode::I64ShrS: + case Opcode::I64ShrS: BINOP_SHIFT(I64, >>, SIGNED); break; - case InterpreterOpcode::I64Eq: + case Opcode::I64Eq: BINOP(I32, I64, ==); break; - case InterpreterOpcode::I64Ne: + case Opcode::I64Ne: BINOP(I32, I64, !=); break; - case InterpreterOpcode::I64LtS: + case Opcode::I64LtS: BINOP_SIGNED(I32, I64, <); break; - case InterpreterOpcode::I64LeS: + case Opcode::I64LeS: BINOP_SIGNED(I32, I64, <=); break; - case InterpreterOpcode::I64LtU: + case Opcode::I64LtU: BINOP(I32, I64, <); break; - case InterpreterOpcode::I64LeU: + case Opcode::I64LeU: BINOP(I32, I64, <=); break; - case InterpreterOpcode::I64GtS: + case Opcode::I64GtS: BINOP_SIGNED(I32, I64, >); break; - case InterpreterOpcode::I64GeS: + case Opcode::I64GeS: BINOP_SIGNED(I32, I64, >=); break; - case InterpreterOpcode::I64GtU: + case Opcode::I64GtU: BINOP(I32, I64, >); break; - case InterpreterOpcode::I64GeU: + case Opcode::I64GeU: BINOP(I32, I64, >=); break; - case InterpreterOpcode::I64Clz: { + case Opcode::I64Clz: { VALUE_TYPE_I64 value = POP_I64(); PUSH_I64(value != 0 ? wabt_clz_u64(value) : 64); break; } - case InterpreterOpcode::I64Ctz: { + case Opcode::I64Ctz: { VALUE_TYPE_I64 value = POP_I64(); PUSH_I64(value != 0 ? wabt_ctz_u64(value) : 64); break; } - case InterpreterOpcode::I64Popcnt: { + case Opcode::I64Popcnt: { VALUE_TYPE_I64 value = POP_I64(); PUSH_I64(wabt_popcount_u64(value)); break; } - case InterpreterOpcode::F32Add: + case Opcode::F32Add: BINOP_FLOAT(F32, +); break; - case InterpreterOpcode::F32Sub: + case Opcode::F32Sub: BINOP_FLOAT(F32, -); break; - case InterpreterOpcode::F32Mul: + case Opcode::F32Mul: BINOP_FLOAT(F32, *); break; - case InterpreterOpcode::F32Div: + case Opcode::F32Div: BINOP_FLOAT_DIV(F32); break; - case InterpreterOpcode::F32Min: + case Opcode::F32Min: MINMAX_FLOAT(F32, MIN); break; - case InterpreterOpcode::F32Max: + case Opcode::F32Max: MINMAX_FLOAT(F32, MAX); break; - case InterpreterOpcode::F32Abs: + case Opcode::F32Abs: TOP().f32_bits &= ~F32_SIGN_MASK; break; - case InterpreterOpcode::F32Neg: + case Opcode::F32Neg: TOP().f32_bits ^= F32_SIGN_MASK; break; - case InterpreterOpcode::F32Copysign: { + case Opcode::F32Copysign: { VALUE_TYPE_F32 rhs = POP_F32(); VALUE_TYPE_F32 lhs = POP_F32(); PUSH_F32((lhs & ~F32_SIGN_MASK) | (rhs & F32_SIGN_MASK)); break; } - case InterpreterOpcode::F32Ceil: + case Opcode::F32Ceil: UNOP_FLOAT(F32, ceilf); break; - case InterpreterOpcode::F32Floor: + case Opcode::F32Floor: UNOP_FLOAT(F32, floorf); break; - case InterpreterOpcode::F32Trunc: + case Opcode::F32Trunc: UNOP_FLOAT(F32, truncf); break; - case InterpreterOpcode::F32Nearest: + case Opcode::F32Nearest: UNOP_FLOAT(F32, nearbyintf); break; - case InterpreterOpcode::F32Sqrt: + case Opcode::F32Sqrt: UNOP_FLOAT(F32, sqrtf); break; - case InterpreterOpcode::F32Eq: + case Opcode::F32Eq: BINOP_FLOAT_COMPARE(F32, ==); break; - case InterpreterOpcode::F32Ne: + case Opcode::F32Ne: BINOP_FLOAT_COMPARE(F32, !=); break; - case InterpreterOpcode::F32Lt: + case Opcode::F32Lt: BINOP_FLOAT_COMPARE(F32, <); break; - case InterpreterOpcode::F32Le: + case Opcode::F32Le: BINOP_FLOAT_COMPARE(F32, <=); break; - case InterpreterOpcode::F32Gt: + case Opcode::F32Gt: BINOP_FLOAT_COMPARE(F32, >); break; - case InterpreterOpcode::F32Ge: + case Opcode::F32Ge: BINOP_FLOAT_COMPARE(F32, >=); break; - case InterpreterOpcode::F64Add: + case Opcode::F64Add: BINOP_FLOAT(F64, +); break; - case InterpreterOpcode::F64Sub: + case Opcode::F64Sub: BINOP_FLOAT(F64, -); break; - case InterpreterOpcode::F64Mul: + case Opcode::F64Mul: BINOP_FLOAT(F64, *); break; - case InterpreterOpcode::F64Div: + case Opcode::F64Div: BINOP_FLOAT_DIV(F64); break; - case InterpreterOpcode::F64Min: + case Opcode::F64Min: MINMAX_FLOAT(F64, MIN); break; - case InterpreterOpcode::F64Max: + case Opcode::F64Max: MINMAX_FLOAT(F64, MAX); break; - case InterpreterOpcode::F64Abs: + case Opcode::F64Abs: TOP().f64_bits &= ~F64_SIGN_MASK; break; - case InterpreterOpcode::F64Neg: + case Opcode::F64Neg: TOP().f64_bits ^= F64_SIGN_MASK; break; - case InterpreterOpcode::F64Copysign: { + case Opcode::F64Copysign: { VALUE_TYPE_F64 rhs = POP_F64(); VALUE_TYPE_F64 lhs = POP_F64(); PUSH_F64((lhs & ~F64_SIGN_MASK) | (rhs & F64_SIGN_MASK)); break; } - case InterpreterOpcode::F64Ceil: + case Opcode::F64Ceil: UNOP_FLOAT(F64, ceil); break; - case InterpreterOpcode::F64Floor: + case Opcode::F64Floor: UNOP_FLOAT(F64, floor); break; - case InterpreterOpcode::F64Trunc: + case Opcode::F64Trunc: UNOP_FLOAT(F64, trunc); break; - case InterpreterOpcode::F64Nearest: + case Opcode::F64Nearest: UNOP_FLOAT(F64, nearbyint); break; - case InterpreterOpcode::F64Sqrt: + case Opcode::F64Sqrt: UNOP_FLOAT(F64, sqrt); break; - case InterpreterOpcode::F64Eq: + case Opcode::F64Eq: BINOP_FLOAT_COMPARE(F64, ==); break; - case InterpreterOpcode::F64Ne: + case Opcode::F64Ne: BINOP_FLOAT_COMPARE(F64, !=); break; - case InterpreterOpcode::F64Lt: + case Opcode::F64Lt: BINOP_FLOAT_COMPARE(F64, <); break; - case InterpreterOpcode::F64Le: + case Opcode::F64Le: BINOP_FLOAT_COMPARE(F64, <=); break; - case InterpreterOpcode::F64Gt: + case Opcode::F64Gt: BINOP_FLOAT_COMPARE(F64, >); break; - case InterpreterOpcode::F64Ge: + case Opcode::F64Ge: BINOP_FLOAT_COMPARE(F64, >=); break; - case InterpreterOpcode::I32TruncSF32: { + case Opcode::I32TruncSF32: { VALUE_TYPE_F32 value = POP_F32(); TRAP_IF(is_nan_f32(value), InvalidConversionToInteger); TRAP_UNLESS(is_in_range_i32_trunc_s_f32(value), IntegerOverflow); @@ -1445,7 +1431,7 @@ InterpreterResult run_interpreter(InterpreterThread* thread, break; } - case InterpreterOpcode::I32TruncSF64: { + case Opcode::I32TruncSF64: { VALUE_TYPE_F64 value = POP_F64(); TRAP_IF(is_nan_f64(value), InvalidConversionToInteger); TRAP_UNLESS(is_in_range_i32_trunc_s_f64(value), IntegerOverflow); @@ -1453,7 +1439,7 @@ InterpreterResult run_interpreter(InterpreterThread* thread, break; } - case InterpreterOpcode::I32TruncUF32: { + case Opcode::I32TruncUF32: { VALUE_TYPE_F32 value = POP_F32(); TRAP_IF(is_nan_f32(value), InvalidConversionToInteger); TRAP_UNLESS(is_in_range_i32_trunc_u_f32(value), IntegerOverflow); @@ -1461,7 +1447,7 @@ InterpreterResult run_interpreter(InterpreterThread* thread, break; } - case InterpreterOpcode::I32TruncUF64: { + case Opcode::I32TruncUF64: { VALUE_TYPE_F64 value = POP_F64(); TRAP_IF(is_nan_f64(value), InvalidConversionToInteger); TRAP_UNLESS(is_in_range_i32_trunc_u_f64(value), IntegerOverflow); @@ -1469,13 +1455,13 @@ InterpreterResult run_interpreter(InterpreterThread* thread, break; } - case InterpreterOpcode::I32WrapI64: { + case Opcode::I32WrapI64: { VALUE_TYPE_I64 value = POP_I64(); PUSH_I32(static_cast<uint32_t>(value)); break; } - case InterpreterOpcode::I64TruncSF32: { + case Opcode::I64TruncSF32: { VALUE_TYPE_F32 value = POP_F32(); TRAP_IF(is_nan_f32(value), InvalidConversionToInteger); TRAP_UNLESS(is_in_range_i64_trunc_s_f32(value), IntegerOverflow); @@ -1483,7 +1469,7 @@ InterpreterResult run_interpreter(InterpreterThread* thread, break; } - case InterpreterOpcode::I64TruncSF64: { + case Opcode::I64TruncSF64: { VALUE_TYPE_F64 value = POP_F64(); TRAP_IF(is_nan_f64(value), InvalidConversionToInteger); TRAP_UNLESS(is_in_range_i64_trunc_s_f64(value), IntegerOverflow); @@ -1491,7 +1477,7 @@ InterpreterResult run_interpreter(InterpreterThread* thread, break; } - case InterpreterOpcode::I64TruncUF32: { + case Opcode::I64TruncUF32: { VALUE_TYPE_F32 value = POP_F32(); TRAP_IF(is_nan_f32(value), InvalidConversionToInteger); TRAP_UNLESS(is_in_range_i64_trunc_u_f32(value), IntegerOverflow); @@ -1499,7 +1485,7 @@ InterpreterResult run_interpreter(InterpreterThread* thread, break; } - case InterpreterOpcode::I64TruncUF64: { + case Opcode::I64TruncUF64: { VALUE_TYPE_F64 value = POP_F64(); TRAP_IF(is_nan_f64(value), InvalidConversionToInteger); TRAP_UNLESS(is_in_range_i64_trunc_u_f64(value), IntegerOverflow); @@ -1507,45 +1493,45 @@ InterpreterResult run_interpreter(InterpreterThread* thread, break; } - case InterpreterOpcode::I64ExtendSI32: { + case Opcode::I64ExtendSI32: { VALUE_TYPE_I32 value = POP_I32(); PUSH_I64(static_cast<int64_t>(BITCAST_I32_TO_SIGNED(value))); break; } - case InterpreterOpcode::I64ExtendUI32: { + case Opcode::I64ExtendUI32: { VALUE_TYPE_I32 value = POP_I32(); PUSH_I64(static_cast<uint64_t>(value)); break; } - case InterpreterOpcode::F32ConvertSI32: { + case Opcode::F32ConvertSI32: { VALUE_TYPE_I32 value = POP_I32(); PUSH_F32( BITCAST_FROM_F32(static_cast<float>(BITCAST_I32_TO_SIGNED(value)))); break; } - case InterpreterOpcode::F32ConvertUI32: { + case Opcode::F32ConvertUI32: { VALUE_TYPE_I32 value = POP_I32(); PUSH_F32(BITCAST_FROM_F32(static_cast<float>(value))); break; } - case InterpreterOpcode::F32ConvertSI64: { + case Opcode::F32ConvertSI64: { VALUE_TYPE_I64 value = POP_I64(); PUSH_F32( BITCAST_FROM_F32(static_cast<float>(BITCAST_I64_TO_SIGNED(value)))); break; } - case InterpreterOpcode::F32ConvertUI64: { + case Opcode::F32ConvertUI64: { VALUE_TYPE_I64 value = POP_I64(); PUSH_F32(BITCAST_FROM_F32(wabt_convert_uint64_to_float(value))); break; } - case InterpreterOpcode::F32DemoteF64: { + case Opcode::F32DemoteF64: { VALUE_TYPE_F64 value = POP_F64(); if (WABT_LIKELY(is_in_range_f64_demote_f32(value))) { PUSH_F32(BITCAST_FROM_F32(static_cast<float>(BITCAST_TO_F64(value)))); @@ -1565,118 +1551,117 @@ InterpreterResult run_interpreter(InterpreterThread* thread, break; } - case InterpreterOpcode::F32ReinterpretI32: { + case Opcode::F32ReinterpretI32: { VALUE_TYPE_I32 value = POP_I32(); PUSH_F32(value); break; } - case InterpreterOpcode::F64ConvertSI32: { + case Opcode::F64ConvertSI32: { VALUE_TYPE_I32 value = POP_I32(); PUSH_F64(BITCAST_FROM_F64( static_cast<double>(BITCAST_I32_TO_SIGNED(value)))); break; } - case InterpreterOpcode::F64ConvertUI32: { + case Opcode::F64ConvertUI32: { VALUE_TYPE_I32 value = POP_I32(); PUSH_F64(BITCAST_FROM_F64(static_cast<double>(value))); break; } - case InterpreterOpcode::F64ConvertSI64: { + case Opcode::F64ConvertSI64: { VALUE_TYPE_I64 value = POP_I64(); PUSH_F64(BITCAST_FROM_F64( static_cast<double>(BITCAST_I64_TO_SIGNED(value)))); break; } - case InterpreterOpcode::F64ConvertUI64: { + case Opcode::F64ConvertUI64: { VALUE_TYPE_I64 value = POP_I64(); PUSH_F64(BITCAST_FROM_F64(wabt_convert_uint64_to_double(value))); break; } - case InterpreterOpcode::F64PromoteF32: { + case Opcode::F64PromoteF32: { VALUE_TYPE_F32 value = POP_F32(); PUSH_F64(BITCAST_FROM_F64(static_cast<double>(BITCAST_TO_F32(value)))); break; } - case InterpreterOpcode::F64ReinterpretI64: { + case Opcode::F64ReinterpretI64: { VALUE_TYPE_I64 value = POP_I64(); PUSH_F64(value); break; } - case InterpreterOpcode::I32ReinterpretF32: { + case Opcode::I32ReinterpretF32: { VALUE_TYPE_F32 value = POP_F32(); PUSH_I32(value); break; } - case InterpreterOpcode::I64ReinterpretF64: { + case Opcode::I64ReinterpretF64: { VALUE_TYPE_F64 value = POP_F64(); PUSH_I64(value); break; } - case InterpreterOpcode::I32Rotr: + case Opcode::I32Rotr: BINOP_ROT(I32, RIGHT); break; - case InterpreterOpcode::I32Rotl: + case Opcode::I32Rotl: BINOP_ROT(I32, LEFT); break; - case InterpreterOpcode::I64Rotr: + case Opcode::I64Rotr: BINOP_ROT(I64, RIGHT); break; - case InterpreterOpcode::I64Rotl: + case Opcode::I64Rotl: BINOP_ROT(I64, LEFT); break; - case InterpreterOpcode::I64Eqz: { + case Opcode::I64Eqz: { VALUE_TYPE_I64 value = POP_I64(); PUSH_I64(value == 0); break; } - case InterpreterOpcode::Alloca: { - InterpreterValue* old_value_stack_top = thread->value_stack_top; + case Opcode::Alloca: { + Value* old_value_stack_top = thread->value_stack_top; thread->value_stack_top += read_u32(&pc); CHECK_STACK(); memset(old_value_stack_top, 0, - (thread->value_stack_top - old_value_stack_top) * - sizeof(InterpreterValue)); + (thread->value_stack_top - old_value_stack_top) * sizeof(Value)); break; } - case InterpreterOpcode::BrUnless: { + case Opcode::BrUnless: { IstreamOffset new_pc = read_u32(&pc); if (!POP_I32()) GOTO(new_pc); break; } - case InterpreterOpcode::Drop: + case Opcode::Drop: (void)POP(); break; - case InterpreterOpcode::DropKeep: { + case Opcode::DropKeep: { uint32_t drop_count = read_u32(&pc); uint8_t keep_count = *pc++; DROP_KEEP(drop_count, keep_count); break; } - case InterpreterOpcode::Data: + case Opcode::Data: /* shouldn't ever execute this */ assert(0); break; - case InterpreterOpcode::Nop: + case Opcode::Nop: break; default: @@ -1690,7 +1675,7 @@ exit_loop: return result; } -void trace_pc(InterpreterThread* thread, Stream* stream) { +void trace_pc(Thread* thread, Stream* stream) { const uint8_t* istream = thread->env->istream->data.data(); const uint8_t* pc = &istream[thread->pc]; size_t value_stack_depth = @@ -1700,352 +1685,337 @@ void trace_pc(InterpreterThread* thread, Stream* stream) { stream->Writef("#%" PRIzd ". %4" PRIzd ": V:%-3" PRIzd "| ", call_stack_depth, pc - thread->env->istream->data.data(), value_stack_depth); - InterpreterOpcode opcode = static_cast<InterpreterOpcode>(*pc++); + Opcode opcode = static_cast<Opcode>(*pc++); switch (opcode) { - case InterpreterOpcode::Select: + case Opcode::Select: stream->Writef("%s %u, %" PRIu64 ", %" PRIu64 "\n", - get_interpreter_opcode_name(opcode), PICK(3).i32, - PICK(2).i64, PICK(1).i64); + get_opcode_name(opcode), PICK(3).i32, PICK(2).i64, + PICK(1).i64); break; - case InterpreterOpcode::Br: - stream->Writef("%s @%u\n", get_interpreter_opcode_name(opcode), - read_u32_at(pc)); + case Opcode::Br: + stream->Writef("%s @%u\n", get_opcode_name(opcode), read_u32_at(pc)); break; - case InterpreterOpcode::BrIf: - stream->Writef("%s @%u, %u\n", get_interpreter_opcode_name(opcode), - read_u32_at(pc), TOP().i32); + case Opcode::BrIf: + stream->Writef("%s @%u, %u\n", get_opcode_name(opcode), read_u32_at(pc), + TOP().i32); break; - case InterpreterOpcode::BrTable: { + case Opcode::BrTable: { Index num_targets = read_u32_at(pc); IstreamOffset table_offset = read_u32_at(pc + 4); VALUE_TYPE_I32 key = TOP().i32; stream->Writef("%s %u, $#%" PRIindex ", table:$%u\n", - get_interpreter_opcode_name(opcode), key, num_targets, - table_offset); + get_opcode_name(opcode), key, num_targets, table_offset); break; } - case InterpreterOpcode::Nop: - case InterpreterOpcode::Return: - case InterpreterOpcode::Unreachable: - case InterpreterOpcode::Drop: - stream->Writef("%s\n", get_interpreter_opcode_name(opcode)); + case Opcode::Nop: + case Opcode::Return: + case Opcode::Unreachable: + case Opcode::Drop: + stream->Writef("%s\n", get_opcode_name(opcode)); break; - case InterpreterOpcode::CurrentMemory: { + case Opcode::CurrentMemory: { Index memory_index = read_u32(&pc); - stream->Writef("%s $%" PRIindex "\n", get_interpreter_opcode_name(opcode), + stream->Writef("%s $%" PRIindex "\n", get_opcode_name(opcode), memory_index); break; } - case InterpreterOpcode::I32Const: - stream->Writef("%s $%u\n", get_interpreter_opcode_name(opcode), - read_u32_at(pc)); + case Opcode::I32Const: + stream->Writef("%s $%u\n", get_opcode_name(opcode), read_u32_at(pc)); break; - case InterpreterOpcode::I64Const: - stream->Writef("%s $%" PRIu64 "\n", get_interpreter_opcode_name(opcode), + case Opcode::I64Const: + stream->Writef("%s $%" PRIu64 "\n", get_opcode_name(opcode), read_u64_at(pc)); break; - case InterpreterOpcode::F32Const: - stream->Writef("%s $%g\n", get_interpreter_opcode_name(opcode), + case Opcode::F32Const: + stream->Writef("%s $%g\n", get_opcode_name(opcode), bitcast_u32_to_f32(read_u32_at(pc))); break; - case InterpreterOpcode::F64Const: - stream->Writef("%s $%g\n", get_interpreter_opcode_name(opcode), + case Opcode::F64Const: + stream->Writef("%s $%g\n", get_opcode_name(opcode), bitcast_u64_to_f64(read_u64_at(pc))); break; - case InterpreterOpcode::GetLocal: - case InterpreterOpcode::GetGlobal: - stream->Writef("%s $%u\n", get_interpreter_opcode_name(opcode), - read_u32_at(pc)); + case Opcode::GetLocal: + case Opcode::GetGlobal: + stream->Writef("%s $%u\n", get_opcode_name(opcode), read_u32_at(pc)); break; - case InterpreterOpcode::SetLocal: - case InterpreterOpcode::SetGlobal: - case InterpreterOpcode::TeeLocal: - stream->Writef("%s $%u, %u\n", get_interpreter_opcode_name(opcode), - read_u32_at(pc), TOP().i32); + case Opcode::SetLocal: + case Opcode::SetGlobal: + case Opcode::TeeLocal: + stream->Writef("%s $%u, %u\n", get_opcode_name(opcode), read_u32_at(pc), + TOP().i32); break; - case InterpreterOpcode::Call: - stream->Writef("%s @%u\n", get_interpreter_opcode_name(opcode), - read_u32_at(pc)); + case Opcode::Call: + stream->Writef("%s @%u\n", get_opcode_name(opcode), read_u32_at(pc)); break; - case InterpreterOpcode::CallIndirect: - stream->Writef("%s $%u, %u\n", get_interpreter_opcode_name(opcode), - read_u32_at(pc), TOP().i32); + case Opcode::CallIndirect: + stream->Writef("%s $%u, %u\n", get_opcode_name(opcode), read_u32_at(pc), + TOP().i32); break; - case InterpreterOpcode::CallHost: - stream->Writef("%s $%u\n", get_interpreter_opcode_name(opcode), - read_u32_at(pc)); + case Opcode::CallHost: + stream->Writef("%s $%u\n", get_opcode_name(opcode), read_u32_at(pc)); break; - case InterpreterOpcode::I32Load8S: - case InterpreterOpcode::I32Load8U: - case InterpreterOpcode::I32Load16S: - case InterpreterOpcode::I32Load16U: - case InterpreterOpcode::I64Load8S: - case InterpreterOpcode::I64Load8U: - case InterpreterOpcode::I64Load16S: - case InterpreterOpcode::I64Load16U: - case InterpreterOpcode::I64Load32S: - case InterpreterOpcode::I64Load32U: - case InterpreterOpcode::I32Load: - case InterpreterOpcode::I64Load: - case InterpreterOpcode::F32Load: - case InterpreterOpcode::F64Load: { + case Opcode::I32Load8S: + case Opcode::I32Load8U: + case Opcode::I32Load16S: + case Opcode::I32Load16U: + case Opcode::I64Load8S: + case Opcode::I64Load8U: + case Opcode::I64Load16S: + case Opcode::I64Load16U: + case Opcode::I64Load32S: + case Opcode::I64Load32U: + case Opcode::I32Load: + case Opcode::I64Load: + case Opcode::F32Load: + case Opcode::F64Load: { Index memory_index = read_u32(&pc); - stream->Writef("%s $%" PRIindex ":%u+$%u\n", - get_interpreter_opcode_name(opcode), memory_index, - TOP().i32, read_u32_at(pc)); + stream->Writef("%s $%" PRIindex ":%u+$%u\n", get_opcode_name(opcode), + memory_index, TOP().i32, read_u32_at(pc)); break; } - case InterpreterOpcode::I32Store8: - case InterpreterOpcode::I32Store16: - case InterpreterOpcode::I32Store: { + case Opcode::I32Store8: + case Opcode::I32Store16: + case Opcode::I32Store: { Index memory_index = read_u32(&pc); - stream->Writef("%s $%" PRIindex ":%u+$%u, %u\n", - get_interpreter_opcode_name(opcode), memory_index, - PICK(2).i32, read_u32_at(pc), PICK(1).i32); + stream->Writef("%s $%" PRIindex ":%u+$%u, %u\n", get_opcode_name(opcode), + memory_index, PICK(2).i32, read_u32_at(pc), PICK(1).i32); break; } - case InterpreterOpcode::I64Store8: - case InterpreterOpcode::I64Store16: - case InterpreterOpcode::I64Store32: - case InterpreterOpcode::I64Store: { + case Opcode::I64Store8: + case Opcode::I64Store16: + case Opcode::I64Store32: + case Opcode::I64Store: { Index memory_index = read_u32(&pc); stream->Writef("%s $%" PRIindex ":%u+$%u, %" PRIu64 "\n", - get_interpreter_opcode_name(opcode), memory_index, - PICK(2).i32, read_u32_at(pc), PICK(1).i64); + get_opcode_name(opcode), memory_index, PICK(2).i32, + read_u32_at(pc), PICK(1).i64); break; } - case InterpreterOpcode::F32Store: { + case Opcode::F32Store: { Index memory_index = read_u32(&pc); - stream->Writef("%s $%" PRIindex ":%u+$%u, %g\n", - get_interpreter_opcode_name(opcode), memory_index, - PICK(2).i32, read_u32_at(pc), + stream->Writef("%s $%" PRIindex ":%u+$%u, %g\n", get_opcode_name(opcode), + memory_index, PICK(2).i32, read_u32_at(pc), bitcast_u32_to_f32(PICK(1).f32_bits)); break; } - case InterpreterOpcode::F64Store: { + case Opcode::F64Store: { Index memory_index = read_u32(&pc); - stream->Writef("%s $%" PRIindex ":%u+$%u, %g\n", - get_interpreter_opcode_name(opcode), memory_index, - PICK(2).i32, read_u32_at(pc), + stream->Writef("%s $%" PRIindex ":%u+$%u, %g\n", get_opcode_name(opcode), + memory_index, PICK(2).i32, read_u32_at(pc), bitcast_u64_to_f64(PICK(1).f64_bits)); break; } - case InterpreterOpcode::GrowMemory: { + case Opcode::GrowMemory: { Index memory_index = read_u32(&pc); - stream->Writef("%s $%" PRIindex ":%u\n", - get_interpreter_opcode_name(opcode), memory_index, - TOP().i32); + stream->Writef("%s $%" PRIindex ":%u\n", get_opcode_name(opcode), + memory_index, TOP().i32); break; } - case InterpreterOpcode::I32Add: - case InterpreterOpcode::I32Sub: - case InterpreterOpcode::I32Mul: - case InterpreterOpcode::I32DivS: - case InterpreterOpcode::I32DivU: - case InterpreterOpcode::I32RemS: - case InterpreterOpcode::I32RemU: - case InterpreterOpcode::I32And: - case InterpreterOpcode::I32Or: - case InterpreterOpcode::I32Xor: - case InterpreterOpcode::I32Shl: - case InterpreterOpcode::I32ShrU: - case InterpreterOpcode::I32ShrS: - case InterpreterOpcode::I32Eq: - case InterpreterOpcode::I32Ne: - case InterpreterOpcode::I32LtS: - case InterpreterOpcode::I32LeS: - case InterpreterOpcode::I32LtU: - case InterpreterOpcode::I32LeU: - case InterpreterOpcode::I32GtS: - case InterpreterOpcode::I32GeS: - case InterpreterOpcode::I32GtU: - case InterpreterOpcode::I32GeU: - case InterpreterOpcode::I32Rotr: - case InterpreterOpcode::I32Rotl: - stream->Writef("%s %u, %u\n", get_interpreter_opcode_name(opcode), - PICK(2).i32, PICK(1).i32); + case Opcode::I32Add: + case Opcode::I32Sub: + case Opcode::I32Mul: + case Opcode::I32DivS: + case Opcode::I32DivU: + case Opcode::I32RemS: + case Opcode::I32RemU: + case Opcode::I32And: + case Opcode::I32Or: + case Opcode::I32Xor: + case Opcode::I32Shl: + case Opcode::I32ShrU: + case Opcode::I32ShrS: + case Opcode::I32Eq: + case Opcode::I32Ne: + case Opcode::I32LtS: + case Opcode::I32LeS: + case Opcode::I32LtU: + case Opcode::I32LeU: + case Opcode::I32GtS: + case Opcode::I32GeS: + case Opcode::I32GtU: + case Opcode::I32GeU: + case Opcode::I32Rotr: + case Opcode::I32Rotl: + stream->Writef("%s %u, %u\n", get_opcode_name(opcode), PICK(2).i32, + PICK(1).i32); break; - case InterpreterOpcode::I32Clz: - case InterpreterOpcode::I32Ctz: - case InterpreterOpcode::I32Popcnt: - case InterpreterOpcode::I32Eqz: - stream->Writef("%s %u\n", get_interpreter_opcode_name(opcode), TOP().i32); + case Opcode::I32Clz: + case Opcode::I32Ctz: + case Opcode::I32Popcnt: + case Opcode::I32Eqz: + stream->Writef("%s %u\n", get_opcode_name(opcode), TOP().i32); break; - case InterpreterOpcode::I64Add: - case InterpreterOpcode::I64Sub: - case InterpreterOpcode::I64Mul: - case InterpreterOpcode::I64DivS: - case InterpreterOpcode::I64DivU: - case InterpreterOpcode::I64RemS: - case InterpreterOpcode::I64RemU: - case InterpreterOpcode::I64And: - case InterpreterOpcode::I64Or: - case InterpreterOpcode::I64Xor: - case InterpreterOpcode::I64Shl: - case InterpreterOpcode::I64ShrU: - case InterpreterOpcode::I64ShrS: - case InterpreterOpcode::I64Eq: - case InterpreterOpcode::I64Ne: - case InterpreterOpcode::I64LtS: - case InterpreterOpcode::I64LeS: - case InterpreterOpcode::I64LtU: - case InterpreterOpcode::I64LeU: - case InterpreterOpcode::I64GtS: - case InterpreterOpcode::I64GeS: - case InterpreterOpcode::I64GtU: - case InterpreterOpcode::I64GeU: - case InterpreterOpcode::I64Rotr: - case InterpreterOpcode::I64Rotl: - stream->Writef("%s %" PRIu64 ", %" PRIu64 "\n", - get_interpreter_opcode_name(opcode), PICK(2).i64, - PICK(1).i64); + case Opcode::I64Add: + case Opcode::I64Sub: + case Opcode::I64Mul: + case Opcode::I64DivS: + case Opcode::I64DivU: + case Opcode::I64RemS: + case Opcode::I64RemU: + case Opcode::I64And: + case Opcode::I64Or: + case Opcode::I64Xor: + case Opcode::I64Shl: + case Opcode::I64ShrU: + case Opcode::I64ShrS: + case Opcode::I64Eq: + case Opcode::I64Ne: + case Opcode::I64LtS: + case Opcode::I64LeS: + case Opcode::I64LtU: + case Opcode::I64LeU: + case Opcode::I64GtS: + case Opcode::I64GeS: + case Opcode::I64GtU: + case Opcode::I64GeU: + case Opcode::I64Rotr: + case Opcode::I64Rotl: + stream->Writef("%s %" PRIu64 ", %" PRIu64 "\n", get_opcode_name(opcode), + PICK(2).i64, PICK(1).i64); break; - case InterpreterOpcode::I64Clz: - case InterpreterOpcode::I64Ctz: - case InterpreterOpcode::I64Popcnt: - case InterpreterOpcode::I64Eqz: - stream->Writef("%s %" PRIu64 "\n", get_interpreter_opcode_name(opcode), - TOP().i64); + case Opcode::I64Clz: + case Opcode::I64Ctz: + case Opcode::I64Popcnt: + case Opcode::I64Eqz: + stream->Writef("%s %" PRIu64 "\n", get_opcode_name(opcode), TOP().i64); break; - case InterpreterOpcode::F32Add: - case InterpreterOpcode::F32Sub: - case InterpreterOpcode::F32Mul: - case InterpreterOpcode::F32Div: - case InterpreterOpcode::F32Min: - case InterpreterOpcode::F32Max: - case InterpreterOpcode::F32Copysign: - case InterpreterOpcode::F32Eq: - case InterpreterOpcode::F32Ne: - case InterpreterOpcode::F32Lt: - case InterpreterOpcode::F32Le: - case InterpreterOpcode::F32Gt: - case InterpreterOpcode::F32Ge: - stream->Writef("%s %g, %g\n", get_interpreter_opcode_name(opcode), + case Opcode::F32Add: + case Opcode::F32Sub: + case Opcode::F32Mul: + case Opcode::F32Div: + case Opcode::F32Min: + case Opcode::F32Max: + case Opcode::F32Copysign: + case Opcode::F32Eq: + case Opcode::F32Ne: + case Opcode::F32Lt: + case Opcode::F32Le: + case Opcode::F32Gt: + case Opcode::F32Ge: + stream->Writef("%s %g, %g\n", get_opcode_name(opcode), bitcast_u32_to_f32(PICK(2).i32), bitcast_u32_to_f32(PICK(1).i32)); break; - case InterpreterOpcode::F32Abs: - case InterpreterOpcode::F32Neg: - case InterpreterOpcode::F32Ceil: - case InterpreterOpcode::F32Floor: - case InterpreterOpcode::F32Trunc: - case InterpreterOpcode::F32Nearest: - case InterpreterOpcode::F32Sqrt: - stream->Writef("%s %g\n", get_interpreter_opcode_name(opcode), + case Opcode::F32Abs: + case Opcode::F32Neg: + case Opcode::F32Ceil: + case Opcode::F32Floor: + case Opcode::F32Trunc: + case Opcode::F32Nearest: + case Opcode::F32Sqrt: + stream->Writef("%s %g\n", get_opcode_name(opcode), bitcast_u32_to_f32(TOP().i32)); break; - case InterpreterOpcode::F64Add: - case InterpreterOpcode::F64Sub: - case InterpreterOpcode::F64Mul: - case InterpreterOpcode::F64Div: - case InterpreterOpcode::F64Min: - case InterpreterOpcode::F64Max: - case InterpreterOpcode::F64Copysign: - case InterpreterOpcode::F64Eq: - case InterpreterOpcode::F64Ne: - case InterpreterOpcode::F64Lt: - case InterpreterOpcode::F64Le: - case InterpreterOpcode::F64Gt: - case InterpreterOpcode::F64Ge: - stream->Writef("%s %g, %g\n", get_interpreter_opcode_name(opcode), + case Opcode::F64Add: + case Opcode::F64Sub: + case Opcode::F64Mul: + case Opcode::F64Div: + case Opcode::F64Min: + case Opcode::F64Max: + case Opcode::F64Copysign: + case Opcode::F64Eq: + case Opcode::F64Ne: + case Opcode::F64Lt: + case Opcode::F64Le: + case Opcode::F64Gt: + case Opcode::F64Ge: + stream->Writef("%s %g, %g\n", get_opcode_name(opcode), bitcast_u64_to_f64(PICK(2).i64), bitcast_u64_to_f64(PICK(1).i64)); break; - case InterpreterOpcode::F64Abs: - case InterpreterOpcode::F64Neg: - case InterpreterOpcode::F64Ceil: - case InterpreterOpcode::F64Floor: - case InterpreterOpcode::F64Trunc: - case InterpreterOpcode::F64Nearest: - case InterpreterOpcode::F64Sqrt: - stream->Writef("%s %g\n", get_interpreter_opcode_name(opcode), + case Opcode::F64Abs: + case Opcode::F64Neg: + case Opcode::F64Ceil: + case Opcode::F64Floor: + case Opcode::F64Trunc: + case Opcode::F64Nearest: + case Opcode::F64Sqrt: + stream->Writef("%s %g\n", get_opcode_name(opcode), bitcast_u64_to_f64(TOP().i64)); break; - case InterpreterOpcode::I32TruncSF32: - case InterpreterOpcode::I32TruncUF32: - case InterpreterOpcode::I64TruncSF32: - case InterpreterOpcode::I64TruncUF32: - case InterpreterOpcode::F64PromoteF32: - case InterpreterOpcode::I32ReinterpretF32: - stream->Writef("%s %g\n", get_interpreter_opcode_name(opcode), + case Opcode::I32TruncSF32: + case Opcode::I32TruncUF32: + case Opcode::I64TruncSF32: + case Opcode::I64TruncUF32: + case Opcode::F64PromoteF32: + case Opcode::I32ReinterpretF32: + stream->Writef("%s %g\n", get_opcode_name(opcode), bitcast_u32_to_f32(TOP().i32)); break; - case InterpreterOpcode::I32TruncSF64: - case InterpreterOpcode::I32TruncUF64: - case InterpreterOpcode::I64TruncSF64: - case InterpreterOpcode::I64TruncUF64: - case InterpreterOpcode::F32DemoteF64: - case InterpreterOpcode::I64ReinterpretF64: - stream->Writef("%s %g\n", get_interpreter_opcode_name(opcode), + case Opcode::I32TruncSF64: + case Opcode::I32TruncUF64: + case Opcode::I64TruncSF64: + case Opcode::I64TruncUF64: + case Opcode::F32DemoteF64: + case Opcode::I64ReinterpretF64: + stream->Writef("%s %g\n", get_opcode_name(opcode), bitcast_u64_to_f64(TOP().i64)); break; - case InterpreterOpcode::I32WrapI64: - case InterpreterOpcode::F32ConvertSI64: - case InterpreterOpcode::F32ConvertUI64: - case InterpreterOpcode::F64ConvertSI64: - case InterpreterOpcode::F64ConvertUI64: - case InterpreterOpcode::F64ReinterpretI64: - stream->Writef("%s %" PRIu64 "\n", get_interpreter_opcode_name(opcode), - TOP().i64); + case Opcode::I32WrapI64: + case Opcode::F32ConvertSI64: + case Opcode::F32ConvertUI64: + case Opcode::F64ConvertSI64: + case Opcode::F64ConvertUI64: + case Opcode::F64ReinterpretI64: + stream->Writef("%s %" PRIu64 "\n", get_opcode_name(opcode), TOP().i64); break; - case InterpreterOpcode::I64ExtendSI32: - case InterpreterOpcode::I64ExtendUI32: - case InterpreterOpcode::F32ConvertSI32: - case InterpreterOpcode::F32ConvertUI32: - case InterpreterOpcode::F32ReinterpretI32: - case InterpreterOpcode::F64ConvertSI32: - case InterpreterOpcode::F64ConvertUI32: - stream->Writef("%s %u\n", get_interpreter_opcode_name(opcode), TOP().i32); + case Opcode::I64ExtendSI32: + case Opcode::I64ExtendUI32: + case Opcode::F32ConvertSI32: + case Opcode::F32ConvertUI32: + case Opcode::F32ReinterpretI32: + case Opcode::F64ConvertSI32: + case Opcode::F64ConvertUI32: + stream->Writef("%s %u\n", get_opcode_name(opcode), TOP().i32); break; - case InterpreterOpcode::Alloca: - stream->Writef("%s $%u\n", get_interpreter_opcode_name(opcode), - read_u32_at(pc)); + case Opcode::Alloca: + stream->Writef("%s $%u\n", get_opcode_name(opcode), read_u32_at(pc)); break; - case InterpreterOpcode::BrUnless: - stream->Writef("%s @%u, %u\n", get_interpreter_opcode_name(opcode), - read_u32_at(pc), TOP().i32); + case Opcode::BrUnless: + stream->Writef("%s @%u, %u\n", get_opcode_name(opcode), read_u32_at(pc), + TOP().i32); break; - case InterpreterOpcode::DropKeep: - stream->Writef("%s $%u $%u\n", get_interpreter_opcode_name(opcode), - read_u32_at(pc), *(pc + 4)); + case Opcode::DropKeep: + stream->Writef("%s $%u $%u\n", get_opcode_name(opcode), read_u32_at(pc), + *(pc + 4)); break; - case InterpreterOpcode::Data: + case Opcode::Data: /* shouldn't ever execute this */ assert(0); break; @@ -2056,7 +2026,7 @@ void trace_pc(InterpreterThread* thread, Stream* stream) { } } -void disassemble(InterpreterEnvironment* env, +void disassemble(Environment* env, Stream* stream, IstreamOffset from, IstreamOffset to) { @@ -2071,293 +2041,279 @@ void disassemble(InterpreterEnvironment* env, while (static_cast<IstreamOffset>(pc - istream) < to) { stream->Writef("%4" PRIzd "| ", pc - istream); - InterpreterOpcode opcode = static_cast<InterpreterOpcode>(*pc++); + Opcode opcode = static_cast<Opcode>(*pc++); switch (opcode) { - case InterpreterOpcode::Select: - stream->Writef("%s %%[-3], %%[-2], %%[-1]\n", - get_interpreter_opcode_name(opcode)); + case Opcode::Select: + stream->Writef("%s %%[-3], %%[-2], %%[-1]\n", get_opcode_name(opcode)); break; - case InterpreterOpcode::Br: - stream->Writef("%s @%u\n", get_interpreter_opcode_name(opcode), - read_u32(&pc)); + case Opcode::Br: + stream->Writef("%s @%u\n", get_opcode_name(opcode), read_u32(&pc)); break; - case InterpreterOpcode::BrIf: - stream->Writef("%s @%u, %%[-1]\n", get_interpreter_opcode_name(opcode), + case Opcode::BrIf: + stream->Writef("%s @%u, %%[-1]\n", get_opcode_name(opcode), read_u32(&pc)); break; - case InterpreterOpcode::BrTable: { + case Opcode::BrTable: { Index num_targets = read_u32(&pc); IstreamOffset table_offset = read_u32(&pc); stream->Writef("%s %%[-1], $#%" PRIindex ", table:$%u\n", - get_interpreter_opcode_name(opcode), num_targets, - table_offset); + get_opcode_name(opcode), num_targets, table_offset); break; } - case InterpreterOpcode::Nop: - case InterpreterOpcode::Return: - case InterpreterOpcode::Unreachable: - case InterpreterOpcode::Drop: - stream->Writef("%s\n", get_interpreter_opcode_name(opcode)); + case Opcode::Nop: + case Opcode::Return: + case Opcode::Unreachable: + case Opcode::Drop: + stream->Writef("%s\n", get_opcode_name(opcode)); break; - case InterpreterOpcode::CurrentMemory: { + case Opcode::CurrentMemory: { Index memory_index = read_u32(&pc); - stream->Writef("%s $%" PRIindex "\n", - get_interpreter_opcode_name(opcode), memory_index); + stream->Writef("%s $%" PRIindex "\n", get_opcode_name(opcode), + memory_index); break; } - case InterpreterOpcode::I32Const: - stream->Writef("%s $%u\n", get_interpreter_opcode_name(opcode), - read_u32(&pc)); + case Opcode::I32Const: + stream->Writef("%s $%u\n", get_opcode_name(opcode), read_u32(&pc)); break; - case InterpreterOpcode::I64Const: - stream->Writef("%s $%" PRIu64 "\n", get_interpreter_opcode_name(opcode), + case Opcode::I64Const: + stream->Writef("%s $%" PRIu64 "\n", get_opcode_name(opcode), read_u64(&pc)); break; - case InterpreterOpcode::F32Const: - stream->Writef("%s $%g\n", get_interpreter_opcode_name(opcode), + case Opcode::F32Const: + stream->Writef("%s $%g\n", get_opcode_name(opcode), bitcast_u32_to_f32(read_u32(&pc))); break; - case InterpreterOpcode::F64Const: - stream->Writef("%s $%g\n", get_interpreter_opcode_name(opcode), + case Opcode::F64Const: + stream->Writef("%s $%g\n", get_opcode_name(opcode), bitcast_u64_to_f64(read_u64(&pc))); break; - case InterpreterOpcode::GetLocal: - case InterpreterOpcode::GetGlobal: - stream->Writef("%s $%u\n", get_interpreter_opcode_name(opcode), - read_u32(&pc)); + case Opcode::GetLocal: + case Opcode::GetGlobal: + stream->Writef("%s $%u\n", get_opcode_name(opcode), read_u32(&pc)); break; - case InterpreterOpcode::SetLocal: - case InterpreterOpcode::SetGlobal: - case InterpreterOpcode::TeeLocal: - stream->Writef("%s $%u, %%[-1]\n", get_interpreter_opcode_name(opcode), + case Opcode::SetLocal: + case Opcode::SetGlobal: + case Opcode::TeeLocal: + stream->Writef("%s $%u, %%[-1]\n", get_opcode_name(opcode), read_u32(&pc)); break; - case InterpreterOpcode::Call: - stream->Writef("%s @%u\n", get_interpreter_opcode_name(opcode), - read_u32(&pc)); + case Opcode::Call: + stream->Writef("%s @%u\n", get_opcode_name(opcode), read_u32(&pc)); break; - case InterpreterOpcode::CallIndirect: { + case Opcode::CallIndirect: { Index table_index = read_u32(&pc); stream->Writef("%s $%" PRIindex ":%u, %%[-1]\n", - get_interpreter_opcode_name(opcode), table_index, - read_u32(&pc)); + get_opcode_name(opcode), table_index, read_u32(&pc)); break; } - case InterpreterOpcode::CallHost: - stream->Writef("%s $%u\n", get_interpreter_opcode_name(opcode), - read_u32(&pc)); - break; - - case InterpreterOpcode::I32Load8S: - case InterpreterOpcode::I32Load8U: - case InterpreterOpcode::I32Load16S: - case InterpreterOpcode::I32Load16U: - case InterpreterOpcode::I64Load8S: - case InterpreterOpcode::I64Load8U: - case InterpreterOpcode::I64Load16S: - case InterpreterOpcode::I64Load16U: - case InterpreterOpcode::I64Load32S: - case InterpreterOpcode::I64Load32U: - case InterpreterOpcode::I32Load: - case InterpreterOpcode::I64Load: - case InterpreterOpcode::F32Load: - case InterpreterOpcode::F64Load: { + case Opcode::CallHost: + stream->Writef("%s $%u\n", get_opcode_name(opcode), read_u32(&pc)); + break; + + case Opcode::I32Load8S: + case Opcode::I32Load8U: + case Opcode::I32Load16S: + case Opcode::I32Load16U: + case Opcode::I64Load8S: + case Opcode::I64Load8U: + case Opcode::I64Load16S: + case Opcode::I64Load16U: + case Opcode::I64Load32S: + case Opcode::I64Load32U: + case Opcode::I32Load: + case Opcode::I64Load: + case Opcode::F32Load: + case Opcode::F64Load: { Index memory_index = read_u32(&pc); stream->Writef("%s $%" PRIindex ":%%[-1]+$%u\n", - get_interpreter_opcode_name(opcode), memory_index, - read_u32(&pc)); + get_opcode_name(opcode), memory_index, read_u32(&pc)); break; } - case InterpreterOpcode::I32Store8: - case InterpreterOpcode::I32Store16: - case InterpreterOpcode::I32Store: - case InterpreterOpcode::I64Store8: - case InterpreterOpcode::I64Store16: - case InterpreterOpcode::I64Store32: - case InterpreterOpcode::I64Store: - case InterpreterOpcode::F32Store: - case InterpreterOpcode::F64Store: { + case Opcode::I32Store8: + case Opcode::I32Store16: + case Opcode::I32Store: + case Opcode::I64Store8: + case Opcode::I64Store16: + case Opcode::I64Store32: + case Opcode::I64Store: + case Opcode::F32Store: + case Opcode::F64Store: { Index memory_index = read_u32(&pc); stream->Writef("%s %%[-2]+$%" PRIindex ", $%u:%%[-1]\n", - get_interpreter_opcode_name(opcode), memory_index, - read_u32(&pc)); + get_opcode_name(opcode), memory_index, read_u32(&pc)); break; } - case InterpreterOpcode::I32Add: - case InterpreterOpcode::I32Sub: - case InterpreterOpcode::I32Mul: - case InterpreterOpcode::I32DivS: - case InterpreterOpcode::I32DivU: - case InterpreterOpcode::I32RemS: - case InterpreterOpcode::I32RemU: - case InterpreterOpcode::I32And: - case InterpreterOpcode::I32Or: - case InterpreterOpcode::I32Xor: - case InterpreterOpcode::I32Shl: - case InterpreterOpcode::I32ShrU: - case InterpreterOpcode::I32ShrS: - case InterpreterOpcode::I32Eq: - case InterpreterOpcode::I32Ne: - case InterpreterOpcode::I32LtS: - case InterpreterOpcode::I32LeS: - case InterpreterOpcode::I32LtU: - case InterpreterOpcode::I32LeU: - case InterpreterOpcode::I32GtS: - case InterpreterOpcode::I32GeS: - case InterpreterOpcode::I32GtU: - case InterpreterOpcode::I32GeU: - case InterpreterOpcode::I32Rotr: - case InterpreterOpcode::I32Rotl: - case InterpreterOpcode::F32Add: - case InterpreterOpcode::F32Sub: - case InterpreterOpcode::F32Mul: - case InterpreterOpcode::F32Div: - case InterpreterOpcode::F32Min: - case InterpreterOpcode::F32Max: - case InterpreterOpcode::F32Copysign: - case InterpreterOpcode::F32Eq: - case InterpreterOpcode::F32Ne: - case InterpreterOpcode::F32Lt: - case InterpreterOpcode::F32Le: - case InterpreterOpcode::F32Gt: - case InterpreterOpcode::F32Ge: - case InterpreterOpcode::I64Add: - case InterpreterOpcode::I64Sub: - case InterpreterOpcode::I64Mul: - case InterpreterOpcode::I64DivS: - case InterpreterOpcode::I64DivU: - case InterpreterOpcode::I64RemS: - case InterpreterOpcode::I64RemU: - case InterpreterOpcode::I64And: - case InterpreterOpcode::I64Or: - case InterpreterOpcode::I64Xor: - case InterpreterOpcode::I64Shl: - case InterpreterOpcode::I64ShrU: - case InterpreterOpcode::I64ShrS: - case InterpreterOpcode::I64Eq: - case InterpreterOpcode::I64Ne: - case InterpreterOpcode::I64LtS: - case InterpreterOpcode::I64LeS: - case InterpreterOpcode::I64LtU: - case InterpreterOpcode::I64LeU: - case InterpreterOpcode::I64GtS: - case InterpreterOpcode::I64GeS: - case InterpreterOpcode::I64GtU: - case InterpreterOpcode::I64GeU: - case InterpreterOpcode::I64Rotr: - case InterpreterOpcode::I64Rotl: - case InterpreterOpcode::F64Add: - case InterpreterOpcode::F64Sub: - case InterpreterOpcode::F64Mul: - case InterpreterOpcode::F64Div: - case InterpreterOpcode::F64Min: - case InterpreterOpcode::F64Max: - case InterpreterOpcode::F64Copysign: - case InterpreterOpcode::F64Eq: - case InterpreterOpcode::F64Ne: - case InterpreterOpcode::F64Lt: - case InterpreterOpcode::F64Le: - case InterpreterOpcode::F64Gt: - case InterpreterOpcode::F64Ge: - stream->Writef("%s %%[-2], %%[-1]\n", - get_interpreter_opcode_name(opcode)); - break; - - case InterpreterOpcode::I32Clz: - case InterpreterOpcode::I32Ctz: - case InterpreterOpcode::I32Popcnt: - case InterpreterOpcode::I32Eqz: - case InterpreterOpcode::I64Clz: - case InterpreterOpcode::I64Ctz: - case InterpreterOpcode::I64Popcnt: - case InterpreterOpcode::I64Eqz: - case InterpreterOpcode::F32Abs: - case InterpreterOpcode::F32Neg: - case InterpreterOpcode::F32Ceil: - case InterpreterOpcode::F32Floor: - case InterpreterOpcode::F32Trunc: - case InterpreterOpcode::F32Nearest: - case InterpreterOpcode::F32Sqrt: - case InterpreterOpcode::F64Abs: - case InterpreterOpcode::F64Neg: - case InterpreterOpcode::F64Ceil: - case InterpreterOpcode::F64Floor: - case InterpreterOpcode::F64Trunc: - case InterpreterOpcode::F64Nearest: - case InterpreterOpcode::F64Sqrt: - case InterpreterOpcode::I32TruncSF32: - case InterpreterOpcode::I32TruncUF32: - case InterpreterOpcode::I64TruncSF32: - case InterpreterOpcode::I64TruncUF32: - case InterpreterOpcode::F64PromoteF32: - case InterpreterOpcode::I32ReinterpretF32: - case InterpreterOpcode::I32TruncSF64: - case InterpreterOpcode::I32TruncUF64: - case InterpreterOpcode::I64TruncSF64: - case InterpreterOpcode::I64TruncUF64: - case InterpreterOpcode::F32DemoteF64: - case InterpreterOpcode::I64ReinterpretF64: - case InterpreterOpcode::I32WrapI64: - case InterpreterOpcode::F32ConvertSI64: - case InterpreterOpcode::F32ConvertUI64: - case InterpreterOpcode::F64ConvertSI64: - case InterpreterOpcode::F64ConvertUI64: - case InterpreterOpcode::F64ReinterpretI64: - case InterpreterOpcode::I64ExtendSI32: - case InterpreterOpcode::I64ExtendUI32: - case InterpreterOpcode::F32ConvertSI32: - case InterpreterOpcode::F32ConvertUI32: - case InterpreterOpcode::F32ReinterpretI32: - case InterpreterOpcode::F64ConvertSI32: - case InterpreterOpcode::F64ConvertUI32: - stream->Writef("%s %%[-1]\n", get_interpreter_opcode_name(opcode)); - break; - - case InterpreterOpcode::GrowMemory: { + case Opcode::I32Add: + case Opcode::I32Sub: + case Opcode::I32Mul: + case Opcode::I32DivS: + case Opcode::I32DivU: + case Opcode::I32RemS: + case Opcode::I32RemU: + case Opcode::I32And: + case Opcode::I32Or: + case Opcode::I32Xor: + case Opcode::I32Shl: + case Opcode::I32ShrU: + case Opcode::I32ShrS: + case Opcode::I32Eq: + case Opcode::I32Ne: + case Opcode::I32LtS: + case Opcode::I32LeS: + case Opcode::I32LtU: + case Opcode::I32LeU: + case Opcode::I32GtS: + case Opcode::I32GeS: + case Opcode::I32GtU: + case Opcode::I32GeU: + case Opcode::I32Rotr: + case Opcode::I32Rotl: + case Opcode::F32Add: + case Opcode::F32Sub: + case Opcode::F32Mul: + case Opcode::F32Div: + case Opcode::F32Min: + case Opcode::F32Max: + case Opcode::F32Copysign: + case Opcode::F32Eq: + case Opcode::F32Ne: + case Opcode::F32Lt: + case Opcode::F32Le: + case Opcode::F32Gt: + case Opcode::F32Ge: + case Opcode::I64Add: + case Opcode::I64Sub: + case Opcode::I64Mul: + case Opcode::I64DivS: + case Opcode::I64DivU: + case Opcode::I64RemS: + case Opcode::I64RemU: + case Opcode::I64And: + case Opcode::I64Or: + case Opcode::I64Xor: + case Opcode::I64Shl: + case Opcode::I64ShrU: + case Opcode::I64ShrS: + case Opcode::I64Eq: + case Opcode::I64Ne: + case Opcode::I64LtS: + case Opcode::I64LeS: + case Opcode::I64LtU: + case Opcode::I64LeU: + case Opcode::I64GtS: + case Opcode::I64GeS: + case Opcode::I64GtU: + case Opcode::I64GeU: + case Opcode::I64Rotr: + case Opcode::I64Rotl: + case Opcode::F64Add: + case Opcode::F64Sub: + case Opcode::F64Mul: + case Opcode::F64Div: + case Opcode::F64Min: + case Opcode::F64Max: + case Opcode::F64Copysign: + case Opcode::F64Eq: + case Opcode::F64Ne: + case Opcode::F64Lt: + case Opcode::F64Le: + case Opcode::F64Gt: + case Opcode::F64Ge: + stream->Writef("%s %%[-2], %%[-1]\n", get_opcode_name(opcode)); + break; + + case Opcode::I32Clz: + case Opcode::I32Ctz: + case Opcode::I32Popcnt: + case Opcode::I32Eqz: + case Opcode::I64Clz: + case Opcode::I64Ctz: + case Opcode::I64Popcnt: + case Opcode::I64Eqz: + case Opcode::F32Abs: + case Opcode::F32Neg: + case Opcode::F32Ceil: + case Opcode::F32Floor: + case Opcode::F32Trunc: + case Opcode::F32Nearest: + case Opcode::F32Sqrt: + case Opcode::F64Abs: + case Opcode::F64Neg: + case Opcode::F64Ceil: + case Opcode::F64Floor: + case Opcode::F64Trunc: + case Opcode::F64Nearest: + case Opcode::F64Sqrt: + case Opcode::I32TruncSF32: + case Opcode::I32TruncUF32: + case Opcode::I64TruncSF32: + case Opcode::I64TruncUF32: + case Opcode::F64PromoteF32: + case Opcode::I32ReinterpretF32: + case Opcode::I32TruncSF64: + case Opcode::I32TruncUF64: + case Opcode::I64TruncSF64: + case Opcode::I64TruncUF64: + case Opcode::F32DemoteF64: + case Opcode::I64ReinterpretF64: + case Opcode::I32WrapI64: + case Opcode::F32ConvertSI64: + case Opcode::F32ConvertUI64: + case Opcode::F64ConvertSI64: + case Opcode::F64ConvertUI64: + case Opcode::F64ReinterpretI64: + case Opcode::I64ExtendSI32: + case Opcode::I64ExtendUI32: + case Opcode::F32ConvertSI32: + case Opcode::F32ConvertUI32: + case Opcode::F32ReinterpretI32: + case Opcode::F64ConvertSI32: + case Opcode::F64ConvertUI32: + stream->Writef("%s %%[-1]\n", get_opcode_name(opcode)); + break; + + case Opcode::GrowMemory: { Index memory_index = read_u32(&pc); - stream->Writef("%s $%" PRIindex ":%%[-1]\n", - get_interpreter_opcode_name(opcode), memory_index); + stream->Writef("%s $%" PRIindex ":%%[-1]\n", get_opcode_name(opcode), + memory_index); break; } - case InterpreterOpcode::Alloca: - stream->Writef("%s $%u\n", get_interpreter_opcode_name(opcode), - read_u32(&pc)); + case Opcode::Alloca: + stream->Writef("%s $%u\n", get_opcode_name(opcode), read_u32(&pc)); break; - case InterpreterOpcode::BrUnless: - stream->Writef("%s @%u, %%[-1]\n", get_interpreter_opcode_name(opcode), + case Opcode::BrUnless: + stream->Writef("%s @%u, %%[-1]\n", get_opcode_name(opcode), read_u32(&pc)); break; - case InterpreterOpcode::DropKeep: { + case Opcode::DropKeep: { uint32_t drop = read_u32(&pc); uint8_t keep = *pc++; - stream->Writef("%s $%u $%u\n", get_interpreter_opcode_name(opcode), - drop, keep); + stream->Writef("%s $%u $%u\n", get_opcode_name(opcode), drop, keep); break; } - case InterpreterOpcode::Data: { + case Opcode::Data: { uint32_t num_bytes = read_u32(&pc); - stream->Writef("%s $%u\n", get_interpreter_opcode_name(opcode), - num_bytes); + stream->Writef("%s $%u\n", get_opcode_name(opcode), num_bytes); /* for now, the only reason this is emitted is for br_table, so display * it as a list of table entries */ if (num_bytes % WABT_TABLE_ENTRY_SIZE == 0) { @@ -2388,12 +2344,11 @@ void disassemble(InterpreterEnvironment* env, } } -void disassemble_module(InterpreterEnvironment* env, - Stream* stream, - InterpreterModule* module) { +void disassemble_module(Environment* env, Stream* stream, Module* module) { assert(!module->is_host); disassemble(env, stream, module->as_defined()->istream_start, module->as_defined()->istream_end); } +} // namespace interpreter } // namespace wabt diff --git a/src/interpreter.h b/src/interpreter.h index 05e69eb8..d37473d5 100644 --- a/src/interpreter.h +++ b/src/interpreter.h @@ -29,10 +29,10 @@ namespace wabt { -// TODO(binji): move all the Interpreter stuff into its own namespace. - class Stream; +namespace interpreter { + #define FOREACH_INTERPRETER_RESULT(V) \ V(Ok, "ok") \ /* returned from the top-most function */ \ @@ -70,7 +70,7 @@ class Stream; /* the expected export kind doesn't match. */ \ V(ExportKindMismatch, "export kind mismatch") -enum class InterpreterResult { +enum class Result { #define V(Name, str) Name, FOREACH_INTERPRETER_RESULT(V) #undef V @@ -92,73 +92,71 @@ static const IstreamOffset kInvalidIstreamOffset = ~0; #define WABT_TABLE_ENTRY_DROP_OFFSET sizeof(uint32_t) #define WABT_TABLE_ENTRY_KEEP_OFFSET (sizeof(IstreamOffset) + sizeof(uint32_t)) -enum class InterpreterOpcode { +enum class Opcode { /* push space on the value stack for N entries */ -#define WABT_OPCODE(rtype, type1, type2, mem_size, code, Name, text) Name = code, +#define WABT_OPCODE(rtype, type1, type2, mem_size, code, Name, text) \ + Name = code, #include "interpreter-opcode.def" #undef WABT_OPCODE - First = static_cast<int>(Opcode::First), + First = static_cast<int>(::wabt::Opcode::First), Last = DropKeep, }; -static const int kInterpreterOpcodeCount = WABT_ENUM_COUNT(InterpreterOpcode); +static const int kOpcodeCount = WABT_ENUM_COUNT(Opcode); -struct InterpreterFuncSignature { +struct FuncSignature { std::vector<Type> param_types; std::vector<Type> result_types; }; -struct InterpreterTable { - explicit InterpreterTable(const Limits& limits) +struct Table { + explicit Table(const Limits& limits) : limits(limits), func_indexes(limits.initial, kInvalidIndex) {} Limits limits; std::vector<Index> func_indexes; }; -struct InterpreterMemory { - InterpreterMemory() { - WABT_ZERO_MEMORY(page_limits); - } - explicit InterpreterMemory(const Limits& limits) +struct Memory { + Memory() { WABT_ZERO_MEMORY(page_limits); } + explicit Memory(const Limits& limits) : page_limits(limits), data(limits.initial * WABT_PAGE_SIZE) {} Limits page_limits; std::vector<char> data; }; -union InterpreterValue { +union Value { uint32_t i32; uint64_t i64; uint32_t f32_bits; uint64_t f64_bits; }; -struct InterpreterTypedValue { - InterpreterTypedValue() {} - explicit InterpreterTypedValue(Type type): type(type) {} - InterpreterTypedValue(Type type, const InterpreterValue& value) - : type(type), value(value) {} +struct TypedValue { + TypedValue() {} + explicit TypedValue(Type type) : type(type) {} + TypedValue(Type type, const Value& value) : type(type), value(value) {} Type type; - InterpreterValue value; + Value value; }; -struct InterpreterGlobal { - InterpreterGlobal() : mutable_(false), import_index(kInvalidIndex) {} - InterpreterGlobal(const InterpreterTypedValue& typed_value, bool mutable_) +struct Global { + Global() : mutable_(false), import_index(kInvalidIndex) {} + Global(const TypedValue& typed_value, bool mutable_) : typed_value(typed_value), mutable_(mutable_) {} - InterpreterTypedValue typed_value; + TypedValue typed_value; bool mutable_; Index import_index; /* or INVALID_INDEX if not imported */ }; -struct InterpreterImport { - InterpreterImport(); - InterpreterImport(InterpreterImport&&); - InterpreterImport& operator=(InterpreterImport&&); - ~InterpreterImport(); +struct Import { + Import(); + Import(Import&&); + Import& operator=(Import&&); + ~Import(); StringSlice module_name; StringSlice field_name; @@ -177,33 +175,32 @@ struct InterpreterImport { }; }; -struct InterpreterFunc; +struct Func; -typedef Result (*InterpreterHostFuncCallback)( - const struct HostInterpreterFunc* func, - const InterpreterFuncSignature* sig, - Index num_args, - InterpreterTypedValue* args, - Index num_results, - InterpreterTypedValue* out_results, - void* user_data); +typedef Result (*HostFuncCallback)(const struct HostFunc* func, + const FuncSignature* sig, + Index num_args, + TypedValue* args, + Index num_results, + TypedValue* out_results, + void* user_data); -struct InterpreterFunc { - WABT_DISALLOW_COPY_AND_ASSIGN(InterpreterFunc); - InterpreterFunc(Index sig_index, bool is_host) +struct Func { + WABT_DISALLOW_COPY_AND_ASSIGN(Func); + Func(Index sig_index, bool is_host) : sig_index(sig_index), is_host(is_host) {} - virtual ~InterpreterFunc() {} + virtual ~Func() {} - inline struct DefinedInterpreterFunc* as_defined(); - inline struct HostInterpreterFunc* as_host(); + inline struct DefinedFunc* as_defined(); + inline struct HostFunc* as_host(); Index sig_index; bool is_host; }; -struct DefinedInterpreterFunc : InterpreterFunc { - DefinedInterpreterFunc(Index sig_index) - : InterpreterFunc(sig_index, false), +struct DefinedFunc : Func { + DefinedFunc(Index sig_index) + : Func(sig_index, false), offset(kInvalidIstreamOffset), local_decl_count(0), local_count(0) {} @@ -214,36 +211,36 @@ struct DefinedInterpreterFunc : InterpreterFunc { std::vector<Type> param_and_local_types; }; -struct HostInterpreterFunc : InterpreterFunc { - HostInterpreterFunc(const StringSlice& module_name, - const StringSlice& field_name, - Index sig_index) - : InterpreterFunc(sig_index, true), +struct HostFunc : Func { + HostFunc(const StringSlice& module_name, + const StringSlice& field_name, + Index sig_index) + : Func(sig_index, true), module_name(module_name), field_name(field_name) {} StringSlice module_name; StringSlice field_name; - InterpreterHostFuncCallback callback; + HostFuncCallback callback; void* user_data; }; -DefinedInterpreterFunc* InterpreterFunc::as_defined() { +DefinedFunc* Func::as_defined() { assert(!is_host); - return static_cast<DefinedInterpreterFunc*>(this); + return static_cast<DefinedFunc*>(this); } -HostInterpreterFunc* InterpreterFunc::as_host() { +HostFunc* Func::as_host() { assert(is_host); - return static_cast<HostInterpreterFunc*>(this); + return static_cast<HostFunc*>(this); } -struct InterpreterExport { - InterpreterExport(const StringSlice& name, ExternalKind kind, Index index) +struct Export { + Export(const StringSlice& name, ExternalKind kind, Index index) : name(name), kind(kind), index(index) {} - InterpreterExport(InterpreterExport&&); - InterpreterExport& operator=(InterpreterExport&&); - ~InterpreterExport(); + Export(Export&&); + Export& operator=(Export&&); + ~Export(); StringSlice name; ExternalKind kind; @@ -255,71 +252,71 @@ struct PrintErrorCallback { void (*print_error)(const char* msg, void* user_data); }; -struct InterpreterHostImportDelegate { +struct HostImportDelegate { void* user_data; - Result (*import_func)(InterpreterImport*, - InterpreterFunc*, - InterpreterFuncSignature*, + ::wabt::Result (*import_func)(Import*, + Func*, + FuncSignature*, PrintErrorCallback, void* user_data); - Result (*import_table)(InterpreterImport*, - InterpreterTable*, - PrintErrorCallback, - void* user_data); - Result (*import_memory)(InterpreterImport*, - InterpreterMemory*, - PrintErrorCallback, - void* user_data); - Result (*import_global)(InterpreterImport*, - InterpreterGlobal*, - PrintErrorCallback, - void* user_data); + ::wabt::Result (*import_table)(Import*, + Table*, + PrintErrorCallback, + void* user_data); + ::wabt::Result (*import_memory)(Import*, + Memory*, + PrintErrorCallback, + void* user_data); + ::wabt::Result (*import_global)(Import*, + Global*, + PrintErrorCallback, + void* user_data); }; -struct InterpreterModule { - WABT_DISALLOW_COPY_AND_ASSIGN(InterpreterModule); - explicit InterpreterModule(bool is_host); - InterpreterModule(const StringSlice& name, bool is_host); - virtual ~InterpreterModule(); +struct Module { + WABT_DISALLOW_COPY_AND_ASSIGN(Module); + explicit Module(bool is_host); + Module(const StringSlice& name, bool is_host); + virtual ~Module(); - inline struct DefinedInterpreterModule* as_defined(); - inline struct HostInterpreterModule* as_host(); + inline struct DefinedModule* as_defined(); + inline struct HostModule* as_host(); StringSlice name; - std::vector<InterpreterExport> exports; + std::vector<Export> exports; BindingHash export_bindings; Index memory_index; /* kInvalidIndex if not defined */ Index table_index; /* kInvalidIndex if not defined */ bool is_host; }; -struct DefinedInterpreterModule : InterpreterModule { - explicit DefinedInterpreterModule(size_t istream_start); +struct DefinedModule : Module { + explicit DefinedModule(size_t istream_start); - std::vector<InterpreterImport> imports; + std::vector<Import> imports; Index start_func_index; /* kInvalidIndex if not defined */ size_t istream_start; size_t istream_end; }; -struct HostInterpreterModule : InterpreterModule { - HostInterpreterModule(const StringSlice& name); +struct HostModule : Module { + HostModule(const StringSlice& name); - InterpreterHostImportDelegate import_delegate; + HostImportDelegate import_delegate; }; -DefinedInterpreterModule* InterpreterModule::as_defined() { +DefinedModule* Module::as_defined() { assert(!is_host); - return static_cast<DefinedInterpreterModule*>(this); + return static_cast<DefinedModule*>(this); } -HostInterpreterModule* InterpreterModule::as_host() { +HostModule* Module::as_host() { assert(is_host); - return static_cast<HostInterpreterModule*>(this); + return static_cast<HostModule*>(this); } /* Used to track and reset the state of the environment. */ -struct InterpreterEnvironmentMark { +struct EnvironmentMark { size_t modules_size; size_t sigs_size; size_t funcs_size; @@ -329,37 +326,41 @@ struct InterpreterEnvironmentMark { size_t istream_size; }; -struct InterpreterEnvironment { - InterpreterEnvironment(); +struct Environment { + Environment(); - std::vector<std::unique_ptr<InterpreterModule>> modules; - std::vector<InterpreterFuncSignature> sigs; - std::vector<std::unique_ptr<InterpreterFunc>> funcs; - std::vector<InterpreterMemory> memories; - std::vector<InterpreterTable> tables; - std::vector<InterpreterGlobal> globals; + std::vector<std::unique_ptr<Module>> modules; + std::vector<FuncSignature> sigs; + std::vector<std::unique_ptr<Func>> funcs; + std::vector<Memory> memories; + std::vector<Table> tables; + std::vector<Global> globals; std::unique_ptr<OutputBuffer> istream; BindingHash module_bindings; BindingHash registered_module_bindings; }; -struct InterpreterThread { - InterpreterThread(); +struct Thread { + Thread(); - InterpreterEnvironment* env; - std::vector<InterpreterValue> value_stack; + Environment* env; + std::vector<Value> value_stack; std::vector<IstreamOffset> call_stack; - InterpreterValue* value_stack_top; - InterpreterValue* value_stack_end; + Value* value_stack_top; + Value* value_stack_end; IstreamOffset* call_stack_top; IstreamOffset* call_stack_end; IstreamOffset pc; }; -#define WABT_INTERPRETER_THREAD_OPTIONS_DEFAULT \ - { 512 * 1024 / sizeof(InterpreterValue), 64 * 1024, kInvalidIstreamOffset } +// TODO(binji): Remove and use default constructor. +#define WABT_INTERPRETER_THREAD_OPTIONS_DEFAULT \ + { \ + 512 * 1024 / sizeof(::wabt::interpreter::Value), 64 * 1024, \ + ::wabt::interpreter::kInvalidIstreamOffset \ + } -struct InterpreterThreadOptions { +struct ThreadOptions { uint32_t value_stack_size; uint32_t call_stack_size; IstreamOffset pc; @@ -369,40 +370,32 @@ bool is_canonical_nan_f32(uint32_t f32_bits); bool is_canonical_nan_f64(uint64_t f64_bits); bool is_arithmetic_nan_f32(uint32_t f32_bits); bool is_arithmetic_nan_f64(uint64_t f64_bits); -bool func_signatures_are_equal(InterpreterEnvironment* env, +bool func_signatures_are_equal(Environment* env, Index sig_index_0, Index sig_index_1); -void destroy_interpreter_environment(InterpreterEnvironment* env); -InterpreterEnvironmentMark mark_interpreter_environment( - InterpreterEnvironment* env); -void reset_interpreter_environment_to_mark(InterpreterEnvironment* env, - InterpreterEnvironmentMark mark); -HostInterpreterModule* append_host_module(InterpreterEnvironment* env, - StringSlice name); -void init_interpreter_thread(InterpreterEnvironment* env, - InterpreterThread* thread, - InterpreterThreadOptions* options); -InterpreterResult push_thread_value(InterpreterThread* thread, - InterpreterValue value); -void destroy_interpreter_thread(InterpreterThread* thread); -InterpreterResult call_host(InterpreterThread* thread, - HostInterpreterFunc* func); -InterpreterResult run_interpreter(InterpreterThread* thread, - int num_instructions, - IstreamOffset* call_stack_return_top); -void trace_pc(InterpreterThread* thread, Stream* stream); -void disassemble(InterpreterEnvironment* env, +// TODO(binji): Use methods on Environment and Thread instead. +void destroy_environment(Environment* env); +EnvironmentMark mark_environment(Environment* env); +void reset_environment_to_mark(Environment* env, EnvironmentMark mark); +HostModule* append_host_module(Environment* env, StringSlice name); +void init_thread(Environment* env, Thread* thread, ThreadOptions* options); +Result push_thread_value(Thread* thread, Value value); +void destroy_thread(Thread* thread); +Result call_host(Thread* thread, HostFunc* func); +Result run_interpreter(Thread* thread, + int num_instructions, + IstreamOffset* call_stack_return_top); +void trace_pc(Thread* thread, Stream* stream); +void disassemble(Environment* env, Stream* stream, IstreamOffset from, IstreamOffset to); -void disassemble_module(InterpreterEnvironment* env, - Stream* stream, - InterpreterModule* module); +void disassemble_module(Environment* env, Stream* stream, Module* module); -InterpreterExport* get_interpreter_export_by_name(InterpreterModule* module, - const StringSlice* name); +Export* get_export_by_name(Module* module, const StringSlice* name); +} // namespace interpreter } // namespace wabt #endif /* WABT_INTERPRETER_H_ */ diff --git a/src/tools/wasm-interp.cc b/src/tools/wasm-interp.cc index 12d292f9..cbc1da4d 100644 --- a/src/tools/wasm-interp.cc +++ b/src/tools/wasm-interp.cc @@ -23,8 +23,8 @@ #include <vector> #include "binary-error-handler.h" -#include "binary-reader.h" #include "binary-reader-interpreter.h" +#include "binary-reader.h" #include "interpreter.h" #include "literal.h" #include "option-parser.h" @@ -34,6 +34,7 @@ #define PROGRAM_NAME "wasm-interp" using namespace wabt; +using namespace wabt::interpreter; #define V(name, str) str, static const char* s_trap_strings[] = {FOREACH_INTERPRETER_RESULT(V)}; @@ -43,8 +44,7 @@ static int s_verbose; static const char* s_infile; static ReadBinaryOptions s_read_binary_options = WABT_READ_BINARY_OPTIONS_DEFAULT; -static InterpreterThreadOptions s_thread_options = - WABT_INTERPRETER_THREAD_OPTIONS_DEFAULT; +static ThreadOptions s_thread_options = WABT_INTERPRETER_THREAD_OPTIONS_DEFAULT; static bool s_trace; static bool s_spec; static bool s_run_all_exports; @@ -71,7 +71,6 @@ enum { NUM_FLAGS }; - static const char s_description[] = " read a file in the wasm binary format, and run in it a stack-based\n" " interpreter.\n" @@ -202,7 +201,7 @@ static StringSlice get_dirname(const char* s) { static void sprint_typed_value(char* buffer, size_t size, - const InterpreterTypedValue* tv) { + const TypedValue* tv) { switch (tv->type) { case Type::I32: snprintf(buffer, size, "i32:%u", tv->value.i32); @@ -232,14 +231,13 @@ static void sprint_typed_value(char* buffer, } } -static void print_typed_value(const InterpreterTypedValue* tv) { +static void print_typed_value(const TypedValue* tv) { char buffer[MAX_TYPED_VALUE_CHARS]; sprint_typed_value(buffer, sizeof(buffer), tv); printf("%s", buffer); } -static void print_typed_value_vector( - const std::vector<InterpreterTypedValue>& values) { +static void print_typed_value_vector(const std::vector<TypedValue>& values) { for (size_t i = 0; i < values.size(); ++i) { print_typed_value(&values[i]); if (i != values.size() - 1) @@ -248,21 +246,21 @@ static void print_typed_value_vector( } static void print_interpreter_result(const char* desc, - InterpreterResult iresult) { + interpreter::Result iresult) { printf("%s: %s\n", desc, s_trap_strings[static_cast<size_t>(iresult)]); } static void print_call(StringSlice module_name, StringSlice func_name, - const std::vector<InterpreterTypedValue>& args, - const std::vector<InterpreterTypedValue>& results, - InterpreterResult iresult) { + const std::vector<TypedValue>& args, + const std::vector<TypedValue>& results, + interpreter::Result iresult) { if (module_name.length) printf(PRIstringslice ".", WABT_PRINTF_STRING_SLICE_ARG(module_name)); printf(PRIstringslice "(", WABT_PRINTF_STRING_SLICE_ARG(func_name)); print_typed_value_vector(args); printf(") =>"); - if (iresult == InterpreterResult::Ok) { + if (iresult == interpreter::Result::Ok) { if (results.size() > 0) { printf(" "); print_typed_value_vector(results); @@ -273,46 +271,45 @@ static void print_call(StringSlice module_name, } } -static InterpreterResult run_defined_function(InterpreterThread* thread, - IstreamOffset offset) { +static interpreter::Result run_defined_function(Thread* thread, + IstreamOffset offset) { thread->pc = offset; - InterpreterResult iresult = InterpreterResult::Ok; + interpreter::Result iresult = interpreter::Result::Ok; int quantum = s_trace ? 1 : INSTRUCTION_QUANTUM; IstreamOffset* call_stack_return_top = thread->call_stack_top; - while (iresult == InterpreterResult::Ok) { + while (iresult == interpreter::Result::Ok) { if (s_trace) trace_pc(thread, s_stdout_stream.get()); iresult = run_interpreter(thread, quantum, call_stack_return_top); } - if (iresult != InterpreterResult::Returned) + if (iresult != interpreter::Result::Returned) return iresult; /* use OK instead of RETURNED for consistency */ - return InterpreterResult::Ok; + return interpreter::Result::Ok; } -static InterpreterResult push_args( - InterpreterThread* thread, - const InterpreterFuncSignature* sig, - const std::vector<InterpreterTypedValue>& args) { +static interpreter::Result push_args(Thread* thread, + const FuncSignature* sig, + const std::vector<TypedValue>& args) { if (sig->param_types.size() != args.size()) - return InterpreterResult::ArgumentTypeMismatch; + return interpreter::Result::ArgumentTypeMismatch; for (size_t i = 0; i < sig->param_types.size(); ++i) { if (sig->param_types[i] != args[i].type) - return InterpreterResult::ArgumentTypeMismatch; + return interpreter::Result::ArgumentTypeMismatch; - InterpreterResult iresult = push_thread_value(thread, args[i].value); - if (iresult != InterpreterResult::Ok) { + interpreter::Result iresult = push_thread_value(thread, args[i].value); + if (iresult != interpreter::Result::Ok) { thread->value_stack_top = thread->value_stack.data(); return iresult; } } - return InterpreterResult::Ok; + return interpreter::Result::Ok; } -static void copy_results(InterpreterThread* thread, - const InterpreterFuncSignature* sig, - std::vector<InterpreterTypedValue>* out_results) { +static void copy_results(Thread* thread, + const FuncSignature* sig, + std::vector<TypedValue>* out_results) { size_t expected_results = sig->result_types.size(); size_t value_stack_depth = thread->value_stack_top - thread->value_stack.data(); @@ -324,23 +321,22 @@ static void copy_results(InterpreterThread* thread, out_results->emplace_back(sig->result_types[i], thread->value_stack[i]); } -static InterpreterResult run_function( - InterpreterThread* thread, - Index func_index, - const std::vector<InterpreterTypedValue>& args, - std::vector<InterpreterTypedValue>* out_results) { +static interpreter::Result run_function(Thread* thread, + Index func_index, + const std::vector<TypedValue>& args, + std::vector<TypedValue>* out_results) { assert(func_index < thread->env->funcs.size()); - InterpreterFunc* func = thread->env->funcs[func_index].get(); + Func* func = thread->env->funcs[func_index].get(); Index sig_index = func->sig_index; assert(sig_index < thread->env->sigs.size()); - InterpreterFuncSignature* sig = &thread->env->sigs[sig_index]; + FuncSignature* sig = &thread->env->sigs[sig_index]; - InterpreterResult iresult = push_args(thread, sig, args); - if (iresult == InterpreterResult::Ok) { + interpreter::Result iresult = push_args(thread, sig, args); + if (iresult == interpreter::Result::Ok) { iresult = func->is_host ? call_host(thread, func->as_host()) : run_defined_function(thread, func->as_defined()->offset); - if (iresult == InterpreterResult::Ok) + if (iresult == interpreter::Result::Ok) copy_results(thread, sig, out_results); } @@ -350,26 +346,25 @@ static InterpreterResult run_function( return iresult; } -static InterpreterResult run_start_function(InterpreterThread* thread, - DefinedInterpreterModule* module) { +static interpreter::Result run_start_function(Thread* thread, + DefinedModule* module) { if (module->start_func_index == kInvalidIndex) - return InterpreterResult::Ok; + return interpreter::Result::Ok; if (s_trace) printf(">>> running start function:\n"); - std::vector<InterpreterTypedValue> args; - std::vector<InterpreterTypedValue> results; - InterpreterResult iresult = + std::vector<TypedValue> args; + std::vector<TypedValue> results; + interpreter::Result iresult = run_function(thread, module->start_func_index, args, &results); assert(results.size() == 0); return iresult; } -static InterpreterResult run_export( - InterpreterThread* thread, - const InterpreterExport* export_, - const std::vector<InterpreterTypedValue>& args, - std::vector<InterpreterTypedValue>* out_results) { +static interpreter::Result run_export(Thread* thread, + const Export* export_, + const std::vector<TypedValue>& args, + std::vector<TypedValue>* out_results) { if (s_trace) { printf(">>> running export \"" PRIstringslice "\":\n", WABT_PRINTF_STRING_SLICE_ARG(export_->name)); @@ -379,56 +374,56 @@ static InterpreterResult run_export( return run_function(thread, export_->index, args, out_results); } -static InterpreterResult run_export_by_name( - InterpreterThread* thread, - InterpreterModule* module, +static interpreter::Result run_export_by_name( + Thread* thread, + Module* module, const StringSlice* name, - const std::vector<InterpreterTypedValue>& args, - std::vector<InterpreterTypedValue>* out_results, + const std::vector<TypedValue>& args, + std::vector<TypedValue>* out_results, RunVerbosity verbose) { - InterpreterExport* export_ = get_interpreter_export_by_name(module, name); + Export* export_ = get_export_by_name(module, name); if (!export_) - return InterpreterResult::UnknownExport; + return interpreter::Result::UnknownExport; if (export_->kind != ExternalKind::Func) - return InterpreterResult::ExportKindMismatch; + return interpreter::Result::ExportKindMismatch; return run_export(thread, export_, args, out_results); } -static InterpreterResult get_global_export_by_name( - InterpreterThread* thread, - InterpreterModule* module, +static interpreter::Result get_global_export_by_name( + Thread* thread, + Module* module, const StringSlice* name, - std::vector<InterpreterTypedValue>* out_results) { - InterpreterExport* export_ = get_interpreter_export_by_name(module, name); + std::vector<TypedValue>* out_results) { + Export* export_ = get_export_by_name(module, name); if (!export_) - return InterpreterResult::UnknownExport; + return interpreter::Result::UnknownExport; if (export_->kind != ExternalKind::Global) - return InterpreterResult::ExportKindMismatch; + return interpreter::Result::ExportKindMismatch; - InterpreterGlobal* global = &thread->env->globals[export_->index]; + Global* global = &thread->env->globals[export_->index]; out_results->clear(); out_results->push_back(global->typed_value); - return InterpreterResult::Ok; + return interpreter::Result::Ok; } -static void run_all_exports(InterpreterModule* module, - InterpreterThread* thread, +static void run_all_exports(Module* module, + Thread* thread, RunVerbosity verbose) { - std::vector<InterpreterTypedValue> args; - std::vector<InterpreterTypedValue> results; - for (const InterpreterExport& export_: module->exports) { - InterpreterResult iresult = run_export(thread, &export_, args, &results); + std::vector<TypedValue> args; + std::vector<TypedValue> results; + for (const Export& export_ : module->exports) { + interpreter::Result iresult = run_export(thread, &export_, args, &results); if (verbose == RunVerbosity::Verbose) { print_call(empty_string_slice(), export_.name, args, results, iresult); } } } -static Result read_module(const char* module_filename, - InterpreterEnvironment* env, - BinaryErrorHandler* error_handler, - DefinedInterpreterModule** out_module) { - Result result; +static wabt::Result read_module(const char* module_filename, + Environment* env, + BinaryErrorHandler* error_handler, + DefinedModule** out_module) { + wabt::Result result; char* data; size_t size; @@ -448,25 +443,24 @@ static Result read_module(const char* module_filename, return result; } -static Result default_host_callback(const HostInterpreterFunc* func, - const InterpreterFuncSignature* sig, - Index num_args, - InterpreterTypedValue* args, - Index num_results, - InterpreterTypedValue* out_results, - void* user_data) { - memset(out_results, 0, sizeof(InterpreterTypedValue) * num_results); +static interpreter::Result default_host_callback(const HostFunc* func, + const FuncSignature* sig, + Index num_args, + TypedValue* args, + Index num_results, + TypedValue* out_results, + void* user_data) { + memset(out_results, 0, sizeof(TypedValue) * num_results); for (Index i = 0; i < num_results; ++i) out_results[i].type = sig->result_types[i]; - std::vector<InterpreterTypedValue> vec_args(args, args + num_args); - std::vector<InterpreterTypedValue> vec_results(out_results, - out_results + num_results); + std::vector<TypedValue> vec_args(args, args + num_args); + std::vector<TypedValue> vec_results(out_results, out_results + num_results); printf("called host "); print_call(func->module_name, func->field_name, vec_args, vec_results, - InterpreterResult::Ok); - return Result::Ok; + interpreter::Result::Ok); + return interpreter::Result::Ok; } #define PRIimport "\"" PRIstringslice "." PRIstringslice "\"" @@ -480,58 +474,58 @@ static void WABT_PRINTF_FORMAT(2, 3) callback.print_error(buffer, callback.user_data); } -static Result spectest_import_func(InterpreterImport* import, - InterpreterFunc* func, - InterpreterFuncSignature* sig, - PrintErrorCallback callback, - void* user_data) { +static wabt::Result spectest_import_func(Import* import, + Func* func, + FuncSignature* sig, + PrintErrorCallback callback, + void* user_data) { if (string_slice_eq_cstr(&import->field_name, "print")) { func->as_host()->callback = default_host_callback; - return Result::Ok; + return wabt::Result::Ok; } else { print_error(callback, "unknown host function import " PRIimport, PRINTF_IMPORT_ARG(*import)); - return Result::Error; + return wabt::Result::Error; } } -static Result spectest_import_table(InterpreterImport* import, - InterpreterTable* table, - PrintErrorCallback callback, - void* user_data) { +static wabt::Result spectest_import_table(Import* import, + Table* table, + PrintErrorCallback callback, + void* user_data) { if (string_slice_eq_cstr(&import->field_name, "table")) { table->limits.has_max = true; table->limits.initial = 10; table->limits.max = 20; - return Result::Ok; + return wabt::Result::Ok; } else { print_error(callback, "unknown host table import " PRIimport, PRINTF_IMPORT_ARG(*import)); - return Result::Error; + return wabt::Result::Error; } } -static Result spectest_import_memory(InterpreterImport* import, - InterpreterMemory* memory, - PrintErrorCallback callback, - void* user_data) { +static wabt::Result spectest_import_memory(Import* import, + Memory* memory, + PrintErrorCallback callback, + void* user_data) { if (string_slice_eq_cstr(&import->field_name, "memory")) { memory->page_limits.has_max = true; memory->page_limits.initial = 1; memory->page_limits.max = 2; memory->data.resize(memory->page_limits.initial * WABT_MAX_PAGES); - return Result::Ok; + return wabt::Result::Ok; } else { print_error(callback, "unknown host memory import " PRIimport, PRINTF_IMPORT_ARG(*import)); - return Result::Error; + return wabt::Result::Error; } } -static Result spectest_import_global(InterpreterImport* import, - InterpreterGlobal* global, - PrintErrorCallback callback, - void* user_data) { +static wabt::Result spectest_import_global(Import* import, + Global* global, + PrintErrorCallback callback, + void* user_data) { if (string_slice_eq_cstr(&import->field_name, "global")) { switch (global->typed_value.type) { case Type::I32: @@ -557,19 +551,19 @@ static Result spectest_import_global(InterpreterImport* import, default: print_error(callback, "bad type for host global import " PRIimport, PRINTF_IMPORT_ARG(*import)); - return Result::Error; + return wabt::Result::Error; } - return Result::Ok; + return wabt::Result::Ok; } else { print_error(callback, "unknown host global import " PRIimport, PRINTF_IMPORT_ARG(*import)); - return Result::Error; + return wabt::Result::Error; } } -static void init_environment(InterpreterEnvironment* env) { - HostInterpreterModule* host_module = +static void init_environment(Environment* env) { + HostModule* host_module = append_host_module(env, string_slice_from_cstr("spectest")); host_module->import_delegate.import_func = spectest_import_func; host_module->import_delegate.import_table = spectest_import_table; @@ -577,19 +571,19 @@ static void init_environment(InterpreterEnvironment* env) { host_module->import_delegate.import_global = spectest_import_global; } -static Result read_and_run_module(const char* module_filename) { - Result result; - InterpreterEnvironment env; - DefinedInterpreterModule* module = nullptr; - InterpreterThread thread; +static wabt::Result read_and_run_module(const char* module_filename) { + wabt::Result result; + Environment env; + DefinedModule* module = nullptr; + Thread thread; BinaryErrorHandlerFile error_handler; init_environment(&env); - init_interpreter_thread(&env, &thread, &s_thread_options); + init_thread(&env, &thread, &s_thread_options); result = read_module(module_filename, &env, &error_handler, &module); if (WABT_SUCCEEDED(result)) { - InterpreterResult iresult = run_start_function(&thread, module); - if (iresult == InterpreterResult::Ok) { + interpreter::Result iresult = run_start_function(&thread, module); + if (iresult == interpreter::Result::Ok) { if (s_run_all_exports) run_all_exports(module, &thread, RunVerbosity::Verbose); } else { @@ -616,9 +610,9 @@ struct Context { WABT_ZERO_MEMORY(prev_loc); } - InterpreterEnvironment env; - InterpreterThread thread; - DefinedInterpreterModule* last_module; + Environment env; + Thread thread; + DefinedModule* last_module; /* Parsing info */ char* json_data; @@ -649,13 +643,13 @@ struct Action { ActionType type = ActionType::Invoke; StringSlice module_name; StringSlice field_name; - std::vector<InterpreterTypedValue> args; + std::vector<TypedValue> args; }; -#define CHECK_RESULT(x) \ - do { \ - if (WABT_FAILED(x)) \ - return Result::Error; \ +#define CHECK_RESULT(x) \ + do { \ + if (WABT_FAILED(x)) \ + return wabt::Result::Error; \ } while (0) #define EXPECT(x) CHECK_RESULT(expect(ctx, x)) @@ -735,26 +729,26 @@ static bool match(Context* ctx, const char* s) { } } -static Result expect(Context* ctx, const char* s) { +static wabt::Result expect(Context* ctx, const char* s) { if (match(ctx, s)) { - return Result::Ok; + return wabt::Result::Ok; } else { print_parse_error(ctx, "expected %s", s); - return Result::Error; + return wabt::Result::Error; } } -static Result expect_key(Context* ctx, const char* key) { +static wabt::Result expect_key(Context* ctx, const char* key) { size_t keylen = strlen(key); size_t quoted_len = keylen + 2 + 1; char* quoted = static_cast<char*>(alloca(quoted_len)); snprintf(quoted, quoted_len, "\"%s\"", key); EXPECT(quoted); EXPECT(":"); - return Result::Ok; + return wabt::Result::Ok; } -static Result parse_uint32(Context* ctx, uint32_t* out_int) { +static wabt::Result parse_uint32(Context* ctx, uint32_t* out_int) { uint32_t result = 0; skip_whitespace(ctx); while (1) { @@ -764,7 +758,7 @@ static Result parse_uint32(Context* ctx, uint32_t* out_int) { result = result * 10 + static_cast<uint32_t>(c - '0'); if (result < last_result) { print_parse_error(ctx, "uint32 overflow"); - return Result::Error; + return wabt::Result::Error; } } else { putback_char(ctx); @@ -772,16 +766,16 @@ static Result parse_uint32(Context* ctx, uint32_t* out_int) { } } *out_int = result; - return Result::Ok; + return wabt::Result::Ok; } -static Result parse_string(Context* ctx, StringSlice* out_string) { +static wabt::Result parse_string(Context* ctx, StringSlice* out_string) { WABT_ZERO_MEMORY(*out_string); skip_whitespace(ctx); if (read_char(ctx) != '"') { print_parse_error(ctx, "expected string"); - return Result::Error; + return wabt::Result::Error; } /* Modify json_data in-place so we can use the StringSlice directly * without having to allocate additional memory; this is only necessary when @@ -799,7 +793,7 @@ static Result parse_string(Context* ctx, StringSlice* out_string) { c = read_char(ctx); if (c != 'u') { print_parse_error(ctx, "expected escape: \\uxxxx"); - return Result::Error; + return wabt::Result::Error; } uint16_t code = 0; for (int i = 0; i < 4; ++i) { @@ -813,7 +807,7 @@ static Result parse_string(Context* ctx, StringSlice* out_string) { cval = c - 'A' + 10; } else { print_parse_error(ctx, "expected hex char"); - return Result::Error; + return wabt::Result::Error; } code = (code << 4) + cval; } @@ -829,35 +823,35 @@ static Result parse_string(Context* ctx, StringSlice* out_string) { } } out_string->length = p - start; - return Result::Ok; + return wabt::Result::Ok; } -static Result parse_key_string_value(Context* ctx, - const char* key, - StringSlice* out_string) { +static wabt::Result parse_key_string_value(Context* ctx, + const char* key, + StringSlice* out_string) { WABT_ZERO_MEMORY(*out_string); EXPECT_KEY(key); return parse_string(ctx, out_string); } -static Result parse_opt_name_string_value(Context* ctx, - StringSlice* out_string) { +static wabt::Result parse_opt_name_string_value(Context* ctx, + StringSlice* out_string) { WABT_ZERO_MEMORY(*out_string); if (match(ctx, "\"name\"")) { EXPECT(":"); CHECK_RESULT(parse_string(ctx, out_string)); EXPECT(","); } - return Result::Ok; + return wabt::Result::Ok; } -static Result parse_line(Context* ctx) { +static wabt::Result parse_line(Context* ctx) { EXPECT_KEY("line"); CHECK_RESULT(parse_uint32(ctx, &ctx->command_line_number)); - return Result::Ok; + return wabt::Result::Ok; } -static Result parse_type_object(Context* ctx, Type* out_type) { +static wabt::Result parse_type_object(Context* ctx, Type* out_type) { StringSlice type_str; EXPECT("{"); PARSE_KEY_STRING_VALUE("type", &type_str); @@ -865,24 +859,24 @@ static Result parse_type_object(Context* ctx, Type* out_type) { if (string_slice_eq_cstr(&type_str, "i32")) { *out_type = Type::I32; - return Result::Ok; + return wabt::Result::Ok; } else if (string_slice_eq_cstr(&type_str, "f32")) { *out_type = Type::F32; - return Result::Ok; + return wabt::Result::Ok; } else if (string_slice_eq_cstr(&type_str, "i64")) { *out_type = Type::I64; - return Result::Ok; + return wabt::Result::Ok; } else if (string_slice_eq_cstr(&type_str, "f64")) { *out_type = Type::F64; - return Result::Ok; + return wabt::Result::Ok; } else { print_parse_error(ctx, "unknown type: \"" PRIstringslice "\"", WABT_PRINTF_STRING_SLICE_ARG(type_str)); - return Result::Error; + return wabt::Result::Error; } } -static Result parse_type_vector(Context* ctx, TypeVector* out_types) { +static wabt::Result parse_type_vector(Context* ctx, TypeVector* out_types) { out_types->clear(); EXPECT("["); bool first = true; @@ -894,10 +888,10 @@ static Result parse_type_vector(Context* ctx, TypeVector* out_types) { first = false; out_types->push_back(type); } - return Result::Ok; + return wabt::Result::Ok; } -static Result parse_const(Context* ctx, InterpreterTypedValue* out_value) { +static wabt::Result parse_const(Context* ctx, TypedValue* out_value) { StringSlice type_str; StringSlice value_str; EXPECT("{"); @@ -915,53 +909,52 @@ static Result parse_const(Context* ctx, InterpreterTypedValue* out_value) { ParseIntType::UnsignedOnly)); out_value->type = Type::I32; out_value->value.i32 = value; - return Result::Ok; + return wabt::Result::Ok; } else if (string_slice_eq_cstr(&type_str, "f32")) { uint32_t value_bits; CHECK_RESULT(parse_int32(value_start, value_end, &value_bits, ParseIntType::UnsignedOnly)); out_value->type = Type::F32; out_value->value.f32_bits = value_bits; - return Result::Ok; + return wabt::Result::Ok; } else if (string_slice_eq_cstr(&type_str, "i64")) { uint64_t value; CHECK_RESULT(parse_int64(value_start, value_end, &value, ParseIntType::UnsignedOnly)); out_value->type = Type::I64; out_value->value.i64 = value; - return Result::Ok; + return wabt::Result::Ok; } else if (string_slice_eq_cstr(&type_str, "f64")) { uint64_t value_bits; CHECK_RESULT(parse_int64(value_start, value_end, &value_bits, ParseIntType::UnsignedOnly)); out_value->type = Type::F64; out_value->value.f64_bits = value_bits; - return Result::Ok; + return wabt::Result::Ok; } else { print_parse_error(ctx, "unknown type: \"" PRIstringslice "\"", WABT_PRINTF_STRING_SLICE_ARG(type_str)); - return Result::Error; + return wabt::Result::Error; } } -static Result parse_const_vector( - Context* ctx, - std::vector<InterpreterTypedValue>* out_values) { +static wabt::Result parse_const_vector(Context* ctx, + std::vector<TypedValue>* out_values) { out_values->clear(); EXPECT("["); bool first = true; while (!match(ctx, "]")) { if (!first) EXPECT(","); - InterpreterTypedValue value; + TypedValue value; CHECK_RESULT(parse_const(ctx, &value)); out_values->push_back(value); first = false; } - return Result::Ok; + return wabt::Result::Ok; } -static Result parse_action(Context* ctx, Action* out_action) { +static wabt::Result parse_action(Context* ctx, Action* out_action) { EXPECT_KEY("action"); EXPECT("{"); EXPECT_KEY("type"); @@ -984,7 +977,7 @@ static Result parse_action(Context* ctx, Action* out_action) { CHECK_RESULT(parse_const_vector(ctx, &out_action->args)); } EXPECT("}"); - return Result::Ok; + return wabt::Result::Ok; } static char* create_module_path(Context* ctx, StringSlice filename) { @@ -1005,30 +998,30 @@ static char* create_module_path(Context* ctx, StringSlice filename) { return path; } -static Result on_module_command(Context* ctx, - StringSlice filename, - StringSlice name) { +static wabt::Result on_module_command(Context* ctx, + StringSlice filename, + StringSlice name) { char* path = create_module_path(ctx, filename); - InterpreterEnvironmentMark mark = mark_interpreter_environment(&ctx->env); + EnvironmentMark mark = mark_environment(&ctx->env); BinaryErrorHandlerFile error_handler; - Result result = + wabt::Result result = read_module(path, &ctx->env, &error_handler, &ctx->last_module); if (WABT_FAILED(result)) { - reset_interpreter_environment_to_mark(&ctx->env, mark); + reset_environment_to_mark(&ctx->env, mark); print_command_error(ctx, "error reading module: \"%s\"", path); delete[] path; - return Result::Error; + return wabt::Result::Error; } delete[] path; - InterpreterResult iresult = + interpreter::Result iresult = run_start_function(&ctx->thread, ctx->last_module); - if (iresult != InterpreterResult::Ok) { - reset_interpreter_environment_to_mark(&ctx->env, mark); + if (iresult != interpreter::Result::Ok) { + reset_environment_to_mark(&ctx->env, mark); print_interpreter_result("error running start function", iresult); - return Result::Error; + return wabt::Result::Error; } if (!string_slice_is_empty(&name)) { @@ -1036,14 +1029,14 @@ static Result on_module_command(Context* ctx, ctx->env.module_bindings.emplace(string_slice_to_string(name), Binding(ctx->env.modules.size() - 1)); } - return Result::Ok; + return wabt::Result::Ok; } -static Result run_action(Context* ctx, - Action* action, - InterpreterResult* out_iresult, - std::vector<InterpreterTypedValue>* out_results, - RunVerbosity verbose) { +static wabt::Result run_action(Context* ctx, + Action* action, + interpreter::Result* out_iresult, + std::vector<TypedValue>* out_results, + RunVerbosity verbose) { out_results->clear(); int module_index; @@ -1054,7 +1047,7 @@ static Result run_action(Context* ctx, } assert(module_index < static_cast<int>(ctx->env.modules.size())); - InterpreterModule* module = ctx->env.modules[module_index].get(); + Module* module = ctx->env.modules[module_index].get(); switch (action->type) { case ActionType::Invoke: @@ -1065,35 +1058,35 @@ static Result run_action(Context* ctx, print_call(empty_string_slice(), action->field_name, action->args, *out_results, *out_iresult); } - return Result::Ok; + return wabt::Result::Ok; case ActionType::Get: { *out_iresult = get_global_export_by_name( &ctx->thread, module, &action->field_name, out_results); - return Result::Ok; + return wabt::Result::Ok; } default: print_command_error(ctx, "invalid action type %d", static_cast<int>(action->type)); - return Result::Error; + return wabt::Result::Error; } } -static Result on_action_command(Context* ctx, Action* action) { - std::vector<InterpreterTypedValue> results; - InterpreterResult iresult; +static wabt::Result on_action_command(Context* ctx, Action* action) { + std::vector<TypedValue> results; + interpreter::Result iresult; ctx->total++; - Result result = + wabt::Result result = run_action(ctx, action, &iresult, &results, RunVerbosity::Verbose); if (WABT_SUCCEEDED(result)) { - if (iresult == InterpreterResult::Ok) { + if (iresult == interpreter::Result::Ok) { ctx->passed++; } else { print_command_error(ctx, "unexpected trap: %s", s_trap_strings[static_cast<size_t>(iresult)]); - result = Result::Error; + result = wabt::Result::Error; } } @@ -1113,32 +1106,32 @@ class BinaryErrorHandlerAssert : public BinaryErrorHandlerFile { } }; -static Result on_assert_malformed_command(Context* ctx, - StringSlice filename, - StringSlice text) { +static wabt::Result on_assert_malformed_command(Context* ctx, + StringSlice filename, + StringSlice text) { BinaryErrorHandlerAssert error_handler(ctx, "assert_malformed"); - InterpreterEnvironment env; + Environment env; init_environment(&env); ctx->total++; char* path = create_module_path(ctx, filename); - DefinedInterpreterModule* module; - Result result = read_module(path, &env, &error_handler, &module); + DefinedModule* module; + wabt::Result result = read_module(path, &env, &error_handler, &module); if (WABT_FAILED(result)) { ctx->passed++; - result = Result::Ok; + result = wabt::Result::Ok; } else { print_command_error(ctx, "expected module to be malformed: \"%s\"", path); - result = Result::Error; + result = wabt::Result::Error; } delete[] path; return result; } -static Result on_register_command(Context* ctx, - StringSlice name, - StringSlice as) { +static wabt::Result on_register_command(Context* ctx, + StringSlice name, + StringSlice as) { int module_index; if (!string_slice_is_empty(&name)) { /* The module names can be different than their registered names. We don't @@ -1160,93 +1153,93 @@ static Result on_register_command(Context* ctx, if (module_index < 0 || module_index >= static_cast<int>(ctx->env.modules.size())) { print_command_error(ctx, "unknown module in register"); - return Result::Error; + return wabt::Result::Error; } ctx->env.registered_module_bindings.emplace(string_slice_to_string(as), Binding(module_index)); - return Result::Ok; + return wabt::Result::Ok; } -static Result on_assert_unlinkable_command(Context* ctx, - StringSlice filename, - StringSlice text) { +static wabt::Result on_assert_unlinkable_command(Context* ctx, + StringSlice filename, + StringSlice text) { BinaryErrorHandlerAssert error_handler(ctx, "assert_unlinkable"); ctx->total++; char* path = create_module_path(ctx, filename); - DefinedInterpreterModule* module; - InterpreterEnvironmentMark mark = mark_interpreter_environment(&ctx->env); - Result result = read_module(path, &ctx->env, &error_handler, &module); - reset_interpreter_environment_to_mark(&ctx->env, mark); + DefinedModule* module; + EnvironmentMark mark = mark_environment(&ctx->env); + wabt::Result result = read_module(path, &ctx->env, &error_handler, &module); + reset_environment_to_mark(&ctx->env, mark); if (WABT_FAILED(result)) { ctx->passed++; - result = Result::Ok; + result = wabt::Result::Ok; } else { print_command_error(ctx, "expected module to be unlinkable: \"%s\"", path); - result = Result::Error; + result = wabt::Result::Error; } delete[] path; return result; } -static Result on_assert_invalid_command(Context* ctx, - StringSlice filename, - StringSlice text) { +static wabt::Result on_assert_invalid_command(Context* ctx, + StringSlice filename, + StringSlice text) { BinaryErrorHandlerAssert error_handler(ctx, "assert_invalid"); - InterpreterEnvironment env; + Environment env; init_environment(&env); ctx->total++; char* path = create_module_path(ctx, filename); - DefinedInterpreterModule* module; - Result result = read_module(path, &env, &error_handler, &module); + DefinedModule* module; + wabt::Result result = read_module(path, &env, &error_handler, &module); if (WABT_FAILED(result)) { ctx->passed++; - result = Result::Ok; + result = wabt::Result::Ok; } else { print_command_error(ctx, "expected module to be invalid: \"%s\"", path); - result = Result::Error; + result = wabt::Result::Error; } delete[] path; return result; } -static Result on_assert_uninstantiable_command(Context* ctx, - StringSlice filename, - StringSlice text) { +static wabt::Result on_assert_uninstantiable_command(Context* ctx, + StringSlice filename, + StringSlice text) { BinaryErrorHandlerFile error_handler; ctx->total++; char* path = create_module_path(ctx, filename); - DefinedInterpreterModule* module; - InterpreterEnvironmentMark mark = mark_interpreter_environment(&ctx->env); - Result result = read_module(path, &ctx->env, &error_handler, &module); + DefinedModule* module; + EnvironmentMark mark = mark_environment(&ctx->env); + wabt::Result result = read_module(path, &ctx->env, &error_handler, &module); if (WABT_SUCCEEDED(result)) { - InterpreterResult iresult = run_start_function(&ctx->thread, module); - if (iresult == InterpreterResult::Ok) { + interpreter::Result iresult = run_start_function(&ctx->thread, module); + if (iresult == interpreter::Result::Ok) { print_command_error(ctx, "expected error running start function: \"%s\"", path); - result = Result::Error; + result = wabt::Result::Error; } else { ctx->passed++; - result = Result::Ok; + result = wabt::Result::Ok; } } else { print_command_error(ctx, "error reading module: \"%s\"", path); - result = Result::Error; + result = wabt::Result::Error; } - reset_interpreter_environment_to_mark(&ctx->env, mark); + reset_environment_to_mark(&ctx->env, mark); delete[] path; return result; } -static bool typed_values_are_equal(const InterpreterTypedValue* tv1, - const InterpreterTypedValue* tv2) { +static bool typed_values_are_equal(const TypedValue* tv1, + const TypedValue* tv2) { if (tv1->type != tv2->type) return false; @@ -1265,45 +1258,47 @@ static bool typed_values_are_equal(const InterpreterTypedValue* tv1, } } -static Result on_assert_return_command( +static wabt::Result on_assert_return_command( Context* ctx, Action* action, - const std::vector<InterpreterTypedValue>& expected) { - std::vector<InterpreterTypedValue> results; - InterpreterResult iresult; + const std::vector<TypedValue>& expected) { + std::vector<TypedValue> results; + interpreter::Result iresult; ctx->total++; - Result result = + wabt::Result result = run_action(ctx, action, &iresult, &results, RunVerbosity::Quiet); if (WABT_SUCCEEDED(result)) { - if (iresult == InterpreterResult::Ok) { + if (iresult == interpreter::Result::Ok) { if (results.size() == expected.size()) { for (size_t i = 0; i < results.size(); ++i) { - const InterpreterTypedValue* expected_tv = &expected[i]; - const InterpreterTypedValue* actual_tv = &results[i]; + const TypedValue* expected_tv = &expected[i]; + const TypedValue* actual_tv = &results[i]; if (!typed_values_are_equal(expected_tv, actual_tv)) { char expected_str[MAX_TYPED_VALUE_CHARS]; char actual_str[MAX_TYPED_VALUE_CHARS]; sprint_typed_value(expected_str, sizeof(expected_str), expected_tv); sprint_typed_value(actual_str, sizeof(actual_str), actual_tv); - print_command_error(ctx, "mismatch in result %" PRIzd - " of assert_return: expected %s, got %s", + print_command_error(ctx, + "mismatch in result %" PRIzd + " of assert_return: expected %s, got %s", i, expected_str, actual_str); - result = Result::Error; + result = wabt::Result::Error; } } } else { print_command_error( - ctx, "result length mismatch in assert_return: expected %" PRIzd - ", got %" PRIzd, + ctx, + "result length mismatch in assert_return: expected %" PRIzd + ", got %" PRIzd, expected.size(), results.size()); - result = Result::Error; + result = wabt::Result::Error; } } else { print_command_error(ctx, "unexpected trap: %s", s_trap_strings[static_cast<size_t>(iresult)]); - result = Result::Error; + result = wabt::Result::Error; } } @@ -1313,24 +1308,24 @@ static Result on_assert_return_command( return result; } -static Result on_assert_return_nan_command(Context* ctx, - Action* action, - bool canonical) { - std::vector<InterpreterTypedValue> results; - InterpreterResult iresult; +static wabt::Result on_assert_return_nan_command(Context* ctx, + Action* action, + bool canonical) { + std::vector<TypedValue> results; + interpreter::Result iresult; ctx->total++; - Result result = + wabt::Result result = run_action(ctx, action, &iresult, &results, RunVerbosity::Quiet); if (WABT_SUCCEEDED(result)) { - if (iresult == InterpreterResult::Ok) { + if (iresult == interpreter::Result::Ok) { if (results.size() != 1) { print_command_error(ctx, "expected one result, got %" PRIzd, results.size()); - result = Result::Error; + result = wabt::Result::Error; } - const InterpreterTypedValue& actual = results[0]; + const TypedValue& actual = results[0]; switch (actual.type) { case Type::F32: { typedef bool (*IsNanFunc)(uint32_t); @@ -1341,7 +1336,7 @@ static Result on_assert_return_nan_command(Context* ctx, sprint_typed_value(actual_str, sizeof(actual_str), &actual); print_command_error(ctx, "expected result to be nan, got %s", actual_str); - result = Result::Error; + result = wabt::Result::Error; } break; } @@ -1355,7 +1350,7 @@ static Result on_assert_return_nan_command(Context* ctx, sprint_typed_value(actual_str, sizeof(actual_str), &actual); print_command_error(ctx, "expected result to be nan, got %s", actual_str); - result = Result::Error; + result = wabt::Result::Error; } break; } @@ -1364,65 +1359,65 @@ static Result on_assert_return_nan_command(Context* ctx, print_command_error(ctx, "expected result type to be f32 or f64, got %s", get_type_name(actual.type)); - result = Result::Error; + result = wabt::Result::Error; break; } } else { print_command_error(ctx, "unexpected trap: %s", s_trap_strings[static_cast<int>(iresult)]); - result = Result::Error; + result = wabt::Result::Error; } } if (WABT_SUCCEEDED(result)) ctx->passed++; - return Result::Ok; + return wabt::Result::Ok; } -static Result on_assert_trap_command(Context* ctx, - Action* action, - StringSlice text) { - std::vector<InterpreterTypedValue> results; - InterpreterResult iresult; +static wabt::Result on_assert_trap_command(Context* ctx, + Action* action, + StringSlice text) { + std::vector<TypedValue> results; + interpreter::Result iresult; ctx->total++; - Result result = + wabt::Result result = run_action(ctx, action, &iresult, &results, RunVerbosity::Quiet); if (WABT_SUCCEEDED(result)) { - if (iresult != InterpreterResult::Ok) { + if (iresult != interpreter::Result::Ok) { ctx->passed++; } else { print_command_error(ctx, "expected trap: \"" PRIstringslice "\"", WABT_PRINTF_STRING_SLICE_ARG(text)); - result = Result::Error; + result = wabt::Result::Error; } } return result; } -static Result on_assert_exhaustion_command(Context* ctx, Action* action) { - std::vector<InterpreterTypedValue> results; - InterpreterResult iresult; +static wabt::Result on_assert_exhaustion_command(Context* ctx, Action* action) { + std::vector<TypedValue> results; + interpreter::Result iresult; ctx->total++; - Result result = + wabt::Result result = run_action(ctx, action, &iresult, &results, RunVerbosity::Quiet); if (WABT_SUCCEEDED(result)) { - if (iresult == InterpreterResult::TrapCallStackExhausted || - iresult == InterpreterResult::TrapValueStackExhausted) { + if (iresult == interpreter::Result::TrapCallStackExhausted || + iresult == interpreter::Result::TrapValueStackExhausted) { ctx->passed++; } else { print_command_error(ctx, "expected call stack exhaustion"); - result = Result::Error; + result = wabt::Result::Error; } } return result; } -static Result parse_command(Context* ctx) { +static wabt::Result parse_command(Context* ctx) { EXPECT("{"); EXPECT_KEY("type"); if (match(ctx, "\"module\"")) { @@ -1508,7 +1503,7 @@ static Result parse_command(Context* ctx) { on_assert_uninstantiable_command(ctx, filename, text); } else if (match(ctx, "\"assert_return\"")) { Action action; - std::vector<InterpreterTypedValue> expected; + std::vector<TypedValue> expected; EXPECT(","); CHECK_RESULT(parse_line(ctx)); @@ -1568,13 +1563,13 @@ static Result parse_command(Context* ctx) { on_assert_exhaustion_command(ctx, &action); } else { print_command_error(ctx, "unknown command type"); - return Result::Error; + return wabt::Result::Error; } EXPECT("}"); - return Result::Ok; + return wabt::Result::Ok; } -static Result parse_commands(Context* ctx) { +static wabt::Result parse_commands(Context* ctx) { EXPECT("{"); PARSE_KEY_STRING_VALUE("source_filename", &ctx->source_filename); EXPECT(","); @@ -1588,26 +1583,26 @@ static Result parse_commands(Context* ctx) { first = false; } EXPECT("}"); - return Result::Ok; + return wabt::Result::Ok; } static void destroy_context(Context* ctx) { delete[] ctx->json_data; } -static Result read_and_run_spec_json(const char* spec_json_filename) { +static wabt::Result read_and_run_spec_json(const char* spec_json_filename) { Context ctx; ctx.loc.filename = spec_json_filename; ctx.loc.line = 1; ctx.loc.first_column = 1; init_environment(&ctx.env); - init_interpreter_thread(&ctx.env, &ctx.thread, &s_thread_options); + init_thread(&ctx.env, &ctx.thread, &s_thread_options); char* data; size_t size; - Result result = read_file(spec_json_filename, &data, &size); + wabt::Result result = read_file(spec_json_filename, &data, &size); if (WABT_FAILED(result)) - return Result::Error; + return wabt::Result::Error; ctx.json_data = data; ctx.json_data_size = size; @@ -1624,13 +1619,13 @@ int ProgramMain(int argc, char** argv) { s_stdout_stream = FileStream::CreateStdout(); - Result result; + wabt::Result result; if (s_spec) { result = read_and_run_spec_json(s_infile); } else { result = read_and_run_module(s_infile); } - return result != Result::Ok; + return result != wabt::Result::Ok; } int main(int argc, char** argv) { |