fix: missing freeing and type (in CIF prepare)

- Feat: finish FFI CIF prepare

CMakeLists.txt

@@ -169,6 +169,7 @@ if (NOT FZL_SKIP_VM)
 		src/vm/reader/vm_rd_sections_sz.c
 		src/vm/fzl_vm.c
 		src/vm/fzl_vm_env.c
+		src/vm/fzl_vm_extern.c
 		src/vm/fzl_vm_reader.c
 		src/vm/fzl_vm_debug.c
 		src/vm/main.c)

include/vm/fzl_vm.h

@@ -5,12 +5,14 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <vm/fzl_vm_env.h>
+#include <vm/fzl_vm_extern.h>
 #include <vm/fzl_vm_reader.h>
 
 // VM descriptor
 typedef struct
 {
   fzl_vm_reader_t *reader;
+  fzl_vm_extern_t *prep_fns;
 
   size_t ip;
 

include/vm/fzl_vm_extern.h

@@ -2,6 +2,8 @@
 #define FZL_VM_EXTERN_H
 
 #include <ffi.h>
+#include <stddef.h>
+#include <vm/fzl_vm_reader.h>
 
 // Loaded extern function definition
 typedef struct
@@ -9,6 +11,25 @@ typedef struct
   void *func_ptr;
   ffi_cif cif;
   ffi_type **arg_types;
+} fzl_vm_sym_t;
+
+// Extern object descriptor
+typedef struct
+{
+  void **libs;
+  size_t libs_loaded;
+
+  fzl_vm_sym_t *syms;
+  size_t syms_loaded;
 } fzl_vm_extern_t;
 
+// Load externs
+fzl_vm_extern_t *fzl_vm_init_externs(fzl_vm_reader_t *reader);
+
+// Get last error from externs loader
+char *fzl_vm_externs_geterror();
+
+// Close and free externs
+void fzl_vm_free_externs(fzl_vm_extern_t *ex);
+
 #endif // FZL_VM_EXTERN_H

src/vm/fzl_vm.c

@@ -8,6 +8,7 @@
 #include <string.h>
 #include <vm/fzl_vm.h>
 #include <vm/fzl_vm_env.h>
+#include <vm/fzl_vm_extern.h>
 #include <vm/fzl_vm_object.h>
 #include <vm/fzl_vm_reader.h>
 #include <vm/internals/opcode.h>

src/vm/fzl_vm_extern.c

