Question

这个程序编译得很好，但是当我输入mult（x，y）的第一个参数的负数时，无法执行。它显示消息＆＃34; Segmentation fault：11＆＃34;。我在Windows上试过它并且运行正常。

我在X代码中编译它时的错误消息是：线程1：EXC_BAD_ACCESS（代码= 2，地址= 0x7fff5f3ffffc）

为什么这不适用于OSX（El Capitan），但在Windows上却不错？非常感谢！

#include <stdio.h>

signed succ(signed a)
{
    return a+1;
}

signed pre(signed b)
{
    return b-1;
}

signed add(signed c, signed d)
{

    if(d == 0) return c;

    return succ(add(c, pre(d)));

}


signed sub(signed e, signed f)
{
    if(f == 0) return e;

    return pre(sub(e, pre(f)));
}



signed mult(signed g, signed h)
{
    if(h == 0 || g == 0) return 0;

    return add(g,mult(g,pre(h)));
}


int main()
{


    printf("mult -2,2: %i\n", mult(-2,2));


    return 0;
}

Answer 1

由于堆栈溢出而崩溃，递归调用mult和add函数。

虽然最好使用调试器，但在每个函数中添加printf可以帮助观察程序流程。例如，将mult更改为：

signed mult(signed g, signed h)
{
    printf(" mult %d %d\n", g, h);
    if(h == 0 || g == 0) return 0;

    return add(g,mult(g,pre(h)));
}

和其他功能类似......输出是：

mult -2 2
pre 2
mult -2 1
pre 1
mult -2 0
add -2 0
add -2 -2
pre -2
add -2 -3
pre -3
add -2 -4
pre -4
add -2 -5
pre -5
add -2 -6
pre -6
add -2 -7
pre -7
add -2 -8
pre -8
add -2 -9
pre -9
add -2 -10
...

并继续调用add，第二个参数递减，直至崩溃。只有当该参数溢出时，if(d == 0)中的条件add才会变为true（在sizeof signed为4的情况下，即超过40亿次迭代后将发生这种情况，即32位）。

当它工作时，我唯一能想到的是编译器正在进行优化并可能删除函数调用。在我的Windows x64计算机上尝试原始程序，使用MinGW中的gcc构建：

在使用gcc file.c
使用gcc -O3 file.c构建时成功运行（此处我更改了优化级别）。

在使用-O3构建的可执行文件上，我运行了objdump -S a.exe > a.lst，这是mult函数已反汇编：

0000000000401550 <mult>:
  401550:   53                      push   %rbx
  401551:   48 83 ec 20             sub    $0x20,%rsp
  401555:   31 c0                   xor    %eax,%eax
  401557:   85 d2                   test   %edx,%edx
  401559:   89 cb                   mov    %ecx,%ebx
  40155b:   75 06                   jne    401563 <mult+0x13>
  40155d:   48 83 c4 20             add    $0x20,%rsp
  401561:   5b                      pop    %rbx
  401562:   c3                      retq   
  401563:   85 c9                   test   %ecx,%ecx
  401565:   74 f6                   je     40155d <mult+0xd>
  401567:   83 fa 01                cmp    $0x1,%edx
  40156a:   75 08                   jne    401574 <mult+0x24>
  40156c:   01 d8                   add    %ebx,%eax
  40156e:   48 83 c4 20             add    $0x20,%rsp
  401572:   5b                      pop    %rbx
  401573:   c3                      retq   
  401574:   83 fa 02                cmp    $0x2,%edx
  401577:   89 c8                   mov    %ecx,%eax
  401579:   74 f1                   je     40156c <mult+0x1c>
  40157b:   83 ea 03                sub    $0x3,%edx
  40157e:   e8 cd ff ff ff          callq  401550 <mult>
  401583:   85 c0                   test   %eax,%eax
  401585:   74 0b                   je     401592 <mult+0x42>
  401587:   01 d8                   add    %ebx,%eax
  401589:   74 0d                   je     401598 <mult+0x48>
  40158b:   01 d8                   add    %ebx,%eax
  40158d:   01 d8                   add    %ebx,%eax
  40158f:   90                      nop
  401590:   eb dc                   jmp    40156e <mult+0x1e>
  401592:   89 d8                   mov    %ebx,%eax
  401594:   01 d8                   add    %ebx,%eax
  401596:   eb f5                   jmp    40158d <mult+0x3d>
  401598:   89 d8                   mov    %ebx,%eax
  40159a:   01 d8                   add    %ebx,%eax
  40159c:   eb d0                   jmp    40156e <mult+0x1e>
  40159e:   90                      nop
  40159f:   90                      nop

可以看出，它不会调用任何其他函数，只能调用它自己（callq 401550 <mult>）。因此编译器优化/内联所有其他调用。通过添加printf（但仅在此函数中，不中断优化），输出为：

 mult -2 2
 mult -2 1
 mult -2 0
mult -2,2: -4

Answer 2

看起来优化器中存在盲点。我认为代码应该崩溃。查看优化代码会很有趣。我看不出会导致优化器混淆的原因。也许优化器不会考虑可能发生的符号翻转。因此，假设负数减去1总是负数，例如......

我不断得到＆＃34;分段错误：11＆＃34;在OSX上的gcc中，但适用于Windows

2 个答案: