Merge pull request #61 from stepfunc/feature/java-aarch64

emgre · web-flow · commit d6970de998b6 · 2021-09-13T10:41:24.000-04:00
Add AArch64 support for Java and .NET
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -39,7 +39,7 @@ jobs:
         run: cargo-license --avoid-dev-deps --avoid-build-deps -j > ../dependencies.json
       - name: Generate dependencies.txt
         working-directory: complicense
-        run: cargo run -- --import ../oo-bindgen/dependencies.json --config ../oo-bindgen/deps-config.json  --token ${{ github.token }} > ../oo-bindgen/dependencies.txt
+        run: cargo run -- --import ../oo-bindgen/dependencies.json --config ../oo-bindgen/deps-config.json --token ${{ github.token }} > ../oo-bindgen/dependencies.txt
       - name: Upload dependencies info
         uses: actions/upload-artifact@v2
         with:
@@ -192,6 +192,65 @@ jobs:
         with:
           name: ffi-modules
           path: tests/bindings/java/foo/src/main/resources
+  # Build bindings on Linux AArch64
+  bindings-aarch64:
+    needs: lock
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          target: aarch64-unknown-linux-gnu
+          override: true
+      - name: Caching
+        uses: Swatinem/rust-cache@v1
+      - name: Download Cargo.lock
+        uses: actions/download-artifact@v2
+        with:
+          name: dependencies
+      - name: Build
+        uses: actions-rs/cargo@v1
+        with:
+          use-cross: true
+          command: build
+          args: --release --target aarch64-unknown-linux-gnu
+      - name: C bindings
+        uses: actions-rs/cargo@v1
+        with:
+          use-cross: true
+          command: run
+          args: --release --target aarch64-unknown-linux-gnu --bin foo-bindings -- --c --no-tests
+      - name: .NET bindings
+        uses: actions-rs/cargo@v1
+        with:
+          use-cross: true
+          command: run
+          args: --release --target aarch64-unknown-linux-gnu --bin foo-bindings -- --dotnet --no-tests
+      - name: Java bindings
+        uses: actions-rs/cargo@v1
+        with:
+          use-cross: true
+          command: run
+          args: --release --target aarch64-unknown-linux-gnu --bin foo-bindings -- --java --no-tests
+      - name: Upload compiled FFI modules
+        uses: actions/upload-artifact@v2
+        with:
+          name: ffi-modules
+          path: tests/bindings/c/generated/aarch64-unknown-linux-gnu/lib
+      - name: Upload C bindings
+        uses: actions/upload-artifact@v2
+        with:
+          name: c-bindings
+          path: tests/bindings/c/generated
+      - name: Upload compiled Java bindings
+        uses: actions/upload-artifact@v2
+        with:
+          name: ffi-modules
+          path: tests/bindings/java/foo/src/main/resources
   # Cross-compilation for ARM devices and produce C bindings
   cross:
     needs: lock
@@ -202,7 +261,6 @@ jobs:
           - arm-unknown-linux-gnueabi # ARMv6 Linux (kernel 3.2, glibc 2.17)
           - arm-unknown-linux-gnueabihf # ARMv6 Linux, hardfloat (kernel 3.2, glibc 2.17)
           - armv7-unknown-linux-gnueabihf # ARMv7 Linux, hardfloat (kernel 3.2, glibc 2.17)
-          - aarch64-unknown-linux-gnu # ARM64 Linux (kernel 4.2, glibc 2.17+)
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
diff --git a/ci-script/src/lib.rs b/ci-script/src/lib.rs
@@ -147,9 +147,11 @@ fn run_builder<'a, B: BindingBuilder<'a>>(
 
     builder.generate(package);
 
-    if !package && run_tests {
-        builder.build();
-        builder.test();
+    if !package {
+        if run_tests {
+            builder.build();
+            builder.test();
+        }
     } else {
         builder.package();
     }
@@ -203,7 +205,7 @@ impl<'a> CBindingBuilder<'a> {
             platform_location: self.platforms.iter().next().unwrap(),
         };
 
-        c_oo_bindgen::generate_doxygen(&self.settings.library, &config)
+        c_oo_bindgen::generate_doxygen(self.settings.library, &config)
             .expect("failed to package C lib");
     }
 
@@ -254,7 +256,7 @@ impl<'a> BindingBuilder<'a> for CBindingBuilder<'a> {
                 platform_location: platform.clone(),
             };
 
-            c_oo_bindgen::generate_c_package(&self.settings.library, &config)
+            c_oo_bindgen::generate_c_package(self.settings.library, &config)
                 .expect("failed to package C lib");
         }
     }
