asm with C expression operands (i386)

[Andrew Haley]

Tomek wrote:
> Hello
> 
> I am asking about memory constraints in asm statements.
> Suppose we have a class:
> 
> class foo
> {
> public:
>         int table[2];
> };
> 
> and a function
> 
> void do_something(foo & out_in, const foo & in)
> {
>      __asm__ (
>      "do something with out_in.table and in.table"
>      );
> }
> 
> I am not sure how to correctly write constraints for out_in.table and
> in.table. Assume that 'in' object is only for reading and 'out_in' is
> for reading and writing. Following http://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html
> I was trying to write:
> 
> void do_something(foo & out_in, const foo & in)
> {
>     __asm__ (
>     "some magic stuff"
>     : "+m"( ({ struct { int x[2]; } *p = (void *)out_in.table ; *p; }) )
>     : other constraints
>     : ....
>     );
> }
> 
> but it gave me:
> test.cpp:50: error: invalid conversion from 'void*' to 'do_something(foo&, const foo&)::<anonymous struct>*'
> (gcc 4.3.3 mingw)
> 
> I changed a little the function and got:
> 
> void do_something(foo & out_in, const foo & in)
> {
> struct temp { int t[2]; };
> temp * table1 = (temp*)out_in.table;
> temp * table2 = (temp*)in.table;

I don't think this is even legal C++.

> 
>    __asm__ (
>    // out_in.table[0] = in.table[0] + in.table[1] + out_in.table[0];
>    // out_in.table[1] = 0;
>    // (i386 asm)
>    
>    "movl (%%ecx),  %%eax   \n"
>    "addl 4(%%ecx), %%eax   \n"
>    "addl %%eax, (%%ebx)    \n"
>    "movl $0, 4(%%ebx)              \n"
> 
>    : "+m" ( *table1 )
>    : "b" (out_in.table), "c" (in.table), "m" ( *table2 )
>    : "%eax", "cc"
>    );
> }
> 
> And my question: is that a correct way to declare that out_in.table
> is read and written by the asm statement (and in.table is only
> for reading)? In this example don't I need to use 'volatile' with the
> __asm__ keyword?

I don't think so.

I've discussed this with some other gcc developers, and consensus is
that if you want to be safe, clobber memory and make the asm volatile.

Like this:

  __asm__ volatile (
	   // out_in.table[0] = in.table[0] + in.table[1] + out_in.table[0];
	   // out_in.table[1] = 0;
	   // (i386 asm)

	   "movl (%2),  %0   \n"
	   "addl 4(%2), %1   \n"
	   "addl %0, (%1)    \n"
	   "movl $0, 4(%1)       \n"

	   : "+r"(tmp)
	   : "r" (out_in.table), "r" (in.table)
	   : "cc", "memory" );

This does mean that your asm is effectively a memory barrier, but we can't
see any way to avoid that.

Andrew.