Segfault函数终止

Question

我有一个用64位x86汇编(用于gcc和GAS的AT&T语法)编写的函数，它执行一些SSE2操作。我已经通过使用gdb和反汇编并查看寄存器值来检查结果，所以我知道它正在产生正确的结果。在retq指令之后，我得到了一个分段错误。由于我对汇编还不熟悉(而且从来没有接触过它的任何类)，所以我猜我没有正确地处理函数/主程序接口。该函数接受2个指针和一个int，并期望返回一个浮点数。这是我在汇编函数中处理输入/输出的方式：

float foo(float *x,float *y,unsigned int s)
{
    __asm__ __volatile__(
    "movl   -0x14(%%rbp),%%ecx \n\t"   //ecx = s
    "movq   -0x8(%%rbp),%%rax \n\t"    //rax -> x
    "movq   -0x10(%%rbp),%%rdx \n\t"   //rdx -> y
    "subq   $4,%%rsp \n\t"             //function result
    #sse2 operations that end up with the answer in xmm4...
    "movss  %%xmm4,(%%rsp) \n\t"       //store result
    "flds   (%%rsp) \n\t"              //load function result
    "addq   $4,%%rsp \n\t"             //adjust stack
    "ret \n\t"
    :
    :"g"(s)
    :"%ecx","%rax","%rdx"
    );
}

下面这行似乎导致了segfault (这是反汇编中ret之后的指令)：

0x00007fffffffe0d0 in ?? ()
=> 0x00007fffffffe0d0:  00 00   add    %al,(%rax)

我不知道为什么在执行完我的函数后，它会把rax的低位的值加回rax，但它似乎会让事情崩溃。我不允许在我的汇编函数中使用rax吗，即使它是通用的，并且我声明它是被破坏的？

我不确定您是否需要查看这一部分，但这就是gcc期望如何处理该函数；我已经包含了调用我的函数的代码行的反汇编：

    #asm dealing with function inputs
    callq  0x400520 <foo>
    movss  %xmm0,-0x48(%rbp)
    mov    -0x48(%rbp),%eax
    mov    %eax,-0x34(%rbp)

这就引出了我的第二个问题，为什么它随意地将xmm0中的值移动到两位？我是否应该让我的函数以xmm0结尾，或者这是否意味着我应该避免使用xmm0？我很困惑，如果能帮上忙我会很感激。提前感谢那些花时间阅读我的noob帖子的人:)

Answer 1

您的问题是内联程序集不会替换函数。您的函数编译为：

_foo:
 push   %rbp              ; function prologue
 mov    %rsp,%rbp
 mov    %rdi,-0x8(%rbp)
 mov    %rsi,-0x10(%rbp)
 mov    %edx,-0x14(%rbp)
 mov    -0x14(%rbp),%eax
 mov    %eax,-0x1c(%rbp)

 mov    -0x14(%rbp),%ecx  ; your code
 mov    -0x8(%rbp),%rax
 mov    -0x10(%rbp),%rdx
 sub    $0x4,%rsp
 movss  %xmm4,(%rsp)
 flds   (%rsp)
 add    $0x4,%rsp
 retq                     ; your return

 movss  -0x18(%rbp),%xmm0 ; function epilogue
 pop    %rbp
 retq                     ; gcc's return

retq弹出堆栈的一个值，并跳转到它。如果一切顺利，这是一个由callq推送的值。gcc生成了一个包含push %rbp的函数前言(上面的前两条指令)。因此，当您的retq运行时，它会弹出rbp (指向堆栈的指针)，并跳转到它。这可能会导致分段错误，因为堆栈是不可执行的(也可能是因为%rax是无效指针，如果出于某种原因，您的堆栈是可执行的)。它碰巧指向的堆栈上的值是00 00 (不出所料，它们在内存中显示得很多)，并巧合地反汇编为add %al,(%rax)。

现在，我是SSE的新手，而且我只使用过几次GCC内联汇编，所以我不确定这是否是一个有效的解决方案。你真的不应该查看堆栈，或者返回，因为不同的编译器会有不同的函数，在你的代码运行时，参数在堆栈上的相对位置。

尝试如下所示：

#include <stdio.h>

float foo(float *x,float *y,unsigned int s)
{
    float result;

    __asm__ __volatile__(
    "movss  (%%rax),%%xmm4 \n\t"       // xmm4 = *x
    "movss  (%%rdx),%%xmm5 \n\t"       // xmm5 = *y
    "addss  %%xmm5,%%xmm4  \n\t"       // xmm4 += xmm5

    "movss  %%xmm4,(%%rbx) \n\t"       // result = xmm4
    :
    :"c"(s), "a"(x), "d"(y), "b"(&result)  // ecx = s, eax = x, edx = y, ebx = &result
    :"memory", "cc"
    );

    return result;
}

int main() {
    float x = 1.0, y = 2.0;
    printf("%f", foo(&x, &y, 99));
    return 0;
}

所有的堆栈分配，参数处理和返回都是在C中完成的，它还传入一个指针来存储浮点结果。

这将生成以下程序集，这大致就是您要查找的程序集：

_foo:
 push   %rbp              ; prologue
 mov    %rsp,%rbp
 push   %rbx

 lea    -0xc(%rbp),%rbx   ; set up registers
 mov    %edx,%ecx
 mov    %rdi,%rax
 mov    %rsi,%rdx

 movss  (%rax),%xmm4      ; your code
 movss  (%rdx),%xmm5
 addss  %xmm5,%xmm4
 movss  %xmm4,(%rbx)

 movss  -0xc(%rbp),%xmm0  ; retrieve result to xmm0 (the return register)

 pop    %rbx              ; epilogue
 pop    %rbp
 retq   

另一种选择是始终将其写入程序集文件中，并在以后将其与C代码链接。

我希望这会对你有所帮助，但如果它没有完全回答你的问题，我很抱歉。

编辑：将代码更新为实际为我运行的代码。