• 将Rust编译成库
    • 调用约定和mangle
    • 指定crate类型
    • 小技巧: Any

    将Rust编译成库

    上一章讲述了如何从rust中调用c库，这一章我们讲如何把rust编译成库让别的语言通过cffi调用。

    调用约定和mangle

    正如上一章讲述的，为了能让rust的函数通过ffi被调用，需要加上extern "C"对函数进行修饰。

    但由于rust支持重载，所以函数名会被编译器进行混淆，就像c++一样。因此当你的函数被编译完毕后，函数名会带上一串表明函数签名的字符串。

    比如：fn test() {}会变成_ZN4test20hf06ae59e934e5641haaE.
    这样的函数名为ffi调用带来了困难，因此，rust提供了#[no_mangle]属性为函数修饰。
    对于带有#[no_mangle]属性的函数，rust编译器不会为它进行函数名混淆。如：

    1. #[no_mangle]
    2. extern "C" fn test() {}

    在nm中观察到为

    1. ...
    2. 00000000001a7820 T test
    3. ...

    至此，test函数将能够被正常的由cffi调用。

    指定crate类型

    rustc默认编译产生rust自用的rlib格式库，要让rustc产生动态链接库或者静态链接库，需要显式指定。

    1. 方法1: 在文件中指定。
      在文件头加上#![crate_type = "foo"], 其中foo的可选类型有bin, lib, rlib, dylib, staticlib.分别对应可执行文件，
      默认(将由rustc自己决定), rlib格式，动态链接库，静态链接库。
    2. 方法2: 编译时给rustc 传--crate-type参数。参数内容同上。
    3. 方法3: 使用cargo，指定crate-type = ["foo"], foo可选类型同1

    小技巧: Any

    由于在跨越ffi过程中，rust类型信息会丢失，比如当用rust提供一个OpaqueStruct给别的语言时：

    1. use std::mem::transmute;
    3. #[derive(Debug)]
    4. struct Foo<T> {
    5.   t: T
    6. }
    8. #[no_mangle]
    9. extern "C" fn new_foo_vec() -> *const c_void {
    10.     Box::into_raw(Box::new(Foo {t: vec![1,2,3]})) as *const c_void
    11. }
    13. #[no_mangle]
    14. extern "C" fn new_foo_int() -> *const c_void {
    15.     Box::into_raw(Box::new(Foo {t: 1})) as *const c_void
    16. }
    18. fn push_foo_element(t: &mut Foo<Vec<i32>>) {
    19.     t.t.push(1);
    20. }
    22. #[no_mangle]
    23. extern "C" fn push_foo_element_c(foo: *mut c_void){
    24.     let foo2 = unsafe {
    25.         &mut *(foo as *mut Foo<Vec<i32>>) // 这么确定是Foo<Vec<i32>>? 万一foo是Foo<i32>怎么办？
    26.     };
    27.     push_foo_element(foo3);
    28. }

    以上代码中完全不知道foo是一个什么东西。安全也无从说起了，只能靠文档。
    因此在ffi调用时往往会丧失掉rust类型系统带来的方便和安全。在这里提供一个小技巧:使用Box<Box<Any>>来包装你的类型。

    rust的Any类型为rust带来了运行时反射的能力，使用Any跨越ffi边界将极大提高程序安全性。

    1. use std::any::Any;
    3. #[derive(Debug)]
    4. struct Foo<T> {
    5.   t: T
    6. }
    8. #[no_mangle]
    9. extern "C" fn new_foo_vec() -> *const c_void {
    10.     Box::into_raw(Box::new(Box::new(Foo {t: vec![1,2,3]}) as Box<Any>)) as *const c_void
    11. }
    13. #[no_mangle]
    14. extern "C" fn new_foo_int() -> *const c_void {
    15.     Box::into_raw(Box::new(Box::new(Foo {t: 1}) as Box<Any>)) as *const c_void
    16. }
    18. fn push_foo_element(t: &mut Foo<Vec<i32>>) {
    19.     t.t.push(1);
    20. }
    22. #[no_mangle]
    23. extern "C" fn push_foo_element_c(foo: *mut c_void){
    24.     let foo2 = unsafe {
    25.         &mut *(foo as *mut Box<Any>)
    26.     };
    27.     let foo3: Option<&mut Foo<Vec<i32>>> = foo2.downcast_mut(); // 如果foo2不是*const Box<Foo<Vec<i32>>>, 则foo3将会是None
    28.     if let Some(value) = foo3 {
    29.       push_foo_element(value);
    30.     }
    31. }

    这样一来，就非常不容易出错了。