APCS，ARM 过程调用标准(ARM Procedure Call Standard)

叁歲伎倆 2022-04-10 10:26 210阅读 0赞

出处：[APCS，ARM 过程调用标准(ARM Procedure Call Standard) ][APCS_ARM _ARM Procedure Call Standard_]

## 介绍 ##

**APCS**，ARM 过程调用标准(ARM Procedure Call Standard)，提供了紧凑的编写例程的一种机制，定义的例程可以与其他例程交织在一起。最显著的一点是对这些例程来自哪里没有明确的限制。它们可以编译自 C、 Pascal、也可以是用汇编语言写成的。

APCS 定义了:

*  对寄存器使用的限制。
 *  使用栈的惯例。
 *  在函数调用之间传递/返回参数。
 *  可以被‘回溯’的基于栈的结构的格式，用来提供从失败点到程序入口的函数(和给予的参数)的列表。

APCS 不一个单一的给定标准，而是一系列类似但在特定条件下有所区别的标准。例如，APCS-R (用于 RISC OS)规定在函数进入时设置的标志必须在函数退出时复位。在 32 位标准下，并不是总能知道进入标志的(没有 USR\_CPSR)，所以你不需要恢复它们。如你所预料的那样，在不同版本间没有相容性。希望恢复标志的代码在它们未被恢复的时候可能会表现失常...

如果你开发一个基于 ARM 的系统，不要求你去实现 APCS。但建议你实现它，因为它不难实现，且可以使你获得各种利益。但是，如果要写用来与编译后的 C 连接的汇编代码，则必须使用 APCS。编译器期望特定的条件，在你的加入(add-in)代码中必须得到满足。一个好例子是 APCS 定义 a1 到 a4 可以被破坏，而 v1 到 v6 必须被保护。现在我确信你正在挠头并自言自语“a 是什么? v 是什么?”。所以首先介绍 APCS-R 寄存器定义...

## 寄存器命名 ##

APCS 对我们通常称为 R0 到 R14 的寄存器起了不同的名字。使用汇编器预处理器的功能，你可以定义 R0 等名字，但在你修改其他人写的代码的时候，最好还是学习使用 APCS 名字。

<table> 
 <tbody> 
  <tr> 
   <td colspan="3">寄存器名字</td> 
  </tr> 
  <tr> 
   <td><code>Reg #&nbsp;</code></td> 
   <td><code>APCS&nbsp;&nbsp;</code></td> 
   <td>意义</td> 
  </tr> 
  <tr> 
   <td><code>R0</code></td> 
   <td><code>a1</code></td> 
   <td>工作寄存器</td> 
  </tr> 
  <tr> 
   <td><code>R1</code></td> 
   <td><code>a2</code></td> 
   <td>"</td> 
  </tr> 
  <tr> 
   <td><code>R2</code></td> 
   <td><code>a3</code></td> 
   <td>"</td> 
  </tr> 
  <tr> 
   <td><code>R3</code></td> 
   <td><code>a4</code></td> 
   <td>"</td> 
  </tr> 
  <tr> 
   <td><code>R4</code></td> 
   <td><code>v1</code></td> 
   <td>必须保护</td> 
  </tr> 
  <tr> 
   <td><code>R5</code></td> 
   <td><code>v2</code></td> 
   <td>"</td> 
  </tr> 
  <tr> 
   <td><code>R6</code></td> 
   <td><code>v3</code></td> 
   <td>"</td> 
  </tr> 
  <tr> 
   <td><code>R7</code></td> 
   <td><code>v4</code></td> 
   <td>"</td> 
  </tr> 
  <tr> 
   <td><code>R8</code></td> 
   <td><code>v5</code></td> 
   <td>"</td> 
  </tr> 
  <tr> 
   <td><code>R9</code></td> 
   <td><code>v6</code></td> 
   <td>"</td> 
  </tr> 
  <tr> 
   <td><code>R10</code></td> 
   <td><code>sl</code></td> 
   <td>栈限制</td> 
  </tr> 
  <tr> 
   <td><code>R11</code></td> 
   <td><code>fp</code></td> 
   <td>桢指针</td> 
  </tr> 
  <tr> 
   <td><code>R12</code></td> 
   <td><code>ip</code></td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>R13</code></td> 
   <td><code>sp</code></td> 
   <td>栈指针</td> 
  </tr> 
  <tr> 
   <td><code>R14</code></td> 
   <td><code>lr</code></td> 
   <td>连接寄存器</td> 
  </tr> 
  <tr> 
   <td><code>R15</code></td> 
   <td><code>pc</code></td> 
   <td>程序计数器</td> 
  </tr> 
 </tbody> 
