how to compare 32 bit char against 32 bit char in, inline assembely c++

Question

I want to compare two 4-char strings . for example "A","T","T","C" against "A","T","T","c". I have stored these chars in an array in c++ and I want to compare this two words in an instruction. moreover, I don't want to use loops for comparison. how can I store this words in "eax" and "ebx" register and compare to each other?

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

if there is another idea for comparing two words in a single instruction please share thank you.

Answer 1

The rest of this answer is assuming you need to use inline asm for some homework assignment (because it will not be more efficient than what a smart compiler will inline for a 4-byte memcmp). See @MartinYork's answer for what gcc/clang do for a 4-byte memcmp. But surprisingly, only gcc7 and later inlines the constant-size memcmp. Clang at least back to 3.5 manages that.

MSVC 2017 also inlines memcmp for a constant 4-byte size, and std::array operator ==, producing the same asm as gcc/clang. (I didn't test earlier versions). See the pure C++ version on the Godbolt compiler explorer.

---

The necessary syntax to load a dword from a char array is a dword ptr size override.

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

As a complete function, this compile as follows, 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

The first 2 mov instruction are generated by the compiler, storing the 4-byte arrays to the stack with dword MOV-immediate.

If you want to return a 0 / non-0 int instead of a 0 / 1 bool, you can use @P__J__'s suggestion of mov / sub instead of checking flags after a cmp. Two equal dwords will leave the register 0, anything else won't. (xor has the same property.)

---

If you wanted to compare 4 bytes of a char* that you got as a function arg, it would be a pointer, not a C array, so you have to load the pointer into a register yourself in inline asm. (Even if the compiler already has the pointers in registers; MSVC inline asm syntax basically sucks for small blocks because it forces a store/reload round-trip (~5 cycles of latency) for inputs, and for output unless you can use the apparently-supported hack of leaving something in EAX and falling off the end of a non-void function. See also What is the difference between 'asm', '__asm' and '__asm__'? for a comparison with GNU C inline asm, which makes it easy to ask for inputs in registers and produce multiple outputs in registers, allowing the compiler to optimize as much as possible. Of course it still defeats constant-propagation; if you used memcmp the compiler could just return 0 because the arrays have compile-time constant contents. https://gcc.gnu.org/wiki/DontUseInlineAsm)

Anyway, this is what you get for comparing the first 4 bytes of function args:

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

And it's actually worse if you compile with -Gv or whatever to enable a better calling convention that passes args in registers: the compiler has to spill the pointer args to the stack for asm to reload them, instead of it turning into a reg-reg move. AFAIK, there's no way via casting or whatever to get the compiler to load pointers into registers for you so you can reference the array contents directly in inline asm.

Answer 2

To start with you have a serious problems with your arrays. You define the arrays to hold 3 elements but you try to fill 4 elements into the arrays. That's real bad and cause undefined behavior.

Besides that... drop the assembly! The lib functions will (in nearly all cases) out perform what you can do in assembly. In other words - just use memcmp

Like:

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

I am going to say that doing it in assembly is a bad idea.

You should be using high level language constructs. This will allow the code to be portable and when push comes to shove the compiler will beat "most" humans at any peephole optimization like this.

So I checked the output of g++ to see what assembly it generated.

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

With optimization enabled, we get nice asm from clang, and usually from recent gcc on the Godbolt compiler explorer. (The main above would optimize away the compares if the functions can inline, because the inputs are compile-time constants.)

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

So std::array and memcmp for comparing 4-byte objects both produce identical code with clang, but with gcc only memcmp optimizes well.

---

Of course, the stand-alone version of the function has to actually produce a 0 / 1 integer, instead of just setting flags for a jcc to branch on directly. The caller of these functions will have to test %eax,%eax before branching. But if the compiler can inline these functions, that overhead goes away.

Answer 4

something like this:

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

}