x86-64 System V abi - 参数传递的参数分类

问题描述

第 3.2.3 节中的 x86_64 System V ABI 指定函数调用的哪些参数进入哪些寄存器，哪些被压入堆栈。我无法理解聚合分类的算法，它说（突出显示的是我的）：

聚合（结构和数组）和联合类型的分类工作如下：

如果一个对象的大小大于 8 个八字节，或者它包含未对齐的字段，则它具有类 MEMORY。
如果 C++ 对象对于调用而言是非平凡的，如 C++ ABI13 中所指定，则通过不可见引用传递（该对象在参数列表中被具有类 INTEGER 的指针替换）。立>
如果聚合的大小超过单个 8 个字节，将分别对每个字节进行分类。每个八字节都被初始化为 NO_CLASS 类。
对象的每个字段都被递归分类，以便始终考虑两个字段。 结果类是根据八字节中字段的类来计算的： (a) 如果两个类相等，这就是结果类。 (b) 如果其中一个类是 NO_CLASS，则结果类是另一个类。 (c) 如果其中一个类是 MEMORY，则结果是 MEMORY 类。(d) 如果其中一个类是 INTEGER，则结果是整数。 (e) 如果其中一个类是 X87、X87UP、COMPLEX_X87 类，则使用 MEMORY 作为类。(f) 否则使用类 SSE。
然后进行合并后清理： (a) 如果其中一个类 是 MEMORY，则整个参数在内存中传递。 (b) 如果 X87UP 前面没有 X87，则整个参数在内存中传递。 (c) 如果聚合的大小超过两个 8 字节并且第一个 8 字节不是 SSE 或任何其他 8 字节不是 SSEUP，则整个参数在内存中传递。 (d) 如果 SSEUP 前面没有 SSE 或 SSEUP，则转换为 SSE

我不明白第 (3)、(4) 和 (5) 点。具体来说，我有以下问题：

第一季度。在第 (3) 点中，“每个都单独分类”，作者的意思是“每个八字节”吗？如果是这样，那么我希望接下来是对八字节分类的解释。

第 2 季度。在第 (4) 点中，“对象的每个字段”是指“作为（在第 (3) 点中分离的结果的八字节的每个字段）吗？

第三季度。在第(4)点中，“总是考虑两个字段”中的“两个字段”是指两个连续的字段吗？

第四季度。在第 (4) 点中，“结果类”是指对象的类、八字节的类、第二个考虑的字段的类，还是其他的类？在最后一种情况下，结果类在哪里使用？这是否意味着算法保持第一个字段的字段不变，然后迭代计算下一个字段的类，直到我们在八字节中拥有所有字段的类？还是说我们算法一次处理两个字段？

问题 5。在第 (4) 点中，如果只有一个字段怎么办？还是偶数个字段？

Q6。在第 (5) 点中，字段或八字节的“类之一”？

如果有人可以提供更正式/更精确的东西 - 例如，伪代码或流程图 - 那将是理想的。

解决方法

见the gcc implementation。

对第 1 点的澄清（回应评论说“八是一个错字，应该是两个”）：

如果一个对象的大小大于 8 个八字节，或者它包含未对齐的字段，则它具有类 MEMORY。

      /* On x86-64 we pass structures larger than 64 bytes on the stack.  */
      if (bytes > 64)
        return 0;

该函数返回用于参数的寄存器数量，零表示应该使用内存。

（后来经过分析，如果有两个以上的八字节，只有第一个为SSE，其余为SSEUP时才使用寄存器，如5.(c)所指出：

第一季度。在第（3）点中，“每个都单独分类”，作者是指“每个八字节”吗？

是的。在代码中，每个八字节被称为一个word。

每个八字节都被初始化为类 NO_CLASS。

  int words = CEIL (bytes + (bit_offset % 64) / 8,UNITS_PER_WORD);
  // ...
      for (i = 0; i < words; i++)
        classes[i] = X86_64_NO_CLASS;

第 2 季度。在第 (4) 点中，“对象的每个字段”是指“作为（在第 (3) 点中分离的结果的八字节的每个字段）吗？

不，它们是指结构/类、联合或数组元素的每个字段。这些在代码中的几个地方处理，但您会看到 for 循环，如：

          for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))

这就是为什么它是递归的。字段本身可以是聚合类型。从每个字段和递归函数开始应用整个逻辑：

要么返回0，表示整个事情都在内存中传递，
或者它返回将使用的寄存器数量（8 个字节）以及每个寄存器的类（通过嵌套字段递归将在具有非聚合类型的字段处终止）。

                      num = classify_argument (TYPE_MODE (type),type,subclasses,(int_bit_position (field)
                                               + bit_offset) % 512);
                      if (!num)
                        return 0;

第三季度。在第(4)点中，“总是考虑两个字段”中的“两个字段”是指两个连续的字段吗？

我认为这里的“字段”不准确。并且不连续。它正在做的是合并到目前为止为每个 word 确定的类，并为对应于相同 word 的字段递归确定类。见下文：

                      pos = (int_bit_position (field)
                            + (bit_offset % 64)) / 8 / 8;
                      for (i = 0; i < num && (i + pos) < words; i++)
                        classes[i + pos]
                          = merge_classes (subclasses[i],classes[i + pos]);

从 pos（该字段所在的八字节）开始，每个类都与该字段的递归调用确定的子类合并。

第四季度。在第 (4) 点中，“结果类”是指对象的类、八字节的类、第二个考虑的字段的类，还是其他的类？

现在描述的是 merge_classes 函数，它接受两个类并返回八字节的合并类。我们正在迭代字段，但类是八字节的。

在最后一种情况下，结果类在哪里使用？

每个类都会确定对应寄存器的类型（GPR/SSE/X87等）。

问题 5。在第 (4) 点中，如果只有一个字段怎么办？还是偶数个字段？

我希望此时回答“两个字段”。例如，如果一个结构体有一个字段，则该类将针对该八字节初始化为 NO_CLASS，然后对于该字段，它将被确定为 INTEGER。然后在合并时，类将变为 INTEGER。

Q6。在第 (5) 点中，字段或八字节的“类之一”？

一个八字节。类总是指一个八字节。

abi abi c calling-convention linux linux x86-64