</table>

译注：ip 是指令指针的简写。

这些名字不是由标准的 Acorn 的 objasm(版本 2.00)所定义的，但是 objasm 的后来版本，和其他汇编器(比如 Nick Robert 的 ASM)定义了它们。要定义一个寄存器名字，典型的，你要在程序最开始的地方使用 `RN` 宏指令(directive):

a1     RN      0
    a2     RN      1
    a3     RN      2
        ...等...
    
    r13    RN      13
    sp     RN      13
    r14    RN      14
    lr     RN      r14
    pc     RN      15

这个例子展示了一些重要的东西:

1.  寄存器可以定义多个名字 - 你可以定义‘r13’和‘sp’二者。
2.  寄存器可以定义自前面定义的寄存器 - ‘lr’定义自叫做‘r14’的寄存器。  
    (对于 objasm 是正确的，其他汇编器可能不是这样)

## 设计关键 ##

*  函数调用应当快、小、和易于(由编译器来)优化。
 *  函数应当可以妥善处理多个栈。
 *  函数应当易于写可重入和可重定位的代码；主要通过把可写的数据与代码分离来实现。
 *  但是最重要的是，它应当简单。这样汇编编程者可以非常容易的使用它的设施，而调试者能够非常容易的跟踪程序。

## 一致性 ##

程序的遵循 APCS 的部分在调用外部函数时被称为“一致”。在程序执行期间的所有时候都遵循 APCS (典型的，由编译器生成的程序)被称为“严格一致”。协议指出，假如你遵守正确的进入和退出参数，你可以在你自己的函数范围内做你需要的任何事情，而仍然保持一致。这在有些时候是必须的，比如在写 SWI 伪装(veneers)的时候使用了许多给实际的 SWI 调用的寄存器。

## 栈 ##

栈是链接起来的‘桢’的一个列表，通过一个叫做‘回溯结构’的东西来链接它们。这个结构存储在每个桢的高端。按递减地址次序分配栈的每一块。寄存器 `sp` 总是指向在最当前桢中最低的使用的地址。这符合传统上的满降序栈。在 APCS-R 中，寄存器 `sl` 持有一个栈限制，你递减 `sp` 不能低于它。在当前栈指针和当前栈之间，不应该有任何其他 APCS 函数所依赖的东西，在被调用的时候，函数可以为自己设置一个栈块。

可以有多个栈区(chunk)。它们可以位于内存中的任何地址，这里没有提供规范。典型的，在可重入方式下执行的时候，这将被用于为相同的代码提供多个栈；一个类比是 FileCore，它通过简单的设置‘状态’信息和并按要求调用相同部分的代码，来向当前可获得的 FileCore 文件系统(ADFS、RAMFS、IDEFS、SCSIFS 等)提供服务。

## 回溯结构 ##

寄存器 `fp` (桢指针)应当是零或者是指向栈回溯结构的列表中的最后一个结构，提供了一种追溯程序的方式，来反向跟踪调用的函数。

回溯结构是:

