Merge pull request #119 from RivenSkaye/main

Add calling convention options for output

Author: neuecc

csbindgen/src/emitter.rs

@@ -146,6 +146,7 @@ pub fn emit_csharp(
             "" => format!("{method_prefix}{entry_point}"),
             x => format!("{x}{entry_point}"),
         };
+        let call_conv = &item.call_conv;
         let return_type = match &item.return_type {
             Some(x) => x.to_csharp_string(
                 options,
@@ -184,7 +185,7 @@ pub fn emit_csharp(
         }
 
         method_list_string.push_str_ln(
-            format!("        [DllImport(__DllName, EntryPoint = \"{entry_point}\", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]").as_str(),
+            format!("        [DllImport(__DllName, EntryPoint = \"{entry_point}\", CallingConvention = CallingConvention.{call_conv}, ExactSpelling = true)]").as_str(),
         );
         if return_type == "bool" {
             method_list_string.push_str_ln("        [return: MarshalAs(UnmanagedType.U1)]");

csbindgen/src/parser.rs

@@ -77,6 +77,50 @@ fn parse_method(item: FnItem, options: &BindgenOptions) -> Option<ExternMethod>
 
     let method_name = sig.ident.to_string();
 
+    let is_x86_windows = std::env::var("CARGO_CFG_TARGET_ARCH").is_ok_and(|v| v == "x86")
+        && std::env::var("CARGO_CFG_TARGET_OS").is_ok_and(|v| v == "windows");
+    let call_conv = if let Some(abi) = sig.abi.map(|abi| abi.name).flatten() {
+        let abi_str = &abi.value();
+        if abi_str.contains("system") {
+            // For i686-pc-windows-* (32-bit binaries) the default calling convention is stdcall, unlike everywhere else.
+            // See https://doc.rust-lang.org/reference/items/external-blocks.html#abi for a list of possible ABIs and what they translate to.
+            if is_x86_windows {"StdCall"}
+            else {"Cdecl"}
+        }
+        else if abi_str.contains("stdcall") {"StdCall"}
+        else if abi_str.contains("thiscall") {
+            if !is_x86_windows {
+                eprintln!("ThisCall is only allowed on 32-bit MSVC as it's the 32-bit member function calling convention. Consider using \"system\" instead.");
+                panic!("Cannot emit `thiscall` code in Rust for a non-x86 target.");
+            }
+            else {"ThisCall"}
+        }
+        else if abi_str.contains("win64") && (std::env::var("CARGO_CFG_TARGET_OS").is_ok_and(|v| v != "windows") || std::env::var("CARGO_CFG_TARGET_ARCH").is_ok_and(|v| v != "x86_64")) {
+            eprintln!("win64 is an AMD64-only calling convention. Consider using \"system\" instead.");
+            panic!("Cannot emit `win64` code in Rust for a non-AMD64-windows target.");
+        }
+        else if abi_str.contains("sysv64") && (std::env::var("CARGO_CFG_TARGET_OS").is_ok_and(|v| v == "windows") || std::env::var("CARGO_CFG_TARGET_ARCH").is_ok_and(|v| v != "x86_64")) {
+            eprintln!("sysv64 is the calling convention for AMD64 non-windows, consider using \"system\" instead.");
+            panic!("Cannot emit `sysv64` on non-AMD64 and/or windows target.");
+        }
+        else if abi_str.contains("aapcs") {
+            eprintln!("ARM is an extremely complex landscape and not all possible combinations can be checked. Emitting at the user's risk.");
+            "WinApi"
+        }
+        else if abi_str.contains("C") || abi_str.contains("cdecl") || abi_str.contains("win64") || abi_str.contains("sysv64") || abi_str.contains("aapcs") {"Cdecl"}
+        else {
+            // This is only ever hit for the `Rust`, `fastcall`, and `efiapi` calling conventions, none of which are supported by C# (as of .NET 9)
+            // https://learn.microsoft.com/en-us/dotnet/api/system.runtime.compilerservices.callconvfastcall?view=net-9.0
+            // https://learn.microsoft.com/en-us/dotnet/standard/native-interop/calling-conventions#platform-default-calling-convention
+            // https://learn.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.callingconvention?view=net-9.0
+            eprintln!("C# support for calling conventions is limited. Please stick to any of the supported options for interop:");
+            eprintln!("`cdecl` for `Cdecl`, `stdcall` for `StdCall`, `thiscall` for `ThisCall`, `C` for the compiler's default (most likely `Cdecl`), `system` for automatic selection, or your platform-specific target.");
+            panic!("Unsupported calling convention requested! .NET interop does not support {abi_str}, please consider using \"system\" for the extern ABI.");
+        }
+    } else {
+        "Cdecl"
+    }.to_string();
+
     let mut parameters: Vec<Parameter> = Vec::new();
     let mut return_type: Option<RustType> = None;
 
@@ -143,6 +187,7 @@ fn parse_method(item: FnItem, options: &BindgenOptions) -> Option<ExternMethod>
             parameters,
             return_type,
             doc_comment: gather_docs(&attrs),
+            call_conv,
         });
     }
 

csbindgen/src/type_meta.rs

@@ -44,6 +44,7 @@ pub struct ExternMethod {
     pub parameters: Vec<Parameter>,
     pub return_type: Option<RustType>,
     pub export_naming: ExportSymbolNaming,
+    pub call_conv: String,
 }
 
 #[derive(Clone, Debug)]