使用内联汇编优化 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 [=13=], %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 [=14=], %%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 [=10=], %%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"
    );

使用 %= 为标识符添加唯一编号以避免冲突。由于寄存器和标志的内容正在被修改，因此您需要通过 'clobbering' 它们将这一事实告知编译器。

但是您还可以执行其他操作，使它更快、更干净。例如，不用在最后做 movl %%eax, %0，你可以告诉 gcc 当块退出时 result 将在 eax 中：

__asm__ __volatile__ (
        "movl %1, %%eax;"
        "movl %2, %%ebx;"
        "CONTD%=: cmpl [=11=], %%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 [=12=], %%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 [=13=], %%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 [=14=], %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 [=15=], %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 [=15=], %1        \n\t"
      "jne CONTD%=        \n"
   "DONE%=:"
   : "=a"(result), "+r"(var2)
   : "a"(var1)
   : "edx", "cc"
);

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

   /APP
        cmpl [=16=], %ecx
        je DONE31
   CONTD31:
        xorl %edx, %edx
        idivl %ecx
        movl %ecx, %eax
        movl %edx, %ecx
        cmpl [=16=], %ecx
        jne CONTD31
   DONE31:
   /NO_APP

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

有关 %=、clobbers 等的详细信息，请查看官方 gcc docs for inline asm。

我想我应该问问你为什么觉得有必要用 asm 写这个而不是用 c 来写，但我假设你有一个很好的理由。

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

Error when optimizing C++ code with inline assembly

c++

g++

inline-assembly

clang++