地址高端
    
       保存代码指针        [fp]         fp 指向这里
       返回 lr 值          [fp, #-4] 
       返回 sp 值          [fp, #-8] 
       返回 fp 值          [fp, #-12]  指向下一个结构 
       [保存的 sl]
       [保存的 v6] 
       [保存的 v5] 
       [保存的 v4] 
       [保存的 v3] 
       [保存的 v2]
       [保存的 v1]
       [保存的 a4]
       [保存的 a3]
       [保存的 a2]
       [保存的 a1]
       [保存的 f7]                          三个字
       [保存的 f6]                          三个字
       [保存的 f5]                          三个字
       [保存的 f4]                          三个字
    
    地址低端

这个结构包含 4 至 27 个字，在方括号中的是可选的值。如果它们存在，则必须按给定的次序存在(例如，在内存中保存的 a3 下面可以是保存的 f4，但 a2-f5 则不能存在)。浮点值按‘内部格式’存储并占用三个字(12 字节)。

fp 寄存器指向当前执行的函数的栈回溯结构。返回 fp 值应当是零，或者是指向由调用了这个当前函数的函数建立的栈回溯结构的一个指针。而这个结构中的返回 fp 值是指向调用了调用了这个当前函数的函数的函数的栈回溯结构的一个指针；并以此类推直到第一个函数。

在函数退出的时候，把返回连接值、返回 sp 值、和返回 fp 值装载到 pc、sp、和 fp 中。

#include <stdio.h>
    
      void one(void);
      void two(void);
      void zero(void);
    
      int main(void)
      {
         one();
         return 0;
      }
    
      void one(void)
      {
         zero();
         two();
         return;
      }
    
      void two(void)
      {
         printf("main...one...two/n");
         return;
      }
    
      void zero(void)
      {
         return;
      }
    
    
      当它在屏幕上输出消息的时候，
      APCS 回溯结构将是:
    
          fp ----> two_structure
                   return link
                   return sp
                   return fp  ----> one_structure
                   ...              return link
                                    return sp
                                    return fp  ----> main_structure
                                    ...              return link
                                                     return sp
                                                     return fp  ----> 0
                                                     ...

所以，我们可以检查 fp 并参看给函数‘two’的结构，它指向给函数‘one’的结构，它指向给‘main’的结构，它指向零来终结。在这种方式下，我们可以反向追溯整个程序并确定我们是如何到达当前的崩溃点的。值得指出‘zero’函数，因为它已经被执行并退出了，此时我们正在做它后面的打印，所以它曾经在回溯结构中，但现在不在了。值得指出的还有对于给定代码不太可能总是生成象上面那样的一个 APCS 结构。原因是不调用任何其他函数的函数不要求完全的 APCS 头部。

为了更细致的理解，下面是代码是 Norcroft C v4.00 为上述代码生成的...

AREA |C$code|, CODE, READONLY
    
            IMPORT  |__main|
    |x$codeseg|
            B       |__main|
    
            DCB     &6d,&61,&69,&6e
            DCB     &00,&00,&00,&00
            DCD     &ff000008
    
            IMPORT  |x$stack_overflow|
            EXPORT  one
            EXPORT  main
    main
            MOV     ip, sp
            STMFD   sp!, {fp,ip,lr,pc}
            SUB     fp, ip, #4
            CMPS    sp, sl
            BLLT    |x$stack_overflow|
            BL      one
            MOV     a1, #0
            LDMEA   fp, {fp,sp,pc}^
    
            DCB     &6f,&6e,&65,&00
            DCD     &ff000004
    
            EXPORT  zero
            EXPORT  two
    one
            MOV     ip, sp
            STMFD   sp!, {fp,ip,lr,pc}
            SUB     fp, ip, #4
            CMPS    sp, sl
            BLLT    |x$stack_overflow|
            BL      zero
            LDMEA   fp, {fp,sp,lr}
            B       two
    
            IMPORT  |_printf|
    two
            ADD     a1, pc, #L000060-.-8
            B       |_printf|
    L000060
            DCB     &6d,&61,&69,&6e
            DCB     &2e,&2e,&2e,&6f
            DCB     &6e,&65,&2e,&2e
            DCB     &2e,&74,&77,&6f
            DCB     &0a,&00,&00,&00
    
    zero
            MOVS    pc, lr
    
            AREA |C$data|
    
    |x$dataseg|
    
            END

这个例子不遵从 32 为体系。APCS-32 规定只是简单的说明了标志不需要被保存。所以删除 LDM 的‘^’后缀，并在函数 zero 中删除 MOVS 的‘S’后缀。则代码就与遵从 32-bit 的编译器生成的一样了。

保存代码指针包含这条设置回溯结构的指令(STMFD ...)的地址再加上 12 字节。记住，对于 26-bit 代码，你需要去除其中的 PSR 来得到实际的代码地址。

现在我们查看刚进入函数的时候:

*  **pc** 总是包含下一个要被执行的指令的位置。
 *  **lr** (总是)包含着退出时要装载到 **pc** 中的值。在 26-bit 位代码中它还包含着 PSR。
 *  **sp** 指向当前的栈块(chunk)限制，或它的上面。这是用于复制临时数据、寄存器和类似的东西到其中的地方。在 RISC OS 下，你有可选择的至少 256 字节来扩展它。
 *  **fp** 要么是零，要么指向回溯结构的最当前的部分。
 *  函数实参布置成(下面)描述的那样。

## 实际参数 ##

APCS 没有定义记录、数组、和类似的格局。这样语言可以自由的定义如何进行这些活动。但是，如果你自己的实现实际上不符合 APCS 的精神，那么将不允许来自你的编译器的代码与来自其他编译器的代码连接在一起。典型的，使用 C 语言的惯例。

*  前 4 个整数实参(或者更少!)被装载到 a1 - a4。
 *  前 4 个浮点实参(或者更少!)被装载到 f0 - f3。
 *  其他任何实参(如果有的话)存储在内存中，用进入函数时紧接在 sp 的值上面的字来指向。换句话说，其余的参数被压入栈顶。所以要想简单。最好定义接受 4 个或更少的参数的函数。

## 函数退出 ##

通过把返回连接值传送到程序计数器中来退出函数，并且:

*  如果函数返回一个小于等于一个字大小的值，则把这个值放置到 a1 中。
 *  如果函数返回一个浮点值，则把它放入 f0 中。
 *  sp、fp、sl、v1-v6、和 f4-f7 应当被恢复(如果被改动了)为包含在进入函数时它所持有的值。  
    我测试了故意的破坏寄存器，而结果是(经常在程序完全不同的部分)出现不希望的和奇异的故障。
 *  ip、lr、a2-a4、f1-f3 和入栈的这些实参可以被破坏。

在 32 位模式下，不需要对 PSR 标志进行跨越函数调用的保护。在 26 位模式下必须这样，并通过传送 lr 到 pc 中(MOVS、或 LDMFD xxx^)来暗中恢复。必须从 lr 重新装载 N、Z、C 和 V，跨越函数保护这些标志不是足够的。

## 建立栈回溯结构 ##

对于一个简单函数(固定个数的参数，不可重入)，你可以用下列指令建立一个栈回溯结构:

function_name_label
            MOV     ip, sp
            STMFD   sp!, {fp,ip,lr,pc}
            SUB     fp, ip, #4

这个片段(来自上述编译后的程序)是最基本的形式。如果你要破坏其他不可破坏的寄存器，则你应该在这个 STMFD 指令中包含它们。

下一个任务是检查栈空间。如果不需要很多空间(小于 256 字节)则你可以使用:

CMPS    sp, sl
            BLLT    |x$stack_overflow|
    
    
    这是 C 版本 4.00 处理溢出的方式。在以后的版本中，你要调用 |__rt_stkovf_split_small|。

接着做你自己的事情...

通过下面的指令完成退出:

LDMEA   fp, {fp,sp,pc}^

还有，如果你入栈了其他寄存器，则也在这里重新装载它们。选择这个简单的 LDM 退出机制的原因是它比分支到一个特殊的函数退出处理器(handler)更容易和更合理。

用在回溯中的对这个协议的一个扩展是把函数名字嵌入到代码中。紧靠在函数(和 `MOV ip, sp`)的前面的应该是:

DCD     &ff0000xx

这里的‘xx’是函数名字符串的长度(包括填充和终结符)。这个字符串是字对齐、尾部填充的，并且应当被直接放置在 DCD &ff....的前面。

所以一个完整的栈回溯代码应当是:

DCB     "my_function_name", 0, 0, 0, 0
            DCD     &ff000010
    my_function_name
            MOV     ip, sp
            STMFD   sp!, {fp, ip, lr, pc}
            SUB     fp, ip, #4
    
            CMPS    sp, sl                    ; 如果你不使用栈
            BLLT    |x$stack_overflow|        ; 则可以省略
    
            ...处理...
    
            LDMEA   fp, {fp, sp, pc}^

要使它遵从 32-bit 体系，只须简单的省略最后一个指令的‘^’。注意你不能在一个编译的 26-bit 代码中使用这个代码。实际上，你可以去除它，但这不是我愿意打赌的事情。

如果你不使用栈，并且你不需要保存任何寄存器，并且你不调用任何东西，则没有必要设置 APCS 块(但在调试阶段对跟踪问题仍是有用的)。在这种情况下你可以:

my_simple_function
    
            ...处理...
    
            MOVS    pc, lr

(再次，对 32 位 APCS 使用 MOV 而不是 MOVS，但是不要冒险与 26 位代码连接)。

## APCS 标准 ##

总的来说，有多个版本的 APCS (实际上是 16 个)。我们只关心在 RISC OS 上可能遇到的。

**APCS-A**  
就是 APCS-Arthur；由早期的 Arthur 所定义。它已经被废弃，原因是它有不同的寄存器定义(对于熟练的 RISC OS 程序员它是某种异类)。它用于在 USR 模式下运行的 Arthur 应用程序。不应该使用它。

*  `sl = R13, fp = R10, ip = R11, sp = R12, lr = R14, pc = R15。`
 *  PRM (p4-411) 中说“用 `r12` 作为 `sp`，而不是在体系上更自然的 `r13`，是历史性的并先于 Arthur 和 RISC OS 二者。”
 *  栈是分段的并可按需要来扩展。
 *  26-bit 程序计数器。
 *  不在 FP 寄存器中传递浮点实参。
 *  不可重入。标志必须被恢复。

**APCS-R**  
就是 APCS-RISC OS。用于 RISC OS 应用程序在 USR 模式下进行操作；或在 SVC 模式下的模块/处理程序。

*  `sl = R10, fp = R11, ip = R12, sp = R13, lr = R14, pc = R15。`
 *  它是唯一的最通用的 APCS 版本。因为所有编译的 C 程序都使用 APCS-R。
 *  显式的栈限制检查。
 *  26-bit 程序计数器。
 *  不在 FP 寄存器中传递浮点实参。
 *  不可重入。标志必须被恢复。

**APCS-U**  
就是 APCS-Unix，Acorn 的 RISCiX 使用它。它用于 RISCiX 应用程序(USR 模式)或内核(SVC 模式)。

*  `sl = R10, fp = R11, ip = R12, sp = R13, lr = R14, pc = R15。`
 *  隐式的栈限制检查(使用 sl)。
 *  26-bit 程序计数器。
 *  不在 FP 寄存器中传递浮点实参。
 *  不可重入。标志必须被恢复。

**APCS-32**  
它是 APCS-2(-R 和 -U)的一个扩展，允许 32-bit 程序计数器，并且从执行在 USR 模式下的一个函数中退出时，允许标志不被恢复。其他事情同于 APCS-R。  
Acorn C 版本 5 支持生成 32-bit 代码；在用于广域调试的 32 位工具中，它是最完整的开发发行。一个简单的测试是要求你的编译器导出汇编源码(而不是制作目标代码)。你不应该找到:  
`MOVS PC, R14`  
或者  
`LDMFD R13!, {Rx-x, PC}^`

## 对编码有用的东西 ##

首先要考虑的是该死的 26/32 位问题。 简单的说，不转弯抹角绝对没有方法为两个版本的 APCS 汇编同一个通用代码。但是幸运的这不是问题。APCS 标准不会突然改变。RISC OS 的 32 位版本也不会立刻变异。所以利用这些，我们可以设计一种支持两种版本的方案。这将远远超出 APCS，对于 RISC OS 的 32 位版本你需要使用 MSR 来处理状态和模式位，而不是使用 TEQP。许多现存的 API 实际上不需要保护标志位。所以在我们的 32 版本中可以通过把 `MOVS PC,...` 变成 `MOV PC,...`，和把 `LDM {...}^` 变成 `LDM {...}`，并重新建造来解决。objasm 汇编器(v3.00 和以后)有一个 `{CONFIG}` 变量可以是 `26` 或 `32`。可以使用它建造宏...

my_function_name
            MOV     ip, sp
            STMFD   sp!, {fp, ip, lr, pc}
            SUB     fp, ip, #4
    
            ...处理...
    
            [ {CONFIG} = 26
              LDMEA   fp, {fp, sp, pc}^
            |
              LDMEA   fp, {fp, sp, pc}
            ]

我未测试这个代码。它(或类似的东西)好象是保持与两个版本的 APCS 相兼容的最佳方式，也是对 RISC OS 的不同版本，26 位版本和将来的 32 位版本的最佳方法。

测试是否处于 32 位? 如果你要求你的代码有适应性，有一个最简单的方法来确定处理器的 PC 状态：

TEQ     PC, PC     ; 对于 32 位是 EQ；对于 26 位是 NE

使用它你可以确定:

*  26 位 PC，可能是 APCS-R 或 APCS-32。
 *  32 位 PC，不能 APCS-R。所有 26-bit 代码(TEQP 等)面临着失败!

# [《Procedure Call Standard for the ARM® Architecture》之（5.1）][Procedure Call Standard for the ARM_ Architecture_5.1] #

本文基于以下版本

Document number: ARM IHI 0042F, current through ABI release 2.10

Date of Issue: 24th November 2015

声明：以下翻译限于个人学识水平，个别语句也加入了个人理解。原文参见：

http://infocenter.arm.com/help/topic/com.arm.doc.ihi0042f/IHI0042F\_aapcs.pdf

5 基本过程调用规范

本节定义一种机器级别的（machine-level）、核心寄存器（core-registers-only）相关的过程调用规范。此规范同时适用于ARM和Thumb指令集。此规范可用于没有浮点硬件部分，或者需要与Thumb指令高度交互的系统。

5.1 寄存器

ARM架构定义了一套核心指令集，外加协处理器相关的指令集。核心指令集可以访问核心寄存器。协处理器提供了更多的寄存器，这些寄存器可以完成特定的操作。

5.1.1 核心寄存器

ARM和Thumb指令集中包含16个32bit的核心寄存器，标号依次是r0-r15或者R0-R15。这些寄存器名称以大写或者小写形式出现在汇编语言中。此规范约定：若在过程调用中，寄存器功能固定（has a fixed role），那么使用大写形式。下表概括了核心寄存器的使用。除此之外，还有一个程序状态寄存器（CPSR）。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1aGVueW91eXV5b3V5dQ_size_16_color_FFFFFF_t_70][]

r0-r3用于向跳转过程传递参数，并存储返回结果。它们也用于暂存运算的中间结果。

r12（IP）可以记录对子程序调用的调用。也可以用来保存一个程序在调用子程序的中间结果。其使用详细参见5.3.1.1。

r9的使用与平台有关。某个平台可以将它作任何用途，同时要有对这些用途的说明文档。例如，在位置无关的数据模型中，可以把它指定位静态基准（static base, SB）。也可以在本地线程存储（thread-local storage）环境中，把它指定作线程寄存器（thread register）。在某些时候，在所有调用过程中，我们期望r9的值固定不变。若不需要r9包含不变的值，可以仅仅把用它存储变量的值（别名v6）。

r4-r8，r10和r11典型用途是存储函数体中的局部变量。其中，只有r1-r4能够用于所有的Thumb指令集。但是AAPCS并不限定Thumb只能使用这些寄存器。

子程序必须保存r4-r8，r10，r11和SP的内容（若r9用于v6，也必须被保存起来）。

r12-r15均作特殊的用途，分别是IP，SP，LR和PC。

CPSR是一个全局寄存器，特性如下：

a) N，Z，C，V和Q比特位（bits 27-31），以及GE（3:0）（bits 16-19）在调用发生时和从调用返回时没有被定义。在程序执行时出现对应状态时，Q和GE（3:0）可能会被修改。

b) ARM6体系中，little-endian或者big-endian-8模式（临时改变字节存储顺序）下使用比特位E（bit8）。任何程序都需要被指定字节序。发生过程调用或者从过程调用中返回时，E的设置值需要与程序的字节序保持一致。

