Question

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

运行我的代码时

g++ filename -O1

它正在编译并且正常运行但是当我尝试使用

时也是如此

clang++-3.6 filename -O1

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

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

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

您可以检查我的代码More Details You can Visit Official Genymotion Website.（我的编译器产生的错误）

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时总是会使用结果，因此不需要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。

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

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

1 个答案: