This is the mail archive of the mailing list for the GCC project.

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: PR 17884

On Oct 13, 2004, at 12:37 AM, Richard Henderson wrote:

On Tue, Oct 12, 2004 at 05:38:24PM -0700, Dale Johannesen wrote:
Of course what our FP guys
really want to do is stick the asm in a macro in a header file
without knowledge of the surrounding code ...

Not going to work. You *need* to know something about the surrounding code; the sources or the results. Otherwise you can't add the kind of data dependencies needed.

I agree, but I can see why it's desirable not to need that.

Anyway, here is the final patch, I hope. Looks ok in info. OK?

2004-10-13 Dale Johannesen <>

* doc/extend.texi (Extended Asm): Rewrite asm volatile description.

Index: extend.texi
RCS file: /cvs/gcc/gcc/gcc/doc/extend.texi,v
retrieving revision 1.223
diff -u -d -b -w -p -r1.223 extend.texi
--- extend.texi 5 Oct 2004 07:15:01 -0000 1.223
+++ extend.texi 13 Oct 2004 17:49:57 -0000
@@ -3724,8 +3724,8 @@ if your instruction does have a side eff
appears not to change, the old value of the variable may be reused later
if it happens to be found in a register.

-You can prevent an @code{asm} instruction from being deleted, moved
-significantly, or combined, by writing the keyword @code{volatile} after
+You can prevent an @code{asm} instruction from being deleted
+by writing the keyword @code{volatile} after
the @code{asm}. For example:

@@ -3737,36 +3737,39 @@ the @code{asm}.  For example:
 @end smallexample

-If you write an @code{asm} instruction with no outputs, GCC will know
-the instruction has side-effects and will not delete the instruction or
-move it outside of loops.
 The @code{volatile} keyword indicates that the instruction has
 important side-effects.  GCC will not delete a volatile @code{asm} if
 it is reachable.  (The instruction can still be deleted if GCC can
 prove that control-flow will never reach the location of the
-instruction.)  In addition, GCC will not reschedule instructions
-across a volatile @code{asm} instruction.  For example:
+instruction.)  Note that even a volatile @code{asm} instruction
+can be moved relative to other code, including across jump
+instructions.  For example, on many targets there is a system
+register which can be set to control the rounding mode of
+floating point operations.  You might try
+setting it with a volatile @code{asm}, like this PowerPC example:

-*(volatile int *)addr = foo;
-asm volatile ("eieio" : : );
+       asm volatile("mtfsf 255,%0" : : "f" (fpenv));
+       sum = x + y;
 @end smallexample

-Assume @code{addr} contains the address of a memory mapped device
-register. The PowerPC @code{eieio} instruction (Enforce In-order
-Execution of I/O) tells the CPU to make sure that the store to that
-device register happens before it issues any other I/O@.
+This will not work reliably, as the compiler may move the addition back
+before the volatile @code{asm}. To make it work you need to add an
+artificial dependency to the @code{asm} referencing a variable in the code
+you don't want moved, for example:

-Note that even a volatile @code{asm} instruction can be moved in ways
-that appear insignificant to the compiler, such as across jump
-instructions.  You can't expect a sequence of volatile @code{asm}
-instructions to remain perfectly consecutive.  If you want consecutive
-output, use a single @code{asm}.  Also, GCC will perform some
-optimizations across a volatile @code{asm} instruction; GCC does not
-``forget everything'' when it encounters a volatile @code{asm}
-instruction the way some other compilers do.
+    asm volatile ("mtfsf 255,%1" : "=X"(sum): "f"(fpenv));
+    sum = x + y;
+@end smallexample
+Similarly, you can't expect a
+sequence of volatile @code{asm} instructions to remain perfectly
+consecutive.  If you want consecutive output, use a single @code{asm}.
+Also, GCC will perform some optimizations across a volatile @code{asm}
+instruction; GCC does not ``forget everything'' when it encounters
+a volatile @code{asm} instruction the way some other compilers do.

 An @code{asm} instruction without any operands or clobbers (an ``old
 style'' @code{asm}) will be treated identically to a volatile

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]