如何在函数调用期间保护寄存器不被覆盖？

如何解决如何在函数调用期间保护寄存器不被覆盖？

我正在尝试为以下函数编写汇编代码：

#include <iostream>
void f(int x) {
    if (x > 0) {
        std::cout << x << std::endl;
        f(x-1);
        std::cout << x << std::endl;
    }
}
int main() {
    f(1);
}

这个函数脚本的输出是1 1。我尝试为所谓的“低成本计算机”汇编程序编写汇编代码，这是 Anthony Dos Reis 为他的书“C and C++ under the hood”发明的计算机。我写的汇编代码是：

startup   jsr main
          halt             ; back to operating system
;==============================================================
                           ; #include <stdio.h>
greater   dout
          nl
          sub r1,r0,1
          push lr
          push fp
          mov fp,sp
          push r1
          jsr f
          add sp,sp,1
          dout
          nl
          mov sp,fp
          pop fp
          pop lr
          ret
;==============================================================
f         push lr          ; int f()
          push fp          ; {
          mov fp,sp
          ldr r0,fp,2
          cmp r0,0
          brgt greater
          mov sp,fp
          pop fp
          pop lr
          ret
;==============================================================
main      push lr
          push fp
          mov fp,sp
          mov r0,1
          push r0
          jsr f
          add sp,1
          mov sp,fp
          pop fp
          pop lr
          ret

代码将 1 0 打印到标准输出，显然是错误的。错误输出的原因在于寄存器r0在分支1求值过程中跳转到函数f之前包含greater，然后函数f 修改寄存器并在进行比较 r0 时将 0 设置为 cmp。这让我想知道我的汇编程序如何在函数调用期间保持寄存器不变。我想到了以下几点：

只需将整个寄存器压入堆栈，然后再加载
以某种方式收集函数调用的内容，然后在需要时“保护”寄存器。

我认为解决方案 1 非常具有防御性并且可能成本很高，而解决方案 2 可能很复杂并且需要很多知识。最有可能的是，我只是在编写程序集时犯了一个错误，但我仍然不明白在一般情况下，汇编程序如何在需要时保持其寄存器不变，或者如何解决上述问题。有人知道在这种情况下该怎么做吗？我很感激任何帮助或建议！

解决方法

通常，计算平台包括一个应用程序二进制接口 (ABI)，它指定函数调用的协议等。 ABI 规定某些处理器寄存器用于传递参数或返回结果，某些寄存器可以被调用的例程（临时或易失性寄存器）自由使用，某些寄存器可以被被调用的例程使用但必须恢复到它们的原始值（保留或非易失性寄存器）和/或某些寄存器不得被调用的例程更改。调用例程的规则也可以称为“调用约定”。

如果您的例程使用调用函数可以自由使用的寄存器之一，并且它希望在函数调用期间保留该寄存器的值，则必须在函数调用之前保存它并在调用之后恢复它。

通常，ABI 和函数在它们使用的寄存器中寻求平衡。如果 ABI 说必须保存和恢复所有寄存器，那么被调用的函数必须保存和恢复它使用的每个寄存器。相反，如果 ABI 说不需要保存和恢复寄存器，那么调用函数就必须保存和恢复它需要的每个寄存器。混合使用时，调用例程可能经常将其某些数据保存在寄存器中（因此它不必在调用前保存它们并在调用之后恢复它们），并且被调用例程将不会使用它必须使用的所有寄存器保留（因此它不必保存和恢复它们；而是使用临时寄存器），因此减少了执行的寄存器保存和恢复的总数。

正如其他人所说，通常每个寄存器都通过称为调用约定的协议分配一个使用模型。有几种使用模式：

Call clobbered — 有时也称为“scratch”，这些寄存器被理解为被函数调用破坏，因此，它们可以在调用之间使用，并且可以被任何函数自由使用。

有时这些被称为“调用者保存”，因为调用者有责任在调用后需要时保存它们的任何值；也称为“易失性”一词。然而，实际上，一旦移动到内存中，它们就不需要恢复，直到真正需要它们的值；这些值不需要恢复到它们在存储到内存时所在的相同寄存器，并且在某些架构上，这些值也可以直接从内存中使用。
保留调用——这些寄存器被理解为由函数调用保留，这意味着为了使用其中之一，必须保留寄存器的原始内容（通常在函数入口处）并稍后恢复（通常在函数退出时）。有时也称为“被调用者保存”，因为调用者可以依赖它们的值被保存，如果使用，被调用者必须保存和恢复它们；也称为非易失性。
其他——在某些处理器上，某些寄存器专用于参数传递和返回值；由于这些用途，它们不一定严格按照 call clobbered 或 call reserved 的方式运行——也就是说，破坏它们的不一定是被调用的函数，但调用者可能需要仅在进行调用时破坏它们，即在之前的参数传递中电话。函数可以在这些寄存器中具有调用后需要的形式参数值，但需要在调用另一个函数的指令序列中将实际参数放入其中。发生这种情况时，调用后所需的参数值通常会重新定位（到内存或调用保留的寄存器）。

以某种方式收集函数调用的内容，然后在需要时“保护”寄存器。

这可以工作。调用约定是一种通用协议，当调用者或被调用者不知道另一个的实现细节时，或者当间接函数调用（通过指针调用）可以调用几个不同的实际函数之一时，它特别有用。然而，当被调用者和调用者在实现中都是已知的，那么作为一种优化，我们可以偏离标准的调用约定。例如，如果我们知道被调用的函数不会修改该临时寄存器，我们可以使用临时寄存器来保存一个值在特定调用中有效。

体系结构/平台组合（例如 Windows-on-x64 或 Linux-on-ARM32）具有所谓的 ABI 或应用程序二进制接口。

ABI 精确指定了寄存器的使用方式、函数的调用方式、异常的工作方式以及函数参数的传递方式。一个重要的方面是，在函数调用期间，必须保存哪些寄存器，谁保存它们，哪些寄存器可能会被破坏。

可以在函数调用期间销毁的寄存器称为易失性寄存器。必须由函数调用保留的寄存器称为非易失性寄存器。通常，如果调用者想要保留一个易失性寄存器，它会将值压入堆栈，调用该函数，然后在完成后将其弹出。如果一个被调用的函数（被调用者）想要使用一个非易失性寄存器，它必须类似地保存它。

阅读Windows x64 calling convention here.

如何在函数调用期间保护寄存器不被覆盖？

如何解决如何在函数调用期间保护寄存器不被覆盖？

解决方法

相关推荐