使用内联汇编优化 C++ 代码时出错

Question

我正在尝试学习内联汇编，并在汇编中实现了欧几里得算法！现在，当我尝试使用

运行我的代码时

g++ filename -O1

它正在编译并运行良好，但是当我尝试对

做同样的事情时

clang++-3.6 filename -O1

代码正在编译但产生分段错误！

当我尝试使用 -O2 或更高标志运行我的代码时，gcc 和 clang 也会产生编译时错误！

g++ 错误

eculid.cpp: Assembler messages:
eculid.cpp:19: Error: symbol `CONTD' is already defined
eculid.cpp:19: Error: symbol `DONE' is already defined

clang 错误

eculid.cpp:7:5: error: invalid symbol redefinition
                            "movl %1, %%eax;"
                            ^
<inline asm>:1:34: note: instantiated into assembly here
    movl %eax, %eax;movl %ecx, %ebx;CONTD: cmpl $0, %ebx;je DONE;xor...
                                    ^
eculid.cpp:7:5: error: invalid symbol redefinition
                            "movl %1, %%eax;"
                            ^
<inline asm>:1:132: note: instantiated into assembly here
  ...%edx;idivl %ebx;movl %ebx, %eax;movl %edx, %ebx;jmp CONTD;DONE: movl %ea...
                                                           ^
2 errors generated.

这是我的代码

#include <iostream>
using namespace std;

int gcd(int var1, int var2) {
    int result = 0;
    __asm__ __volatile__ (
            "movl %1, %%eax;"
            "movl %2, %%ebx;"
            "CONTD: cmpl $0, %%ebx;"
            "je DONE;"
            "xorl %%edx, %%edx;"
            "idivl %%ebx;"
            "movl %%ebx, %%eax;"
            "movl %%edx, %%ebx;"
            "jmp CONTD;"
            "DONE: movl %%eax, %0;"
            :"=r"(result)
            :"r"(var1), "r"(var2)
        );
    return result;
}

int main(void) {

    int first = 0, second = 0;
    cin >> first >> second;
    cout << "GCD is: " << gcd(first, second) << endl;

    return 0;
}

你可以检查我的代码here（我的编译器产生同样的错误）

Answer 1

只是将其放入答案形式以便可以关闭问题（如果它回答了您的问题，请单击此答案旁边的复选标记），最简单的是，您需要像这样更改您的代码：

__asm__ __volatile__ (
        "movl %1, %%eax;"
        "movl %2, %%ebx;"
        "CONTD%=: cmpl $0, %%ebx;"
        "je DONE%=;"
        "xorl %%edx, %%edx;"
        "idivl %%ebx;"
        "movl %%ebx, %%eax;"
        "movl %%edx, %%ebx;"
        "jmp CONTD%=;"
        "DONE%=: movl %%eax, %0;"
        :"=r"(result)
        :"r"(var1), "r"(var2)
        : "eax", "ebx", "edx", "cc"
    );

使用 %= 为标识符添加一个唯一编号以避免冲突。而且由于寄存器和标志的内容正在被修改，您需要通过“破坏”它们来告知编译器这一事实。

但是您还可以做一些其他的事情来让这个过程更快一点，更干净一点。例如，不要在最后做movl %%eax, %0，你可以告诉gcc当块退出时result将在eax中：

__asm__ __volatile__ (
        "movl %1, %%eax;"
        "movl %2, %%ebx;"
        "CONTD%=: cmpl $0, %%ebx;"
        "je DONE%=;"
        "xorl %%edx, %%edx;"
        "idivl %%ebx;"
        "movl %%ebx, %%eax;"
        "movl %%edx, %%ebx;"
        "jmp CONTD%=;"
        "DONE%=:"
        :"=a"(result)
        :"r"(var1), "r"(var2)
        : "ebx", "edx", "cc"
    );

同样，您可以告诉 gcc 在调用块之前将 var1 和 var2 放入 eax 和 ebx 中，而不是在块内手动执行：

__asm__ (
        "CONTD%=: cmpl $0, %%ebx;"
        "je DONE%=;"
        "xorl %%edx, %%edx;"
        "idivl %%ebx;"
        "movl %%ebx, %%eax;"
        "movl %%edx, %%ebx;"
        "jmp CONTD%=;"
        "DONE%=:"
        :"=a"(result), "+b"(var2)
        : "a"(var1)
        : "edx", "cc"
    );

此外，由于您（可能）在调用 gcd 时总是使用 result，因此 volatile 是不必要的。如果您不使用结果，那么无论如何都没有必要强制进行计算。

正如所写，该语句的 -S 输出将是很长的一行，使调试变得困难。这使我们：

__asm__ (
   "CONTD%=:              \n\t"
      "cmpl $0, %%ebx     \n\t"
      "je DONE%=          \n\t"
      "xorl %%edx, %%edx  \n\t"
      "idivl %%ebx        \n\t"
      "movl %%ebx, %%eax  \n\t"
      "movl %%edx, %%ebx  \n\t"
      "jmp CONTD%=        \n"
   "DONE%=:"
   : "=a"(result), "+b"(var2)
   : "a"(var1)
   : "edx", "cc"
);

而且我认为没有特别的理由强制 gcc 使用 ebx。如果我们让 gcc 选择它自己的寄存器（通常会提供最佳性能），这给了我们：

__asm__ (
   "CONTD%=:              \n\t"
      "cmpl $0, %1        \n\t"
      "je DONE%=          \n\t"
      "xorl %%edx, %%edx  \n\t"
      "idivl %1           \n\t"
      "movl %1, %%eax     \n\t"
      "movl %%edx, %1     \n\t"
      "jmp CONTD%=        \n"
   "DONE%=:"
   : "=a"(result), "+r"(var2)
   : "a"(var1)
   : "edx", "cc"
);

最后，当循环完成时避免额外的跳转给我们：

__asm__ (
      "cmpl $0, %1        \n\t"
      "je DONE%=          \n"
   "CONTD%=:              \n\t"
      "xorl %%edx, %%edx  \n\t"
      "idivl %1           \n\t"
      "movl %1, %%eax     \n\t"
      "movl %%edx, %1     \n\t"
      "cmpl $0, %1        \n\t"
      "jne CONTD%=        \n"
   "DONE%=:"
   : "=a"(result), "+r"(var2)
   : "a"(var1)
   : "edx", "cc"
);

查看 gcc 的 -S 输出，这给了我们：

   /APP
        cmpl $0, %ecx
        je DONE31
   CONTD31:
        xorl %edx, %edx
        idivl %ecx
        movl %ecx, %eax
        movl %edx, %ecx
        cmpl $0, %ecx
        jne CONTD31
   DONE31:
   /NO_APP

与原始代码相比，此代码使用更少的寄存器、执行更少的跳转和更少的 asm 指令。 FWIW。

有关 %=、clobbers 等的详细信息，请查看官方 gcc docs 的内联汇编。

我想我应该问一下为什么你觉得有必要用 asm 来写而不是只用 c 来写，但我只是假设你有充分的理由。