aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--design/stack_machine.v12
-rwxr-xr-xtclasm.tcl9
l---------tests/wasm_compile_if_else/Makefile1
-rw-r--r--tests/wasm_compile_if_else/instructions.wat19
l---------tests/wasm_compile_if_else/test.v1
-rw-r--r--tests/wasm_compile_if_else/words_to_verify.mem5
-rw-r--r--tests/wasm_compile_simple_module/test.v6
-rw-r--r--tools/assemble.c40
-rw-r--r--tools/parse_module.c45
-rw-r--r--tools/stack_machine_instruction.h69
-rw-r--r--tools/translate.c246
-rw-r--r--tools/translate_xmacro.h5
-rw-r--r--tools/wasm.h30
-rw-r--r--tools/wasm_compile.h24
14 files changed, 416 insertions, 96 deletions
diff --git a/design/stack_machine.v b/design/stack_machine.v
index 91e808b..5e6e0d6 100644
--- a/design/stack_machine.v
+++ b/design/stack_machine.v
@@ -247,6 +247,10 @@ module stack_machine_new
assign instr_cond_jump = use_im && stack_shrinks_by_1 &&
instruction[11:7] == 5'd1;
+ wire instr_cond_jump_n;
+ assign instr_cond_jump_n = use_im && stack_shrinks_by_1 &&
+ instruction[11:7] == 5'd2;
+
reg halt; /* Set once a halt instruction is encountered */
assign finished = halt;
@@ -314,7 +318,7 @@ module stack_machine_new
always @ (posedge CLK_I) begin
if (RST_I) begin
`SET_PC(0);
- `SET_SP(21'h0FFFFF);
+ `SET_SP(21'h0FFFFC);
I_STB_O <= 0;
I_CYC_O <= 0;
@@ -563,10 +567,12 @@ module stack_machine_new
if (instr_drop && arithmetic_uncompleted)
r1 <= r0;
- if (instr_cond_jump && arithmetic_uncompleted) begin
+ if ((instr_cond_jump || instr_cond_jump_n) &&
+ arithmetic_uncompleted) begin
r1 <= r0;
- if (r1)
+ if ((r1 && instr_cond_jump) ||
+ (!r1 && instr_cond_jump_n))
`SET_PC(im_effective);
end
diff --git a/tclasm.tcl b/tclasm.tcl
index 0dec4b0..000f2ca 100755
--- a/tclasm.tcl
+++ b/tclasm.tcl
@@ -337,5 +337,14 @@ proc cond_jump {address} {
}
+proc _cond_jump_n {address_part} {
+ puts 011100010[__to_binary $address_part 7]
+}
+
+proc cond_jump_n {address} {
+ _with_im _cond_jump_n $address
+}
+
+
# translate instructions in the file given as command line argument
source [lindex $argv 0]
diff --git a/tests/wasm_compile_if_else/Makefile b/tests/wasm_compile_if_else/Makefile
new file mode 120000
index 0000000..e451c8b
--- /dev/null
+++ b/tests/wasm_compile_if_else/Makefile
@@ -0,0 +1 @@
+../wasm_compile_simple_module/Makefile \ No newline at end of file
diff --git a/tests/wasm_compile_if_else/instructions.wat b/tests/wasm_compile_if_else/instructions.wat
new file mode 100644
index 0000000..14faa6f
--- /dev/null
+++ b/tests/wasm_compile_if_else/instructions.wat
@@ -0,0 +1,19 @@
+(module
+ (memory 0 2)
+ (func $eq10 (param $x i32) (result i32)
+ (if (result i32)
+ (i32.sub
+ (get_local $x)
+ (i32.const 10))
+ (then
+ (i32.add (i32.const -3) (i32.const 3)))
+ (else
+ (i32.const -1))))
+ (func $main
+ ;; write 0x00000000 at MEMORY_BOTTOM_ADDR
+ (i32.store offset=0x0 align=2 (i32.const 0x0)
+ (call $eq10 (i32.const 12)))
+ ;; write 0xFFFFFFFF at MEMORY_BOTTOM_ADDR + 0x4
+ (i32.store offset=0x0 align=2 (i32.const 0x4)
+ (call $eq10 (i32.const 10))))
+ (export "main" (func $main)))
diff --git a/tests/wasm_compile_if_else/test.v b/tests/wasm_compile_if_else/test.v
new file mode 120000
index 0000000..f0235d8
--- /dev/null
+++ b/tests/wasm_compile_if_else/test.v
@@ -0,0 +1 @@
+../wasm_compile_simple_module/test.v \ No newline at end of file
diff --git a/tests/wasm_compile_if_else/words_to_verify.mem b/tests/wasm_compile_if_else/words_to_verify.mem
new file mode 100644
index 0000000..75a6c84
--- /dev/null
+++ b/tests/wasm_compile_if_else/words_to_verify.mem
@@ -0,0 +1,5 @@
+// address value
+ 0FFFFC 23
+
+ 200 00000000
+ 204 FFFFFFFF
diff --git a/tests/wasm_compile_simple_module/test.v b/tests/wasm_compile_simple_module/test.v
index 686a7fc..80f5590 100644
--- a/tests/wasm_compile_simple_module/test.v
+++ b/tests/wasm_compile_simple_module/test.v
@@ -159,7 +159,7 @@ module wasm_compile_test();
CLK <= 0;
RST <= 1;
- for (i = 0; i < 3500; i++) begin
+ for (i = 0; i < 5000; i++) begin
#1;
CLK <= ~CLK;
@@ -194,9 +194,9 @@ module wasm_compile_test();
$finish;
end // if (M_finished)
- end // for (i = 0; i < 3500; i++)
+ end // for (i = 0; i < 5000; i++)
- $display("error: cpu hasn't finished its operations in 1750 ticks");
+ $display("error: cpu hasn't finished its operations in 2500 ticks");
$finish;
end // initial begin
endmodule // stack_machine_test
diff --git a/tools/assemble.c b/tools/assemble.c
index 11bb7c9..b8bd75e 100644
--- a/tools/assemble.c
+++ b/tools/assemble.c
@@ -55,7 +55,8 @@ static uint8_t estimate_instruction_size(struct instruction *instruction)
case DATA_NONE :
return 2;
case DATA_KNOWN :
- case DATA_UNKNOWN :
+ case DATA_INSTR_ADDR :
+ case DATA_ADDR_AFTER :
return 6;
case DATA_KNOWN_21_BITS :
return 4;
@@ -81,16 +82,26 @@ static void assign_addresses_and_sizes(struct instruction *expr,
uint32_t address)
{
struct instruction *tmp = expr;
+ uint32_t target_addr;
do {
+ if ((tmp->data.info == DATA_INSTR_ADDR ||
+ tmp->data.info == DATA_ADDR_AFTER) &&
+ *tmp->data.data.ptr &&
+ (*tmp->data.data.ptr)->address_assigned) {
+ target_addr = (*tmp->data.data.ptr)->address;
+
+ if (tmp->data.info == DATA_ADDR_AFTER) {
+ target_addr += estimate_instruction_size
+ (*tmp->data.data.ptr);
+ }
+
+ tmp->data = im(target_addr);
+ }
+
tmp->address = address;
tmp->address_assigned = true;
- if (tmp->data.info == DATA_UNKNOWN &&
- *tmp->data.data.ptr &&
- (*tmp->data.data.ptr)->address_assigned)
- tmp->data = im((*tmp->data.data.ptr)->address);
-
address += estimate_instruction_size(tmp);
tmp = tmp->next;
} while (tmp != expr);
@@ -108,21 +119,24 @@ static void encode_instruction(struct instruction *instruction,
uint16_t encoding = instruction->encoding;
uint16_t *dest = memory + instruction->address / 2;
- if (instruction->data.info != DATA_NONE) {
- if (instruction->data.info == DATA_UNKNOWN)
- im = (*instruction->data.data.ptr)->address;
- else
- im = instruction->data.data.im;
+ if (instruction->data.info == DATA_INSTR_ADDR) {
+ im = (*instruction->data.data.ptr)->address;
+ } else if (instruction->data.info == DATA_ADDR_AFTER) {
+ im = (*instruction->data.data.ptr)->address +
+ estimate_instruction_size(*instruction->data.data.ptr);
+ } else if (instruction->data.info != DATA_NONE) {
+ im = instruction->data.data.im;
}
switch (instruction->data.info) {
- case DATA_UNKNOWN :
+ case DATA_INSTR_ADDR :
+ case DATA_ADDR_AFTER :
case DATA_KNOWN :
*(dest++) = im_instruction(im >> 22);
case DATA_KNOWN_21_BITS :
*(dest++) = im_instruction(im >> 7);
case DATA_KNOWN_6_BITS :
- encoding |= (im & 0x7F);
+ encoding |= im & 0x7F;
}
*dest = encoding;
diff --git a/tools/parse_module.c b/tools/parse_module.c
index 75329f8..3f9895c 100644
--- a/tools/parse_module.c
+++ b/tools/parse_module.c
@@ -2,39 +2,11 @@
#include "wasm_compile.h"
#include "wasm.h"
-static inline int is_valid_valtype(char value_type)
-{
- if (value_type == VALTYPE_I32)
- return 1;
-
- if (value_type == VALTYPE_I64 ||
- value_type == VALTYPE_F32 ||
- value_type == VALTYPE_F64)
- PRERR("Only type i32 is recognized for now");
-
- return -1;
-
- /* return */
- /* value_type == VALTYPE_I32 || */
- /* value_type == VALTYPE_I64 || */
- /* value_type == VALTYPE_F32 || */
- /* value_type == VALTYPE_F64; */
-}
-
-static inline int is_valid_exportdesc(char desc)
-{
- return
- desc == EXPORT_FUNCIDX ||
- desc == EXPORT_TABLEIDX ||
- desc == EXPORT_MEMIDX ||
- desc == EXPORT_GLOBALIDX;
-}
-
-int leb_u32(FILE *handle, uint32_t *result)
+int leb_32(FILE *handle, uint32_t *result, bool with_sign)
{
int i, j;
int encoded[5];
- uint64_t decoded;
+ int64_t decoded;
for (i = 0; i < 5; i++) {
encoded[i] = fgetc(handle);
@@ -53,12 +25,17 @@ int leb_u32(FILE *handle, uint32_t *result)
}
}
- decoded = 0;
+ if (with_sign && encoded[i] & (1 << 6))
+ decoded = -1;
+ else
+ decoded = 0;
for (j = i; j >= 0; j--)
decoded = (decoded << 7) | (encoded[j] & 0x7F);
- if (decoded > UINT32_MAX) {
+ if ((with_sign && decoded > INT32_MAX) ||
+ (with_sign && decoded < INT32_MIN) ||
+ (!with_sign && decoded > UINT32_MAX)) {
PRERR(MSG_BAD_NUM_ENC);
return -1;
}
@@ -105,6 +82,8 @@ void free_module(struct module *module)
free(module->exports);
+ free_targets(module->targets);
+
free(module);
}
@@ -602,7 +581,7 @@ struct module *parse_module(FILE *handle)
/* check magic number */
if (memcmp(initial, magic, 4)) {
- PRERR("Bad magic number");
+ PRERR("Bad magic number\n");
goto fail;
}
diff --git a/tools/stack_machine_instruction.h b/tools/stack_machine_instruction.h
index 7b22c83..ea65334 100644
--- a/tools/stack_machine_instruction.h
+++ b/tools/stack_machine_instruction.h
@@ -1,5 +1,7 @@
#include <stdbool.h>
+#include "wasm_compile.h"
+
/*
* TODO: this enum is to be removed; it it only still here as a cheat sheet
* for use when defining missing inline functions for those instructions
@@ -43,7 +45,8 @@ enum instruction_code {
#define DATA_KNOWN 1
#define DATA_KNOWN_21_BITS 2
#define DATA_KNOWN_6_BITS 3
-#define DATA_UNKNOWN 4
+#define DATA_INSTR_ADDR 4
+#define DATA_ADDR_AFTER 5
struct instruction_data {
char info;
@@ -65,8 +68,6 @@ struct instruction {
.info = DATA_NONE \
})
-#define POW(n) (((int64_t) 1) << (n))
-
inline static uint8_t im_instruction_size(int32_t im)
{
if (im < POW(6) && im >= -POW(6))
@@ -98,7 +99,16 @@ inline static struct instruction_data im(uint32_t im)
inline static struct instruction_data ptr(struct instruction **val) {
struct instruction_data data;
- data.info = DATA_UNKNOWN;
+ data.info = DATA_INSTR_ADDR;
+ data.data.ptr = val;
+
+ return data;
+}
+
+inline static struct instruction_data ptr_after(struct instruction **val) {
+ struct instruction_data data;
+
+ data.info = DATA_ADDR_AFTER;
data.data.ptr = val;
return data;
@@ -122,30 +132,33 @@ int add_instruction(struct instruction **expr, uint16_t encoding,
return add_instruction(expr, encoding, NO_DATA); \
}
-X(store, 0x7E00) /* 0111_1110_0xxx_xxxx */
-X(store_p, 0x6E00) /* 0110_1110_0xxx_xxxx */
-X(storeb_p, 0x6C00) /* 0110_1100_0xxx_xxxx */
-X(storew_p, 0x6D00) /* 0110_1101_0xxx_xxxx */
-X(load, 0x5E00) /* 0101_1110_0xxx_xxxx */
-X(load_p, 0x4E00) /* 0100_1110_0xxx_xxxx */
-X(loadbzx_p, 0x4C00) /* 0100_1100_0xxx_xxxx */
-X(loadbsx_p, 0x4C80) /* 0100_1100_1xxx_xxxx */
-X(loadwzx_p, 0x4D00) /* 0100_1101_0xxx_xxxx */
-X(loadwsx_p, 0x4D80) /* 0100_1101_1xxx_xxxx */
-Y(swap, 0x0002) /* 0000_0000_0000_0010 */
-X(set_sp, 0x4000) /* 0100_0000_0xxx_xxxx */
-X(jump, 0x4080) /* 0100_0000_1xxx_xxxx */
-Y(tee, 0x1000) /* 0001_0000_0000_0000 */
-Y(get_frame, 0x1001) /* 0001_0000_0000_0001 */
-X(const, 0x5000) /* 0101_0000_0xxx_xxxx */
-X(call, 0x5080) /* 0101_0000_1xxx_xxxx */
-Y(add, 0x3000) /* 0011_0000_0000_0000 */
-Y(sub, 0x3001) /* 0011_0000_0000_0001 */
-Y(div, 0x3002) /* 0011_0000_0000_0010 */
-Y(mul, 0x3003) /* 0011_0000_0000_0011 */
-Y(drop, 0x3004) /* 0011_0000_0000_0100 */
-Y(ret, 0x3080) /* 0011_0000_1000_0000 */
-Y(halt, 0x0000) /* 0000_0000_0000_0000 */
+X(store, 0x7E00) /* 0111_1110_0xxx_xxxx */
+X(store_p, 0x6E00) /* 0110_1110_0xxx_xxxx */
+X(storeb_p, 0x6C00) /* 0110_1100_0xxx_xxxx */
+X(storew_p, 0x6D00) /* 0110_1101_0xxx_xxxx */
+X(load, 0x5E00) /* 0101_1110_0xxx_xxxx */
+X(load_p, 0x4E00) /* 0100_1110_0xxx_xxxx */
+X(loadbzx_p, 0x4C00) /* 0100_1100_0xxx_xxxx */
+X(loadbsx_p, 0x4C80) /* 0100_1100_1xxx_xxxx */
+X(loadwzx_p, 0x4D00) /* 0100_1101_0xxx_xxxx */
+X(loadwsx_p, 0x4D80) /* 0100_1101_1xxx_xxxx */
+Y(nop, 0x0001) /* 0000_0000_0000_0001 */
+Y(swap, 0x0002) /* 0000_0000_0000_0010 */
+X(set_sp, 0x4000) /* 0100_0000_0xxx_xxxx */
+X(jump, 0x4080) /* 0100_0000_1xxx_xxxx */
+Y(tee, 0x1000) /* 0001_0000_0000_0000 */
+Y(get_frame, 0x1001) /* 0001_0000_0000_0001 */
+X(const, 0x5000) /* 0101_0000_0xxx_xxxx */
+X(call, 0x5080) /* 0101_0000_1xxx_xxxx */
+Y(add, 0x3000) /* 0011_0000_0000_0000 */
+Y(sub, 0x3001) /* 0011_0000_0000_0001 */
+Y(div, 0x3002) /* 0011_0000_0000_0010 */
+Y(mul, 0x3003) /* 0011_0000_0000_0011 */
+Y(drop, 0x3004) /* 0011_0000_0000_0100 */
+Y(ret, 0x3080) /* 0011_0000_1000_0000 */
+X(cond_jump, 0x7080) /* 0111_0000_1xxx_xxxx */
+X(cond_jump_n, 0x7100) /* 0111_0001_0xxx_xxxx */
+Y(halt, 0x0000) /* 0000_0000_0000_0000 */
#undef X
#undef Y
diff --git a/tools/translate.c b/tools/translate.c
index b3d2afd..3a4496d 100644
--- a/tools/translate.c
+++ b/tools/translate.c
@@ -2,9 +2,15 @@
#include "wasm.h"
#include "stack_machine_instruction.h"
+struct target {
+ struct instruction *instr;
+ struct target *prev;
+};
+
struct types {
struct types *prev;
char type; /* should be one of VALTYPE_* constants from wasm.h */
+ int refs;
};
struct translation {
@@ -14,7 +20,40 @@ struct translation {
struct types *types_stack;
};
-void free_types_stack(struct types *top)
+struct end_markers {
+ int count;
+ const uint8_t *codes;
+};
+
+void free_targets(struct target *top)
+{
+ struct target *tmp;
+
+ while (top) {
+ tmp = top->prev;
+ free(top);
+ top = tmp;
+ }
+}
+
+inline static void get_type(struct types *type)
+{
+ if (type)
+ type->refs++;
+}
+
+static void put_type(struct types *type)
+{
+ struct types *tmp;
+
+ while (type && !--type->refs) {
+ tmp = type->prev;
+ free(type);
+ type = tmp;
+ }
+}
+
+static void free_types_stack(struct types *top)
{
struct types *tmp;
@@ -25,13 +64,163 @@ void free_types_stack(struct types *top)
}
}
+static int translate_expr(struct translation *data, struct resulttype *args,
+ struct resulttype *results,
+ const struct end_markers *end_markers,
+ char *marker_found);
+
/* All functions, that go into one of function pointer arrays, start with _ */
-/** DEFINE TRANSLATION FUNCTIONS **/
+/** DEFINE INSTRUCTION TRANSLATION FUNCTIONS **/
/* Translate complex - those routines have to be defined manually */
#define TC(wasm_opcode, name, argtypes, restype)
+static int parse_blocktype(FILE *handle, struct resulttype *args,
+ struct resulttype *results, char *storage,
+ struct module *module)
+{
+ int readval;
+ uint32_t typeidx;
+
+ readval = fgetc(handle);
+
+ if (readval == EOF) {
+ PRERR(MSG_EOF);
+ return -1;
+ }
+
+ if (readval == 0x40) {
+ /* Blocktype is empty (no arguments, no result values) */
+ *args = (struct resulttype) {.count = 0, .types = NULL};
+ *results = *args;
+ return 0;
+ }
+
+ /*
+ * A nonnegative array index encoded as signed number in LEB
+ * shall have 0 as the second (most significant) bit of the first byte.
+ * Otherwise, it can't be array index, but might be a simple value type.
+ */
+ if (readval & (1 << 6)) {
+ if (!is_valid_valtype(readval))
+ goto fail;
+
+ *args = (struct resulttype) {.count = 0, .types = NULL};
+ *storage = readval;
+ *results = (struct resulttype) {.count = 1, .types = storage};
+ return 0;
+ }
+
+ /*
+ * We know for sure it's a nonnegative number, we can just use leb_u32
+ * decoding function (encoding as signed or unsigned is the same in this
+ * particular case).
+ */
+ ungetc(readval, handle);
+
+ if (leb_u32(handle, &typeidx)) {
+ PRERR(MSG_BAD_NUM);
+ goto fail;
+ }
+
+ if (typeidx <= module->functypes_count) {
+ PRERR(MSG_BAD_IDX("type index"));
+ goto fail;
+ }
+
+ *args = module->functypes[typeidx].args;
+ *results = module->functypes[typeidx].results;
+ return 0;
+
+fail:
+ PRERR("Couldn't parse blocktype\n");
+ return -1;
+}
+
+static struct target *add_target(struct module *module)
+{
+ struct target *tgt;
+
+ tgt = malloc(sizeof(struct target));
+
+ if (!tgt) {
+ PRERR(MSG_ALLOC_FAIL(sizeof(struct target)));
+ return NULL;
+ }
+
+ tgt->instr = NULL;
+ tgt->prev = module->targets;
+ module->targets = tgt;
+ return tgt;
+}
+
+static int _translate_if(struct translation *data)
+{
+ struct types *backed_stack;
+ struct resulttype block_args, block_results;
+ char type_storage;
+ struct target *if_end, *else_end;
+ struct instruction **expr = &data->function->translated_body;
+ static const uint8_t if_end_markers_codes[2] = {WASM_ELSE, WASM_END};
+ static const struct end_markers if_end_markers = {
+ .count = 2,
+ .codes = if_end_markers_codes
+ };
+ static const struct end_markers else_end_markers = {
+ .count = 1,
+ .codes = if_end_markers_codes + 1
+ };
+ char marker_found;
+ int retval;
+
+ if (parse_blocktype(data->handle, &block_args, &block_results,
+ &type_storage, data->module))
+ goto fail;
+
+ if_end = add_target(data->module);
+ else_end = add_target(data->module);
+
+ if (!if_end || !else_end)
+ goto fail;
+
+ if (i_cond_jump_n(ptr_after(&if_end->instr), expr))
+ goto fail;
+
+ backed_stack = data->types_stack;
+ get_type(backed_stack);
+
+ retval = translate_expr(data, &block_args, &block_results,
+ &if_end_markers, &marker_found);
+
+ put_type(data->types_stack);
+ data->types_stack = backed_stack;
+
+ if (retval)
+ goto fail;
+
+ if (i_jump(ptr_after(&else_end->instr), expr))
+ goto fail;
+
+ if_end->instr = data->function->translated_body->prev;
+
+ if (marker_found == WASM_END)
+ ungetc(WASM_END, data->handle);
+
+ if (translate_expr(data, &block_args, &block_results,
+ &else_end_markers, NULL))
+ goto fail;
+
+ else_end->instr = data->function->translated_body->prev;
+
+ return 0;
+
+fail:
+ PRERR("Couldn't translate if-else instruction\n");
+
+ return -1;
+}
+
static int typecheck_call(struct translation *data, struct function *callee);
static int _translate_call(struct translation *data)
@@ -98,9 +287,9 @@ static int _translate_local_get(struct translation *data)
static int _translate_const(struct translation *data)
{
- uint32_t constant;
+ int32_t constant;
- if (leb_u32(data->handle, &constant)) {
+ if (leb_s32(data->handle, &constant)) {
PRERR(MSG_BAD_NUM);
return -1;
}
@@ -209,7 +398,11 @@ static int argcheck_generic(struct types **types_stack, char expected)
top_type = *types_stack;
*types_stack = top_type->prev;
- free(top_type);
+
+ if (*types_stack)
+ get_type(*types_stack);
+
+ put_type(top_type);
return 0;
}
@@ -254,7 +447,7 @@ static int rescheck_generic(struct types **types_stack, char returned)
return -1;
}
- *top = (struct types) {.prev = *types_stack, .type = returned};
+ *top = (struct types) {.prev = *types_stack, .type = returned, .refs = 1};
*types_stack = top;
return 0;
@@ -289,7 +482,7 @@ struct typecheck {
int (*argcheck) (struct types **), (*rescheck) (struct types **);
};
-/*static*/ struct typecheck typecheck_routines[256] = {
+static struct typecheck typecheck_routines[256] = {
#include "translate_xmacro.h"
};
@@ -355,7 +548,9 @@ static int translate_instr(struct translation *data, uint8_t wasm_opcode)
}
static int translate_expr(struct translation *data, struct resulttype *args,
- struct resulttype *results)
+ struct resulttype *results,
+ const struct end_markers *end_markers,
+ char *marker_found)
{
struct types **tmp, *types_stack_rest;
uint32_t i;
@@ -382,13 +577,23 @@ static int translate_expr(struct translation *data, struct resulttype *args,
goto fail;
}
- if (wasm_opcode == WASM_END)
- break;
+ i = end_markers->count;
+
+ while (i--) {
+ if (wasm_opcode == end_markers->codes[i]) {
+ if (marker_found)
+ *marker_found = wasm_opcode;
+
+ goto block_end;
+ }
+ }
if (translate_instr(data, wasm_opcode))
goto fail;
}
+block_end:
+
tmp = &data->types_stack;
i = results ? results->count : 0;
@@ -408,7 +613,7 @@ static int translate_expr(struct translation *data, struct resulttype *args,
return 0;
fail:
- free_types_stack(data->types_stack);
+ put_type(data->types_stack);
data->types_stack = types_stack_rest;
return -1;
@@ -421,10 +626,16 @@ int translate(FILE *handle, struct function *function, struct module *module)
uint32_t locals_count = function->locals_count;
uint32_t all_locals_count = args_count + locals_count;
size_t i;
+ static const uint8_t function_end_marker_code = WASM_END;
+ static const struct end_markers function_end_markers = {
+ .count = 1,
+ .codes = &function_end_marker_code
+ };
struct translation data = {.handle = handle,
.function = function,
.module = module,
.types_stack = NULL};
+ int retval = -1;
if (locals_count + (uint64_t) args_count > STACK_TOP_ADDR * 4) {
PRERR("Too many locals in a function\n");
@@ -445,7 +656,8 @@ int translate(FILE *handle, struct function *function, struct module *module)
goto fail;
/* actual function body */
- if (translate_expr(&data, NULL, &function->type->results))
+ if (translate_expr(&data, NULL, &function->type->results,
+ &function_end_markers, NULL))
goto fail;
/* function epilogue */
@@ -471,7 +683,6 @@ int translate(FILE *handle, struct function *function, struct module *module)
i_load_p (im(0), expr) ||
i_store (im(STACK_FRAME_BACKUP_ADDR), expr))
goto fail;
-
}
i = locals_count + args_count + 2;
@@ -487,13 +698,18 @@ int translate(FILE *handle, struct function *function, struct module *module)
if (i_ret(expr))
goto fail;
- return 0;
+ retval = 0;
fail:
+ free_types_stack(data.types_stack);
+
+ if (!retval)
+ return retval;
+
PRERR("Couldn't translate function to stack machine\n");
free_expr(*expr);
function->translated_body = NULL;
- return -1;
+ return retval;
}
diff --git a/tools/translate_xmacro.h b/tools/translate_xmacro.h
index 5e5bd79..b271e75 100644
--- a/tools/translate_xmacro.h
+++ b/tools/translate_xmacro.h
@@ -15,6 +15,11 @@ TLS(WASM_I32_STORE, store_p, i32_i32, empty)
TLS(WASM_I32_STORE8, storeb_p, i32_i32, empty)
TLS(WASM_I32_STORE16, storew_p, i32_i32, empty)
+/*
+ * There are more checks to be performed in case of if, but we do them
+ * another way and only check for the i32 condition value here.
+ */
+TC (WASM_IF, if, i32, custom)
TC (WASM_CALL, call, custom, custom)
TC (WASM_LOCAL_GET, local_get, empty, custom)
TC (WASM_I32_CONST, const, empty, i32)
diff --git a/tools/wasm.h b/tools/wasm.h
index 07252fc..bf85490 100644
--- a/tools/wasm.h
+++ b/tools/wasm.h
@@ -22,6 +22,8 @@
#define EXPORT_GLOBALIDX 0x03
/* WebAssembly opcodes */
+#define WASM_IF 0x04
+#define WASM_ELSE 0x05
#define WASM_END 0x0B
#define WASM_CALL 0x10
@@ -43,3 +45,31 @@
#define WASM_I32_SUB 0x6B
#define WASM_I32_MUL 0x6C
#define WASM_I32_DIV_U 0x6E
+
+static inline int is_valid_valtype(char value_type)
+{
+ if (value_type == VALTYPE_I32)
+ return 1;
+
+ if (value_type == VALTYPE_I64 ||
+ value_type == VALTYPE_F32 ||
+ value_type == VALTYPE_F64)
+ PRERR("Only type i32 is recognized for now");
+
+ return -1;
+
+ /* return */
+ /* value_type == VALTYPE_I32 || */
+ /* value_type == VALTYPE_I64 || */
+ /* value_type == VALTYPE_F32 || */
+ /* value_type == VALTYPE_F64; */
+}
+
+static inline int is_valid_exportdesc(char desc)
+{
+ return
+ desc == EXPORT_FUNCIDX ||
+ desc == EXPORT_TABLEIDX ||
+ desc == EXPORT_MEMIDX ||
+ desc == EXPORT_GLOBALIDX;
+}
diff --git a/tools/wasm_compile.h b/tools/wasm_compile.h
index e223ec6..4cee1bb 100644
--- a/tools/wasm_compile.h
+++ b/tools/wasm_compile.h
@@ -1,8 +1,12 @@
+#ifndef WASM_COMPILE_H
+#define WASM_COMPILE_H
+
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdint.h>
+#include <stdbool.h>
#define STACK_FRAME_BACKUP_ADDR 0x0FFFFC
#define STACK_TOP_ADDR 0x0FFFFC
@@ -24,6 +28,8 @@
#define PRERR(...) fprintf(stderr, __VA_ARGS__)
+#define POW(n) (((int64_t) 1) << (n))
+
struct resulttype {
uint32_t count;
char *types;
@@ -40,6 +46,7 @@ struct function {
char *locals;
struct instruction *translated_body;
+ struct target *targets;
uint32_t start_addr;
};
@@ -62,12 +69,25 @@ struct module {
uint32_t mem_min, mem_max;
uint32_t exports_count;
struct export *exports;
+ struct target *targets;
};
-int leb_u32(FILE *handle, uint32_t *result);
+int leb_32(FILE *handle, uint32_t *result, bool with_sign);
+
+inline static int leb_u32(FILE *handle, uint32_t *result)
+{
+ return leb_32(handle, result, false);
+}
+
+inline static int leb_s32(FILE *handle, int32_t *result)
+{
+ return leb_32(handle, (uint32_t *) result, true);
+}
void free_expr(struct instruction *expr);
+void free_targets(struct target *top);
+
void free_module(struct module *module);
struct module *parse_module(FILE *handle);
@@ -76,3 +96,5 @@ int translate(FILE *handle, struct function *function, struct module *module);
int assemble(uint32_t memory_size, uint16_t memory[memory_size],
struct module *module);
+
+#endif /* WASM_COMPILE_H */
generated by cgit