Factorize mfa as a key logic

Update signature of `atom_write_mfa` so it takes atom length and data separately
to prepare for longer atoms.

Signed-off-by: Paul Guyot <pguyot@kallisys.net>

Author: pguyot

src/libAtomVM/atom.c

@@ -87,19 +87,17 @@ static void utoa10(unsigned int int_value, char *integer_string)
     integer_string[integer_string_len] = '\0';
 }
 
-void atom_write_mfa(char *buf, size_t buf_size, AtomString module, AtomString function, unsigned int arity)
+void atom_write_mfa(char *buf, size_t buf_size, size_t module_name_len, const void *module_data, size_t function_name_len, const void *function_data, unsigned int arity)
 {
-    size_t module_name_len = atom_string_len(module);
-    memcpy(buf, atom_string_data(module), module_name_len);
+    memcpy(buf, module_data, module_name_len);
 
     buf[module_name_len] = ':';
 
-    size_t function_name_len = atom_string_len(function);
     if (UNLIKELY((module_name_len + 1 + function_name_len + 1 + 4 + 1 > buf_size))) {
         fprintf(stderr, "Insufficient room to write mfa.\n");
         AVM_ABORT();
     }
-    memcpy(buf + module_name_len + 1, atom_string_data(function), function_name_len);
+    memcpy(buf + module_name_len + 1, function_data, function_name_len);
 
     buf[module_name_len + function_name_len + 1] = '/';
     utoa10(arity, buf + module_name_len + 1 + function_name_len + 1);

src/libAtomVM/atom.h

@@ -99,11 +99,13 @@ static inline const void *atom_string_data(AtomString atom_str)
  *          buffer size.
  * @param   buf the buffer to write into
  * @param   buf_size the amount of room in the buffer
- * @param   module the module name
- * @param   function the function name
+ * @param   module_name_len length of the module name
+ * @param   module_data the module name
+ * @param   function_name_len length of the function name
+ * @param   function_data the function name
  * @param   arity the function arity
  */
-void atom_write_mfa(char *buf, size_t buf_size, AtomString module, AtomString function, unsigned int arity);
+void atom_write_mfa(char *buf, size_t buf_size, size_t module_name_len, const void *module_data, size_t function_name_len, const void *function_data, unsigned int arity);
 
 #ifdef __cplusplus
 }

src/libAtomVM/bif.c

@@ -59,12 +59,9 @@
         RAISE_ERROR_BIF(fail_label, BADARG_ATOM);              \
     }
 
