如何比较 32 位字符和 32 位字符，内联汇编 C++ [关闭]

Question

我想比较两个 4 字符的字符串。例如“A”、“T”、“T”、“C” 反对“A”、“T”、“T”、“c”。我已将这些字符存储在 C++ 中的一个数组中，我想在一条指令中比较这两个单词。此外，我不想使用循环进行比较。如何将这些单词存储在“eax”和“ebx”寄存器中并相互比较？

int _tmain()
{
char b[3],a[3];
b[0]='A',b[1]='T',b[2]='C',b[3]='G';
a[0]='A',a[1]='T',a[2]='C',a[3]='G';
__asm
{
    movzx eax,b[1]  //here i want to load b to eax
}
getchar();
return 0;
}

如果有其他想法可以在一条指令中比较两个单词，请分享，谢谢。

Answer 1

这个答案的其余部分假设您需要使用内联汇编来完成一些家庭作业（因为它不会比智能编译器内联的效率更高一个 4 字节的 memcmp)。请参阅@MartinYork 的答案，了解 gcc/clang 对 4 字节 memcmp 的作用。但令人惊讶的是，只有 gcc7 及更高版本内联了常量大小的memcmp。至少回到 3.5 的 Clang 可以做到这一点。

MSVC 2017 还内联 memcmp 以获得恒定的 4 字节大小，以及 std::array 运算符 ==，生成与 gcc/clang 相同的 asm。 （我没有测试早期版本）。见纯C++版本on the Godbolt compiler explorer。

---

从 char 数组加载双字的必要语法是 dword ptr 大小覆盖。

// true for equal, false for not-equal
bool foo()
{
    //char a[] = "ACTG";
    char a[] = {'A', 'C', 'T', 'G'};
    char b[] = {'A', 'T', 'T', 'G'};
    _asm {
        mov eax, dword ptr a       // mov eax, a   would complain 
        cmp eax, dword ptr b
        sete al                    // al= 0 or 1 depending on ZF, the "e" condition like je
    }
    // falling off the end of a non-void function implicitly returns EAX
    // apparently this is supported in MSVC even when inlining
}

作为一个完整的函数，编译如下，with MSVC 19, 2017, with -Ox on the Godbolt compiler explorer：

 ;; define a couple assembler constants for use
_a$ = -8                                                ; size = 4
_b$ = -4                                                ; size = 4
foo PROC
        sub      esp, 8
        mov      DWORD PTR _a$[esp+8], 1196704577 ; 47544341H
        mov      DWORD PTR _b$[esp+8], 1196708929 ; 47545441H
  ;; inline asm block starts here
        mov      eax, DWORD PTR _a$[esp+8]
        cmp      eax, DWORD PTR _b$[esp+8]
        sete     al
  ;; and ends here
        add      esp, 8
        ret      0
foo ENDP

前 2 条mov 指令由编译器生成，将 4 字节数组以 dword MOV-immediate 的形式存储到堆栈中。

如果你想返回一个 0 / 非 0 int 而不是一个 0 / 1 bool，你可以使用 @P__J__ 的 mov / sub 的建议，而不是在 cmp 之后检查标志.两个相等的双字将离开寄存器 0，其他任何东西都不会。 （xor 具有相同的属性。）

---

如果您想比较作为函数 arg 获得的 char* 的 4 个字节，它将是一个指针，而不是 C 数组，因此您必须自己将指针加载到内联 asm 中的寄存器中。 （即使编译器已经在寄存器中有指针；MSVC 内联 asm 语法对于小块基本上很烂，因为它强制为输入和输出进行存储/重新加载往返（约 5 个延迟周期），除非您可以使用显然- 支持在 EAX 中留下一些东西并从非 void 函数的末尾脱落。另请参阅 What is the difference between 'asm', '__asm' and '__asm__'? 与 GNU C 内联 asm 的比较，这使得在寄存器中请求输入并在寄存器中产生多个输出变得容易，允许编译器尽可能地优化。当然它仍然会破坏常量传播；如果你使用memcmp，编译器可以只使用return 0，因为数组具有编译时常量内容。https://gcc.gnu.org/wiki/DontUseInlineAsm)

无论如何，这是比较函数 args 的前 4 个字节得到的结果：

char bar(char *a, char *b)
{
    // a and b are pointers, not arrays
    _asm {
        mov eax, a              // loads the address
        mov eax, [eax]          // loads 4 bytes of data
        mov ecx, b
        cmp eax, [ecx]
        sete al
    }
}

bar PROC
        mov      eax, DWORD PTR _a$[esp-4]
        mov      eax, DWORD PTR [eax]
        mov      ecx, DWORD PTR _b$[esp-4]
        cmp      eax, DWORD PTR [ecx]
        sete     al
        ret      0

