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

Question

我正在尝试学习内联汇编，并且我在汇编中实现了 Euclid 算法!现在，当我尝试使用

运行我的代码时

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 在 block 退出时将在 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 在调用 block 之前将 var1 和 var2 放入 eax 和 ebx，而不是您在 block 内手动执行:

__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 时总是使用结果，因此 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 来写，但我只是假设你有一个很好的理由。