refactor: have instruction as macro to generate enum, functions and array

wai.c

@@ -54,6 +54,7 @@ enum section {
 };
 
 enum TYPE {
+  TYPE_ANY = 0,
   TYPE_I32 = 0x7F,
   TYPE_I64 = 0x7E,
   TYPE_F32 = 0x7D,
@@ -63,68 +64,6 @@ enum TYPE {
   TYPE_EXTERNREF = 0x6F
 };
 
-struct stack {
-  u_char items[STACK_CAPACITY];
-  size_t bytes;
-};
-
-struct func_type_t {
-  enum TYPE param[MAX_FUNCTION_PARAMETERS];
-  enum TYPE result[MAX_FUNCTION_RESULTS];
-  size_t num_params;
-  size_t num_results;
-};
-
-struct func_t {
-  size_t func_type_index;
-  size_t num_local_vars;
-  u_char *func_start_addr;
-};
-
-enum export_desc {
-  Export_Func,
-  Export_Table,
-  Export_Mem,
-  Export_Global,
-};
-
-struct export_t {
-  char name[MAX_EXPORT_NAME_LENGTH];
-  size_t name_length;
-  size_t func_index;
-  enum export_desc description;
-};
-
-struct module {
-  struct func_type_t func_types[MAX_FUNCTIONS]; // TYPE SECTION
-  u_char *code[MAX_FUNCTIONS];                  // CODE SECTION
-  size_t func_to_func_type[MAX_FUNCTIONS];      // FUNCTION SECTION
-  struct table_t *tables;
-  struct mem_t *mems;
-  struct global_t *globals;
-  struct elem_t *elems;
-  struct data_t *datas;
-  struct start_t *start;
-  struct import_t *imports;
-  struct export_t exports[MAX_FUNCTIONS];
-  u_char *binary;
-  struct stack stack;
-  size_t num_exports;
-  int scope;
-};
-
-enum INSTRUCTION {
-  INSTR_CALL = 0x10,
-  INSTR_ELSE = 0x05,
-  INSTR_END = 0x0b,
-  INSTR_F64_CONST = 0x44,
-  INSTR_F64_LT = 0x63,
-  INSTR_F64_MUL = 0xa2,
-  INSTR_F64_SUB = 0xa1,
-  INSTR_IF = 0x04,
-  INSTR_LOCAL_GET = 0x20,
-};  
-
 static const int TYPE_SIZE[] = {
   [TYPE_I32] = 4,
   [TYPE_I64] = 8,
@@ -142,7 +81,56 @@ static const char *TYPE_NAME[] = {
   [TYPE_F64] = "F64",
   [TYPE_V128] = "V128",
   [TYPE_FUNCREF] = "FREF",
-  [TYPE_EXTERNREF] = "EXTR"
+  [TYPE_EXTERNREF] = "EXTR",
+  [TYPE_ANY] = "ANY",
+};
+
+struct stack {
+  u_char items[STACK_CAPACITY];
+  size_t bytes;
+};
+
+struct func_type_t {
+  enum TYPE param[MAX_FUNCTION_PARAMETERS];
+  enum TYPE result[MAX_FUNCTION_RESULTS];
+  size_t num_params;
+  size_t num_results;
+};
+
+struct func_t {
+  size_t func_type_index;
+  size_t num_local_vars;
+  u_char *addr;
+};
+
+enum export_desc {
+  Export_Func,
+  Export_Table,
+  Export_Mem,
+  Export_Global,
+};
+
+struct export_t {
+  char name[MAX_EXPORT_NAME_LENGTH];
+  size_t name_length;
+  size_t func_index;
+  enum export_desc description;
+};
+
+struct module {
+  struct func_type_t func_types[MAX_FUNCTIONS];
+  struct func_t func[MAX_FUNCTIONS];
+  struct table_t *tables;
+  struct mem_t *mems;
+  struct global_t *globals;
+  struct elem_t *elems;
+  struct data_t *datas;
+  struct start_t *start;
+  struct import_t *imports;
+  struct export_t exports[MAX_FUNCTIONS];
+  u_char *binary;
+  struct stack stack;
+  size_t num_exports;
 };
 
 struct value_t {
@@ -158,7 +146,13 @@ struct value_t {
   } value;
 };
 
-#define incr(i, len) i++; if (i >= len) {return -1;}
+struct context {
+  struct module *module;
+  size_t func_i;
+  size_t func_stack_begin;
+};
+
+#define incr(i, len) i++; if (i >= len) {return 0;}
 
 void print_value(struct value_t *value) {
   void *number = &value->value;
@@ -167,6 +161,7 @@ void print_value(struct value_t *value) {
       printf("%d", *(int32_t*)number);
       break;
     case TYPE_I64:
+    case TYPE_ANY:
       printf("%ld", *(int64_t*)number);
       break;
     case TYPE_F32:
@@ -176,7 +171,7 @@ void print_value(struct value_t *value) {
       printf("%f", *(double*)number);
       break;
     case TYPE_V128:
-      printf("%ld", *(__int128*)number);
+      printf("%f", (double) *(__int128*)number);
       break;
     case TYPE_FUNCREF:
       printf("%ld", *(int64_t*)number);
@@ -190,7 +185,7 @@ void print_value(struct value_t *value) {
 
 void stack_peak(struct stack *s, struct value_t *value, size_t nth, size_t from) {
   int byte_i = from - 1; 
-  for (int element_i = 0; element_i < nth && byte_i > 0; element_i++) {
+  for (size_t element_i = 0; element_i < nth && byte_i > 0; element_i++) {
     byte_i -= TYPE_SIZE[s->items[byte_i]];
   }
   value->type = s->items[byte_i];
@@ -205,9 +200,6 @@ void stack_push(struct stack *s, const struct value_t *value) {
 
   printf("stack: ");
   for (int i = s->bytes - 1; i > 0; i -= TYPE_SIZE[s->items[i]] + 1) {
-    enum TYPE t = s->items[i];
-    size_t type_size = TYPE_SIZE[t];
-    void *number = &s->items[i - type_size];
     struct value_t stack_value = {0};
     stack_peak(s, &stack_value, 0, i + 1);
     print_value(&stack_value);
@@ -226,133 +218,157 @@ void stack_pop(struct stack *s, struct value_t *value) {
   s->bytes -= TYPE_SIZE[value->type] + 1;
 }
 
-int parse_function(struct module *module, size_t func_i, int len);
+int parse_function(struct module *module, size_t func_i, size_t len);
-int parse_instruction(struct module *module, u_char *binary, size_t func_i, size_t func_stack_begin, int len) {
+int parse_instruction(struct context context, u_char *binary, size_t len);
-  int i = 0;
+
-  enum INSTRUCTION instr = binary[i];
+#define PARAMS(...) __VA_ARGS__
+
+// https://webassembly.github.io/spec/core/appendix/index-instructions.html
+// OP(NAME, CODE, PARAM, NUM_RESULTS, LEN_IMMIDIATE, BODY)
+#define DEFINE_OPERATIONS(OP)                                                                                                         \
+OP(INSTR_F64_MUL,   0xa2, PARAMS(TYPE_F64, TYPE_F64), 1, 0, result->type = TYPE_F64; result->value.f64 = a->value.f64 * b->value.f64) \
+OP(INSTR_F64_SUB,   0xa1, PARAMS(TYPE_F64, TYPE_F64), 1, 0, result->type = TYPE_F64; result->value.f64 = b->value.f64 - a->value.f64) \
+OP(INSTR_F64_LT,    0x63, PARAMS(TYPE_F64, TYPE_F64), 1, 0, result->type = TYPE_F64; result->value.f64 = b->value.f64 < a->value.f64) \
+OP(INSTR_F64_CONST, 0x44, PARAMS(), 1, 8, result->type = TYPE_F64; result->value.f64 = *(double*)immidiate)                           \
+OP(INSTR_LOCAL_GET, 0x20, PARAMS(), 1, 1,                                                                                             \
+  size_t func_type_i = context.module->func[context.func_i].func_type_index;                                                          \
+  struct func_type_t *func_type = &context.module->func_types[func_type_i];                                                           \
+  int num_locals = func_type->num_params + context.module->func[context.func_i].num_local_vars;                                       \
+                                                                                                                                      \
+  printf("num locals %d, %d\n", num_locals, num_locals - 1 - *(u_char*)immidiate);                                                    \
+  stack_peak(&context.module->stack, result, num_locals - 1 - *(u_char*)immidiate, context.func_stack_begin);                         \
+)                                                                                                                                     \
+OP(INSTR_CALL, 0x10, PARAMS(), 0, 1, parse_function(context.module, *(u_char*)immidiate, len))                                        \
+OP(INSTR_IF, 0x04, PARAMS(TYPE_ANY), 0, 1,                                                                                            \
+  size_t i = 0;                                                                                                                       \
+  enum TYPE condition_type = *(u_char*) immidiate;                                                                                    \
+  if (a->type != condition_type)                                                                                                      \
+    printf("Wrong types!\n");                                                                                                         \
+                                                                                                                                      \
+  while (binary[i] != INSTR_ELSE) {                                                                                                   \
+    if (a->value.i64) {                                                                                                               \
+      i += parse_instruction(context, &binary[i], len);                                                                               \
+    } else {                                                                                                                          \
+      incr(i, len);                                                                                                                   \
+    }                                                                                                                                 \
+  }                                                                                                                                   \
+  incr(i, len);                                                                                                                       \
+  while (binary[i] != INSTR_END) {                                                                                                    \
+    if (a->value.i64) {                                                                                                               \
+      incr(i, len);                                                                                                                   \
+    } else {                                                                                                                          \
+      i += parse_instruction(context, &binary[i], len);                                                                               \
+    }                                                                                                                                 \
+  }                                                                                                                                   \
+  incr(i, len);                                                                                                                       \
+  return i;                                                                                                                           \
+)
+
+enum OP_CODES {
+#define AS_ENUM(NAME, CODE, PARAM, NUM_RESULTS, LEN_IMMIDIATE, BODY) NAME = CODE,
+DEFINE_OPERATIONS(AS_ENUM)
+  INSTR_END = 0x0B,
+  INSTR_ELSE = 0x05
+};  
+
+
+#define AS_FUNCTION(NAME, CODE, PARAM, NUM_RESULTS, LEN_IMMIDIATE, BODY)       \
+  int exec_##NAME(struct context context, struct value_t *a,                   \
+                  struct value_t *b, void *immidiate, struct value_t *result,  \
+                  u_char *binary, size_t len) {                                \
+    (void) context;                                                            \
+    (void) a;                                                                  \
+    (void) b;                                                                  \
+    (void) immidiate;                                                          \
+    (void) result;                                                             \
+    (void) binary;                                                             \
+    (void) len;                                                                \
+    BODY;                                                                      \
+    return 0;                                                                  \
+  }
+DEFINE_OPERATIONS(AS_FUNCTION)
+
+struct instruction {
+  size_t num_param;
+  enum TYPE params[2];
+  size_t len_immidiate;
+  size_t num_results;
+  int (*exec) (struct context context, struct value_t *a, struct value_t *b, void *immidiate, struct value_t *result, u_char *binary, size_t len);
+};
+
+struct instruction INSTRUCTIONS[] = {
+#define AS_INSTRUCTION(NAME, CODE, PARAM, NUM_RESULTS, LEN_IMMIDIATE, BODY)    \
+  [NAME] = {                                                                   \
+    .num_param = sizeof((enum TYPE[]) {PARAM}) / sizeof(enum TYPE),            \
+    .params = {PARAM},                                                         \
+    .num_results = NUM_RESULTS,                                                \
+    .len_immidiate = LEN_IMMIDIATE,                                            \
+    .exec = &exec_##NAME                                                       \
+  },                                                                                                    
+DEFINE_OPERATIONS(AS_INSTRUCTION)
+};
+
+int parse_instruction(struct context context, u_char *binary, size_t len) {
+  size_t i = 0;	
+  enum OP_CODES op_code = binary[i];
   u_char *instr_addr = &binary[i];
-  struct value_t a = {0};
-  struct value_t b = {0};
   struct value_t result = {0};
+  struct value_t arguments[2];
 
   incr(i, len);
 
-  switch (instr) {
+  struct instruction *instr = &INSTRUCTIONS[op_code];
-    case INSTR_CALL: {
+  if (instr->exec == NULL) {
-      int func_index = binary[i];
+    printf("not implemented/illegal instruction %x at %lx\n", op_code, instr_addr - context.module->binary);
-      incr(i, len);
+    exit(1);
-      // stack_pop(&module->stack, &a);
+  };
-      parse_function(module, func_index, 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) {
+  for (size_t param_i = 0; param_i < instr->num_param; param_i++) {
-        // TODO test condition with correct type. 
+    stack_pop(&context.module->stack, &arguments[param_i]);
-        // This might not matter since all types are false with 0x0
+    if (instr->params[param_i] != TYPE_ANY && arguments[param_i].type != instr->params[param_i]) {
-        if (a.value.i64) {
+      printf("wrong type! %x\n", op_code);
-          i += parse_instruction(module, &binary[i], func_i, func_stack_begin, 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], func_i, func_stack_begin, len);
-        }
-      }
-      incr(i, len);
-      break;
-      }
-    case INSTR_LOCAL_GET: {
-      int local_index = binary[i];
-      size_t func_type_i = module->func_to_func_type[func_i];
-      struct func_type_t *func_type = &module->func_types[func_type_i];
-      // TODO: take local variables into account in addition to parameters
-      int num_locals = func_type->num_params;
-      printf("num locals %d, %d\n", num_locals, num_locals - 1 - local_index);
-      stack_peak(&module->stack, &result, num_locals - 1 - local_index, func_stack_begin);
-      incr(i, len); 
-      stack_push(&module->stack, &result);
-      break;
-      }
-    default:
-      printf("unknown instruction! %x at %lx\n", instr, instr_addr - module->binary);
-      exit(1);
   }
+  i += instr->exec(context, &arguments[0], &arguments[1], &binary[i], &result, &binary[i + instr->len_immidiate], len);
+  i += instr->len_immidiate;
+  if (instr->num_results) {
+    stack_push(&context.module->stack, &result);
+  }
+
   return i;
 }
 
-int parse_function(struct module *module, size_t func_i, int len) {
+int parse_function(struct module *module, size_t func_i, size_t len) {
-  int i = 0;
+  size_t i = 0;	
-  u_char *binary = module->code[func_i];
+  struct func_t *func = &module->func[func_i];
-  size_t func_type_i = module->func_to_func_type[func_i];
+  u_char *binary = func->addr;
+  size_t func_type_i = func->func_type_index;
   struct func_type_t *func_type = &module->func_types[func_type_i];
-  int body_size = binary[i];
+  // int body_size = binary[i];
   size_t func_stack_begin = module->stack.bytes;
   size_t func_stack_end;
   struct value_t result = {0};
+  struct context context = {
+    .module = module,
+    .func_i = func_i,
+    .func_stack_begin = func_stack_begin
+  };
 
   incr(i, len);
-  // int local_decl_cound = binary[i];
+  func->num_local_vars = binary[i];
   incr(i, len);
-  module->scope = 1;
+  for (size_t local_var_i = 0; local_var_i < func->num_local_vars; local_var_i++) {
+    stack_push(&module->stack, &(struct value_t) {.type = binary[i], .value = {0}}); 
+    incr(i, len);
+  }
   while (binary[i] != INSTR_END) {
-    i += parse_instruction(module, &binary[i], func_i, func_stack_begin, len);
+    i += parse_instruction(context, &binary[i], len);
   }
   incr(i, len);
   
   func_stack_end = module->stack.bytes;
   module->stack.bytes = func_stack_begin;
-  for (size_t param_i = 0; param_i < func_type->num_params; param_i++) {
+  for (size_t local_i = 0; local_i < func_type->num_params + func->num_local_vars; local_i++) {
     stack_pop(&module->stack, &result);
   }
   for (size_t result_i = 0; result_i < func_type->num_results; result_i++) {
@@ -362,8 +378,8 @@ int parse_function(struct module *module, size_t func_i, int len) {
   return i;
 }
 
-int parse_section(struct module *module, u_char *binary, int len) {
+int parse_section(struct module *module, u_char *binary, size_t len) {
-  int i = 0;
+  size_t i = 0;	
   enum section type = binary[i];
   incr(i, len);
   int size = binary[i];
@@ -381,7 +397,7 @@ int parse_section(struct module *module, u_char *binary, int len) {
         for (size_t type_i = 0; type_i < num_types; type_i++) {
           if (binary[i] != 0x60) {
             printf("expected function type, found %x\n", binary[i]);
-            return -1;
+            return 0;
           }
           incr(i, len);
           func_type = &module->func_types[type_i];
@@ -406,7 +422,7 @@ int parse_section(struct module *module, u_char *binary, int len) {
       size_t num_functions = binary[i];
       incr(i, len);
       for (size_t function_i = 0; function_i < num_functions; function_i++) {
-        module->func_to_func_type[function_i] = binary[i];
+        module->func[function_i].func_type_index = binary[i];
         incr(i, len);
       }
       break;
@@ -422,7 +438,7 @@ int parse_section(struct module *module, u_char *binary, int len) {
       
       if(module->num_exports > MAX_FUNCTIONS) {
         printf("Number of exports exceeds maximum number of functions in a module (%d)", MAX_FUNCTIONS);
-        return -1;
+        return 0;
       }
       
       incr(i, len);
@@ -442,7 +458,7 @@ int parse_section(struct module *module, u_char *binary, int len) {
         printf("export name: %s of type %d\n", export->name, export->description);
         if (export->description == Export_Func) {
           printf("exported function %s(", export->name);
-          size_t func_type_index = module->func_to_func_type[export->func_index];
+          size_t func_type_index = module->func[export->func_index].func_type_index;
           struct func_type_t *func_type = &module->func_types[func_type_index];
           for (size_t param_i = 0; param_i < func_type->num_params; param_i++) {
             printf("%s", TYPE_NAME[func_type->param[param_i]]);
@@ -472,7 +488,7 @@ int parse_section(struct module *module, u_char *binary, int len) {
       int num_functions2 = binary[i];
       incr(i, len);
       for (int function_i = 0; function_i < num_functions2; function_i++) {
-        module->code[function_i] = &binary[i];
+        module->func[function_i].addr = &binary[i];
         stack_push(&module->stack, &(struct value_t) {.type = TYPE_F64, .value.f64 = 1});
         i += parse_function(module, function_i, len);
         stack_pop(&module->stack, &(struct value_t) {0});
@@ -493,7 +509,7 @@ int parse_section(struct module *module, u_char *binary, int len) {
 }
 
 int parse_module(struct module *module, u_char *binary, size_t len) {
-  int i = 0;
+  size_t i = 0;	
   char *magic = "\0asm";
   while (i < 4) {
     if ((char) binary[i] != magic[i]) {
@@ -505,7 +521,7 @@ int parse_module(struct module *module, u_char *binary, size_t len) {
   printf("magic found\n");
   printf("wasm version: %d\n", le32toh(*(int*)&binary[i]));
   i += 4;
-  printf("addr %d\n", i);
+  printf("addr %zu\n", i);
 
   module->binary = binary;
 
@@ -521,8 +537,9 @@ int main(int argc, char **argv) {
   struct stat st;
   struct module module = {0};
 
-  if (argc != 2) {
+  if (argc < 3) {
     printf("Usage: %s [file] [function name] [function arguments ...]\n", argv[0]);
+    exit(1);
   };
   file = fopen(argv[1], "r");
   if (file == NULL) {
@@ -552,8 +569,9 @@ int main(int argc, char **argv) {
     exit(1);
   }
   size_t function_search_i = module.exports[export_search_i].func_index;
-  struct func_type_t *func_type_search = &module.func_types[module.func_to_func_type[function_search_i]];
+  size_t function_search_type_index = module.func[function_search_i].func_type_index;
-  if (func_type_search->num_params != argc - 3) {
+  struct func_type_t *func_type_search = &module.func_types[function_search_type_index];
+  if (func_type_search->num_params != (size_t) (argc - 3)) {
     printf("Not enough function arguments provided. Got %d expected %zu. \n", argc - 3, func_type_search->num_params);
     exit(1);
   }