Cache utility function pointers

Author: Bromeon

godot-codegen/src/central_generator.rs

@@ -116,6 +116,59 @@ pub(crate) fn generate_sys_classes_file(
     }
 }
 
+pub(crate) fn generate_sys_utilities_file(
+    api: &ExtensionApi,
+    ctx: &mut Context,
+    sys_gen_path: &Path,
+    submit_fn: &mut SubmitFn,
+) {
+    let mut table = MethodTableInfo {
+        table_name: ident("UtilityFunctionTable"),
+        imports: quote! {},
+        ctor_parameters: quote! {
+            interface: &crate::GDExtensionInterface,
+            string_names: &mut crate::StringCache,
+        },
+        pre_init_code: quote! {
+            let get_utility_fn = interface.variant_get_ptr_utility_function
+                .expect("variant_get_ptr_utility_function absent");
+        },
+        method_decls: vec![],
+        method_inits: vec![],
+        class_count: 0,
+        method_count: 0,
+    };
+
+    for function in api.utility_functions.iter() {
+        if codegen_special_cases::is_function_excluded(function, ctx) {
+            continue;
+        }
+
+        let fn_name_str = &function.name;
+        let field = util::make_utility_function_ptr_name(&function);
+        let hash = function.hash;
+
+        table.method_decls.push(quote! {
+            pub #field: crate::UtilityFunctionBind,
+        });
+
+        table.method_inits.push(quote! {
+            #field: {
+                let utility_fn = unsafe {
+                    get_utility_fn(string_names.fetch(#fn_name_str), #hash)
+                };
+                crate::validate_utility_function(utility_fn, #fn_name_str, #hash)
+            },
+        });
+
+        table.method_count += 1;
+    }
+
+    let code = make_method_table(table);
+
+    submit_fn(sys_gen_path.join("table_utilities.rs"), code);
+}
+
 /// Generate code for a method table based on shared layout.
 fn make_method_table(info: MethodTableInfo) -> TokenStream {
     let MethodTableInfo {
@@ -635,10 +688,11 @@ fn populate_class_methods(
             continue;
         }
 
-        let method_field = util::make_class_method_ptr_name(&class.name, method);
+        let field = util::make_class_method_ptr_name(&class.name, method);
 
-        let method_decl = make_class_method_decl(&method_field);
-        let method_init = make_class_method_init(method, &method_field, class_var, class_name_str);
+        // Note: varcall/ptrcall is only decided at call time; the method bind is the same for both.
+        let method_decl = quote! { pub #field: crate::ClassMethodBind, };
+        let method_init = make_class_method_init(method, &field, class_var, class_name_str);
 
         table.method_decls.push(method_decl);
         table.method_inits.push(method_init);
@@ -656,25 +710,20 @@ fn populate_builtin_methods(
             continue;
         }
 
-        let method_field = util::make_builtin_method_ptr_name(type_name, method);
+        let field = util::make_builtin_method_ptr_name(type_name, method);
 
-        let method_decl = make_builtin_method_decl(method, &method_field);
-        let method_init = make_builtin_method_init(method, &method_field, type_name);
+        let method_decl = quote! { pub #field: crate::BuiltinMethodBind, };
+        let method_init = make_builtin_method_init(method, &field, type_name);
 
         table.method_decls.push(method_decl);
         table.method_inits.push(method_init);
         table.method_count += 1;
     }
 }
 
-fn make_class_method_decl(method_field: &Ident) -> TokenStream {
-    // Note: varcall/ptrcall is only decided at call time; the method bind is the same for both.
-    quote! { pub #method_field: crate::ClassMethodBind, }
-}
-
 fn make_class_method_init(
     method: &ClassMethod,
-    method_field: &Ident,
+    field: &Ident,
     class_var: &Ident,
     class_name_str: &str,
 ) -> TokenStream {
@@ -689,7 +738,7 @@ fn make_class_method_init(
     });
 
     quote! {
-        #method_field: {
+        #field: {
             let method_bind = unsafe {
                 get_method_bind(#class_var, #method_sname, #hash)
             };
@@ -698,13 +747,9 @@ fn make_class_method_init(
     }
 }
 
-fn make_builtin_method_decl(_method: &BuiltinClassMethod, method_field: &Ident) -> TokenStream {
-    quote! { pub #method_field: crate::BuiltinMethodBind, }
-}
-
 fn make_builtin_method_init(
     method: &BuiltinClassMethod,
-    method_field: &Ident,
+    field: &Ident,
     type_name: &TypeNames,
 ) -> TokenStream {
     let method_name_str = method.name.as_str();
@@ -721,7 +766,7 @@ fn make_builtin_method_init(
     });
 
     quote! {
-        #method_field: {
+        #field: {
             let method_bind = unsafe {
                 get_builtin_method(sys::#variant_type, #method_sname, #hash)
             };

godot-codegen/src/class_generator.rs

@@ -1210,18 +1210,15 @@ pub(crate) fn make_utility_function_definition(
     }
 
     let function_name_str = &function.name;
-    let function_name_stringname = make_string_name(function_name_str);
+    let fn_ptr = util::make_utility_function_ptr_name(&function);
 
     let return_value = function
         .return_type
         .as_deref()
         .map(MethodReturn::from_type_no_meta);
-    let hash = function.hash;
     let variant_ffi = function.is_vararg.then_some(VariantFfi::type_ptr());
     let init_code = quote! {
-        let __function_name = #function_name_stringname;
-        let __call_fn = sys::interface_fn!(variant_get_ptr_utility_function)(__function_name.string_sys(), #hash);
-        let __call_fn = __call_fn.unwrap_unchecked();
+        let __call_fn = sys::utility_function_table().#fn_ptr;
     };
     let invocation = quote! {
         __call_fn(return_ptr, __args_ptr, __args.len() as i32);

godot-codegen/src/lib.rs

@@ -31,7 +31,8 @@ use util::{ident, to_pascal_case, to_snake_case};
 use utilities_generator::generate_utilities_file;
 
 use crate::central_generator::{
-    generate_sys_builtin_lifecycle_file, generate_sys_builtin_methods_file, BuiltinTypeMap,
+    generate_sys_builtin_lifecycle_file, generate_sys_builtin_methods_file,
+    generate_sys_utilities_file, BuiltinTypeMap,
 };
 use crate::context::NotificationEnum;
 use proc_macro2::{Ident, TokenStream};
@@ -80,6 +81,9 @@ pub fn generate_sys_files(
     generate_sys_classes_file(&api, &mut ctx, sys_gen_path, watch, &mut submit_fn);
     // watch records inside the function.
 
+    generate_sys_utilities_file(&api, &mut ctx, sys_gen_path, &mut submit_fn);
+    watch.record("generate_utilities_file");
+
     let is_godot_4_0 = api.header.version_major == 4 && api.header.version_minor == 0;
     generate_sys_interface_file(h_path, sys_gen_path, is_godot_4_0, &mut submit_fn);
     watch.record("generate_interface_file");

godot-codegen/src/util.rs

@@ -4,7 +4,9 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use crate::api_parser::{BuiltinClassMethod, Class, ClassConstant, ClassMethod, Enum};
+use crate::api_parser::{
+    BuiltinClassMethod, Class, ClassConstant, ClassMethod, Enum, UtilityFunction,
+};
 use crate::central_generator::TypeNames;
 use crate::special_cases::is_builtin_scalar;
 use crate::{Context, GodotTy, ModName, RustTy, TyName};
@@ -85,6 +87,10 @@ pub fn make_builtin_method_ptr_name(
     format_ident!("{}__{}", variant_type.json_builtin_name, method.name)
 }
 
+pub fn make_utility_function_ptr_name(function: &UtilityFunction) -> Ident {
+    safe_ident(&function.name)
+}
+
 // TODO should eventually be removed, as all StringNames are cached
 pub fn make_string_name(identifier: &str) -> TokenStream {
     quote! {

godot-ffi/src/godot_ffi.rs

@@ -4,8 +4,9 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use crate::{self as sys, ptr_then};
+use crate as sys;
 use std::{error::Error, fmt::Debug, marker::PhantomData, ptr};
+use sys::ptr_then;
 
 /// Adds methods to convert from and to Godot FFI pointers.
 /// See [crate::ffi_methods] for ergonomic implementation.

godot-ffi/src/lib.rs

@@ -23,11 +23,11 @@ pub(crate) mod gen {
     pub mod table_servers_classes;
     pub mod table_scene_classes;
     pub mod table_editor_classes;
+    pub mod table_utilities;
 
     pub mod central;
     pub mod gdextension_interface;
     pub mod interface;
-
 }
 
 mod compat;
@@ -58,6 +58,7 @@ pub use gen::table_builtins_lifecycle::*;
 pub use gen::table_editor_classes::*;
 pub use gen::table_scene_classes::*;
 pub use gen::table_servers_classes::*;
+pub use gen::table_utilities::*;
 
 // Other
 pub use gdextension_plus::*;
@@ -85,6 +86,7 @@ struct GodotBinding {
     class_scene_method_table: Option<ClassSceneMethodTable>,    // late-init
     class_editor_method_table: Option<ClassEditorMethodTable>,  // late-init
     builtin_method_table: BuiltinMethodTable,
+    utility_function_table: UtilityFunctionTable,
     runtime_metadata: GdextRuntimeMetadata,
     config: GdextConfig,
 }
@@ -140,6 +142,9 @@ pub unsafe fn initialize(
     let builtin_method_table = BuiltinMethodTable::load(&interface, &mut string_names);
     out!("Loaded builtin method table.");
 
+    let utility_function_table = UtilityFunctionTable::load(&interface, &mut string_names);
+    out!("Loaded utility function table.");
+
     let runtime_metadata = GdextRuntimeMetadata {
         godot_version: version,
     };
@@ -149,10 +154,11 @@ pub unsafe fn initialize(
     BINDING = Some(GodotBinding {
         interface,
         global_method_table,
-        builtin_method_table,
         class_server_method_table: None,
         class_scene_method_table: None,
         class_editor_method_table: None,
+        builtin_method_table,
+        utility_function_table,
         library,
         runtime_metadata,
         config,
@@ -248,6 +254,14 @@ pub unsafe fn builtin_method_table() -> &'static BuiltinMethodTable {
     &unwrap_ref_unchecked(&BINDING).builtin_method_table
 }
 
+/// # Safety
+///
+/// The interface must have been initialised with [`initialize`] before calling this function.
+#[inline(always)]
+pub unsafe fn utility_function_table() -> &'static UtilityFunctionTable {
+    &unwrap_ref_unchecked(&BINDING).utility_function_table
+}
+
 /// # Safety
 ///
 /// The interface must have been initialised with [`initialize`] before calling this function.

godot-ffi/src/toolbox.rs

@@ -218,6 +218,12 @@ pub(crate) type BuiltinMethodBind = unsafe extern "C" fn(
     p_argument_count: std::os::raw::c_int,
 );
 
+pub(crate) type UtilityFunctionBind = unsafe extern "C" fn(
+    r_return: sys::GDExtensionTypePtr,
+    p_args: *const sys::GDExtensionConstTypePtr,
+    p_argument_count: std::os::raw::c_int,
+);
+
 pub(crate) fn validate_builtin_method(
     method: sys::GDExtensionPtrBuiltInMethod,
     variant_type: &str,
@@ -231,20 +237,24 @@ pub(crate) fn validate_builtin_method(
         hash
     );*/
     method.unwrap_or_else(|| {
-        panic!(
-            "Failed to load builtin method {}::{} (hash {}).\n\
-            Make sure gdext and Godot are compatible: https://godot-rust.github.io/book/gdext/advanced/compatibility.html",
-            variant_type,
-            method_name,
-            hash
-        )
+        panic!("Failed to load builtin method {variant_type}::{method_name} (hash {hash}).{INFO}")
     })
 }
 
 pub(crate) fn validate_builtin_lifecycle<T>(function: Option<T>, description: &str) -> T {
-    function.unwrap_or_else(|| panic!(
-        "Failed to load builtin lifecycle function {}.\n\
-        Make sure gdext and Godot are compatible: https://godot-rust.github.io/book/gdext/advanced/compatibility.html",
-        description
-    ))
+    function.unwrap_or_else(|| {
+        panic!("Failed to load builtin lifecycle function {description}.{INFO}",)
+    })
+}
+
+pub(crate) fn validate_utility_function(
+    utility_fn: sys::GDExtensionPtrUtilityFunction,
+    name: &str,
+    hash: i64,
+) -> UtilityFunctionBind {
+    utility_fn.unwrap_or_else(|| {
+        panic!("Failed to load builtin lifecycle function {name} (hash {hash}).{INFO}")
+    })
 }
+
+const INFO: &'static str = "\nMake sure gdext and Godot are compatible: https://godot-rust.github.io/book/gdext/advanced/compatibility.html";