bh_arena_init(&debug->tmp_arena, bh_heap_allocator(), 16 * 1024);
debug->tmp_alloc = bh_arena_allocator(&debug->tmp_arena);
-
+
debug->info = NULL;
debug->threads = NULL;
u32 offset = 0;
info->has_debug_info = true;
- i32 count = uleb128_to_uint(data, &offset);
+ i32 count = uleb128_to_uint(data, (i32 *)&offset);
fori (i, 0, (i32) count) {
debug_file_info_t file_info;
file_info.line_buffer_offset = -1;
- u32 file_id = uleb128_to_uint(data, &offset);
+ u32 file_id = uleb128_to_uint(data, (i32 *)&offset);
file_info.file_id = file_id;
- file_info.line_count = uleb128_to_uint(data, &offset);
+ file_info.line_count = uleb128_to_uint(data, (i32 *)&offset);
- u32 name_length = uleb128_to_uint(data, &offset);
+ u32 name_length = uleb128_to_uint(data, (i32 *)&offset);
file_info.name = bh_alloc_array(info->alloc, char, name_length + 1);
memcpy(file_info.name, data + offset, name_length);
file_info.name[name_length] = 0;
u32 offset = 0;
info->has_debug_info = true;
- i32 count = uleb128_to_uint(data, &offset);
+ i32 count = uleb128_to_uint(data, (i32 *)&offset);
fori (i, 0, (i32) count) {
debug_func_info_t func_info;
- func_info.func_id = uleb128_to_uint(data, &offset);
- func_info.file_id = uleb128_to_uint(data, &offset);
- func_info.line = uleb128_to_uint(data, &offset);
+ func_info.func_id = uleb128_to_uint(data, (i32 *)&offset);
+ func_info.file_id = uleb128_to_uint(data, (i32 *)&offset);
+ func_info.line = uleb128_to_uint(data, (i32 *)&offset);
- u32 name_length = uleb128_to_uint(data, &offset);
+ u32 name_length = uleb128_to_uint(data, (i32 *)&offset);
if (name_length == 0) {
func_info.name = NULL;
} else {
}
func_info.internal = data[offset++] != 0;
- func_info.debug_op_offset = uleb128_to_uint(data, &offset);
- func_info.stack_ptr_idx = uleb128_to_uint(data, &offset);
+ func_info.debug_op_offset = uleb128_to_uint(data, (i32 *)&offset);
+ func_info.stack_ptr_idx = uleb128_to_uint(data, (i32 *)&offset);
- uleb128_to_uint(data, &offset);
+ uleb128_to_uint(data, (i32 *)&offset);
bh_arr_set_at(info->funcs, func_info.func_id, func_info);
}
u32 offset = 0;
info->has_debug_info = true;
- i32 count = uleb128_to_uint(data, &offset);
+ i32 count = uleb128_to_uint(data, (i32 *)&offset);
fori (i, 0, count) {
debug_sym_info_t sym_info;
- sym_info.sym_id = uleb128_to_uint(data, &offset);
+ sym_info.sym_id = uleb128_to_uint(data, (i32 *)&offset);
- u32 name_length = uleb128_to_uint(data, &offset);
+ u32 name_length = uleb128_to_uint(data, (i32 *)&offset);
if (name_length == 0) {
sym_info.name = NULL;
} else {
sym_info.name[name_length] = 0;
offset += name_length;
}
-
- sym_info.loc_kind = uleb128_to_uint(data, &offset);
- sym_info.loc = uleb128_to_uint(data, &offset);
- sym_info.type = uleb128_to_uint(data, &offset);
+
+ sym_info.loc_kind = uleb128_to_uint(data, (i32 *)&offset);
+ sym_info.loc = uleb128_to_uint(data, (i32 *)&offset);
+ sym_info.type = uleb128_to_uint(data, (i32 *)&offset);
bh_arr_set_at(info->symbols, sym_info.sym_id, sym_info);
}
u32 offset = 0;
info->has_debug_info = true;
- i32 count = uleb128_to_uint(data, &offset);
+ i32 count = uleb128_to_uint(data, (i32 *)&offset);
fori (i, 0, count) {
debug_type_info_t type;
- type.id = uleb128_to_uint(data, &offset);
+ type.id = uleb128_to_uint(data, (i32 *)&offset);
- u32 name_length = uleb128_to_uint(data, &offset);
+ u32 name_length = uleb128_to_uint(data, (i32 *)&offset);
if (name_length == 0) {
type.name = NULL;
} else {
offset += name_length;
}
- type.size = uleb128_to_uint(data, &offset);
- type.kind = uleb128_to_uint(data, &offset);
+ type.size = uleb128_to_uint(data, (i32 *)&offset);
+ type.kind = uleb128_to_uint(data, (i32 *)&offset);
switch (type.kind) {
case debug_type_kind_primitive:
- type.primitive.primitive_kind = uleb128_to_uint(data, &offset);
+ type.primitive.primitive_kind = uleb128_to_uint(data, (i32 *)&offset);
break;
case debug_type_kind_modifier:
- type.modifier.modifier_kind = uleb128_to_uint(data, &offset);
- type.modifier.modified_type = uleb128_to_uint(data, &offset);
+ type.modifier.modifier_kind = uleb128_to_uint(data, (i32 *)&offset);
+ type.modifier.modified_type = uleb128_to_uint(data, (i32 *)&offset);
break;
case debug_type_kind_structure:
- type.structure.simple = uleb128_to_uint(data, &offset);
+ type.structure.simple = uleb128_to_uint(data, (i32 *)&offset);
- type.structure.member_count = uleb128_to_uint(data, &offset);
+ type.structure.member_count = uleb128_to_uint(data, (i32 *)&offset);
type.structure.members = bh_alloc_array(info->alloc, debug_type_structure_member_t, type.structure.member_count);
fori (i, 0, type.structure.member_count) {
- type.structure.members[i].offset = uleb128_to_uint(data, &offset);
- type.structure.members[i].type = uleb128_to_uint(data, &offset);
+ type.structure.members[i].offset = uleb128_to_uint(data, (i32 *)&offset);
+ type.structure.members[i].type = uleb128_to_uint(data, (i32 *)&offset);
- u32 name_length = uleb128_to_uint(data, &offset);
+ u32 name_length = uleb128_to_uint(data, (i32 *)&offset);
type.structure.members[i].name = bh_alloc_array(info->alloc, char, name_length + 1);
memcpy(type.structure.members[i].name, data + offset, name_length);
type.structure.members[i].name[name_length] = 0;
break;
case debug_type_kind_array:
- type.array.count = uleb128_to_uint(data, &offset);
- type.array.type = uleb128_to_uint(data, &offset);
+ type.array.count = uleb128_to_uint(data, (i32 *)&offset);
+ type.array.type = uleb128_to_uint(data, (i32 *)&offset);
break;
case debug_type_kind_alias:
- type.alias.alias_kind = uleb128_to_uint(data, &offset);
- type.alias.aliased_type = uleb128_to_uint(data, &offset);
+ type.alias.alias_kind = uleb128_to_uint(data, (i32 *)&offset);
+ type.alias.aliased_type = uleb128_to_uint(data, (i32 *)&offset);
break;
case debug_type_kind_function:
- type.function.param_count = uleb128_to_uint(data, &offset);
+ type.function.param_count = uleb128_to_uint(data, (i32 *)&offset);
type.function.param_types = bh_alloc_array(info->alloc, u32, type.function.param_count);
fori (i, 0, type.function.param_count) {
- type.function.param_types[i] = uleb128_to_uint(data, &offset);
+ type.function.param_types[i] = uleb128_to_uint(data, (i32 *)&offset);
}
- type.function.return_type = uleb128_to_uint(data, &offset);
+ type.function.return_type = uleb128_to_uint(data, (i32 *)&offset);
break;
case debug_type_kind_slice:
- type.slice.type = uleb128_to_uint(data, &offset);
+ type.slice.type = uleb128_to_uint(data, (i32 *)&offset);
break;
case debug_type_kind_enum:
- type.enumeration.backing_type = uleb128_to_uint(data, &offset);
- type.enumeration.value_count = uleb128_to_uint(data, &offset);
+ type.enumeration.backing_type = uleb128_to_uint(data, (i32 *)&offset);
+ type.enumeration.value_count = uleb128_to_uint(data, (i32 *)&offset);
type.enumeration.values = bh_alloc_array(info->alloc, debug_type_enum_value_t, type.enumeration.value_count);
fori (i, 0, type.enumeration.value_count) {
- type.enumeration.values[i].value = uleb128_to_uint(data, &offset);
+ type.enumeration.values[i].value = uleb128_to_uint(data, (i32 *)&offset);
- u32 name_length = uleb128_to_uint(data, &offset);
+ u32 name_length = uleb128_to_uint(data, (i32 *)&offset);
type.enumeration.values[i].name = bh_alloc_array(info->alloc, char, name_length + 1);
memcpy(type.enumeration.values[i].name, data + offset, name_length);
type.enumeration.values[i].name[name_length] = 0;
break;
case debug_type_kind_union:
- type.onion.tag_size = uleb128_to_uint(data, &offset);
- type.onion.variant_count = uleb128_to_uint(data, &offset);
+ type.onion.tag_size = uleb128_to_uint(data, (i32 *)&offset);
+ type.onion.variant_count = uleb128_to_uint(data, (i32 *)&offset);
type.onion.variants = bh_alloc_array(info->alloc, debug_type_union_variant_t, type.onion.variant_count);
-
+
fori (i, 0, type.onion.variant_count) {
- u32 name_length = uleb128_to_uint(data, &offset);
+ u32 name_length = uleb128_to_uint(data, (i32 *)&offset);
type.onion.variants[i].name = bh_alloc_array(info->alloc, char, name_length + 1);
memcpy(type.onion.variants[i].name, data + offset, name_length);
type.onion.variants[i].name[name_length] = 0;
offset += name_length;
-
- type.onion.variants[i].type = uleb128_to_uint(data, &offset);
+
+ type.onion.variants[i].type = uleb128_to_uint(data, (i32 *)&offset);
}
break;
// Error handling
- default: assert(("Unrecognized type kind", 0));
+ default: assert(0 && "Unrecognized type kind");
}
bh_arr_set_at(info->types, type.id, type);
static i32 debug_info_builder_push_scope(debug_info_builder_t *builder) {
debug_sym_scope_t scope;
scope.symbols = NULL;
- bh_arr_new(builder->info->alloc, scope.symbols, 4);
+ bh_arr_new(builder->info->alloc, scope.symbols, 4);
scope.parent = builder->current_scope;
i32 scope_id = bh_arr_length(builder->info->symbol_scopes);
switch (instr) {
case 0: builder->locked = 1; break; // Early return!
case 1:
- builder->current_file_id = uleb128_to_uint(builder->data, &builder->reader_offset);
- builder->current_line = uleb128_to_uint(builder->data, &builder->reader_offset);
+ builder->current_file_id = uleb128_to_uint(builder->data, (i32 *)&builder->reader_offset);
+ builder->current_line = uleb128_to_uint(builder->data, (i32 *)&builder->reader_offset);
break;
case 2:
debug_info_builder_push_scope(builder);
break;
-
+
case 3:
debug_info_builder_pop_scope(builder);
break;
case 4:
debug_info_builder_add_symbol(
builder,
- uleb128_to_uint(builder->data, &builder->reader_offset));
+ uleb128_to_uint(builder->data, (i32 *)&builder->reader_offset));
break;
}
break;
while (builder->remaining_reps == 0 && !builder->locked) {
debug_info_builder_parse(builder);
- debug_loc_info_t info;
+ debug_loc_info_t info;
info.file_id = builder->current_file_id;
info.line = builder->current_line;
info.symbol_scope = builder->current_scope;
void debug_info_builder_end_func(debug_info_builder_t *builder) {
if (!builder->data) return;
-
+
assert(!builder->locked);
debug_info_builder_step(builder);
assert(builder->locked);
return false;
}
- *out = stack_ptr.u32;
+ *out = stack_ptr.u32;
return true;
}
case debug_type_primitive_kind_void: WRITE("void"); break;
case debug_type_primitive_kind_signed_integer:
switch (type->size) {
- case 1: WRITE_FORMAT("%hhd", *(i8 *) base); break;
- case 2: WRITE_FORMAT("%hd", *(i16 *) base); break;
- case 4: WRITE_FORMAT("%d", *(i32 *) base); break;
- case 8: WRITE_FORMAT("%ld", *(i64 *) base); break;
+ case 1: WRITE_FORMAT("%hhd", *(i8 *) base); break;
+ case 2: WRITE_FORMAT("%hd", *(i16 *) base); break;
+ case 4: WRITE_FORMAT("%d", *(i32 *) base); break;
+ case 8: WRITE_FORMAT("%lld", *(i64 *) base); break;
default: WRITE("(err)"); break;
}
break;
case debug_type_primitive_kind_unsigned_integer:
switch (type->size) {
- case 1: WRITE_FORMAT("%hhu", *(u8 *) base); break;
- case 2: WRITE_FORMAT("%hu", *(u16 *) base); break;
- case 4: WRITE_FORMAT("%u", *(u32 *) base); break;
- case 8: WRITE_FORMAT("%lu", *(u64 *) base); break;
+ case 1: WRITE_FORMAT("%hhu", *(u8 *) base); break;
+ case 2: WRITE_FORMAT("%hu", *(u16 *) base); break;
+ case 4: WRITE_FORMAT("%u", *(u32 *) base); break;
+ case 8: WRITE_FORMAT("%llu", *(u64 *) base); break;
default: WRITE("(err)"); break;
}
break;
switch (type->modifier.modifier_kind) {
case debug_type_modifier_kind_pointer:
switch (type->size) {
- case 4: WRITE_FORMAT("0x%x", *(u32 *) base); break;
- case 8: WRITE_FORMAT("0x%lx", *(u64 *) base); break;
+ case 4: WRITE_FORMAT("0x%x", *(u32 *) base); break;
+ case 8: WRITE_FORMAT("0x%llx", *(u64 *) base); break;
default: WRITE("(err)"); break;
}
break;
if (name) {
WRITE(name);
} else {
- WRITE_FORMAT("%lu", value);
+ WRITE_FORMAT("%llu", value);
}
break;
} else {
debug_type_union_variant_t *uv = &type->onion.variants[variant];
- WRITE_FORMAT("%s(", uv->name);
+ WRITE_FORMAT("%s(", uv->name);
append_value_from_memory_with_type(builder, bh_pointer_add(base, type->onion.tag_size), uv->type);
WRITE(")");
}
case debug_type_primitive_kind_void: WRITE("void"); break;
case debug_type_primitive_kind_signed_integer:
switch (type->size) {
- case 1: WRITE_FORMAT("%hhd", value.i8); break;
- case 2: WRITE_FORMAT("%hd", value.i16); break;
- case 4: WRITE_FORMAT("%d", value.i32); break;
- case 8: WRITE_FORMAT("%ld", value.i64); break;
+ case 1: WRITE_FORMAT("%hhd", value.i8); break;
+ case 2: WRITE_FORMAT("%hd", value.i16); break;
+ case 4: WRITE_FORMAT("%d", value.i32); break;
+ case 8: WRITE_FORMAT("%lld", value.i64); break;
default: WRITE("(err)"); break;
}
break;
case debug_type_primitive_kind_unsigned_integer:
switch (type->size) {
- case 1: WRITE_FORMAT("%hhu", value.u8); break;
- case 2: WRITE_FORMAT("%hu", value.u16); break;
- case 4: WRITE_FORMAT("%u", value.u32); break;
- case 8: WRITE_FORMAT("%lu", value.u64); break;
+ case 1: WRITE_FORMAT("%hhu", value.u8); break;
+ case 2: WRITE_FORMAT("%hu", value.u16); break;
+ case 4: WRITE_FORMAT("%u", value.u32); break;
+ case 8: WRITE_FORMAT("%llu", value.u64); break;
default: WRITE("(err)"); break;
}
break;
case debug_type_modifier_kind_pointer:
switch (type->size) {
case 4: WRITE_FORMAT("0x%x", value.u32); break;
- case 8: WRITE_FORMAT("0x%lx", value.u64); break;
+ case 8: WRITE_FORMAT("0x%llx", value.u64); break;
default: WRITE("(err)"); break;
}
break;
case debug_type_kind_enum: {
char *name = debug_info_type_enum_find_name(builder->info, type_id, value.u64);
if (name == NULL) {
- WRITE_FORMAT("%lu", value.u64);
+ WRITE_FORMAT("%llu", value.u64);
} else {
WRITE(name);
}
case debug_type_kind_modifier:
if (t->modifier.modifier_kind == debug_type_modifier_kind_pointer) return 1;
return 0;
-
+
case debug_type_kind_alias:
return get_subvalues_for_type(builder, t->alias.aliased_type);
case debug_type_kind_structure:
return t->structure.member_count;
-
+
case debug_type_kind_array: return t->array.count;
case debug_type_kind_slice: {
u32 stack_ptr;
if (!lookup_stack_pointer(builder, &stack_ptr)) {
return 0;
- }
+ }
u32 *ptr_loc = bh_pointer_add(builder->state->ovm_engine->memory, stack_ptr + builder->base_loc + 4);
count = *ptr_loc;
return count;
}
+
+ default: return 0;
}
}
u32 stack_ptr;
if (!lookup_stack_pointer(builder, &stack_ptr)) {
goto bad_case;
- }
+ }
u32 *ptr_loc = bh_pointer_add(builder->state->ovm_engine->memory, stack_ptr + builder->base_loc);
builder->base_loc = *ptr_loc;
u32 stack_ptr;
if (!lookup_stack_pointer(builder, &stack_ptr)) {
goto bad_case;
- }
+ }
u32 *data_loc = bh_pointer_add(builder->state->ovm_engine->memory, stack_ptr + builder->base_loc);
bad_case:
builder->base_loc_kind = debug_sym_loc_unknown;
- return;
+ return;
}
bool debug_runtime_value_build_step(debug_runtime_value_builder_t *builder) {
u32 stack_ptr;
if (!lookup_stack_pointer(builder, &stack_ptr)) {
return false;
- }
+ }
u32 *data_loc = bh_pointer_add(builder->state->ovm_engine->memory, stack_ptr + builder->base_loc);
u32 stack_ptr;
if (!lookup_stack_pointer(builder, &stack_ptr)) {
return false;
- }
+ }
u32 *data_loc = bh_pointer_add(builder->state->ovm_engine->memory, stack_ptr + builder->base_loc);
}
}
-static void send_bytes(debug_state_t *debug, const char *bytes, unsigned int len) {
+static void send_bytes(debug_state_t *debug, const unsigned char *bytes, unsigned int len) {
bh_buffer_write_u32(&debug->send_buffer, len);
bh_buffer_append(&debug->send_buffer, bytes, len);
}
debug_file_info_t file_info;
debug_info_lookup_file_by_name(debug->info, filename, &file_info);
-
+
debug_breakpoint_t bp;
bp.id = debug->next_breakpoint_id++;
bp.instr = instr;
static DEBUG_COMMAND_HANDLER(debug_command_step) {
u32 granularity = parse_int(debug, ctx);
u32 thread_id = parse_int(debug, ctx);
-
+
if (granularity == 1) {
ON_THREAD(thread_id) {
(*thread)->pause_at_next_line = true;
debug_runtime_value_build_clear(&builder);
}
-
+
// This is important, as when doing a layered query, only one symbol
// should be considered, and once found, should immediate stop.
goto syms_done;
symbol_scope = sym_scope.parent;
}
-
+
syms_done:
send_int(debug, 1);
debug_runtime_value_build_free(&builder);
u32 addr = parse_int(debug, ctx);
u32 count;
- u8 *data = parse_bytes(debug, ctx, &count);
+ u8 *data = (u8 *)parse_bytes(debug, ctx, &count);
memcpy(bh_pointer_add(debug->ovm_engine->memory, addr), data, count);
send_response_header(debug, msg_id);
// Set up socket listener
// Wait for initial connection/handshake before entering loop.
-
+
debug->listen_socket_fd = socket(AF_UNIX, SOCK_STREAM, 0);
struct sockaddr_un local_addr, remote_addr;
listen(debug->listen_socket_fd, 1);
len = sizeof(struct sockaddr_un);
- debug->client_fd = accept(debug->listen_socket_fd, (void * restrict)&remote_addr, &len);
+ debug->client_fd = accept(debug->listen_socket_fd, (void * restrict)&remote_addr, (socklen_t * restrict)&len);
close(debug->listen_socket_fd);
// #define BUILDER_DEBUG
#if defined(BUILDER_DEBUG)
- #define POP_VALUE(b) (bh_arr_length((b)->execution_stack) == 0 ? (assert(("invalid value pop", 0)), 0) : bh_arr_pop((b)->execution_stack))
+ #define POP_VALUE(b) (bh_arr_length((b)->execution_stack) == 0 ? (assert(0 && "invalid value pop"), 0) : bh_arr_pop((b)->execution_stack))
#else
#define POP_VALUE(b) bh_arr_pop((b)->execution_stack)
#endif
ovm_program_modify_static_int(builder->program, patch.static_arr, patch.static_idx, br_delta);
break;
}
-
+
bh_arr_fastdelete(builder->branch_patches, i);
i--;
}
case OVM_TYPE_I64: imm_instr.l = *(u64 *) imm; break;
case OVM_TYPE_F32: imm_instr.f = *(f32 *) imm; break;
case OVM_TYPE_F64: imm_instr.d = *(f64 *) imm; break;
- default: assert(("bad ovm type for add_imm", 0));
+ default: assert(0 && "bad ovm type for add_imm");
}
debug_info_builder_emit_location(builder->debug_builder);
instrs[3].r = tmp_register;
instrs[3].a = table_idx;
instrs[3].b = index_register;
-
+
instrs[4].full_instr = OVM_TYPED_INSTR(OVMI_BRI, OVM_TYPE_NONE);
instrs[4].a = tmp_register;
-
+
POP_VALUE(builder);
-
+
fori (i, 0, count) {
branch_patch_t patch;
patch.kind = branch_patch_static_idx;
ovm_instr_t *last_instr = &bh_arr_last(builder->program->code);
if (OVM_INSTR_INSTR(*last_instr) == OVMI_MOV) {
if (IS_TEMPORARY_VALUE(builder, last_instr->r) && last_instr->r == LAST_VALUE(builder)) {
-
+
last_instr->full_instr = OVM_TYPED_INSTR(OVMI_REG_SET, OVM_TYPE_NONE);
last_instr->r = reg_idx;
// PUSH_VALUE(builder, cmpxchg_instr.r);
// return;
// }
-
+
ovm_instr_t instrs[3] = {0};
// imm.i32 %n, offset
instrs[0].full_instr = OVM_TYPED_INSTR(OVMI_IMM, OVM_TYPE_I32);
case instr_format_imm:
switch (OVM_INSTR_TYPE(*instr)) {
case OVM_TYPE_I8: formatted = snprintf(buf, 255, "%%%d, %hhd", instr->r, instr->i); break;
- case OVM_TYPE_I16: formatted = snprintf(buf, 255, "%%%d, %hd", instr->r, instr->i); break;
- case OVM_TYPE_I32: formatted = snprintf(buf, 255, "%%%d, %d", instr->r, instr->i); break;
- case OVM_TYPE_I64: formatted = snprintf(buf, 255, "%%%d, %ld", instr->r, instr->l); break;
- case OVM_TYPE_F32: formatted = snprintf(buf, 255, "%%%d, %f", instr->r, instr->f); break;
- case OVM_TYPE_F64: formatted = snprintf(buf, 255, "%%%d, %lf", instr->r, instr->d); break;
+ case OVM_TYPE_I16: formatted = snprintf(buf, 255, "%%%d, %hd", instr->r, instr->i); break;
+ case OVM_TYPE_I32: formatted = snprintf(buf, 255, "%%%d, %d", instr->r, instr->i); break;
+ case OVM_TYPE_I64: formatted = snprintf(buf, 255, "%%%d, %lld", instr->r, instr->l); break;
+ case OVM_TYPE_F32: formatted = snprintf(buf, 255, "%%%d, %f", instr->r, instr->f); break;
+ case OVM_TYPE_F64: formatted = snprintf(buf, 255, "%%%d, %lf", instr->r, instr->d); break;
}
break;
formatted = snprintf(buf, 255, "%%%d", instr->a);
}
break;
+
+ default: break;
}
if (formatted > 0) {
static inline void ovm_print_val(ovm_value_t val) {
switch (val.type) {
- case OVM_TYPE_I32: printf("i32[%d]", val.i32); break;
- case OVM_TYPE_I64: printf("i64[%ld]", val.i64); break;
- case OVM_TYPE_F32: printf("f32[%f]", val.f32); break;
- case OVM_TYPE_F64: printf("f64[%lf]", val.f64); break;
+ case OVM_TYPE_I32: printf("i32[%d]", val.i32); break;
+ case OVM_TYPE_I64: printf("i64[%lld]", val.i64); break;
+ case OVM_TYPE_F32: printf("f32[%f]", val.f32); break;
+ case OVM_TYPE_F64: printf("f64[%lf]", val.f64); break;
}
}
}
void wasm_global_get(const wasm_global_t *global, wasm_val_t *value) {
- assert(("unimplemented", 0));
+ assert(0 && "unimplemented");
}
void wasm_global_set(wasm_global_t *global, const wasm_val_t *value) {
- assert(("unimplemented", 0));
+ assert(0 && "unimplemented");
}
(o).f64 = (w).of.f64; \
break; \
\
- default: assert(("invalid wasm value type for conversion", 0)); \
+ default: assert(0 && "invalid wasm value type for conversion"); \
} }
#define OVM_TO_WASM(o, w) { \
\
default: \
printf("INVALID: %d\n", (o).type); \
- assert(("invalid ovm value type for conversion", 0)); \
+ assert(0 && "invalid ovm value type for conversion"); \
} }
static wasm_trap_t *wasm_to_ovm_func_call_binding(void *vbinding, const wasm_val_vec_t *args, wasm_val_vec_t *res) {
if (!wasm_functype_equals(
wasm_externtype_as_functype(importtype->type),
wasm_externtype_as_functype((wasm_externtype_t *) imports->data[i]->type))) {
- assert(("MISMATCHED FUNCTION TYPE", 0));
+ assert(0 && "MISMATCHED FUNCTION TYPE");
}
wasm_func_t *func = wasm_extern_as_func(imports->data[i]);
binding->result_count = functype->results.size;
binding->func = func;
binding->param_buffer.data = bh_alloc(ovm_store->arena_allocator, sizeof(wasm_val_t) * binding->param_count);
- binding->param_buffer.size = binding->param_count;
+ binding->param_buffer.size = binding->param_count;
ovm_state_register_external_func(ovm_state, importtype->external_func_idx, ovm_to_wasm_func_call_binding, binding);
break;
binding->program = ovm_program;
binding->state = ovm_state;
binding->instance = instance;
-
- wasm_func_t *func = wasm_func_new_with_env(instance->store, instance->module->functypes.data[i],
+
+ wasm_func_t *func = wasm_func_new_with_env(instance->store, instance->module->functypes.data[i],
wasm_to_ovm_func_call_binding, binding, NULL);
bh_arr_push(instance->funcs, func);
//
// This file is not to be compile like normal.
// It is instead included in wasm/module.c
-//
+//
// Currently, this file has a lot of code that directly manipulates
// the code builder object. I would like to move this into the API
// for the code builder itself, to make it more portable and easy
int func_table_arr_idx;
int next_external_func_idx;
-
+
debug_info_builder_t debug_builder;
// This will be set/reset for every code (function) entry.
case 0x7e: return WASM_I64;
case 0x7d: return WASM_F32;
case 0x7c: return WASM_F64;
- case 0x7b: assert(("SIMD values are not currently supported", 0));
+ case 0x7b: assert(0 && "SIMD values are not currently supported");
case 0x70: return WASM_FUNCREF;
case 0x6F: return WASM_ANYREF;
- default: assert(("Invalid valtype.", 0));
+ default: assert(0 && "Invalid valtype.");
}
}
static void parse_custom_section(build_context *ctx) {
- unsigned int section_size = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int section_size = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
unsigned int end_of_section = ctx->offset + section_size;
struct wasm_custom_section_t cs;
char name[256];
- unsigned int name_len = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int name_len = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
if (name_len < sizeof(name) - 1) {
strncpy(name, &((char *) ctx->binary.data)[ctx->offset], name_len);
name[name_len] = '\0';
shput(ctx->module->custom_sections, name, cs);
if (!strcmp(name, "ovm_debug_files")) {
- debug_info_import_file_info(ctx->debug_builder.info, cs.data, cs.size);
+ debug_info_import_file_info(ctx->debug_builder.info, (u8 *)cs.data, cs.size);
}
if (!strcmp(name, "ovm_debug_funcs")) {
- debug_info_import_func_info(ctx->debug_builder.info, cs.data, cs.size);
+ debug_info_import_func_info(ctx->debug_builder.info, (u8 *)cs.data, cs.size);
}
if (!strcmp(name, "ovm_debug_ops")) {
- debug_info_builder_prepare(&ctx->debug_builder, cs.data);
+ debug_info_builder_prepare(&ctx->debug_builder, (u8 *)cs.data);
}
if (!strcmp(name, "ovm_debug_syms")) {
- debug_info_import_sym_info(ctx->debug_builder.info, cs.data, cs.size);
+ debug_info_import_sym_info(ctx->debug_builder.info, (u8 *)cs.data, cs.size);
}
if (!strcmp(name, "ovm_debug_types")) {
- debug_info_import_type_info(ctx->debug_builder.info, cs.data, cs.size);
+ debug_info_import_type_info(ctx->debug_builder.info, (u8 *)cs.data, cs.size);
}
}
}
static void parse_type_section(build_context *ctx) {
- unsigned int section_size = uleb128_to_uint(ctx->binary.data, &ctx->offset);
- unsigned int type_count = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int section_size = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
+ unsigned int type_count = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
wasm_functype_vec_new_uninitialized(&ctx->module->type_section, type_count);
fori (i, 0, (int) type_count) {
assert(CONSUME_BYTE(ctx) == 0x60); // @ReportError
- unsigned int param_count = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int param_count = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
wasm_valtype_vec_t param_types;
wasm_valtype_vec_new_uninitialized(¶m_types, param_count);
fori (p, 0, (int) param_count) {
param_types.data[p] = wasm_valtype_new(parse_valtype(ctx));
}
- unsigned int result_count = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int result_count = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
wasm_valtype_vec_t result_types;
wasm_valtype_vec_new_uninitialized(&result_types, result_count);
fori (p, 0, (int) result_count) {
bool maximum_present = CONSUME_BYTE(ctx) & 0x01;
wasm_limits_t limits;
- limits.min = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ limits.min = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
if (maximum_present) {
- limits.max = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ limits.max = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
} else {
limits.max = wasm_limits_max_default;
}
}
static void parse_import_section(build_context *ctx) {
- unsigned int section_size = uleb128_to_uint(ctx->binary.data, &ctx->offset);
- unsigned int import_count = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int section_size = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
+ unsigned int import_count = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
wasm_importtype_vec_new_uninitialized(&ctx->module->imports, import_count);
fori (i, 0, (int) import_count) {
- unsigned int mod_name_size = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int mod_name_size = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
wasm_byte_vec_t module_name;
wasm_byte_vec_new_uninitialized(&module_name, mod_name_size);
fori (n, 0, mod_name_size) module_name.data[n] = CONSUME_BYTE(ctx);
- unsigned int import_name_size = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int import_name_size = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
wasm_byte_vec_t import_name;
wasm_byte_vec_new_uninitialized(&import_name, import_name_size);
fori (n, 0, import_name_size) import_name.data[n] = CONSUME_BYTE(ctx);
wasm_externtype_t *import_type = NULL;
switch (CONSUME_BYTE(ctx)) {
case 0x00: {
- unsigned int type_idx = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int type_idx = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
import_type = wasm_functype_as_externtype(ctx->module->type_section.data[type_idx]);
break;
}
}
static void parse_func_section(build_context *ctx) {
- unsigned int section_size = uleb128_to_uint(ctx->binary.data, &ctx->offset);
- unsigned int func_count = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int section_size = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
+ unsigned int func_count = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
wasm_functype_vec_new_uninitialized(&ctx->module->functypes, func_count);
fori (i, 0, (int) func_count) {
- unsigned int index = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int index = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
ctx->module->functypes.data[i] = ctx->module->type_section.data[index];
}
}
static void parse_table_section(build_context *ctx) {
- unsigned int section_size = uleb128_to_uint(ctx->binary.data, &ctx->offset);
- unsigned int table_count = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int section_size = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
+ unsigned int table_count = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
wasm_tabletype_vec_new_uninitialized(&ctx->module->tabletypes, table_count);
}
static void parse_memory_section(build_context *ctx) {
- unsigned int section_size = uleb128_to_uint(ctx->binary.data, &ctx->offset);
- unsigned int memory_count = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int section_size = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
+ unsigned int memory_count = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
wasm_memorytype_vec_new_uninitialized(&ctx->module->memorytypes, memory_count);
}
static void parse_global_section(build_context *ctx) {
- unsigned int section_size = uleb128_to_uint(ctx->binary.data, &ctx->offset);
- unsigned int global_count = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int section_size = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
+ unsigned int global_count = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
wasm_globaltype_vec_new_uninitialized(&ctx->module->globaltypes, global_count);
switch (CONSUME_BYTE(ctx)) {
case 0x41: {
gt->type.global.initial_value.kind = WASM_I32;
- gt->type.global.initial_value.of.i32 = (i32) uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ gt->type.global.initial_value.of.i32 = (i32) uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
break;
}
case 0x42: {
gt->type.global.initial_value.kind = WASM_I64;
- gt->type.global.initial_value.of.i64 = (i64) uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ gt->type.global.initial_value.of.i64 = (i64) uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
break;
}
}
static void parse_export_section(build_context *ctx) {
- unsigned int section_size = uleb128_to_uint(ctx->binary.data, &ctx->offset);
- unsigned int export_count = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int section_size = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
+ unsigned int export_count = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
wasm_exporttype_vec_new_uninitialized(&ctx->module->exports, export_count);
fori (i, 0, (int) export_count) {
- unsigned int export_name_size = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int export_name_size = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
wasm_byte_vec_t export_name;
wasm_byte_vec_new_uninitialized(&export_name, export_name_size);
fori (n, 0, export_name_size) export_name.data[n] = CONSUME_BYTE(ctx);
unsigned int type = CONSUME_BYTE(ctx);
- unsigned int idx = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int idx = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
wasm_externtype_t *export_type = NULL;
}
static void parse_start_section(build_context *ctx) {
- unsigned int section_size = uleb128_to_uint(ctx->binary.data, &ctx->offset);
- ctx->module->start_func_idx = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int section_size = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
+ ctx->module->start_func_idx = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
}
static void parse_elem_section(build_context *ctx) {
- unsigned int section_size = uleb128_to_uint(ctx->binary.data, &ctx->offset);
- unsigned int elem_count = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int section_size = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
+ unsigned int elem_count = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
// This is going to be a mess...
// I am only going to handle the case of a single, active, offset-0,
assert(CONSUME_BYTE(ctx) == 0x00);
assert(CONSUME_BYTE(ctx) == 0x0B);
- unsigned int entry_count = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int entry_count = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
ctx->module->elem_count = entry_count;
ctx->module->elem_entries = malloc(sizeof(unsigned int) * entry_count);
fori (i, 0, (int) entry_count) {
- ctx->module->elem_entries[i] = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ ctx->module->elem_entries[i] = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
}
- ctx->func_table_arr_idx = ovm_program_register_static_ints(ctx->program, entry_count, ctx->module->elem_entries);
+ ctx->func_table_arr_idx = ovm_program_register_static_ints(ctx->program, entry_count, (int *)ctx->module->elem_entries);
assert(ctx->module->tabletypes.size == 1);
ctx->module->tabletypes.data[0]->type.table.static_arr = ctx->func_table_arr_idx;
}
static void parse_data_section(build_context *ctx) {
- unsigned int section_size = uleb128_to_uint(ctx->binary.data, &ctx->offset);
- unsigned int data_count = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int section_size = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
+ unsigned int data_count = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
if (ctx->module->data_count_present) {
assert(ctx->module->data_count == data_count);
char data_type = CONSUME_BYTE(ctx);
if (data_type == 0x00) {
assert(CONSUME_BYTE(ctx) == 0x41);
- data_entry.offset = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ data_entry.offset = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
data_entry.passive = false;
assert(CONSUME_BYTE(ctx) == 0x0B);
}
- data_entry.length = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ data_entry.length = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
data_entry.data = bh_pointer_add(ctx->binary.data, ctx->offset);
ctx->offset += data_entry.length;
}
static void parse_data_count_section(build_context *ctx) {
- unsigned int section_size = uleb128_to_uint(ctx->binary.data, &ctx->offset);
- unsigned int data_count = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int section_size = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
+ unsigned int data_count = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
ctx->module->data_count_present = true;
ctx->module->data_count = data_count;
static void parse_expression(build_context *ctx);
static void parse_fc_instruction(build_context *ctx) {
- int instr_num = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ int instr_num = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
switch (instr_num) {
case 0: ovm_code_builder_add_unop (&ctx->builder, OVM_TYPED_INSTR(OVMI_CVT_F32, OVM_TYPE_I32)); break;
case 7: ovm_code_builder_add_unop (&ctx->builder, OVM_TYPED_INSTR(OVMI_CVT_F64, OVM_TYPE_I64)); break;
case 8: {
- int dataidx = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ int dataidx = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
assert(CONSUME_BYTE(ctx) == 0x00);
ovm_code_builder_add_imm(&ctx->builder, OVM_TYPE_I32, &dataidx);
break;
}
- default: assert(("UNHANDLED FC INSTRUCTION", 0));
+ default: assert(0 && "UNHANDLED FC INSTRUCTION");
}
}
static void parse_fe_instruction(build_context *ctx) {
- int instr_num = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ int instr_num = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
switch (instr_num) {
#define LOAD_CASE(num, type) \
case num : { \
- int alignment = uleb128_to_uint(ctx->binary.data, &ctx->offset); \
- int offset = uleb128_to_uint(ctx->binary.data, &ctx->offset); \
+ int alignment = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset); \
+ int offset = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset); \
ovm_code_builder_add_atomic_load(&ctx->builder, type, offset); \
break; \
}
#define STORE_CASE(num, type) \
case num : { \
- int alignment = uleb128_to_uint(ctx->binary.data, &ctx->offset); \
- int offset = uleb128_to_uint(ctx->binary.data, &ctx->offset); \
+ int alignment = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset); \
+ int offset = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset); \
ovm_code_builder_add_atomic_store(&ctx->builder, type, offset); \
break; \
}
#define CMPXCHG_CASE(num, type) \
case num : { \
- int alignment = uleb128_to_uint(ctx->binary.data, &ctx->offset); \
- int offset = uleb128_to_uint(ctx->binary.data, &ctx->offset); \
+ int alignment = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset); \
+ int offset = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset); \
ovm_code_builder_add_cmpxchg(&ctx->builder, type, offset); \
break; \
}
#undef CMPXCHG_CASE
- default: assert(("UNHANDLED ATOMIC INSTRUCTION... SORRY :/", 0));
+ default: assert(0 && "UNHANDLED ATOMIC INSTRUCTION... SORRY :/");
}
}
}
case 0x0C: {
- int label_idx = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ int label_idx = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
label_target_t target = ovm_code_builder_wasm_target_idx(&ctx->builder, label_idx);
ovm_code_builder_add_branch(&ctx->builder, target.idx);
}
case 0x0D: {
- int label_idx = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ int label_idx = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
label_target_t target = ovm_code_builder_wasm_target_idx(&ctx->builder, label_idx);
ovm_code_builder_add_cond_branch(&ctx->builder, target.idx, true, false);
case 0x0E: {
// Branch tables are the most complicated thing ever :/
- int entry_count = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ int entry_count = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
int *entries = bh_alloc_array(bh_heap_allocator(), int, entry_count);
fori (i, 0, entry_count) {
- int label_idx = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ int label_idx = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
label_target_t target = ovm_code_builder_wasm_target_idx(&ctx->builder, label_idx);
entries[i] = target.idx;
}
- int default_entry_idx = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ int default_entry_idx = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
label_target_t target = ovm_code_builder_wasm_target_idx(&ctx->builder, default_entry_idx);
int default_entry = target.idx;
}
case 0x10: {
- int func_idx = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ int func_idx = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
wasm_functype_t *functype = wasm_module_index_functype(ctx->module, func_idx);
int param_count = functype->type.func.params.size;
}
case 0x11: {
- int type_idx = uleb128_to_uint(ctx->binary.data, &ctx->offset);
- int table_idx = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ int type_idx = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
+ int table_idx = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
assert(table_idx == 0);
wasm_functype_t *functype = ctx->module->type_section.data[type_idx];
case 0x1B: assert(0);
case 0x20: {
- int local_idx = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ int local_idx = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
ovm_code_builder_add_local_get(&ctx->builder, local_idx);
break;
}
case 0x21: {
- int local_idx = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ int local_idx = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
ovm_code_builder_add_local_set(&ctx->builder, local_idx);
break;
}
case 0x22: {
- int local_idx = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ int local_idx = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
ovm_code_builder_add_local_tee(&ctx->builder, local_idx);
break;
}
case 0x23: {
- int global_idx = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ int global_idx = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
ovm_code_builder_add_register_get(&ctx->builder, global_idx);
break;
}
case 0x24: {
- int global_idx = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ int global_idx = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
ovm_code_builder_add_register_set(&ctx->builder, global_idx);
break;
}
#define LOAD_CASE(num, type, convert, convert_op, convert_type) \
case num : { \
- int alignment = uleb128_to_uint(ctx->binary.data, &ctx->offset); \
- int offset = uleb128_to_uint(ctx->binary.data, &ctx->offset); \
+ int alignment = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset); \
+ int offset = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset); \
ovm_code_builder_add_load(&ctx->builder, type, offset); \
if (convert) ovm_code_builder_add_unop(&ctx->builder, OVM_TYPED_INSTR(convert_op, convert_type)); \
break; \
#define STORE_CASE(num, type) \
case num : { \
- int alignment = uleb128_to_uint(ctx->binary.data, &ctx->offset); \
- int offset = uleb128_to_uint(ctx->binary.data, &ctx->offset); \
+ int alignment = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset); \
+ int offset = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset); \
ovm_code_builder_add_store(&ctx->builder, type, offset); \
break; \
}
}
case 0x41: {
- i64 value = leb128_to_int(ctx->binary.data, &ctx->offset);
+ i64 value = leb128_to_int((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
// NOTE: This assumes a little-endian CPU as the address is assumes
// to be the least significant byte.
}
case 0x42: {
- i64 value = leb128_to_int(ctx->binary.data, &ctx->offset);
+ i64 value = leb128_to_int((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
ovm_code_builder_add_imm(&ctx->builder, OVM_TYPE_I64, &value);
break;
}
case 0xFC: parse_fc_instruction(ctx); break;
case 0xFE: parse_fe_instruction(ctx); break;
- default: assert(("UNHANDLED INSTRUCTION", 0));
+ default: assert(0 && "UNHANDLED INSTRUCTION");
}
}
}
static void parse_code_section(build_context *ctx) {
- unsigned int section_size = uleb128_to_uint(ctx->binary.data, &ctx->offset);
- unsigned int code_count = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int section_size = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
+ unsigned int code_count = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
assert(ctx->module->functypes.size == code_count);
ctx->module->memory_init_external_idx = ctx->next_external_func_idx++;
-
+
// HACK HACK HACK THIS IS SUCH A BAD WAY OF DOING THIS
ctx->module->memory_init_idx = bh_arr_length(ctx->program->funcs) + code_count;
fori (i, 0, (int) code_count) {
- unsigned int code_size = uleb128_to_uint(ctx->binary.data, &ctx->offset);
- unsigned int local_sections_count = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int code_size = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
+ unsigned int local_sections_count = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
unsigned int total_locals = 0;
fori (j, 0, (int) local_sections_count) {
- unsigned int local_count = uleb128_to_uint(ctx->binary.data, &ctx->offset);
+ unsigned int local_count = uleb128_to_uint((u8 *)ctx->binary.data, (i32 *)&ctx->offset);
wasm_valkind_t valtype = parse_valtype(ctx);
total_locals += local_count;
case WASM_CODE_SECTION: parse_code_section(ctx); break;
case WASM_DATA_SECTION: parse_data_section(ctx); break;
case WASM_DATAC_SECTION: parse_data_count_section(ctx); break;
- default: assert(("bad section number", 0)); break;
+ default: assert(0 && "bad section number"); break;
}
}
projects / onyx.git / commitdiff