如果您使用-Gv 或其他任何方式进行编译以启用在寄存器中传递 args 的更好调用约定，实际上会更糟：编译器必须将指针 args 溢出到堆栈中以便 asm 重新加载他们，而不是变成一个 reg-reg 移动。 AFAIK，无法通过强制转换或其他任何方式让编译器为您将指针加载到寄存器中，因此您可以直接在内联 asm 中引用数组内容。

Answer 2

首先，您的阵列存在严重问题。您将数组定义为包含 3 个元素，但您尝试将 4 个元素填充到数组中。这真的很糟糕，会导致未定义的行为。

除此之外...放下程序集！ lib 函数将（在几乎所有情况下）执行您在汇编中可以执行的操作。换句话说 - 只需使用memcmp

喜欢：

int main()
{
    char b[4],a[4];
    b[0]='A',b[1]='T',b[2]='C',b[3]='G';
    a[0]='A',a[1]='T',a[2]='C',a[3]='G';

    if (memcmp(a, b, sizeof(a)) == 0)
         printf("Equal\n");
    else
         printf("Different");

    return 0;
}

Answer 3

我要说的是，在汇编中这样做是个坏主意。

您应该使用高级语言结构。这将允许代码是可移植的，当推来推去时，编译器将在任何像这样的窥孔优化中击败“大多数”人类。

所以我检查了 g++ 的输出，看看它生成了什么程序集。

main.cpp

#include <array>
#include <iostream>

bool testX(int a, int b);
bool testY(std::array<char, 4> const& a, std::array<char, 4> const& b);
bool testZ(char const(&a)[4], char const(&b)[4]);

int main()
{
    {
        int a = 'ATCG';
        int b = 'ATCG';
        if (testX(a, b)) {
            std::cout << "Equal\n";
        }
    }
    {
        std::array<char, 4> a {'A', 'T', 'C', 'G'};
        std::array<char, 4> b {'A', 'T', 'C', 'G'};
        if (testY(a, b)) {
            std::cout << "Equal\n";
        }
    }
    {
        char    a[] = {'A', 'T', 'C', 'G'};
        char    b[] = {'A', 'T', 'C', 'G'};

        if (testZ(a, b)) {
            std::cout << "Equal\n";
        }
    }
}

启用优化后，我们可以从 clang 获得不错的 asm，通常来自最近的 gcc on the Godbolt compiler explorer。 （如果函数可以内联，上面的 main 将优化比较，因为输入是编译时常量。）

X.cpp

bool testX(int a, int b)
{
    return a == b;
}

# gcc and clang -O3 asm output
testX(int, int):
    cmpl    %esi, %edi
    sete    %al
    ret

Z.cpp

#include <cstring>

bool testZ(char const(&a)[4], char const(&b)[4])
{
    return std::memcmp(a, b, sizeof(a)) == 0;
}

Z.s

# clang, and gcc7 and newer, -O3
testZ(char const (&) [4], char const (&) [4]):
    movl    (%rdi), %eax
    cmpl    (%rsi), %eax
    sete    %al
    retq

Y.cpp

#include <array>

bool testY(std::array<char, 4> const& a, std::array<char, 4> const& b)
{
    return a == b;
}

Y.s

# only clang does this.  gcc8.2 actually calls memcmp with a constant 4-byte size
testY(std::array<char, 4ul> const&, std::array<char, 4ul> const&):           
    movl    (%rdi), %eax
    cmpl    (%rsi), %eax
    sete    %al
    retq

因此，用于比较 4 字节对象的 std::array 和 memcmp 都使用 clang 生成相同的代码，但仅使用 gcc 时 memcmp 优化得很好。

---

当然，该函数的独立版本必须实际产生一个 0 / 1 整数，而不是仅仅为 jcc 设置标志以直接分支。这些函数的调用者必须在分支之前test %eax,%eax。但如果编译器可以内联这些函数，那么这种开销就会消失。

Answer 4

类似这样的：

asm{

mov eax,'A'
mov ebx,'C'

 cmp eax,ebx
 JAE input_a
** here you print that 'A' <= 'C'  **
jump endofMain
input_a:
** here you print that 'A' >= 'C'  **
endofMain: 
}
return 0;

Answer 5

int main()
{
volatile char b[4],a[4];
b[0]='A';b[1]='T';b[2]='C';b[3]='G';
a[0]='A';a[1]='T';a[2]='C';a[3]='G';

uint32_t val;


__asm__("movl %0, %%eax;" : "=m" (a) : "m" (a));
__asm__ ( "subl %1, %%eax;" : "=a" (val) : "m" (b) );

printf("%s\n", !val ? "Equal" : "Not equal");

}