style: formatting
This commit is contained in:
parent
bce3e3bf25
commit
906b2d03e3
469
wai.c
469
wai.c
|
|
@ -3,8 +3,8 @@
|
|||
*
|
||||
* SPDX-License-Identifier: GPL-3.0
|
||||
*
|
||||
* This program, named WAI, is a WebAssembly Interpreter.
|
||||
* Compile using make.
|
||||
* This program, named WAI, is a WebAssembly Interpreter.
|
||||
* Compile using make.
|
||||
* Usage: wai [FILE.wasm]
|
||||
*
|
||||
* Copyright (C) 2025 orangrot <me@orangerot.dev>
|
||||
|
|
@ -24,12 +24,12 @@
|
|||
*/
|
||||
|
||||
#include <endian.h>
|
||||
#include <inttypes.h>
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/stat.h>
|
||||
#include <inttypes.h>
|
||||
|
||||
enum section {
|
||||
Section_Custom,
|
||||
|
|
@ -94,42 +94,40 @@ enum INSTRUCTION {
|
|||
INSTR_F64_SUB = 0xa1,
|
||||
INSTR_IF = 0x04,
|
||||
INSTR_LOCAL_GET = 0x20,
|
||||
};
|
||||
};
|
||||
|
||||
enum TYPE {
|
||||
TYPE_I32 = 0x7F,
|
||||
TYPE_I64 = 0x7E,
|
||||
TYPE_F32 = 0x7D,
|
||||
TYPE_F64 = 0x7C,
|
||||
TYPE_V128= 0x7B,
|
||||
TYPE_V128 = 0x7B,
|
||||
TYPE_FUNCREF = 0x70,
|
||||
TYPE_EXTERNREF = 0x6F
|
||||
};
|
||||
|
||||
static const int TYPE_SIZE[] = {
|
||||
[TYPE_I32] = 4,
|
||||
[TYPE_I64] = 8,
|
||||
[TYPE_F32] = 4,
|
||||
[TYPE_F64] = 8,
|
||||
[TYPE_V128] = 16,
|
||||
[TYPE_FUNCREF] = 16,
|
||||
[TYPE_EXTERNREF] = 16
|
||||
};
|
||||
[TYPE_I32] = 4, [TYPE_I64] = 8, [TYPE_F32] = 4, [TYPE_F64] = 8,
|
||||
[TYPE_V128] = 16, [TYPE_FUNCREF] = 16, [TYPE_EXTERNREF] = 16};
|
||||
|
||||
struct value_t {
|
||||
enum TYPE type;
|
||||
union {
|
||||
int32_t i32;
|
||||
int64_t i64;
|
||||
float f32;
|
||||
double f64;
|
||||
__int128 v128;
|
||||
int64_t funcref;
|
||||
int64_t extref;
|
||||
int32_t i32;
|
||||
int64_t i64;
|
||||
float f32;
|
||||
double f64;
|
||||
__int128 v128;
|
||||
int64_t funcref;
|
||||
int64_t extref;
|
||||
} value;
|
||||
};
|
||||
|
||||
#define incr(i, len) i++; if (i >= len) {return -1;}
|
||||
#define incr(i, len) \
|
||||
i++; \
|
||||
if (i >= len) { \
|
||||
return -1; \
|
||||
}
|
||||
|
||||
void stack_push(struct stack *s, const struct value_t *value) {
|
||||
size_t type_size = TYPE_SIZE[value->type];
|
||||
|
|
@ -144,37 +142,38 @@ void stack_push(struct stack *s, const struct value_t *value) {
|
|||
void *value = &s->items[i - type_size];
|
||||
|
||||
switch (t) {
|
||||
case TYPE_I32:
|
||||
printf("%d (I32)", *(int32_t*)value);
|
||||
break;
|
||||
case TYPE_I64:
|
||||
printf("%ld (I32)", *(int64_t*)value);
|
||||
break;
|
||||
case TYPE_F32:
|
||||
printf("%f (F32)", *(float*)value);
|
||||
break;
|
||||
case TYPE_F64:
|
||||
printf("%f (F64)", *(double*)value);
|
||||
break;
|
||||
case TYPE_V128:
|
||||
printf("%ld (V128)", *(__int128*)value);
|
||||
break;
|
||||
case TYPE_FUNCREF:
|
||||
printf("%ld (EREF)", *(int64_t*)value);
|
||||
break;
|
||||
case TYPE_EXTERNREF:
|
||||
printf("%ld (EREF)", *(int64_t*)value);
|
||||
break;
|
||||
case TYPE_I32:
|
||||
printf("%d (I32)", *(int32_t *)value);
|
||||
break;
|
||||
case TYPE_I64:
|
||||
printf("%ld (I32)", *(int64_t *)value);
|
||||
break;
|
||||
case TYPE_F32:
|
||||
printf("%f (F32)", *(float *)value);
|
||||
break;
|
||||
case TYPE_F64:
|
||||
printf("%f (F64)", *(double *)value);
|
||||
break;
|
||||
case TYPE_V128:
|
||||
printf("%ld (V128)", *(__int128 *)value);
|
||||
break;
|
||||
case TYPE_FUNCREF:
|
||||
printf("%ld (EREF)", *(int64_t *)value);
|
||||
break;
|
||||
case TYPE_EXTERNREF:
|
||||
printf("%ld (EREF)", *(int64_t *)value);
|
||||
break;
|
||||
}
|
||||
printf(", ");
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
|
||||
void stack_top(struct stack *s, struct value_t *value) {
|
||||
value->type = s->items[s->bytes-1];
|
||||
memcpy(&value->value, &(s->items[s->bytes - 1 - TYPE_SIZE[value->type]]), TYPE_SIZE[value->type]);
|
||||
}
|
||||
value->type = s->items[s->bytes - 1];
|
||||
memcpy(&value->value, &(s->items[s->bytes - 1 - TYPE_SIZE[value->type]]),
|
||||
TYPE_SIZE[value->type]);
|
||||
}
|
||||
|
||||
void stack_pop(struct stack *s, struct value_t *value) {
|
||||
stack_top(s, value);
|
||||
|
|
@ -187,24 +186,26 @@ int parse_type(u_char *binary, int len) {
|
|||
printf("type %x\n", param);
|
||||
incr(i, len);
|
||||
switch (param) {
|
||||
case TYPE_I32:
|
||||
case TYPE_I64:
|
||||
case TYPE_F32:
|
||||
case TYPE_F64:
|
||||
case TYPE_V128:
|
||||
case TYPE_FUNCREF:
|
||||
case TYPE_EXTERNREF:
|
||||
break;
|
||||
default:
|
||||
return -1;
|
||||
case TYPE_I32:
|
||||
case TYPE_I64:
|
||||
case TYPE_F32:
|
||||
case TYPE_F64:
|
||||
case TYPE_V128:
|
||||
case TYPE_FUNCREF:
|
||||
case TYPE_EXTERNREF:
|
||||
break;
|
||||
default:
|
||||
return -1;
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
int parse_function(struct module *module, u_char *binary, double param, int len);
|
||||
int parse_instruction(struct module *module, u_char *binary, double param, int len) {
|
||||
int parse_function(struct module *module, u_char *binary, double param,
|
||||
int len);
|
||||
int parse_instruction(struct module *module, u_char *binary, double param,
|
||||
int len) {
|
||||
int i = 0;
|
||||
enum INSTRUCTION instr = (u_char) binary[i];
|
||||
enum INSTRUCTION instr = (u_char)binary[i];
|
||||
u_char *instr_addr = &binary[i];
|
||||
struct value_t a = {0};
|
||||
struct value_t b = {0};
|
||||
|
|
@ -213,94 +214,97 @@ int parse_instruction(struct module *module, u_char *binary, double param, int l
|
|||
incr(i, len);
|
||||
|
||||
switch (instr) {
|
||||
case INSTR_CALL: {
|
||||
int func_index = binary[i];
|
||||
incr(i, len);
|
||||
stack_pop(&module->stack, &a);
|
||||
parse_function(module, module->funcs[func_index], a.value.f64, len);
|
||||
break;
|
||||
}
|
||||
case INSTR_ELSE:
|
||||
printf("reached else instruction: impossible!\n");
|
||||
case INSTR_END:
|
||||
break;
|
||||
case INSTR_F64_CONST:
|
||||
result.type = TYPE_F64;
|
||||
result.value.f64 = *(double*)&binary[i];
|
||||
i += 8;
|
||||
stack_push(&module->stack, &result);
|
||||
break;
|
||||
case INSTR_F64_LT: {
|
||||
stack_pop(&module->stack, &a);
|
||||
stack_pop(&module->stack, &b);
|
||||
if (a.type != TYPE_F64 || b.type != TYPE_F64)
|
||||
printf("Wrong types!\n");
|
||||
result.type = TYPE_F64;
|
||||
result.value.f64 = b.value.f64 < a.value.f64;
|
||||
stack_push(&module->stack, &result);
|
||||
break;
|
||||
}
|
||||
case INSTR_F64_MUL: {
|
||||
stack_pop(&module->stack, &a);
|
||||
stack_pop(&module->stack, &b);
|
||||
if (a.type != TYPE_F64 || b.type != TYPE_F64)
|
||||
printf("Wrong types!\n");
|
||||
result.type = TYPE_F64;
|
||||
result.value.f64 = a.value.f64 * b.value.f64;
|
||||
stack_push(&module->stack, &result);
|
||||
break;
|
||||
}
|
||||
case INSTR_F64_SUB: {
|
||||
stack_pop(&module->stack, &a);
|
||||
stack_pop(&module->stack, &b);
|
||||
if (a.type != TYPE_F64 || b.type != TYPE_F64)
|
||||
printf("Wrong types!\n");
|
||||
result.type = TYPE_F64;
|
||||
result.value.f64 = b.value.f64 - a.value.f64;
|
||||
stack_push(&module->stack, &result);
|
||||
break;
|
||||
}
|
||||
case INSTR_IF: {
|
||||
stack_pop(&module->stack, &a);
|
||||
enum TYPE condition_type = binary[i];
|
||||
incr(i, len);
|
||||
if (a.type != condition_type)
|
||||
printf("Wrong types!\n");
|
||||
case INSTR_CALL: {
|
||||
int func_index = binary[i];
|
||||
incr(i, len);
|
||||
stack_pop(&module->stack, &a);
|
||||
parse_function(module, module->funcs[func_index], a.value.f64, len);
|
||||
break;
|
||||
}
|
||||
case INSTR_ELSE:
|
||||
printf("reached else instruction: impossible!\n");
|
||||
case INSTR_END:
|
||||
break;
|
||||
case INSTR_F64_CONST:
|
||||
result.type = TYPE_F64;
|
||||
result.value.f64 = *(double *)&binary[i];
|
||||
i += 8;
|
||||
stack_push(&module->stack, &result);
|
||||
break;
|
||||
case INSTR_F64_LT: {
|
||||
stack_pop(&module->stack, &a);
|
||||
stack_pop(&module->stack, &b);
|
||||
if (a.type != TYPE_F64 || b.type != TYPE_F64)
|
||||
printf("Wrong types!\n");
|
||||
result.type = TYPE_F64;
|
||||
result.value.f64 = b.value.f64 < a.value.f64;
|
||||
stack_push(&module->stack, &result);
|
||||
break;
|
||||
}
|
||||
case INSTR_F64_MUL: {
|
||||
stack_pop(&module->stack, &a);
|
||||
stack_pop(&module->stack, &b);
|
||||
if (a.type != TYPE_F64 || b.type != TYPE_F64)
|
||||
printf("Wrong types!\n");
|
||||
result.type = TYPE_F64;
|
||||
result.value.f64 = a.value.f64 * b.value.f64;
|
||||
stack_push(&module->stack, &result);
|
||||
break;
|
||||
}
|
||||
case INSTR_F64_SUB: {
|
||||
stack_pop(&module->stack, &a);
|
||||
stack_pop(&module->stack, &b);
|
||||
if (a.type != TYPE_F64 || b.type != TYPE_F64)
|
||||
printf("Wrong types!\n");
|
||||
result.type = TYPE_F64;
|
||||
result.value.f64 = b.value.f64 - a.value.f64;
|
||||
stack_push(&module->stack, &result);
|
||||
break;
|
||||
}
|
||||
case INSTR_IF: {
|
||||
stack_pop(&module->stack, &a);
|
||||
enum TYPE condition_type = binary[i];
|
||||
incr(i, len);
|
||||
if (a.type != condition_type)
|
||||
printf("Wrong types!\n");
|
||||
|
||||
while (binary[i] != INSTR_ELSE) {
|
||||
// TODO test condition with correct type.
|
||||
// This might not matter since all types are false with 0x0
|
||||
if (a.value.i64) {
|
||||
i += parse_instruction(module, &binary[i], param, len);
|
||||
} else {
|
||||
incr(i, len);
|
||||
}
|
||||
}
|
||||
incr(i, len);
|
||||
while (binary[i] != INSTR_END) {
|
||||
if (a.value.i64) {
|
||||
incr(i, len);
|
||||
} else {
|
||||
i += parse_instruction(module, &binary[i], param, len);
|
||||
}
|
||||
while (binary[i] != INSTR_ELSE) {
|
||||
// TODO test condition with correct type.
|
||||
// This might not matter since all types are false with 0x0
|
||||
if (a.value.i64) {
|
||||
i += parse_instruction(module, &binary[i], param, len);
|
||||
} else {
|
||||
incr(i, len);
|
||||
}
|
||||
incr(i, len);
|
||||
break;
|
||||
}
|
||||
incr(i, len);
|
||||
while (binary[i] != INSTR_END) {
|
||||
if (a.value.i64) {
|
||||
incr(i, len);
|
||||
} else {
|
||||
i += parse_instruction(module, &binary[i], param, len);
|
||||
}
|
||||
case INSTR_LOCAL_GET: {
|
||||
int local_index = binary[i];
|
||||
incr(i, len);
|
||||
stack_push(&module->stack, &(struct value_t) {.value.f64 = param, .type = TYPE_F64});
|
||||
break;
|
||||
}
|
||||
default:
|
||||
printf("unknown instruction! %x at %lx\n", instr, instr_addr - module->binary);
|
||||
exit(1);
|
||||
}
|
||||
incr(i, len);
|
||||
break;
|
||||
}
|
||||
case INSTR_LOCAL_GET: {
|
||||
int local_index = binary[i];
|
||||
incr(i, len);
|
||||
stack_push(&module->stack,
|
||||
&(struct value_t){.value.f64 = param, .type = TYPE_F64});
|
||||
break;
|
||||
}
|
||||
default:
|
||||
printf("unknown instruction! %x at %lx\n", instr,
|
||||
instr_addr - module->binary);
|
||||
exit(1);
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
int parse_function(struct module *module, u_char *binary, double param, int len) {
|
||||
int parse_function(struct module *module, u_char *binary, double param,
|
||||
int len) {
|
||||
int i = 0;
|
||||
int body_size = binary[i];
|
||||
incr(i, len);
|
||||
|
|
@ -322,98 +326,102 @@ int parse_section(struct module *module, u_char *binary, int len) {
|
|||
incr(i, len);
|
||||
printf("section %x with size %d\n", type, size);
|
||||
|
||||
switch ((enum section) type) {
|
||||
case Section_Custom:
|
||||
break;
|
||||
case Section_Type:
|
||||
printf("section: type\n");
|
||||
int num_types = binary[i];
|
||||
incr(i, len);
|
||||
for (int type_i = 0; type_i < num_types; type_i++) {
|
||||
if (binary[i] != 0x60) {
|
||||
printf("expected function type, found %x\n", binary[i]);
|
||||
return -1;
|
||||
}
|
||||
incr(i, len);
|
||||
int num_params = binary[i];
|
||||
incr(i, len);
|
||||
for (int params_i = 0; params_i < num_params; params_i++) {
|
||||
i += (parse_type(&binary[i], len));
|
||||
}
|
||||
int num_results = binary[i];
|
||||
incr(i, len);
|
||||
for (int results_i = 0; results_i < num_results; results_i++) {
|
||||
i += (parse_type(&binary[i], len));
|
||||
}
|
||||
}
|
||||
break;
|
||||
case Section_Import:
|
||||
break;
|
||||
case Section_Function:
|
||||
printf("section: function\n");
|
||||
int num_functions = binary[i];
|
||||
incr(i, len);
|
||||
for (int function_i = 0; function_i < num_functions; function_i++) {
|
||||
incr(i, len);
|
||||
switch ((enum section)type) {
|
||||
case Section_Custom:
|
||||
break;
|
||||
case Section_Type:
|
||||
printf("section: type\n");
|
||||
int num_types = binary[i];
|
||||
incr(i, len);
|
||||
for (int type_i = 0; type_i < num_types; type_i++) {
|
||||
if (binary[i] != 0x60) {
|
||||
printf("expected function type, found %x\n", binary[i]);
|
||||
return -1;
|
||||
}
|
||||
break;
|
||||
case Section_Table:
|
||||
break;
|
||||
case Section_Memory:
|
||||
break;
|
||||
case Section_Global:
|
||||
break;
|
||||
case Section_Export:
|
||||
printf("section: exports\n");
|
||||
int num_exports = binary[i];
|
||||
|
||||
if(num_exports > MAX_FUNCTIONS) {
|
||||
printf("Number of exports exceeds maximum number of functions in a module (%d)", MAX_FUNCTIONS);
|
||||
return -1;
|
||||
}
|
||||
|
||||
incr(i, len);
|
||||
for (int exports_i = 0; exports_i < num_exports; exports_i++) {
|
||||
struct export_t *export = &module->exports[i];
|
||||
int num_params = binary[i];
|
||||
incr(i, len);
|
||||
for (int params_i = 0; params_i < num_params; params_i++) {
|
||||
i += (parse_type(&binary[i], len));
|
||||
}
|
||||
int num_results = binary[i];
|
||||
incr(i, len);
|
||||
for (int results_i = 0; results_i < num_results; results_i++) {
|
||||
i += (parse_type(&binary[i], len));
|
||||
}
|
||||
}
|
||||
break;
|
||||
case Section_Import:
|
||||
break;
|
||||
case Section_Function:
|
||||
printf("section: function\n");
|
||||
int num_functions = binary[i];
|
||||
incr(i, len);
|
||||
for (int function_i = 0; function_i < num_functions; function_i++) {
|
||||
incr(i, len);
|
||||
}
|
||||
break;
|
||||
case Section_Table:
|
||||
break;
|
||||
case Section_Memory:
|
||||
break;
|
||||
case Section_Global:
|
||||
break;
|
||||
case Section_Export:
|
||||
printf("section: exports\n");
|
||||
int num_exports = binary[i];
|
||||
|
||||
export->name_length = binary[i];
|
||||
incr(i, len);
|
||||
|
||||
for (int si = 0; si < export->name_length; si++) {
|
||||
export->name[si] = binary[i];
|
||||
incr(i, len);
|
||||
}
|
||||
export->description = (int) binary[i];
|
||||
incr(i, len);
|
||||
export->index = (uint32_t) binary[i];
|
||||
printf("export name: %s of type %d\n", export->name, export->description);
|
||||
incr(i, len);
|
||||
}
|
||||
break;
|
||||
case Section_Start:
|
||||
break;
|
||||
case Section_Element:
|
||||
break;
|
||||
case Section_Code:
|
||||
printf("section: code\n");
|
||||
int num_functions2 = binary[i];
|
||||
if (num_exports > MAX_FUNCTIONS) {
|
||||
printf("Number of exports exceeds maximum number of functions in a "
|
||||
"module (%d)",
|
||||
MAX_FUNCTIONS);
|
||||
return -1;
|
||||
}
|
||||
|
||||
incr(i, len);
|
||||
for (int exports_i = 0; exports_i < num_exports; exports_i++) {
|
||||
struct export_t *export = &module->exports[i];
|
||||
|
||||
export->name_length = binary[i];
|
||||
incr(i, len);
|
||||
for (int function_i = 0; function_i < num_functions2; function_i++) {
|
||||
module->funcs[function_i] = &binary[i];
|
||||
i += parse_function(module, &binary[i], 4, len);
|
||||
|
||||
for (size_t si = 0; si < export->name_length; si++) {
|
||||
export->name[si] = binary[i];
|
||||
incr(i, len);
|
||||
}
|
||||
// printf("result: %f\n", module->stack.items[0]);
|
||||
break;
|
||||
case Section_Data:
|
||||
break;
|
||||
case Section_Data_Count:
|
||||
break;
|
||||
default:
|
||||
fprintf(stderr, "expectet section\n");
|
||||
exit(1);
|
||||
export->description = (int)binary[i];
|
||||
incr(i, len);
|
||||
export->index = (uint32_t)binary[i];
|
||||
printf("export name: %s of type %d\n", export->name, export->description);
|
||||
incr(i, len);
|
||||
}
|
||||
break;
|
||||
case Section_Start:
|
||||
break;
|
||||
case Section_Element:
|
||||
break;
|
||||
case Section_Code:
|
||||
printf("section: code\n");
|
||||
int num_functions2 = binary[i];
|
||||
incr(i, len);
|
||||
for (int function_i = 0; function_i < num_functions2; function_i++) {
|
||||
module->funcs[function_i] = &binary[i];
|
||||
i += parse_function(module, &binary[i], 4, len);
|
||||
}
|
||||
// printf("result: %f\n", module->stack.items[0]);
|
||||
break;
|
||||
case Section_Data:
|
||||
break;
|
||||
case Section_Data_Count:
|
||||
break;
|
||||
default:
|
||||
fprintf(stderr, "expectet section\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
if (size == 0x0) {incr(i, len);}
|
||||
if (size == 0x0) {
|
||||
incr(i, len);
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
|
|
@ -421,14 +429,14 @@ int parse_module(u_char *binary, size_t len) {
|
|||
int i = 0;
|
||||
char *magic = "\0asm";
|
||||
while (i < 4) {
|
||||
if ((char) binary[i] != magic[i]) {
|
||||
if ((char)binary[i] != magic[i]) {
|
||||
fprintf(stderr, "no wasm magic\n");
|
||||
return 0;
|
||||
}
|
||||
incr(i, len);
|
||||
}
|
||||
printf("magic found\n");
|
||||
printf("wasm version: %d\n", le32toh(*(int*)&binary[i]));
|
||||
printf("wasm version: %d\n", le32toh(*(int *)&binary[i]));
|
||||
i += 4;
|
||||
printf("addr %d\n", i);
|
||||
|
||||
|
|
@ -442,7 +450,7 @@ int parse_module(u_char *binary, size_t len) {
|
|||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
|
||||
|
||||
if (argc != 2) {
|
||||
fprintf(stderr, "Usage: %s [file]\n", argv[0]);
|
||||
return 1;
|
||||
|
|
@ -456,16 +464,15 @@ int main(int argc, char **argv) {
|
|||
struct stat st;
|
||||
stat(argv[1], &st);
|
||||
printf("size: %ld\n", st.st_size);
|
||||
|
||||
|
||||
u_char *binary = malloc(st.st_size);
|
||||
fread(binary, st.st_size, 1, file);
|
||||
|
||||
if (parse_module(binary, st.st_size) == -1) {
|
||||
printf("error :(\n");
|
||||
}
|
||||
|
||||
|
||||
free(binary);
|
||||
fclose(file);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue