diff options
Diffstat (limited to 'src/ast.c')
| -rw-r--r-- | src/ast.c | 378 |
1 files changed, 166 insertions, 212 deletions
@@ -19,8 +19,6 @@ #include <assert.h> #include <stddef.h> -#include "allocator.h" - int wabt_get_index_from_var(const WabtBindingHash* hash, const WabtVar* var) { if (var->type == WABT_VAR_TYPE_NAME) return wabt_find_binding_index_by_name(hash, &var->name); @@ -155,12 +153,11 @@ WabtModule* wabt_get_module_by_var(const WabtScript* script, } void wabt_make_type_binding_reverse_mapping( - struct WabtAllocator* allocator, const WabtTypeVector* types, const WabtBindingHash* bindings, WabtStringSliceVector* out_reverse_mapping) { uint32_t num_names = types->size; - wabt_reserve_string_slices(allocator, out_reverse_mapping, num_names); + wabt_reserve_string_slices(out_reverse_mapping, num_names); out_reverse_mapping->size = num_names; memset(out_reverse_mapping->data, 0, num_names * sizeof(WabtStringSlice)); @@ -201,10 +198,8 @@ void wabt_find_duplicate_bindings(const WabtBindingHash* bindings, } } -WabtModuleField* wabt_append_module_field(struct WabtAllocator* allocator, - WabtModule* module) { - WabtModuleField* result = - wabt_alloc_zero(allocator, sizeof(WabtModuleField), WABT_DEFAULT_ALIGN); +WabtModuleField* wabt_append_module_field(WabtModule* module) { + WabtModuleField* result = wabt_alloc_zero(sizeof(WabtModuleField)); if (!module->first_field) module->first_field = result; else if (module->last_field) @@ -213,58 +208,40 @@ WabtModuleField* wabt_append_module_field(struct WabtAllocator* allocator, return result; } -WabtFuncType* wabt_append_implicit_func_type(struct WabtAllocator* allocator, - WabtLocation* loc, +WabtFuncType* wabt_append_implicit_func_type(WabtLocation* loc, WabtModule* module, WabtFuncSignature* sig) { - WabtModuleField* field = wabt_append_module_field(allocator, module); + WabtModuleField* field = wabt_append_module_field(module); field->loc = *loc; field->type = WABT_MODULE_FIELD_TYPE_FUNC_TYPE; field->func_type.sig = *sig; WabtFuncType* func_type_ptr = &field->func_type; - wabt_append_func_type_ptr_value(allocator, &module->func_types, - &func_type_ptr); + wabt_append_func_type_ptr_value(&module->func_types, &func_type_ptr); return func_type_ptr; } -#define ALLOC_EXPR_TYPE_ZERO(allocator, member) \ - wabt_alloc_zero(allocator, \ - offsetof(WabtExpr, member) + sizeof(((WabtExpr*)0)->member), \ - WABT_DEFAULT_ALIGN) - -#define FOREACH_EXPR_TYPE(V) \ - V(WABT_EXPR_TYPE_BINARY, binary, binary) \ - V(WABT_EXPR_TYPE_BLOCK, block, block) \ - V(WABT_EXPR_TYPE_BR, br, br) \ - V(WABT_EXPR_TYPE_BR_IF, br_if, br_if) \ - V(WABT_EXPR_TYPE_BR_TABLE, br_table, br_table) \ - V(WABT_EXPR_TYPE_CALL, call, call) \ - V(WABT_EXPR_TYPE_CALL_INDIRECT, call_indirect, call_indirect) \ - V(WABT_EXPR_TYPE_COMPARE, compare, compare) \ - V(WABT_EXPR_TYPE_CONST, const, const_) \ - V(WABT_EXPR_TYPE_CONVERT, convert, convert) \ - V(WABT_EXPR_TYPE_GET_GLOBAL, get_global, get_global) \ - V(WABT_EXPR_TYPE_GET_LOCAL, get_local, get_local) \ - V(WABT_EXPR_TYPE_IF, if, if_) \ - V(WABT_EXPR_TYPE_LOAD, load, load) \ - V(WABT_EXPR_TYPE_LOOP, loop, loop) \ - V(WABT_EXPR_TYPE_SET_GLOBAL, set_global, set_global) \ - V(WABT_EXPR_TYPE_SET_LOCAL, set_local, set_local) \ - V(WABT_EXPR_TYPE_STORE, store, store) \ - V(WABT_EXPR_TYPE_TEE_LOCAL, tee_local, tee_local) \ - V(WABT_EXPR_TYPE_UNARY, unary, unary) - -#define DEFINE_NEW_EXPR(type_, name, member) \ - WabtExpr* wabt_new_##name##_expr(WabtAllocator* allocator) { \ - WabtExpr* result = ALLOC_EXPR_TYPE_ZERO(allocator, member); \ - result->type = type_; \ - return result; \ - } -FOREACH_EXPR_TYPE(DEFINE_NEW_EXPR) -#undef DEFINE_NEW_EXPR - -#define FOREACH_EMPTY_EXPR_TYPE(V) \ +#define FOREACH_EXPR_TYPE(V) \ + V(WABT_EXPR_TYPE_BINARY, binary) \ + V(WABT_EXPR_TYPE_BLOCK, block) \ + V(WABT_EXPR_TYPE_BR, br) \ + V(WABT_EXPR_TYPE_BR_IF, br_if) \ + V(WABT_EXPR_TYPE_BR_TABLE, br_table) \ + V(WABT_EXPR_TYPE_CALL, call) \ + V(WABT_EXPR_TYPE_CALL_INDIRECT, call_indirect) \ + V(WABT_EXPR_TYPE_COMPARE, compare) \ + V(WABT_EXPR_TYPE_CONST, const) \ + V(WABT_EXPR_TYPE_CONVERT, convert) \ + V(WABT_EXPR_TYPE_GET_GLOBAL, get_global) \ + V(WABT_EXPR_TYPE_GET_LOCAL, get_local) \ + V(WABT_EXPR_TYPE_IF, if) \ + V(WABT_EXPR_TYPE_LOAD, load) \ + V(WABT_EXPR_TYPE_LOOP, loop) \ + V(WABT_EXPR_TYPE_SET_GLOBAL, set_global) \ + V(WABT_EXPR_TYPE_SET_LOCAL, set_local) \ + V(WABT_EXPR_TYPE_STORE, store) \ + V(WABT_EXPR_TYPE_TEE_LOCAL, tee_local) \ + V(WABT_EXPR_TYPE_UNARY, unary) \ V(WABT_EXPR_TYPE_CURRENT_MEMORY, current_memory) \ V(WABT_EXPR_TYPE_DROP, drop) \ V(WABT_EXPR_TYPE_GROW_MEMORY, grow_memory) \ @@ -273,95 +250,86 @@ FOREACH_EXPR_TYPE(DEFINE_NEW_EXPR) V(WABT_EXPR_TYPE_SELECT, select) \ V(WABT_EXPR_TYPE_UNREACHABLE, unreachable) -#define DEFINE_NEW_EMPTY_EXPR(type_, name) \ - WabtExpr* wabt_new_##name##_expr(WabtAllocator* allocator) { \ - WabtExpr* result = ALLOC_EXPR_TYPE_ZERO(allocator, next); \ - result->type = type_; \ - return result; \ +#define DEFINE_NEW_EXPR(type_, name) \ + WabtExpr* wabt_new_##name##_expr(void) { \ + WabtExpr* result = wabt_alloc_zero(sizeof(WabtExpr)); \ + result->type = type_; \ + return result; \ } -FOREACH_EMPTY_EXPR_TYPE(DEFINE_NEW_EMPTY_EXPR) -#undef DEFINE_NEW_EMPTY_EXPR - -WabtExpr* wabt_new_empty_expr(struct WabtAllocator* allocator, - WabtExprType type) { - WabtExpr* result = ALLOC_EXPR_TYPE_ZERO(allocator, next); - result->type = type; - return result; -} +FOREACH_EXPR_TYPE(DEFINE_NEW_EXPR) +#undef DEFINE_NEW_EXPR -void wabt_destroy_var(WabtAllocator* allocator, WabtVar* var) { +void wabt_destroy_var(WabtVar* var) { if (var->type == WABT_VAR_TYPE_NAME) - wabt_destroy_string_slice(allocator, &var->name); + wabt_destroy_string_slice(&var->name); } -void wabt_destroy_var_vector_and_elements(WabtAllocator* allocator, - WabtVarVector* vars) { - WABT_DESTROY_VECTOR_AND_ELEMENTS(allocator, *vars, var); +void wabt_destroy_var_vector_and_elements(WabtVarVector* vars) { + WABT_DESTROY_VECTOR_AND_ELEMENTS(*vars, var); } -void wabt_destroy_func_signature(WabtAllocator* allocator, - WabtFuncSignature* sig) { - wabt_destroy_type_vector(allocator, &sig->param_types); - wabt_destroy_type_vector(allocator, &sig->result_types); +void wabt_destroy_func_signature(WabtFuncSignature* sig) { + wabt_destroy_type_vector(&sig->param_types); + wabt_destroy_type_vector(&sig->result_types); } -void wabt_destroy_expr_list(WabtAllocator* allocator, WabtExpr* first) { +void wabt_destroy_expr_list(WabtExpr* first) { WabtExpr* expr = first; while (expr) { WabtExpr* next = expr->next; - wabt_destroy_expr(allocator, expr); + wabt_destroy_expr(expr); expr = next; } } -void wabt_destroy_block(WabtAllocator* allocator, WabtBlock* block) { - wabt_destroy_string_slice(allocator, &block->label); - wabt_destroy_type_vector(allocator, &block->sig); - wabt_destroy_expr_list(allocator, block->first); +void wabt_destroy_block(WabtBlock* block) { + wabt_destroy_string_slice(&block->label); + wabt_destroy_type_vector(&block->sig); + wabt_destroy_expr_list(block->first); } -void wabt_destroy_expr(WabtAllocator* allocator, WabtExpr* expr) { +void wabt_destroy_expr(WabtExpr* expr) { switch (expr->type) { case WABT_EXPR_TYPE_BLOCK: - wabt_destroy_block(allocator, &expr->block); + wabt_destroy_block(&expr->block); break; case WABT_EXPR_TYPE_BR: - wabt_destroy_var(allocator, &expr->br.var); + wabt_destroy_var(&expr->br.var); break; case WABT_EXPR_TYPE_BR_IF: - wabt_destroy_var(allocator, &expr->br_if.var); + wabt_destroy_var(&expr->br_if.var); break; case WABT_EXPR_TYPE_BR_TABLE: - WABT_DESTROY_VECTOR_AND_ELEMENTS(allocator, expr->br_table.targets, var); - wabt_destroy_var(allocator, &expr->br_table.default_target); + WABT_DESTROY_VECTOR_AND_ELEMENTS(expr->br_table.targets, var); + wabt_destroy_var(&expr->br_table.default_target); break; case WABT_EXPR_TYPE_CALL: - wabt_destroy_var(allocator, &expr->call.var); + wabt_destroy_var(&expr->call.var); break; case WABT_EXPR_TYPE_CALL_INDIRECT: - wabt_destroy_var(allocator, &expr->call_indirect.var); + wabt_destroy_var(&expr->call_indirect.var); break; case WABT_EXPR_TYPE_GET_GLOBAL: - wabt_destroy_var(allocator, &expr->get_global.var); + wabt_destroy_var(&expr->get_global.var); break; case WABT_EXPR_TYPE_GET_LOCAL: - wabt_destroy_var(allocator, &expr->get_local.var); + wabt_destroy_var(&expr->get_local.var); break; case WABT_EXPR_TYPE_IF: - wabt_destroy_block(allocator, &expr->if_.true_); - wabt_destroy_expr_list(allocator, expr->if_.false_); + wabt_destroy_block(&expr->if_.true_); + wabt_destroy_expr_list(expr->if_.false_); break; case WABT_EXPR_TYPE_LOOP: - wabt_destroy_block(allocator, &expr->loop); + wabt_destroy_block(&expr->loop); break; case WABT_EXPR_TYPE_SET_GLOBAL: - wabt_destroy_var(allocator, &expr->set_global.var); + wabt_destroy_var(&expr->set_global.var); break; case WABT_EXPR_TYPE_SET_LOCAL: - wabt_destroy_var(allocator, &expr->set_local.var); + wabt_destroy_var(&expr->set_local.var); break; case WABT_EXPR_TYPE_TEE_LOCAL: - wabt_destroy_var(allocator, &expr->tee_local.var); + wabt_destroy_var(&expr->tee_local.var); break; case WABT_EXPR_TYPE_BINARY: @@ -380,45 +348,44 @@ void wabt_destroy_expr(WabtAllocator* allocator, WabtExpr* expr) { case WABT_EXPR_TYPE_UNREACHABLE: break; } - wabt_free(allocator, expr); + wabt_free(expr); } -void wabt_destroy_func_declaration(WabtAllocator* allocator, - WabtFuncDeclaration* decl) { - wabt_destroy_var(allocator, &decl->type_var); +void wabt_destroy_func_declaration(WabtFuncDeclaration* decl) { + wabt_destroy_var(&decl->type_var); if (!(decl->flags & WABT_FUNC_DECLARATION_FLAG_SHARED_SIGNATURE)) - wabt_destroy_func_signature(allocator, &decl->sig); + wabt_destroy_func_signature(&decl->sig); } -void wabt_destroy_func(WabtAllocator* allocator, WabtFunc* func) { - wabt_destroy_string_slice(allocator, &func->name); - wabt_destroy_func_declaration(allocator, &func->decl); - wabt_destroy_type_vector(allocator, &func->local_types); - wabt_destroy_binding_hash(allocator, &func->param_bindings); - wabt_destroy_binding_hash(allocator, &func->local_bindings); - wabt_destroy_expr_list(allocator, func->first_expr); +void wabt_destroy_func(WabtFunc* func) { + wabt_destroy_string_slice(&func->name); + wabt_destroy_func_declaration(&func->decl); + wabt_destroy_type_vector(&func->local_types); + wabt_destroy_binding_hash(&func->param_bindings); + wabt_destroy_binding_hash(&func->local_bindings); + wabt_destroy_expr_list(func->first_expr); } -void wabt_destroy_global(WabtAllocator* allocator, WabtGlobal* global) { - wabt_destroy_string_slice(allocator, &global->name); - wabt_destroy_expr_list(allocator, global->init_expr); +void wabt_destroy_global(WabtGlobal* global) { + wabt_destroy_string_slice(&global->name); + wabt_destroy_expr_list(global->init_expr); } -void wabt_destroy_import(WabtAllocator* allocator, WabtImport* import) { - wabt_destroy_string_slice(allocator, &import->module_name); - wabt_destroy_string_slice(allocator, &import->field_name); +void wabt_destroy_import(WabtImport* import) { + wabt_destroy_string_slice(&import->module_name); + wabt_destroy_string_slice(&import->field_name); switch (import->kind) { case WABT_EXTERNAL_KIND_FUNC: - wabt_destroy_func(allocator, &import->func); + wabt_destroy_func(&import->func); break; case WABT_EXTERNAL_KIND_TABLE: - wabt_destroy_table(allocator, &import->table); + wabt_destroy_table(&import->table); break; case WABT_EXTERNAL_KIND_MEMORY: - wabt_destroy_memory(allocator, &import->memory); + wabt_destroy_memory(&import->memory); break; case WABT_EXTERNAL_KIND_GLOBAL: - wabt_destroy_global(allocator, &import->global); + wabt_destroy_global(&import->global); break; case WABT_NUM_EXTERNAL_KINDS: assert(0); @@ -426,168 +393,158 @@ void wabt_destroy_import(WabtAllocator* allocator, WabtImport* import) { } } -void wabt_destroy_export(WabtAllocator* allocator, WabtExport* export) { - wabt_destroy_string_slice(allocator, &export->name); - wabt_destroy_var(allocator, &export->var); +void wabt_destroy_export(WabtExport* export) { + wabt_destroy_string_slice(&export->name); + wabt_destroy_var(&export->var); } -void wabt_destroy_func_type(WabtAllocator* allocator, WabtFuncType* func_type) { - wabt_destroy_string_slice(allocator, &func_type->name); - wabt_destroy_func_signature(allocator, &func_type->sig); +void wabt_destroy_func_type(WabtFuncType* func_type) { + wabt_destroy_string_slice(&func_type->name); + wabt_destroy_func_signature(&func_type->sig); } -void wabt_destroy_data_segment(WabtAllocator* allocator, - WabtDataSegment* data) { - wabt_destroy_var(allocator, &data->memory_var); - wabt_destroy_expr_list(allocator, data->offset); - wabt_free(allocator, data->data); +void wabt_destroy_data_segment(WabtDataSegment* data) { + wabt_destroy_var(&data->memory_var); + wabt_destroy_expr_list(data->offset); + wabt_free(data->data); } -void wabt_destroy_memory(struct WabtAllocator* allocator, WabtMemory* memory) { - wabt_destroy_string_slice(allocator, &memory->name); +void wabt_destroy_memory(WabtMemory* memory) { + wabt_destroy_string_slice(&memory->name); } -void wabt_destroy_table(struct WabtAllocator* allocator, WabtTable* table) { - wabt_destroy_string_slice(allocator, &table->name); +void wabt_destroy_table(WabtTable* table) { + wabt_destroy_string_slice(&table->name); } -static void destroy_module_field(WabtAllocator* allocator, - WabtModuleField* field) { +static void destroy_module_field(WabtModuleField* field) { switch (field->type) { case WABT_MODULE_FIELD_TYPE_FUNC: - wabt_destroy_func(allocator, &field->func); + wabt_destroy_func(&field->func); break; case WABT_MODULE_FIELD_TYPE_GLOBAL: - wabt_destroy_global(allocator, &field->global); + wabt_destroy_global(&field->global); break; case WABT_MODULE_FIELD_TYPE_IMPORT: - wabt_destroy_import(allocator, &field->import); + wabt_destroy_import(&field->import); break; case WABT_MODULE_FIELD_TYPE_EXPORT: - wabt_destroy_export(allocator, &field->export_); + wabt_destroy_export(&field->export_); break; case WABT_MODULE_FIELD_TYPE_FUNC_TYPE: - wabt_destroy_func_type(allocator, &field->func_type); + wabt_destroy_func_type(&field->func_type); break; case WABT_MODULE_FIELD_TYPE_TABLE: - wabt_destroy_table(allocator, &field->table); + wabt_destroy_table(&field->table); break; case WABT_MODULE_FIELD_TYPE_ELEM_SEGMENT: - wabt_destroy_elem_segment(allocator, &field->elem_segment); + wabt_destroy_elem_segment(&field->elem_segment); break; case WABT_MODULE_FIELD_TYPE_MEMORY: - wabt_destroy_memory(allocator, &field->memory); + wabt_destroy_memory(&field->memory); break; case WABT_MODULE_FIELD_TYPE_DATA_SEGMENT: - wabt_destroy_data_segment(allocator, &field->data_segment); + wabt_destroy_data_segment(&field->data_segment); break; case WABT_MODULE_FIELD_TYPE_START: - wabt_destroy_var(allocator, &field->start); + wabt_destroy_var(&field->start); break; } } -void wabt_destroy_module(WabtAllocator* allocator, WabtModule* module) { - wabt_destroy_string_slice(allocator, &module->name); +void wabt_destroy_module(WabtModule* module) { + wabt_destroy_string_slice(&module->name); WabtModuleField* field = module->first_field; while (field != NULL) { WabtModuleField* next_field = field->next; - destroy_module_field(allocator, field); - wabt_free(allocator, field); + destroy_module_field(field); + wabt_free(field); field = next_field; } /* everything that follows shares data with the module fields above, so we only need to destroy the containing vectors */ - wabt_destroy_func_ptr_vector(allocator, &module->funcs); - wabt_destroy_global_ptr_vector(allocator, &module->globals); - wabt_destroy_import_ptr_vector(allocator, &module->imports); - wabt_destroy_export_ptr_vector(allocator, &module->exports); - wabt_destroy_func_type_ptr_vector(allocator, &module->func_types); - wabt_destroy_table_ptr_vector(allocator, &module->tables); - wabt_destroy_elem_segment_ptr_vector(allocator, &module->elem_segments); - wabt_destroy_memory_ptr_vector(allocator, &module->memories); - wabt_destroy_data_segment_ptr_vector(allocator, &module->data_segments); - wabt_destroy_binding_hash_entry_vector(allocator, - &module->func_bindings.entries); - wabt_destroy_binding_hash_entry_vector(allocator, - &module->global_bindings.entries); - wabt_destroy_binding_hash_entry_vector(allocator, - &module->export_bindings.entries); - wabt_destroy_binding_hash_entry_vector(allocator, - &module->func_type_bindings.entries); - wabt_destroy_binding_hash_entry_vector(allocator, - &module->table_bindings.entries); - wabt_destroy_binding_hash_entry_vector(allocator, - &module->memory_bindings.entries); -} - -void wabt_destroy_raw_module(WabtAllocator* allocator, WabtRawModule* raw) { + wabt_destroy_func_ptr_vector(&module->funcs); + wabt_destroy_global_ptr_vector(&module->globals); + wabt_destroy_import_ptr_vector(&module->imports); + wabt_destroy_export_ptr_vector(&module->exports); + wabt_destroy_func_type_ptr_vector(&module->func_types); + wabt_destroy_table_ptr_vector(&module->tables); + wabt_destroy_elem_segment_ptr_vector(&module->elem_segments); + wabt_destroy_memory_ptr_vector(&module->memories); + wabt_destroy_data_segment_ptr_vector(&module->data_segments); + wabt_destroy_binding_hash_entry_vector(&module->func_bindings.entries); + wabt_destroy_binding_hash_entry_vector(&module->global_bindings.entries); + wabt_destroy_binding_hash_entry_vector(&module->export_bindings.entries); + wabt_destroy_binding_hash_entry_vector(&module->func_type_bindings.entries); + wabt_destroy_binding_hash_entry_vector(&module->table_bindings.entries); + wabt_destroy_binding_hash_entry_vector(&module->memory_bindings.entries); +} + +void wabt_destroy_raw_module(WabtRawModule* raw) { if (raw->type == WABT_RAW_MODULE_TYPE_TEXT) { - wabt_destroy_module(allocator, raw->text); - wabt_free(allocator, raw->text); + wabt_destroy_module(raw->text); + wabt_free(raw->text); } else { - wabt_destroy_string_slice(allocator, &raw->binary.name); - wabt_free(allocator, raw->binary.data); + wabt_destroy_string_slice(&raw->binary.name); + wabt_free(raw->binary.data); } } -void wabt_destroy_action(WabtAllocator* allocator, WabtAction* action) { - wabt_destroy_var(allocator, &action->module_var); +void wabt_destroy_action(WabtAction* action) { + wabt_destroy_var(&action->module_var); switch (action->type) { case WABT_ACTION_TYPE_INVOKE: - wabt_destroy_string_slice(allocator, &action->invoke.name); - wabt_destroy_const_vector(allocator, &action->invoke.args); + wabt_destroy_string_slice(&action->invoke.name); + wabt_destroy_const_vector(&action->invoke.args); break; case WABT_ACTION_TYPE_GET: - wabt_destroy_string_slice(allocator, &action->get.name); + wabt_destroy_string_slice(&action->get.name); break; } } -void wabt_destroy_command(WabtAllocator* allocator, WabtCommand* command) { +void wabt_destroy_command(WabtCommand* command) { switch (command->type) { case WABT_COMMAND_TYPE_MODULE: - wabt_destroy_module(allocator, &command->module); + wabt_destroy_module(&command->module); break; case WABT_COMMAND_TYPE_ACTION: - wabt_destroy_action(allocator, &command->action); + wabt_destroy_action(&command->action); break; case WABT_COMMAND_TYPE_REGISTER: - wabt_destroy_string_slice(allocator, &command->register_.module_name); - wabt_destroy_var(allocator, &command->register_.var); + wabt_destroy_string_slice(&command->register_.module_name); + wabt_destroy_var(&command->register_.var); break; case WABT_COMMAND_TYPE_ASSERT_MALFORMED: - wabt_destroy_raw_module(allocator, &command->assert_malformed.module); - wabt_destroy_string_slice(allocator, &command->assert_malformed.text); + wabt_destroy_raw_module(&command->assert_malformed.module); + wabt_destroy_string_slice(&command->assert_malformed.text); break; case WABT_COMMAND_TYPE_ASSERT_INVALID: case WABT_COMMAND_TYPE_ASSERT_INVALID_NON_BINARY: - wabt_destroy_raw_module(allocator, &command->assert_invalid.module); - wabt_destroy_string_slice(allocator, &command->assert_invalid.text); + wabt_destroy_raw_module(&command->assert_invalid.module); + wabt_destroy_string_slice(&command->assert_invalid.text); break; case WABT_COMMAND_TYPE_ASSERT_UNLINKABLE: - wabt_destroy_raw_module(allocator, &command->assert_unlinkable.module); - wabt_destroy_string_slice(allocator, &command->assert_unlinkable.text); + wabt_destroy_raw_module(&command->assert_unlinkable.module); + wabt_destroy_string_slice(&command->assert_unlinkable.text); break; case WABT_COMMAND_TYPE_ASSERT_UNINSTANTIABLE: - wabt_destroy_raw_module(allocator, - &command->assert_uninstantiable.module); - wabt_destroy_string_slice(allocator, - &command->assert_uninstantiable.text); + wabt_destroy_raw_module(&command->assert_uninstantiable.module); + wabt_destroy_string_slice(&command->assert_uninstantiable.text); break; case WABT_COMMAND_TYPE_ASSERT_RETURN: - wabt_destroy_action(allocator, &command->assert_return.action); - wabt_destroy_const_vector(allocator, &command->assert_return.expected); + wabt_destroy_action(&command->assert_return.action); + wabt_destroy_const_vector(&command->assert_return.expected); break; case WABT_COMMAND_TYPE_ASSERT_RETURN_NAN: - wabt_destroy_action(allocator, &command->assert_return_nan.action); + wabt_destroy_action(&command->assert_return_nan.action); break; case WABT_COMMAND_TYPE_ASSERT_TRAP: case WABT_COMMAND_TYPE_ASSERT_EXHAUSTION: - wabt_destroy_action(allocator, &command->assert_trap.action); - wabt_destroy_string_slice(allocator, &command->assert_trap.text); + wabt_destroy_action(&command->assert_trap.action); + wabt_destroy_string_slice(&command->assert_trap.text); break; case WABT_NUM_COMMAND_TYPES: assert(0); @@ -595,22 +552,19 @@ void wabt_destroy_command(WabtAllocator* allocator, WabtCommand* command) { } } -void wabt_destroy_command_vector_and_elements(WabtAllocator* allocator, - WabtCommandVector* commands) { - WABT_DESTROY_VECTOR_AND_ELEMENTS(allocator, *commands, command); +void wabt_destroy_command_vector_and_elements(WabtCommandVector* commands) { + WABT_DESTROY_VECTOR_AND_ELEMENTS(*commands, command); } -void wabt_destroy_elem_segment(WabtAllocator* allocator, - WabtElemSegment* elem) { - wabt_destroy_var(allocator, &elem->table_var); - wabt_destroy_expr_list(allocator, elem->offset); - WABT_DESTROY_VECTOR_AND_ELEMENTS(allocator, elem->vars, var); +void wabt_destroy_elem_segment(WabtElemSegment* elem) { + wabt_destroy_var(&elem->table_var); + wabt_destroy_expr_list(elem->offset); + WABT_DESTROY_VECTOR_AND_ELEMENTS(elem->vars, var); } void wabt_destroy_script(WabtScript* script) { - WABT_DESTROY_VECTOR_AND_ELEMENTS(script->allocator, script->commands, - command); - wabt_destroy_binding_hash(script->allocator, &script->module_bindings); + WABT_DESTROY_VECTOR_AND_ELEMENTS(script->commands, command); + wabt_destroy_binding_hash(&script->module_bindings); } #define CHECK_RESULT(expr) \ |