如何在C中返回void *指针？

Question

Basically I need to know what register void* pointers are placed in when they are returned from a C function. I have this code:

void* kmalloc(unsigned int size)
{
    asm("mov %[size], %%esi"
    : /* no outputs */
    : [size] "m" (size)
    : "esi");
    asm("movl $9, %eax");
    asm("int $0x80");

}

which should put an address into EAX. I thought that return values in C were stored in EAX, but apparently not, (oh and I am using GCC BTW). I need to some how return EAX, register int won't work either because of the compiler settings. Is there a register that is used for returning pointers? Or is it like pushed onto the stack or something?

Answer 1

This is not a valid way to write inline asm. Even if you put the return value in the right register, it could be lost/clobbered by the time the function actually returns, because the compiler can add arbitrary epilogue code. You must use output constraints and a return statement to return the results of inline asm:

void* kmalloc(unsigned int size)
{
    void *p;
    asm("int $0x80" : "=a"(p) : "S"(size), "a"(9));
    return p;
}

Answer 2

Test code:

void * myfunc(void) { return (void *) 0x20341022; }

Compiles (with gcc --save-temps -O2 -c test.c ) to:

myfunc:
.LFB0:
    .cfi_startproc
    movl    $540282914, %eax
    ret
    .cfi_endproc

Answer is obvious.

Answer 3

You should declare how your inline assembly code returns it's result with an output constraint, like this:

void* kmalloc(unsigned int size)
{
   void *result;
   asm("mov %[size], %%esi\n"
       "movl $9, %%eax\n"
       "int $0x80"
   : "=a" (result)
   : [size] "m" (size)
   : "esi");

   return result;
}

The "=a" tells the compiler to move the contents of EAX to the result variable.

Note that i also grouped all the asm statements in one block, this way i only need to specify the input/output for this block, instead of for each statement by itself.

Compiling this with gcc -O3 x.cpp -S will show you the resulting compiled code:

_kmalloc:
Leh_func_begin1:
    pushq   %rbp
Ltmp0:
    movq    %rsp, %rbp
Ltmp1:
    movl    %edi, -4(%rbp)
    ## InlineAsm Start
    mov -4(%rbp), %esi
    movl $9, %eax
    int $0x80
    ## InlineAsm End
    popq    %rbp
    ret
Leh_func_end1:

Note that the optimizer figures out that the result variable equals EAX , and thus does not need to be allocated on the stack.