GCC inline - push address, not its value to stack

While inline asm is always a bit tricky, calling functions from it is particularly challenging. Not something I would suggest for a "getting to known inline asm" project. If you haven't already, I suggest looking through the very latest inline asm docs. A lot of work has been done to try to explain how inline asm works.

That said, here are some thoughts:

1) Using multiple asm statements like this is a bad idea. As the docs say: Do not expect a sequence of asm statements to remain perfectly consecutive after compilation. If certain instructions need to remain consecutive in the output, put them in a single multi-instruction asm statement.

2) Directly modifying registers (like you are doing with eax) without letting gcc know you are doing so is also a bad idea. You should either use register constraints (so gcc can pick its own registers) or clobbers to let gcc know you are stomping on them.

3) When a function (like puts) is called, while some registers must have their values restored before returning, some registers can be treated as scratch registers by the called function (ie modified and not restored before returning). As I mentioned in #2, having your asm modify registers without informing gcc is a very bad idea. If you know the ABI for the function you are calling, you can add its scratch registers to the asm's clobber list.

4) While in this specific example you are using a constant string, as a general rule, when passing asm pointers to strings, structs, arrays, etc, you are likely to need the "memory" clobber to ensure that any pending writes to memory are performed before starting to execute your asm.

5) Actually, the lea is doing something very important. The value of esp is not known at compile time, so it's not like you can perform push $12345. Someone needs to compute (esp + the offset of localmsg) before it can be pushed on the stack. Also, see second example below.

6) If you prefer intel format (and what right-thinking person wouldn't?), you can use -masm=intel.

Given all this, my first cut at this code looks like this. Note that this does NOT clobber puts' scratch registers. That's left as an exercise...

#include <stdio.h>

int main()
{
  const char localmsg[] = "my local message";

  int result;

  /* Use 'volatile' since 'result' is usually not going to get used,
     which might tempt gcc to discard this asm statement as unneeded. */

  asm volatile ("push %[msg] \n\t"   /* Push the address of the string. */
                "call %[puts] \n \t" /* Call the print function. */
                "add $4,%%esp"       /* Clean up the stack. */

                : "=a" (result) /* The result code from puts. */
                : [puts] "m" (puts), [msg] "r" (localmsg)
                : "memory", "esp");

   printf("%d\n", result);
}

True this doesn't avoid the lea due to #5. However, if that's really important, try this:

#include <stdio.h>
const char localmsg[] = "my local message";

int main()
{

  int result;

  /* Use 'volatile' since 'result' is usually not going to get used. */

  asm volatile ("push %[msg] \n\t" /* Push the address of the string. */
                "call %[puts] \n \t" /* Call the print function. */
                "add $4,%%esp"       /* Clean up the stack. */

                : "=a" (result) /* The result code. */
                : [puts] "m" (puts), [msg] "i" (localmsg)
                : "memory", "esp");

   printf("%d\n", result);
}

As a global, the address of localmsg is now knowable at compile time (ok, I'm simplifying a bit), the asm produced looks like this:

push $__ZL8localmsg
call _puts
add $4,%esp

Tada.