c) 比特T（bit5）和比特J（比特24）是程序执行状态位。只有特定的指令可以修改它们。

d) 比特A, I, F 和 M\[4:0\] bits (bits 0-7)是权限标志位，只能被特权模式下的程序修改。

e) 其他的比特位被保留且不能被修改。它们的状态没有被定义。

5.1.1.1 bit数多于32的数据处理

一个函数的参数可能是多于32bits的基本数据类型数据。也可能一个函数返回数据类型多于32bits。这种情况下作如下处理：

a) 双字在两个连续的寄存器中保存。此时寄存器中的值相当于使用LDM指令从存储器中加载出来的值。

b) 128 bits的矢量数据保存在连续4个寄存器中。此时寄存器中的值相当于使用LDM指令从存储器中加载出来的值。

5.1.2 协处理器寄存器

协处理指令空间可以操作更多的寄存器。从某种程度上来说，这些寄存器不用于传递参数或者保存返回参数。协处理器寄存器的使用与此标准是兼容的。每一个协处理器都应该提供如何操作这些寄存器的规范。

注意：虽然协处理器寄存器不用于传递函数参数或者返回函数值，但是运行时的某些元素需要知道一个程序中所有使用的协处理器，以正确执行。

5.1.2.1 VFP寄存器规范

VFP-V2协处理器有32个单精度寄存器，s0-s31。也可以被当做16个双精度寄存器d0-d14使用（d0对应s0+s1；d1对应s2+s3，以此类推）。此外，根据不同的实现，还包含3个或者更多系统寄存器。VFP-V3扩充16个双精度寄存器d16-d31。但是并没有对应扩充单精度寄存器。SIMD扩展使用VFP寄存器组。64bits数据类型时使用双精度寄存器。对于128bits类型数据，使用四字寄存器（q0对应d0和d1；q1对应d2和d3，以此类推）。

