how to use C variables in an assembly code in c++ while compiling in gcc?

Question

I compiled this code using visual studio,

double callVariadicDoubleFunc(double * doubles, unsigned int numDoubles,double(*TestFunc)(double,...))

{

    // sizeof(double) must be 8!
    if (numDoubles == 0)
        return 0;
    double * lastDouble = doubles + (numDoubles - 1);
    double res;
    int temp;

    __asm mov eax, numDoubles
    __asm mov edx, lastDouble
    __asm mov temp,esp

    __asm label_loop:
    __asm sub esp, 8
    __asm fld qword ptr [edx]
    __asm fstp qword ptr [esp]
    __asm sub eax, 1
    __asm sub edx, 8
    __asm test eax, eax
    __asm jnz label_loop

    __asm call TestFunc
    __asm fstp        qword ptr res;
    __asm mov esp, temp

    return res;
}

but now I'm trying to compile it using gcc but there are some error I can't resolve! to remove all compile time errors I've changed that code a little to this shape:

double evaluationHelper(double* arguments, unsigned numDoubles, double(*mFunction)(...)) 
{
    int temp;
    double res;
    arguments += numDoubles;
    asm("mov eax, numDoubles"  "\n"
        "mov ecx, arguments"   "\n"
        "mov temp,esp"         "\n"

        "label_loop:"          "\n"
        "sub esp, 8"           "\n"
        "fld qword ptr [ecx]"  "\n"
        "fstp qword ptr [esp]" "\n"
        "sub eax, 1"           "\n"
        "sub ecx, 8"           "\n"
        "test eax, eax"        "\n"
        "jnz label_loop"       "\n"

        "call mFunction"       "\n"
        "fstp qword ptr res"   "\n"
        "mov esp, temp"        );
    return res;
}

but now I'm getting linking errors:

undefined reference to `numDoubles'
undefined reference to `arguments'
undefined reference to `temp'

any idea how can I resolve them?

sidenote: I'm compiling my code with these options :"-g -masm=intel -O0 -Wall"

rodrigo · Accepted Answer · 2011-12-28 11:08:03Z

The thing is a bit more complicated. You should use the extended GCC assembly with constraints. Also, your use of temp to save the stack pointer is a bad idea, as local variables' addresses depend on the value of the stack pointer. It is better to create a standard stack frame.

Also, you have forgotten to substract 1 to the pointer. As a bonus, in GCC there is no need for a temporary variable for the last pointer in the array.

Something along the lines of:

double evaluationHelper(double* arguments, unsigned numDoubles, double(*mFunction)()) 
{
    double res;
    asm(
        /* set up the frame pointer */
        "push ebp"             "\n"
        "mov ebp, esp"         "\n"

        "label_loop:"          "\n"
        "sub esp, 8"           "\n"
        "fld qword ptr [%2]"   "\n"
        "fstp qword ptr [esp]" "\n"
        "sub %1, 1"            "\n"
        "sub %2, 8"            "\n"
        "test %1, %1"          "\n"
        "jnz label_loop"       "\n"

        "call %3"              "\n"
        "fstp qword ptr [%0]"  "\n"
        "mov esp, ebp"         "\n"
        "pop ebp"              "\n"
        : /* no output */
        :"b"(&res), "a"(numDoubles), "c"(arguments + (numDoubles - 1)), "d"(mFunction) /* input */
        :"cc" /* clobber */);
    return res;
}

The res variable cannot be used as an output because the fstp instruction requires a pointer, which is an input. You could use a m constraint if you weren't doing funny things with the stack (see my correction below).

OTHER CORRECTION: And you could use a r constraint if you hadn't have to list EAX, ECX and EDX in the clobbered list, because they are not preseved through function calls (and you are calling a function). But you cannot list a clobbered register that is used as a input/output.

Note that &res uses the constraint "b" that is preserved trough the function call, and so the fstp will work as expected.

Lastly, only "cc" is listed in the clobbered list because you are changing the flags register (with test) and with the function call.

Running gcc -masm=intel -save-temps we can check the generated assembly:

; Before the asm
mov     eax, DWORD PTR [ebp+12] ; numDoubles
sub     eax, 1 
sal     eax, 3 
mov     ecx, eax           
add     ecx, DWORD PTR [ebp+8]  ; arguments + 8*(numDoubles - 1)
lea     ebx, [ebp-16]           ; res
mov     eax, DWORD PTR [ebp+12] ; numDoubles
mov     edx, DWORD PTR [ebp+16] ; mFunction

; The asm
push ebp
mov ebp, esp
label_loop: 
sub esp, 8  
fld qword ptr [ecx]
fstp qword ptr [esp]
sub eax, 1
sub ecx, 8
test eax, eax
jnz label_loop
call edx         ; clobbers eax, ecx, edx and flags
fstp qword ptr [ebx]
mov esp, ebp
pop ebp

; After the asm
fld QWORD PTR [ebp-16]  ; return res

That seems mostly correct to me.

CORRECTION: Not quite. The function pointer and the res variable must be held into registers because you are creating a stack frame that the compiler knows nothing about, and so it cannot compute the addresses of these local variables. So my last few corrections are nice but useless.

Also the pointer to the res variable has to be in ECX.

Reverted.

when I first pasted your code I got a segmentation fault, after lots of time spending on debug I've found out the problem! everything runs smoothly before call ebx but when ebx is called are the registers get scrambled. so I just had to break my inline asm function into two parts, one to initialize and call the function and the second one to collect it's results.
Hmmm, tricky... x86 ABI says that EAX, ECX and EDX are not preserved through function calls, but EBX is. So the solution would be just tu use EBX to hold the &res pointer. You cannot save it in the stack because of your playing with it. Please see if my updated answer solves it.

Joel · Accepted Answer · 2011-12-28 01:26:46Z

0

When referring to variables in inline assembly, they have to be preceded with a $. Also, gcc uses AT&T syntax for assembly, so src and dst are backwards compared to Intel.

http://ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html

Edit:

The issue seems to be that you are referring to locals by name, not globals. So when the assembler sees the names, then tries to link, it can't find them. To resolve this, I think you need to use extended asm.

edited Dec 28, 2011 at 1:26

answered Dec 28, 2011 at 0:43

Joel

5,6741 gold badge23 silver badges19 bronze badges

2 Comments

Ali1S232 Over a year ago

I've already added -masm=intel to make gcc use intel syntax. and in intel syntax you don't have to use $ to refer to variables. (I've tested it and gcc complained "undefined reference to `$numDoubles'"

Joel Over a year ago

You also have to tell the assembler, via asm(".intel_syntax noprefix\n");

Collectives™ on Stack Overflow

how to use C variables in an assembly code in c++ while compiling in gcc?

2 Answers 2

2 Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related