编写 thunk 来验证 SysV ABI 合规性

The SysV ABI定义 Linux 的 C 级和汇编调用约定。

我想编写一个通用的 thunk 来验证函数是否满足被调用者保留寄存器的 ABI 限制，并且（可能）尝试返回一个值。

So given a target function like int foo(int, int) it's pretty easy3 to write such a thunk in assembly, something like¹:

foo_thunk:
push rbp
push rbx
push r12
push r13
push r14
push r15
call foo
cmp rbp, [rsp + 40]
jne bad_rbp
cmp rbx, [rsp + 32]
jne bad_rbx
cmp r12, [rsp + 24]
jne bad_r12
cmp r13, [rsp + 16]
jne bad_r13
cmp r14, [rsp + 8]
jne bad_r14
cmp r15, [rsp]
jne bad_r15
ret

现在当然我实际上不想写一个单独的foo_thunk每次调用的方法，我只想要一个通用的方法。这个应该带有一个指向底层函数的指针（假设在rax)，并且会使用间接调用call [rax] than call foo但否则会是一样的。

我不明白的是如何在 C 级别（或在 C++ 中，似乎有更多元编程选项 - 但我们在这里坚持使用 C）实现 thunk 的透明使用。我想采取类似的东西：

foo(1, 2);

并将其翻译为对thunk，但仍然在相同的位置传递相同的参数（这是 thunk 工作所必需的）。

预计我会修改源代码，也许使用宏或模板魔法，因此上面的调用可以更改为：

CHECK_THUNK(foo, (1, 2));

Giving the macro the name of the underlying function. In principle it could translate this to²:

check_thunk(&foo, 1, 2);

我怎样才能声明 check_thunk 呢？第一个参数是“某种类型”的函数指针。我们可以尝试：

check_thunk(void (*ptr)(void), ...);

因此，一个“通用”函数指针（所有指针都可以有效地转换为该指针，我们实际上只会将其称为汇编，在语言标准之外），加上可变参数。

但这不起作用：...与正确原型化的函数相比，具有完全不同的提升规则。它将适用于foo(1, 2)例如，但如果你打电话foo(1.0, 2)相反，varargs 版本只会将 1.0 保留为double你会打电话给foo具有完全错误的值（adouble值双关为整数。

上面还有将函数指针作为第一个参数传递的缺点，这意味着 thunk 不再按原样工作：它必须将函数指针保存在rdi某处，然后将所有值移一（即，mov rdi, rsi）。如果存在非寄存器参数，事情就会变得非常混乱。

有什么办法可以让这项工作顺利进行吗？

Note:这种类型的 thunk 基本上与堆栈上的任何参数传递都不兼容，这是这种方法的一个可接受的限制（它不应该用于具有那么多参数或带有多个参数的函数）MEMORY类参数）。

¹ This is checks the callee preserved registers, but the other checks are similarly straightforward.

² In fact, you don't even really need the macro for that - but it's also there so you can turn off the thunk in release builds and just do a direct call.

³ Well by "easy" I guess I mean one that doesn't work in all cases. The shown thunk doesn't correctly align the stack (easy to fix), and breaks if foo has any stack-passed arguments (significantly harder to fix).

以 gcc 特定的方式做到这一点的一种方法是利用typeof and 嵌套函数创建一个函数指针embeds对底层函数的调用，但本身没有任何参数。

该指针可以传递给 thunk 方法，该方法调用它并验证 ABI 合规性。

下面是一个将调用转换为int add3(int, int, int)使用这种方法：

原始调用如下所示：

int res = add3(a, b, c);

Then you wrap the call in a macro, like this²:

CALL_THUNKED(int res, add3, (a,b,c));

...它扩展到类似：

    typedef typeof(add3  (a,b,c)) ret_type; 

    ret_type closure() {              
        return add3  (a,b,c);         
    }                                 
    typedef ret_type (*typed_closure)(void);  
    typedef ret_type (*thunk_t)(typed_closure); 

    thunk_t thunk = (thunk_t)closure_thunk; 
    int res = thunk(&closure);

We create the closure() function on the stack, which calls directly into add3 with the original arguments. We can take the address of this closure and pass it an asm function without difficulty: calling it will have the ultimate effect of calling add3 with the arguments¹.

其余的 typedef 基本上处理返回类型。我们只有一个closure_thunk方法，这样声明void* closure_thunk(void (*)(void));并在装配中实施。它需要一个函数指针（任何函数指针都可以转换为任何其他函数指针），但返回类型是“错误的”。我们把它投射到thunk_t这是动态生成的typedef对于具有“正确”返回类型的函数。

当然，这对于 C 函数来说肯定是不合法的，但是我们正在 asm 中实现该函数，因此我们有点回避这个问题（如果您想要更兼容一点，您也许可以向 asm 代码询问函数指针正确的类型，每次都可以“生成”它，超出了标准的范围：当然，它只是每次返回相同的指针）。

The closure_thunkasm 中的函数是按照以下方式实现的：

GLOBAL closure_thunk:function

closure_thunk:

push rsi
push_callee_saved

call rdi

; set up the function name
mov rdi, [rsp + 48]

; now check whether any regs were clobbered
cmp rbp, [rsp + 40]
jne bad_rbp
cmp rbx, [rsp + 32]
jne bad_rbx
cmp r12, [rsp + 24]
jne bad_r12
cmp r13, [rsp + 16]
jne bad_r13
cmp r14, [rsp + 8]
jne bad_r14
cmp r15, [rsp]
jne bad_r15

add rsp, 7 * 8
ret

也就是说，将我们要检查的所有寄存器压入堆栈（连同函数名），调用该函数rdi然后进行检查。这bad_*方法没有显示，但它们基本上会吐出一条错误消息，例如“函数 add3 覆盖了 rbp...顽皮！”和abort()的过程。

如果在堆栈上传递任何参数，这会中断，但它确实适用于在堆栈上传递的返回值（因为该情况的 ABI 传递一个指向“rax”中返回值位置的指针）。

¹ How this is accomplished is kind of magic: gcc actually writes a few bytes of executable code onto the stack, and the closure function pointer points there. The few bytes basically loads a register with a pointer to the region that contains the captured variables (a, b, c in this case), and then calls the actual (read-only) closure() code which then can access the captured variables though that pointer (and pass them to add3).

² As it turns out, we could probably use gcc's statement expression syntax to write the macro in a more usual function like syntax, something like int res = CALL_THUNKED(add3, (a,b,c)).