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

问题描述

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

#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. 以某种方式收集函数调用的内容,然后在需要时“保护”寄存器。

我认为解决方案 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.

相关问答

错误1:Request method ‘DELETE‘ not supported 错误还原:...
错误1:启动docker镜像时报错:Error response from daemon:...
错误1:private field ‘xxx‘ is never assigned 按Alt...
报错如下,通过源不能下载,最后警告pip需升级版本 Requirem...