@@ -0,0 +1,271 @@
+#include <common/fzl_extern.h>
+#include <common/fzl_types.h>
+#include <dlfcn.h>
+#include <ffi.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <vm/fzl_vm_extern.h>
+#include <vm/fzl_vm_reader.h>
+
+char ex_err[256];
+
+// Resolve specified type reference
+ffi_type *resolve_type(fzl_vm_reader_t *reader, fzl_extern_type_ref_t *ref)
+{
+  if (ref->is_primitive)
+  {
+    switch (ref->primitive)
+    {
+      case FZL_TYPE_INT8:
+        return &ffi_type_sint8;
+
+      case FZL_TYPE_INT16:
+        return &ffi_type_sint16;
+
+      case FZL_TYPE_INT32:
+        return &ffi_type_sint32;
+
+      case FZL_TYPE_INT64:
+        return &ffi_type_sint64;
+
+      case FZL_TYPE_UINT8:
+      case FZL_TYPE_BOOL:
+        return &ffi_type_uint8;
+
+      case FZL_TYPE_UINT16:
+        return &ffi_type_uint16;
+
+      case FZL_TYPE_UINT32:
+        return &ffi_type_uint32;
+
+      case FZL_TYPE_UINT64:
+        return &ffi_type_uint64;
+
+      case FZL_TYPE_INT:
+        return &ffi_type_sint;
+
+      case FZL_TYPE_UINT:
+        return &ffi_type_uint;
+
+      case FZL_TYPE_CHAR:
+        return &ffi_type_schar;
+
+      case FZL_TYPE_STRING:
+      case FZL_TYPE_HANDLE:
+      case FZL_TYPE_STRUCT:
+        return &ffi_type_pointer;
+
+      default:
+        return &ffi_type_void;
+    }
+  }
+  else
+  {
+    fzl_extern_type_t *t = &reader->extern_types[ref->type_slot];
+    if (!t)
+      return &ffi_type_void;
+
+    switch (t->kind)
+    {
+      case FZL_EXTERN_KIND_STRUCT:
+      case FZL_EXTERN_KIND_HANDLE:
+      case FZL_EXTERN_KIND_REF:
+        return &ffi_type_pointer;
+
+      case FZL_EXTERN_KIND_ALIAS:
+        return resolve_type(reader, &t->alias_target);
+    }
+  }
+}
+
+// Preapre sym, put result in out and return operation result
+bool prepare_sym(fzl_vm_reader_t *reader, void *sym, fzl_extern_fn_t *fn,
+                 fzl_vm_sym_t *out)
+{
+  if (!reader || !fn || !sym || !out)
+  {
+    snprintf(ex_err, sizeof(ex_err),
+             "cannot prepare sym: function def, symbol handle or outvar is not "
+             "specified");
+    return false;
+  }
+  memset(out, 0, sizeof(fzl_vm_sym_t));
+
+  out->func_ptr  = sym;
+  out->arg_types = malloc(sizeof(ffi_type *) * fn->args_count);
+  if (!out->arg_types)
+  {
+    snprintf(ex_err, sizeof(ex_err), "out of memory");
+    return false;
+  }
+
+  memset(out->arg_types, 0, sizeof(ffi_type *) * fn->args_count);
+  for (size_t i = 0; i < fn->args_count; i++)
+  {
+    fzl_extern_arg_t *arg = &fn->args[i];
+    if (arg->is_out)
+      out->arg_types[i] = &ffi_type_pointer;
+    else
+      out->arg_types[i] = resolve_type(reader, &arg->type);
+  }
+
+  ffi_type *ret =
+      fn->has_return ? resolve_type(reader, &fn->ret_type) : &ffi_type_void;
+  ffi_status res = ffi_prep_cif(&out->cif, FFI_DEFAULT_ABI, fn->args_count, ret,
+                                out->arg_types);
+  if (res != FFI_OK)
+  {
+    snprintf(ex_err, sizeof(ex_err), "failed to prepare FFI");
+    return false;
+  }
+
+  return true;
+}
+
+fzl_vm_extern_t *fzl_vm_init_externs(fzl_vm_reader_t *reader)
+{
+  if (!reader)
+  {
+    snprintf(ex_err, sizeof(ex_err), "reader is not provided");
+    return NULL;
+  }
+
+  fzl_vm_extern_t *ex = malloc(sizeof(fzl_vm_extern_t));
+  if (!ex)
+  {
+    snprintf(ex_err, sizeof(ex_err), "out of memory");
+    return NULL;
+  }
+
+  memset(ex, 0, sizeof(fzl_vm_extern_t));
+
+  if (reader->extern_libs_count < 1 || reader->extern_fns_count < 1)
+    return ex;
+
+  ex->libs = malloc(sizeof(void *) * reader->extern_libs_count);
+  if (!ex->libs)
+  {
+    snprintf(ex_err, sizeof(ex_err), "out of memory");
+    free(ex);
+    return NULL;
+  }
+
+  memset(ex->libs, 0, sizeof(void *) * reader->extern_libs_count);
+  for (uint16_t i = 0; i < reader->extern_libs_count; i++)
+  {
+    void *lib = dlopen(reader->extern_libs[i], RTLD_NOW);
+    if (!lib)
+    {
+      snprintf(ex_err, sizeof(ex_err), "cannot open library '%s'",
+               reader->extern_libs[i]);
+
+      if (i > 0)
+      {
+        for (size_t j = 0; j < ex->libs_loaded; j++)
+          if (ex->libs[j])
+            dlclose(ex->libs[j]);
+      }
+
+      free(ex->libs);
+      free(ex);
+      return NULL;
+    }
+
+    ex->libs[ex->libs_loaded++] = lib;
+  }
+
+  ex->syms = malloc(sizeof(fzl_vm_sym_t) * reader->extern_fns_count);
+  if (!ex->syms)
+  {
+    snprintf(ex_err, sizeof(ex_err), "out of memory");
+
+    for (size_t i = 0; i < ex->libs_loaded; i++)
+      if (ex->libs[i])
+        dlclose(ex->libs[i]);
+
+    free(ex->libs);
+    free(ex);
+    return NULL;
+  }
+
+  memset(ex->syms, 0, sizeof(fzl_vm_sym_t) * reader->extern_fns_count);
+  for (uint16_t i = 0; i < reader->extern_fns_count; i++)
+  {
+    fzl_extern_fn_t *fn = &reader->extern_fns[i];
+    char *fnname = fn->symbol_name != NULL ? fn->symbol_name : fn->used_name;
+
+    void *sym = dlsym(ex->libs[fn->lib_slot], fnname);
+    if (!sym)
+    {
+      snprintf(ex_err, sizeof(ex_err), "couldn't find symbol '%s' in lib '%s'",
+               fnname, reader->extern_libs[fn->lib_slot]);
+
+      for (size_t j = 0; j < ex->libs_loaded; j++)
+        if (ex->libs[j])
+          dlclose(ex->libs[j]);
+
+      free(ex->libs);
+
+      for (size_t j = 0; j < ex->syms_loaded; j++)
+      {
+        if (ex->syms->arg_types)
+          free(ex->syms->arg_types);
+      }
+
+      free(ex->syms);
+      free(ex);
+      return NULL;
+    }
+
+    if (!prepare_sym(reader, sym, fn, &ex->syms[ex->syms_loaded++]))
+    {
+      if (!ex_err[0])
+      {
+        snprintf(ex_err, sizeof(ex_err),
+                 "failed to preapre FFI structure for sym '%s'", fnname);
+      }
+
+      for (size_t j = 0; j < ex->libs_loaded; j++)
+        if (ex->libs[j])
+          dlclose(ex->libs[j]);
+
+      free(ex->libs);
+      free(ex->syms);
+      free(ex);
+      return NULL;
+    }
+  }
+
+  return ex;
+}
+
+char *fzl_vm_externs_geterror() { return ex_err; }
+
+void fzl_vm_free_externs(fzl_vm_extern_t *ex)
+{
+  if (!ex)
+    return;
+
+  if (ex->libs)
+  {
+    for (size_t i = 0; i < ex->libs_loaded; i++)
+      if (ex->libs[i])
+        dlclose(ex->libs[i]);
+
+    free(ex->libs);
+  }
+
+  if (ex->syms)
+  {
+    for (size_t i = 0; i < ex->syms_loaded; i++)
+      free(ex->syms[i].arg_types);
+
+    free(ex->syms);
+  }
+
+  free(ex);
+}