发生过程调用时s16-s31 (d8-d15, q4-q7)必须被保存。 s0-s15 (d0-d7, q0-q3)则不需要被保存（这些寄存器可用来保存传递参数和函数返回值）。d16-d31 (q8-q15)在函数调用时也不需要被保存。

FPSCR是协处理器的状态寄存器。它是全局寄存器。特性如下：

a) 条件码比特（bits (28-31)，cumulative saturation (QC) bit (27) 和cumulative exception-status bits (0-4)不需要再调用发生时保存。

b) exception-control bits (8-12), rounding mode bits (22-23) 和flush-to-zero bits (24)，当调用某些影响全局状态的函数时，可能会被修改。

c) length bits (16-18) 和 stride bits (20-21)，调用函数时和从子程序返回时，必须是全0。

d) 其他bits被保留没有被使用。对于它们的状态，spec没有定义。

[APCS_ARM _ARM Procedure Call Standard_]: https://blog.csdn.net/itismine/article/details/4752489
[Procedure Call Standard for the ARM_ Architecture_5.1]: https://blog.csdn.net/linglingzhan/article/details/52884196
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1aGVueW91eXV5b3V5dQ_size_16_color_FFFFFF_t_70]: /images/20220331/7d9b90b9e2dc4fb09eba70cb4fd3f474.png