使用内联汇编优化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

铛错误

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;
}

您可以在此处检查我的代码（由我的编译器产生的错误）

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"
    );

使用％=将唯一的数字添加到标识符以避免冲突。 并且由于寄存器和标志的内容正在修改，因此您需要通过“笼罩”它们来告知编译器该事实。

但是您还可以执行其他一些操作，以使此操作更快，更干净。 例如，您可以告诉gcc当块退出时， result将在eax中，而不是在最后进行movl %%eax, %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%=:"
        :"=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等的详细信息，请查看内联asm的官方gcc文档 。

我想我应该问一个问题，为什么您觉得需要用asm编写而不是仅仅用c编写，但是我假设您有充分的理由。