src/vm/handlers/group_fn.c

@@ -1,5 +1,8 @@
+#include <common/fzl_value.h>
+#include <stddef.h>
 #include <stdio.h>
 #include <vm/fzl_vm.h>
+#include <vm/fzl_vm_extern.h>
 #include <vm/internals/opcode.h>
 
 // Call function (store return address and jump into function init)
@@ -28,7 +31,31 @@ int op_ret(fzl_vm_t *vm)
 // Call externally defined function
 int op_call_extern(fzl_vm_t *vm)
 {
-  (void)vm;
-  // TODO: implement
+  size_t fn_n = vm->reader->ops[++vm->ip];
+  if (fn_n >= vm->reader->extern_fns_count)
+  {
+    snprintf(last_err, sizeof(last_err),
+             "runtime error - unknown external function");
+    print_err_data(vm);
+    return -1;
+  }
+
+  fzl_vm_sym_t *fn = &vm->prep_fns->syms[fn_n];
+  if (!fn)
+  {
+    snprintf(last_err, sizeof(last_err),
+             "runtime error - failed to load extern function");
+    print_err_data(vm);
+    return -1;
+  }
+
+  if (vm->dtop < fn->cif.nargs)
+  {
+    snprintf(last_err, sizeof(last_err),
+             "runtime error - expected %u valued on dstack", fn->cif.nargs);
+    print_err_data(vm);
+    return -1;
+  }
+
   return 0;
 }

src/vm/main.c

@@ -6,6 +6,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <vm/fzl_vm.h>
+#include <vm/fzl_vm_extern.h>
 #include <vm/fzl_vm_reader.h>
 
 typedef struct
@@ -140,6 +141,18 @@ int main(int argc, char **argv)
     return -1;
   }
 
+  vm->prep_fns = fzl_vm_init_externs(reader);
+  if (!vm->prep_fns)
+  {
+    printf("%sError%s: %s\n", FZL_CERROR, FZL_CRST, fzl_vm_externs_geterror());
+
+    free(args);
+    fzl_vm_free_externs(vm->prep_fns);
+    fzl_vm_freereader(reader);
+    fzl_freevm(vm);
+    return -1;
+  }
+
   vm->allow_infinite = args->allow_infinite;
   vm->max_iter       = args->max_iter;
 
@@ -155,6 +168,7 @@ int main(int argc, char **argv)
         printf("%sError%s: %s\n", FZL_CERROR, FZL_CRST, err);
 
       free(args);
+      fzl_vm_free_externs(vm->prep_fns);
       fzl_vm_freereader(reader);
       fzl_freevm(vm);
       return -1;
@@ -162,6 +176,7 @@ int main(int argc, char **argv)
   }
 
   free(args);
+  fzl_vm_free_externs(vm->prep_fns);
   fzl_vm_freereader(reader);
   fzl_freevm(vm);
 

tests/programs/pos_math_lib.fzs

@@ -1,4 +1,4 @@
-extern "math" {
+extern "libmath" {
   fn double_num(int num) int;
 }