Trying to understand simple disassembled code from g++

Question

I am still struggling with g++ inline assembler and trying to understand how to use it.

I've adapted a piece of code from here: http://asm.sourceforge.net/articles/linasm.html (Quoted from the "Assembler Instructions with C Expressions Operands" section in gcc info files)

static inline uint32_t sum0() {
   uint32_t foo = 1, bar=2;
   uint32_t ret;
   __asm__ __volatile__ (
      "add  %%ebx,%%eax" 
         : "=eax"(ret)              // ouput
         : "eax"(foo), "ebx"(bar)   // input
         : "eax"                    // modify
   );
   return ret;
}

I've compiled disabling optimisations:

g++ -Og -O0 inline1.cpp -o test

The disassembled code puzzles me:

(gdb) disassemble sum0
Dump of assembler code for function sum0():
   0x00000000000009de <+0>:   push   %rbp                  ;prologue...
   0x00000000000009df <+1>:   mov    %rsp,%rbp             ;prologue...
   0x00000000000009e2 <+4>:   movl   $0x1,-0xc(%rbp)       ;initialize foo
   0x00000000000009e9 <+11>:  movl   $0x2,-0x8(%rbp)       ;initialize bar
   0x00000000000009f0 <+18>:  mov    -0xc(%rbp),%edx       ;
   0x00000000000009f3 <+21>:  mov    -0x8(%rbp),%ecx       ;
   0x00000000000009f6 <+24>:  mov    %edx,-0x14(%rbp)      ; This is unexpected
   0x00000000000009f9 <+27>:  movd   -0x14(%rbp),%xmm1     ; why moving variables
   0x00000000000009fe <+32>:  mov    %ecx,-0x14(%rbp)      ; to extended registers?
   0x0000000000000a01 <+35>:  movd   -0x14(%rbp),%xmm2     ;
   0x0000000000000a06 <+40>:  add    %ebx,%eax             ; add (as expected)
   0x0000000000000a08 <+42>:  movd   %xmm0,%edx            ; copying the wrong result to ret
   0x0000000000000a0c <+46>:  mov    %edx,-0x4(%rbp)       ;    "     "    "     "     "  "
   0x0000000000000a0f <+49>:  mov    -0x4(%rbp),%eax       ;    "     "    "     "     "  "
   0x0000000000000a12 <+52>:  pop    %rbp                  ;
   0x0000000000000a13 <+53>:  retq   
End of assembler dump.

As expected, the sum0() function returns the wrong value.

Any thoughts? What is going on? How to get it right?

-- EDIT -- Based on @MarcGlisse comment, I tried:

static inline uint32_t sum0() {
   uint32_t foo = 1, bar=2;
   uint32_t ret;
   __asm__ __volatile__ (
      "add  %%ebx,%%eax" 
         : "=a"(ret)             // ouput
         : "a"(foo), "b"(bar)     // input
         : "eax"                 // modify
   );
   return ret;
}

It seems that the tutorial I've been following is misleading. "eax" in the output/input field does not mean the register itself, but e,a,x abbreviations on the abbrev table.

Anyway, I still do not get it right. The code above results in a compilation error: 'asm' operand has impossible constraints.

I don't see why.

Answer 1

The Extended inline assembly constraints for x86 are listed in the official documentation.
The complete documentation is also worth reading.

As you can see, the constraints are all single letters.
The constraint "eax" fo foo specifies three constraints:

a
   The a register.

x
   Any SSE register.

e
   32-bit signed integer constant, or ...

Since you are telling GCC that eax is clobbered it cannot put the input operand there and it picks xmm0.

When the compiler selects the registers to use to represent the input operands, it does not use any of the clobbered registers

The proper constraint is simply "a".
You need to remove eax (by the way it should be rax due to zeroing of the upper bits) from the clobbers (and add "cc").