How to write inline assembly to bit rotate

Question

I was reading gcc's guide on extended ASM and I'm running into a problem where the compiler isn't interpreting the assembly the way I thought it would. I thought I'd try it with a bit rotate instruction since those aren't readily available in C.

Here's my C function:

int rotate_right(int num,int count) {
    asm (
        "rcr %[value],%[count]"
        : [value] "=r" (num)
        : [count] "r" (count)
        );

    return num;
}

And the compiled output using x86-64 gcc (trunk) -O0:

        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], edi
        mov     DWORD PTR [rbp-8], esi
        mov     eax, DWORD PTR [rbp-8]
        rcr eax,eax
        mov     DWORD PTR [rbp-4], eax
        mov     eax, DWORD PTR [rbp-4]
        pop     rbp
        ret

The problem I'm having is that GCC is taking my inline assembly to mean "rotate EAX by EAX rather than by the count parameter I intended. This is what I expected to get:

        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], edi
        mov     DWORD PTR [rbp-8], esi
        mov     eax, DWORD PTR [rbp-8]
        mov     ecx, DWORD PTR [rbp-4]
        rcr     eax,ecx
        pop     rbp
        ret

Answer 1

First, let me solve your problem as stated in the title.

static inline int ror(int num, int count) {
  __asm__ ("ror\t%0, %b1" : "+r"(num) : "c"(count));
  return num;
}

ror(int, int):
        mov     eax, edi
        mov     ecx, esi
        ror     eax, cl
        ret

This is how you do it, and don't forget -masm=intel. I'll explain some details below, but basically, you have to read carefully the GCC docs.

---

Quoting the OP,

I really find gcc's inline asm syntax much worse than Visual Studio's. It's almost as if GCC is trying to discourage users from using assembly...

It's worse in a sense that it takes more time to learn, but after you know the details, it's a powerful tool for various low level programing and optimization.

One case I use inline assembly in an actual program is to use the rcpss instruction. There is an Intel intrinsic for it, but the current version of GCC (12.1) produces quite horrible code when you use it for a single float.

static inline float float_recip(float x) {
  if (__builtin_constant_p(x)) {
    return 1 / x;
  }
  __asm__ ("rcpss\t%0, %0" : "+x"(x));
  return x;
}

This is the actual code. __builtin_constant_p makes constant substitution possible when the value of x is known at compile-time. I intentionally put both operands the same to avoid the false dependency problem.

See how the assembly is generated when it's called somewhere.

float f(float x) {
  return float_recip(x) + float_recip(2);
}

f(float):
        rcpss   xmm0, xmm0
        addss   xmm0, DWORD PTR .LC0[rip]
        ret
.LC0:
        .long   1056964608

You can see float_recip(2) is replaced with a 0.5f constant, and all the unnecessary copies are gone.

You cannot do this with MSVC inline assembly, apart from that it's not even supported for 64-bit.

Answer 2

Use a +r constraint for num indicating that num will be read and not just written to. Otherwise gcc will assume that the previous value of num doesn't matter and just picks an unused register to dump the output into.

You'll also have to use a c constraint for count as the shift amount must be in cl for the ror instruction. Refer to the other answer for a more detailed explanation.

Before doing any inline assembly programming, read the manual carefully! It is somewhat tricky to get right and there are many subtle details to pay attention to.

Also note that even if the inline assembly seems to work right, it is possible to be incorrect, e.g. due to missing clobbers that just so happen to not affect anything relevant with this particular compiler version at this particular optimisation level for this particular version of the code. So be extra careful and try to avoid using it if possible.

For example in your case, you can just use the standard C rotation idiom. The compiler will pick it up as long as optimisations are enabled:

#include <limits.h>

int rotate_right(int num,int count) {
    return ((unsigned)num >> count | num << CHAR_BIT * sizeof num - count);
}