@@ -493,12 +495,21 @@ impl<'a> BindingBuilder<'a> for JavaBindingBuilder<'a> {
             // You: *still puzzled about the situation, but accepting this hack*
             let target_dir = pathdiff::diff_paths("./target", self.rust_build_dir()).unwrap();
             let mut cmd = Command::new("cargo");
+
+            let current_platform = Platform::from_target_triple(env!("TARGET_TRIPLE")).unwrap();
+
             cmd.current_dir(self.rust_build_dir()).args(&[
                 "build",
                 "--target-dir",
                 &target_dir.to_string_lossy(),
             ]);
 
+            if current_platform == Platform::LinuxArm8Gnu {
+                // This is a hack in order to have the CI properly work
+                // It is due to how `cross` works.
+                cmd.args(&["--target", env!("TARGET_TRIPLE")]);
+            }
+
             if env!("PROFILE") == "release" {
                 cmd.arg("--release");
             }
diff --git a/generators/dotnet-oo-bindgen/src/class.rs b/generators/dotnet-oo-bindgen/src/class.rs
@@ -163,7 +163,7 @@ fn generate_constructor(
     f.write(")")?;
 
     blocked(f, |f| {
-        call_native_function(f, &constructor, "this.self = ", None, true)
+        call_native_function(f, constructor, "this.self = ", None, true)
     })
 }
 
