RE: Pb with G++ 3.4.2 MinGW and inline assembly V2

["John Yates" <jyates at netezza dot com>]

Caveat.  I am still stuck with gcc 2.96.  I dug this out of something I
wrote a few years back.  The main difference from your code is that I
do not explicitly load esi, edi and ecx.  I get gcc's operand loading
to do it.  The virtue is that gcc then can see those instructions and
schedule them.  The key to achieving this is the decimal digit input
operand constraint which says place the input operand in the same
location as the N-th (0-based) output operand.

inline void copy_foo(foo const* lhs, foo const* rhs)
{
    void*    discard_edi;
    void*    discard_esi;
    unsigned discard_ecx;

    __asm__ __volatile__
    (
	"rep\n\t"
	"movsl"

    : "=D" (discard_edi)
    , "=S" (discard_esi)
    , "=c" (discard_ecx)

    :  "0" (lhs)
    ,  "1" (rhs)
    ,  "2" (sizeof(foo)/4)

    : "memory"
    );
 }

You need to include "cc" in the clobber list if you include ANY
instruction that modifies ANY condition code bit.  (I do not
know whether that includes the x87 FP status bits.)  I am not
familiar with "st" as a clobbered object.  Might it be the x87
FPU's stack of 8 floating point temporaries?

I have never worried about the DF.  I have just assumed that it is
reset and that on exit from any asm that I write I must leave it in
that state.

/john

-----Original Message-----
From: Studious Apprentice [mailto:apprentice_99@hotmail.com]
Sent: Thursday, February 09, 2006 9:27 AM
To: gcc-help@gcc.gnu.org
Subject: Pb with G++ 3.4.2 MinGW and inline assembly V2


Thanks a lot for your answer John! Since then I managed to get this code 
working but I still have a few questions, for you or others ;-) :

1.- Is there an official help for the clobbered register list and its use ? 
I could not find any relevant section in the GCC manual
2.- Is there a place where I could find up to date examples (all example 
around the web I could find use registers in both input and clobbered list, 
which GCC no longer supports as far as I understand, and results in the 
compilation error  : can't find a register in class `CREG' while reloading 
`asm')
3.- What is the difference in the clobber list between "cc" and "st"? When 
do I have to use them ? Only when I modified the flag registers and intend 
to read them thereafter or as soon as I use an instruction which might 
modify them ?
4.- Is using "cld" or "std" instructions considered modifying the flags 
register ?
5.- Is the proposed snippet I wrote below as good as it can be ?

Thanks in advance,

Charles


I have made several versions of my assembly code until I got one perfectly 
working. I went through several pitfalls :
- an early clobbered registers is not considered as clobbered register... This 
means that though I put an ampersand in front of an input operant, GCC would 
use it as if it had not changed thereafter...
- an asm block which provides no output variable is optimized away by the 
compiler with the -O2 flag. This happens, even when the "memory" clobber is 
used... You have to use the __volatile__ keyword additionally...

Here is the working version :
{
	uint32 dummy_ecx;
	uint32 dummy_esi;
	uint32 dummy_edi;
	__asm__ __volatile__
		(
		"cld\n\t"
		"movl %3, %%esi\n\t"
		"movl %4, %%edi\n\t"
		"movl %5, %%ecx\n\t"
		"rep\n\t"
		"movsl"
		: "=&c"(dummy_ecx), "=&S"(dummy_esi), "=&D"(dummy_edi)
		: "g"(from), "g"(where), "g"(times)
		: "memory"
		);
}

And here is all the snippets I tried :
////First version (no clobber)
//{
//	__asm__ __volatile__
//		(
//		"cld\n\t"
//		"rep\n\t"
//		"movsl"
//		:
//	: "S"(from), "D"(where), "c"(times)
//		: "memory"
//		);
//}
//Version 2 (cant remember what happened on this one)
//{
//	std::size_t ecx_dummy;
//	std::size_t esi_dummy;
//	std::size_t edi_dummy;
//	__asm__ __volatile__
//		(
//		"cld\n\t"
//		"rep\n\t"
//		"movsl"
//		: "=S"(esi_dummy), "=D"(edi_dummy), "=c"(ecx_dummy)
//		: "S"(from), "D"(where), "c"(times)
//		: "memory"
//		);
//}
//Version 3 (early clobber)
//{
//	__asm__
//		(
//		"cld\n\t"
//		"movl %0, %%esi\n\t"
//		"movl %1, %%edi\n\t"
//		"movl %2, %%ecx\n\t"
//		"rep\n\t"
//		"movsl"
//		:
//		: "g"(from), "g"(where), "g"(times)
//		: "%esi", "%edi", "%ecx", "memory"
//		);
//}
//Version 4 (lacking volatile... should never had suppressed it...)
//{
//	uint32 dummy_ecx;
//	uint32 dummy_esi;
//	uint32 dummy_edi;
//	__asm__
//		(
//		"cld\n\t"
//		"movl %3, %%esi\n\t"
//		"movl %4, %%edi\n\t"
//		"movl %5, %%ecx\n\t"
//		"rep\n\t"
//		"movsl"
//		: "=&c"(dummy_ecx), "=&S"(dummy_esi), "=&D"(dummy_edi)
//		: "g"(from), "g"(where), "g"(times)
//		: "memory"
//		);
//}
//Version 5 (does not compile)
//{
//	uint32 dummy_ecx;
//	uint32 dummy_esi;
//	uint32 dummy_edi;
//	__asm__ __volatile__
//		(
//		"cld\n\t"
//		"rep\n\t"
//		"movsl"
//		: "=&c"(dummy_ecx), "=&S"(dummy_esi), "=&D"(dummy_edi)
//		: "S"(from), "D"(where), "c"(times)
//		: "memory"
//		);
//}