-const struct ExportedFunction *bif_registry_get_handler(AtomString module, AtomString function, int arity)
+const struct ExportedFunction *bif_registry_get_handler(const char *mfa)
 {
-    char bifname[MAX_BIF_NAME_LEN];
-
-    atom_write_mfa(bifname, MAX_BIF_NAME_LEN, module, function, arity);
-    const BifNameAndPtr *nameAndPtr = in_word_set(bifname, strlen(bifname));
+    const BifNameAndPtr *nameAndPtr = in_word_set(mfa, strlen(mfa));
     if (!nameAndPtr) {
         return NULL;
     }

src/libAtomVM/bif.h

@@ -39,7 +39,7 @@ extern "C" {
 
 #define MAX_BIF_NAME_LEN 260
 
-const struct ExportedFunction *bif_registry_get_handler(AtomString module, AtomString function, int arity);
+const struct ExportedFunction *bif_registry_get_handler(const char *mfa);
 
 term bif_erlang_self_0(Context *ctx);
 term bif_erlang_node_0(Context *ctx);

src/libAtomVM/module.c

@@ -117,13 +117,15 @@ static enum ModuleLoadResult module_build_imported_functions_table(Module *this_
         AtomString module_atom = module_get_atom_string_by_id(this_module, local_module_atom_index, glb);
         AtomString function_atom = module_get_atom_string_by_id(this_module, local_function_atom_index, glb);
         uint32_t arity = READ_32_UNALIGNED(table_data + i * 12 + 8 + 12);
+        char mfa[MAX_MFA_NAME_LEN];
+        atom_write_mfa(mfa, sizeof(mfa), atom_string_len(module_atom), atom_string_data(module_atom), atom_string_len(function_atom), atom_string_data(function_atom), arity);
 
-        const struct ExportedFunction *bif = bif_registry_get_handler(module_atom, function_atom, arity);
+        const struct ExportedFunction *bif = bif_registry_get_handler(mfa);
 
         if (bif) {
             this_module->imported_funcs[i] = bif;
         } else {
-            this_module->imported_funcs[i] = &nifs_get(module_atom, function_atom, arity)->base;
+            this_module->imported_funcs[i] = &nifs_get(mfa)->base;
         }
 
         if (!this_module->imported_funcs[i]) {
@@ -435,8 +437,8 @@ const struct ExportedFunction *module_resolve_function0(Module *mod, int import_
     if (LIKELY(found_module != NULL)) {
         int exported_label = module_search_exported_function(found_module, function_name_atom, arity, glb);
         if (exported_label == 0) {
-            char buf[256];
-            atom_write_mfa(buf, 256, module_name_atom, function_name_atom, arity);
+            char buf[MAX_MFA_NAME_LEN];
+            atom_write_mfa(buf, sizeof(buf), atom_string_len(module_name_atom), atom_string_data(module_name_atom), atom_string_len(function_name_atom), atom_string_data(function_name_atom), arity);
             fprintf(stderr, "Warning: function %s cannot be resolved.\n", buf);
             return NULL;
         }

src/libAtomVM/nifs.c

@@ -61,7 +61,6 @@
 #include "unicode.h"
 #include "utils.h"
 
-#define MAX_NIF_NAME_LEN 260
 #define FLOAT_BUF_SIZE 64
 
 #define RAISE(a, b)  \
@@ -909,30 +908,11 @@ DEFINE_MATH_NIF(tanh)
 #include "nifs_hash.h"
 #pragma GCC diagnostic pop
 
-const struct Nif *nifs_get(AtomString module, AtomString function, int arity)
+const struct Nif *nifs_get(const char *mfa)
 {
-    char nifname[MAX_NIF_NAME_LEN];
-
-    int module_name_len = atom_string_len(module);
-    memcpy(nifname, atom_string_data(module), module_name_len);
-
-    nifname[module_name_len] = ':';
-
-    int function_name_len = atom_string_len(function);
-    if (UNLIKELY((arity > 9) || (module_name_len + function_name_len + 4 > MAX_NIF_NAME_LEN))) {
-        // In AtomVM NIFs are limited to 9 parameters
-        return NULL;
-    }
-    memcpy(nifname + module_name_len + 1, atom_string_data(function), function_name_len);
-
-    //TODO: handle NIFs with more than 9 parameters
-    nifname[module_name_len + function_name_len + 1] = '/';
-    nifname[module_name_len + function_name_len + 2] = '0' + arity;
-    nifname[module_name_len + function_name_len + 3] = 0;
-
-    const NifNameAndNifPtr *nameAndPtr = nif_in_word_set(nifname, strlen(nifname));
+    const NifNameAndNifPtr *nameAndPtr = nif_in_word_set(mfa, strlen(mfa));
     if (!nameAndPtr) {
-        return platform_nifs_get_nif(nifname);
+        return platform_nifs_get_nif(mfa);
     }
 
     return nameAndPtr->nif;
@@ -3610,16 +3590,22 @@ static term nif_erlang_function_exported(Context *ctx, int argc, term argv[])
     VALIDATE_VALUE(function, term_is_atom);
     VALIDATE_VALUE(arity_term, term_is_integer);
 
-    AtomString module_name = globalcontext_atomstring_from_term(ctx->global, module);
-    AtomString function_name = globalcontext_atomstring_from_term(ctx->global, function);
+    atom_index_t module_name_ix = term_to_atom_index(module);
+    AtomString module_name = atom_table_get_atom_string(ctx->global->atom_table, module_name_ix);
+    atom_index_t function_name_ix = term_to_atom_index(function);
+    AtomString function_name = atom_table_get_atom_string(ctx->global->atom_table, function_name_ix);
+
     avm_int_t arity = term_to_int(arity_term);
 
-    const struct ExportedFunction *bif = bif_registry_get_handler(module_name, function_name, arity);
+    char mfa[MAX_MFA_NAME_LEN];
+    atom_write_mfa(mfa, sizeof(mfa), atom_string_len(module_name), atom_string_data(module_name), atom_string_len(function_name), atom_string_data(function_name), arity);
+
+    const struct ExportedFunction *bif = bif_registry_get_handler(mfa);
     if (bif) {
         return TRUE_ATOM;
     }
 
-    struct Nif *nif = (struct Nif *) nifs_get(module_name, function_name, arity);
+    struct Nif *nif = (struct Nif *) nifs_get(mfa);
     if (nif) {
         return TRUE_ATOM;
     }

src/libAtomVM/nifs.h

@@ -46,7 +46,7 @@ extern "C" {
     ctx->x[1] = (error_type_atom);   \
     return term_invalid_term();
 
-const struct Nif *nifs_get(AtomString module, AtomString function, int arity);
+const struct Nif *nifs_get(const char *mfa);
 
 // spawn opt is used by distribution nifs
 term nif_erlang_spawn_opt(Context *ctx, int argc, term argv[]);

src/libAtomVM/opcodesswitch.h

@@ -1665,7 +1665,9 @@ term make_fun(Context *ctx, const Module *mod, int fun_index, term argv[])
 static bool maybe_call_native(Context *ctx, AtomString module_name, AtomString function_name, int arity,
     term *return_value)
 {
-    const struct ExportedFunction *exported_bif = bif_registry_get_handler(module_name, function_name, arity);
+    char mfa[MAX_MFA_NAME_LEN];
+    atom_write_mfa(mfa, sizeof(mfa), atom_string_len(module_name), atom_string_data(module_name), atom_string_len(function_name), atom_string_data(function_name), arity);
+    const struct ExportedFunction *exported_bif = bif_registry_get_handler(mfa);
     if (exported_bif) {
         if (exported_bif->type == GCBIFFunctionType) {
             const struct GCBif *gcbif = EXPORTED_FUNCTION_TO_GCBIF(exported_bif);
@@ -1702,7 +1704,7 @@ static bool maybe_call_native(Context *ctx, AtomString module_name, AtomString f
         }
     }
 
-    struct Nif *nif = (struct Nif *) nifs_get(module_name, function_name, arity);
+    struct Nif *nif = (struct Nif *) nifs_get(mfa);
     if (nif) {
         *return_value = nif->nif_ptr(ctx, arity, ctx->x);
         return true;

src/libAtomVM/term_typedef.h

@@ -144,4 +144,10 @@ typedef union {
     avm_float_t f;
 } float_term_t;
 
+// Quite a low value, BEAM is 255 + 255 + 1 + strlen(max(arity))
+// This buffer is typically allocated on C stack
+// This is a hard limit for bifs and nifs. It currently is only used for
+// printing error messages for other functions.
+#define MAX_MFA_NAME_LEN 260
+
 #endif