diff --git a/generators/dotnet-oo-bindgen/src/interface.rs b/generators/dotnet-oo-bindgen/src/interface.rs
@@ -81,12 +81,7 @@ pub(crate) fn generate(
 
         // Write the Action<>/Func<> based implementation if it's a functional interface
         if interface.is_functional() {
-            generate_functional_callback(
-                f,
-                &interface,
-                interface.callbacks().next().unwrap(),
-                lib,
-            )?;
+            generate_functional_callback(f, interface, interface.callbacks().next().unwrap(), lib)?;
             f.newline()?;
         }
 
diff --git a/generators/dotnet-oo-bindgen/src/lib.rs b/generators/dotnet-oo-bindgen/src/lib.rs
@@ -69,7 +69,11 @@ mod wrappers;
 
 pub const NATIVE_FUNCTIONS_CLASSNAME: &str = "NativeFunctions";
 
-const SUPPORTED_PLATFORMS: &[Platform] = &[Platform::WinX64Msvc, Platform::LinuxX64Gnu];
+const SUPPORTED_PLATFORMS: &[Platform] = &[
+    Platform::WinX64Msvc,
+    Platform::LinuxX64Gnu,
+    Platform::LinuxArm8Gnu,
+];
 
 pub struct DotnetBindgenConfig {
     pub output_dir: PathBuf,
@@ -450,6 +454,7 @@ fn dotnet_platform_string(platform: Platform) -> &'static str {
     match platform {
         Platform::WinX64Msvc => "win-x64",
         Platform::LinuxX64Gnu => "linux-x64",
+        Platform::LinuxArm8Gnu => "linux-arm64",
         _ => panic!("Unsupported platform"),
     }
 }
diff --git a/generators/java-oo-bindgen/src/java/class.rs b/generators/java-oo-bindgen/src/java/class.rs
@@ -136,7 +136,7 @@ fn generate_constructor(
     f.write(")")?;
 
     blocked(f, |f| {
-        call_native_function(f, &constructor, &format!("{} object = ", classname), false)?;
+        call_native_function(f, constructor, &format!("{} object = ", classname), false)?;
         f.writeln("this.self = object.self;")?;
         f.writeln("object.disposed.set(true);")
     })
diff --git a/generators/java-oo-bindgen/src/java/mod.rs b/generators/java-oo-bindgen/src/java/mod.rs
@@ -1,6 +1,7 @@
 use self::conversion::*;
 use self::formatting::*;
 use crate::JavaBindgenConfig;
+use heck::ShoutySnakeCase;
 use heck::{CamelCase, KebabCase};
 use oo_bindgen::formatting::*;
 use oo_bindgen::native_function::*;
@@ -20,7 +21,11 @@ mod structure;
 
 const NATIVE_FUNCTIONS_CLASSNAME: &str = "NativeFunctions";
 
-const SUPPORTED_PLATFORMS: &[Platform] = &[Platform::WinX64Msvc, Platform::LinuxX64Gnu];
+const SUPPORTED_PLATFORMS: &[Platform] = &[
+    Platform::WinX64Msvc,
+    Platform::LinuxX64Gnu,
+    Platform::LinuxArm8Gnu,
+];
 
 pub fn generate_java_bindings(lib: &Library, config: &JavaBindgenConfig) -> FormattingResult<()> {
     fs::create_dir_all(&config.java_output_dir)?;
@@ -46,7 +51,7 @@ pub fn generate_java_bindings(lib: &Library, config: &JavaBindgenConfig) -> Form
         let mut target_file = target_dir.clone();
         target_file.push(platform.bin_filename(&ffi_name));
 
-        fs::copy(source_file, target_file)?;
+        fs::copy(&source_file, &target_file)?;
     }
 
     // Copy the extra files
@@ -170,11 +175,6 @@ fn generate_pom(lib: &Library, config: &JavaBindgenConfig) -> FormattingResult<(
         f.writeln("        <artifactId>joou-java-6</artifactId>")?;
         f.writeln("        <version>0.9.4</version>")?;
         f.writeln("    </dependency>")?;
-        f.writeln("    <dependency>")?;
-        f.writeln("        <groupId>org.apache.commons</groupId>")?;
-        f.writeln("        <artifactId>commons-lang3</artifactId>")?;
-        f.writeln("        <version>3.11</version>")?;
-        f.writeln("    </dependency>")?;
         f.writeln("</dependencies>")?;
 
         f.newline()?;
@@ -226,35 +226,62 @@ fn generate_native_func_class(lib: &Library, config: &JavaBindgenConfig) -> Form
         blocked(f, |f| {
             f.writeln("try")?;
             blocked(f, |f| {
-                let libname = format!("{}_java", config.ffi_name);
-                for platform in config.platforms.iter() {
-                    match platform.platform {
-                        Platform::WinX64Msvc => {
-                            f.writeln("if(org.apache.commons.lang3.SystemUtils.IS_OS_WINDOWS && org.apache.commons.lang3.ArchUtils.getProcessor().is64Bit())")?;
-                            blocked(f, |f| {
-                                f.writeln(&format!(
-                                    "loadLibrary(\"{}\", \"{}\", \"dll\");",
-                                    platform.platform.as_string(),
-                                    libname
-                                ))
-                            })?;
-                        }
-                        Platform::LinuxX64Gnu => {
-                            f.writeln("if(org.apache.commons.lang3.SystemUtils.IS_OS_LINUX && org.apache.commons.lang3.ArchUtils.getProcessor().is64Bit())")?;
-                            blocked(f, |f| {
-                                f.writeln(&format!(
-                                    "loadLibrary(\"{}\", \"lib{}\", \"so\");",
-                                    platform.platform.as_string(),
-                                    libname
-                                ))
-                            })?;
+                let env_variable_name =
+                    format!("{}_NATIVE_LIB_LOCATION", lib.name.to_shouty_snake_case());
+                f.writeln(&format!(
+                    "String nativeLibLocation = System.getenv(\"{}\");",
+                    env_variable_name
+                ))?;
+                f.writeln("if(nativeLibLocation != null)")?;
+                blocked(f, |f| f.writeln("System.load(nativeLibLocation);"))?;
+
+                f.writeln("else")?;
+                blocked(f, |f| {
+                    f.writeln("boolean loaded = false;")?;
+                    let libname = format!("{}_java", config.ffi_name);
+                    for platform in config.platforms.iter() {
+                        match platform.platform {
+                            Platform::WinX64Msvc => {
+                                f.writeln("if(!loaded)")?;
+                                blocked(f, |f| {
+                                    f.writeln(&format!(
+                                        "loaded = loadLibrary(\"{}\", \"{}\", \"dll\");",
+                                        platform.platform.as_string(),
+                                        libname
+                                    ))
+                                })?;
+                            }
+                            Platform::LinuxX64Gnu => {
+                                f.writeln("if(!loaded)")?;
+                                blocked(f, |f| {
+                                    f.writeln(&format!(
+                                        "loaded = loadLibrary(\"{}\", \"lib{}\", \"so\");",
+                                        platform.platform.as_string(),
+                                        libname
+                                    ))
+                                })?;
+                            }
+                            Platform::LinuxArm8Gnu => {
+                                f.writeln("if(!loaded)")?;
+                                blocked(f, |f| {
+                                    f.writeln(&format!(
+                                        "loaded = loadLibrary(\"{}\", \"lib{}\", \"so\");",
+                                        platform.platform.as_string(),
+                                        libname
+                                    ))
+                                })?;
+                            }
+                            _ => (), // Other platforms are not supported
                         }
-                        _ => (), // Other platforms are not supported
                     }
-                }
-                Ok(())
+
+                    f.writeln("if(!loaded)")?;
+                    blocked(f, |f| {
+                        f.writeln("throw new Exception(\"Unable to load any of the included native library\");")
+                    })
+                })
             })?;
-            f.writeln("catch(java.io.IOException e)")?;
+            f.writeln("catch(Exception e)")?;
             blocked(f, |f| {
                 f.writeln("System.err.println(\"Native code library failed to load: \" + e);")?;
                 f.writeln("System.exit(1);")
@@ -264,13 +291,20 @@ fn generate_native_func_class(lib: &Library, config: &JavaBindgenConfig) -> Form
         f.newline()?;
 
         // Load library helper function
-        f.writeln("private static void loadLibrary(String directory, String name, String extension) throws java.io.IOException {")?;
-        f.writeln("    java.io.InputStream stream = NativeFunctions.class.getResourceAsStream(\"/\" + directory + \"/\" + name + \".\" + extension);")?;
-        f.writeln("    java.nio.file.Path tempFilePath = java.nio.file.Files.createTempFile(name, \".\" + extension);")?;
-        f.writeln("    tempFilePath.toFile().deleteOnExit();")?;
-        f.writeln("    java.nio.file.Files.copy(stream, tempFilePath, java.nio.file.StandardCopyOption.REPLACE_EXISTING);")?;
-        f.writeln("    System.load(tempFilePath.toString());")?;
-        f.writeln("}")?;
+        f.writeln("private static boolean loadLibrary(String directory, String name, String extension) throws Exception")?;
+        blocked(f, |f| {
+            f.writeln("try")?;
+            blocked(f, |f| {
+                f.writeln("java.io.InputStream stream = NativeFunctions.class.getResourceAsStream(\"/\" + directory + \"/\" + name + \".\" + extension);")?;
+                f.writeln("java.nio.file.Path tempFilePath = java.nio.file.Files.createTempFile(name, \".\" + extension);")?;
+                f.writeln("tempFilePath.toFile().deleteOnExit();")?;
+                f.writeln("java.nio.file.Files.copy(stream, tempFilePath, java.nio.file.StandardCopyOption.REPLACE_EXISTING);")?;
+                f.writeln("System.load(tempFilePath.toString());")?;
+                f.writeln("return true;")
+            })?;
+            f.writeln("catch(Exception e)")?;
+            blocked(f, |f| f.writeln("return false;"))
+        })?;
 
         f.newline()?;
 
diff --git a/generators/java-oo-bindgen/src/rust/interface.rs b/generators/java-oo-bindgen/src/rust/interface.rs
@@ -222,10 +222,10 @@ fn write_interface_init<'a>(
                 "({}){}",
                 callback
                     .params()
-                    .map(|param| { param.param_type.as_jni_sig(&lib_path) })
+                    .map(|param| { param.param_type.as_jni_sig(lib_path) })
                     .collect::<Vec<_>>()
                     .join(""),
-                callback.return_type.as_jni_sig(&lib_path)
+                callback.return_type.as_jni_sig(lib_path)
             );
             f.writeln(&format!("let cb_{method_snake} = env.get_method_id(class, \"{method_mixed}\", \"{method_sig}\").map(|mid| mid.into_inner().into()).expect(\"Unable to find method {method_mixed}\");", method_snake=callback.name.to_snake_case(), method_mixed=callback.name.to_mixed_case(), method_sig=method_sig))?;
         }
@@ -289,7 +289,7 @@ fn call_java_callback<'a>(
         "_env.call_method_unchecked(_obj.as_obj(), _cache.interfaces.{}.cb_{}, jni::signature::JavaType::from_str(\"{}\").unwrap(), &[{}]).unwrap();",
         interface_name,
         callback_name,
-        return_type.as_jni_sig(&lib_path),
+        return_type.as_jni_sig(lib_path),
         params.iter().map(|param| format!("{}.into()", param.name.to_snake_case())).collect::<Vec<_>>().join(", ")
     ))?;
 
diff --git a/oo-bindgen/src/lib.rs b/oo-bindgen/src/lib.rs
diff --git a/oo-bindgen/src/native_struct.rs b/oo-bindgen/src/native_struct.rs
diff --git a/oo-bindgen/src/platforms.rs b/oo-bindgen/src/platforms.rs

Original file line number	Diff line number	Diff line change
`@@ -163,7 +163,7 @@ fn generate_constructor(`
`163`	`163`	`f.write(")")?;`
`164`	`164`
`165`	`165`	`blocked(f, \|f\| {`
`166`		`- call_native_function(f, &constructor, "this.self = ", None, true)`
	`166`	`+ call_native_function(f, constructor, "this.self = ", None, true)`
`167`	`167`	`})`
`168`	`168`	`}`
`169`	`169`