将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. }

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