DragonFFI: 使用 Clang/LLVM 的 C 语言 FFI/JIT

引言

import pydffi
CU = pydffi.FFI().cdef("int puts(const char* s);");
CU.funcs.puts("hello world!")

import pydffi
pydffi.dlopen("/path/to/libarchive.so")
CU = pydffi.FFI().cdef("#include <archive.h>")
a = funcs.archive_read_new()
assert a
...

$ pip install pydffi

相关工作

• libffi不支持 Linux x64 下的 Microsoft x64 ABI。添加新的 ABI 并不像看起来那么简单（手工编写 ABI，确保 ABI 正确等等），而编译器已经投入了大量精力来确保这些 ABI 的正确性。
• PyCParser仅支持非常有限的 C 子集（没有包含文件、函数属性等等）。

• 它使用 Clang 解析头文件，允许直接使用 C 库头文件，无需修改；
• 它支持与 Clang/LLVM 一样多的调用约定和函数属性；
• 作为额外的好处，Clang 和 LLVM 允许对 C 函数进行即时编译，而无需依赖系统上是否存在编译器（不过，你仍然需要系统 libc 的头文件，或者 Windows 下的 MSVCRT 头文件）；
• 这是一种用 Clang 和 LLVM 玩得开心的好方法！：）

为 C 创建一个 FFI 库

支持 C ABI

typedef struct {
  short a;
  int b;
} A;

void print_A(A s) {
  printf("%d %d\n", s.a, s.b);
}

target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-linux-gnu"

@.str = private unnamed_addr constant [7 x i8] c"%d %d\0A\00", align 1

define void @print_A(i64) local_unnamed_addr {
  %2 = trunc i64 %0 to i32
  %3 = lshr i64 %0, 32
  %4 = trunc i64 %3 to i32
  %5 = shl i32 %2, 16
  %6 = ashr exact i32 %5, 16
  %7 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0), i32 %6, i32 %4)
  ret void
}

寻找合适的类型抽象

• 函数类型及其调用约定
• 对于结构体：字段偏移量和名称
• 对于联合体/枚举：字段名称（和值）

[...]
|-RecordDecl 0x5561d7f9fc20 <a.c:1:9, line:4:1> line:1:9 struct definition
| |-FieldDecl 0x5561d7ff4750 <line:2:3, col:9> col:9 referenced a 'short'
| `-FieldDecl 0x5561d7ff47b0 <line:3:3, col:7> col:7 referenced b 'int'

target triple = "x86_64-pc-linux-gnu"
%struct.A = type { i16, i32 }
@.str = private unnamed_addr constant [7 x i8] c"%d %d\0A\00", align 1

define void @print_A(i64) local_unnamed_addr !dbg !7 {
  %2 = trunc i64 %0 to i32
  %3 = lshr i64 %0, 32
  %4 = trunc i64 %3 to i32
  tail call void @llvm.dbg.value(metadata i32 %4, i64 0, metadata !18, metadata !19), !dbg !20
  tail call void @llvm.dbg.declare(metadata %struct.A* undef, metadata !18, metadata !21), !dbg !20
  %5 = shl i32 %2, 16, !dbg !22
  %6 = ashr exact i32 %5, 16, !dbg !22
  %7 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([...] @.str, i64 0, i64 0), i32 %6, i32 %4), !dbg !23
  ret void, !dbg !24
}

[...]
; DISubprogram defines (in our case) a C function, with its full type
!7 = distinct !DISubprogram(name: "print_A", scope: !1, file: !1, line: 6, type: !8, [...], variables: !17)
; This defines the type of our subprogram
!8 = !DISubroutineType(types: !9)
; We have the "original" types used for print_A, with the first one being the
; return type (null => void), and the other ones the arguments (in !10)
!9 = !{null, !10}
!10 = !DIDerivedType(tag: DW_TAG_typedef, name: "A", file: !1, line: 4, baseType: !11)
; This defines our structure, with its various fields
!11 = distinct !DICompositeType(tag: DW_TAG_structure_type, file: !1, line: 1, size: 64, elements: !12)
!12 = !{!13, !15}
; We have here the size and name of the member "a". Offset is 0 (default value)
!13 = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: !11, file: !1, line: 2, baseType: !14, size: 16)
!14 = !DIBasicType(name: "short", size: 16, encoding: DW_ATE_signed)
; We have here the size, offset and name of the member "b"
!15 = !DIDerivedType(tag: DW_TAG_member, name: "b", scope: !11, file: !1, line: 3, baseType: !16, size: 32, offset: 32)
!16 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
[...]

内部工作原理

• 创建一个类型系统，只从元数据树中收集必要的信息（我们不需要全部调试信息）
• 使 DragonFFI 库的公共头文件摆脱任何 LLVM 头文件（这样就无需使用库的全部 LLVM 头文件）

DFFI FFI([...]);
// This will declare puts as a function that returns int and takes a const

// char* as an argument. We could also create this function type by hand.
CompilationUnit CU = FFI.cdef("int puts(const char* s);", [...]);
NativeFunc F = CU.getFunction("puts");
const char* s = "hello world!";
void* Args[] = {&s};
int Ret;
F.call(&Ret, Args);

void call_puts(void* Ret, void** Args) {
  *((int*)Ret) = puts((const char*) Args[0]);
}

typedef void(*puts_call_ty)(void*, void**);
puts_call_ty Wrapper = /* pointer to the compiled wrapper function */;
Wrapper(Ret, Args);

void __dffi_wrapper_0(int32_t( __attribute__((cdecl)) *__FPtr)(char *), int32_t *__Ret, void** __Args) {
  *__Ret = (__FPtr)(*((char **)__Args[0]));
}

Clang 的问题

typedef struct {
  short a;
  int b;
} A;

void print_A(A s);

$ clang -S -emit-llvm -g -femit-all-decls -o - a.c |grep print_A |wc -l
0

void __dffi_force_decl_print_A(A s) { }

Python 绑定

项目状态

• 存在用户和开发者文档！
• 支持另一种外语（JS？Ruby？）
• DragonFFI 主库 API 被认为是稳定的
• 添加了一组数量可观的测试
• 文件中的所有内容TODO都已完成：）

未来的各种想法

解析嵌入式 DWARF 信息

轻量级调试信息？

• 在 libarchive 3.3.2 上，DWARF 从 1.8Mb 降至 536Kb，原始二进制代码大小为 735Kb
• 在 zlib 1.2.11 上，DWARF 从 162Kb 降至 61Kb，原始二进制代码大小为 99Kb

• 如今，调试信息在所有平台上都得到了很好的支持：存在用于解析它们、从二进制文件中嵌入/提取它们的工具，等等。
• 我们已经有了 DWARD 和 PDB：https://xkcd.com/927/

从最终语言 (如 Python) 到本机函数代码的 JIT 代码

• 根据函数类型，将参数从 Python 转换为 C
• 从 DragonFFI 收集函数指针和包装器
• 进行最终调用

减小 DragonFFI 库大小

• 使用 (Thin) LTO 编译 DragonFFI、Clang 和 LLVM，并为 Clang 和 LLVM 设置隐藏可见性。这可能会导致从 Clang/LLVM 中删除 DragonFFI 未使用的代码。
• 使 DragonFFI 更加模块化：- 仅包含 CodeGen 中处理 ABI 的部分的核心模块。如果类型和函数原型是“手动”定义的 (没有DFFI::cdef)，这基本上是唯一需要的部分 (当然还有 LLVM) - 包含完整 clang 编译器的可选模块 (以提供DFFI::cdef和DFFI::compileAPI)

结论

致谢