Re: [PATCH] Add atomic type qualifier

[Andrew MacLeod <amacleod at redhat dot com>]

On 07/30/2013 07:41 AM, Joseph S. Myers wrote:
> On Mon, 29 Jul 2013, Andrew MacLeod wrote:
>
> > Ive been poking at this today, and Im wondering what you think of the idea of
> > adding a flag to MODIFY_EXPR,
> > #define MODIFY_EXPR_IS_COMPOUND(NODE)
> > MODIFY_EXPR_CHECK(NODE)->base.asm_written_flag
> >
> > and set that in the MODIFY_EXPR node when we create it from the "x op= y" form
> > in the front end.   That flag seems to be free for expressions.
> My suggestion is that the IR generated by the front end should make it
> completely explicit what may need retrying with a compare-and-exchange,
> rather than relying on non-obvious details to reconstruct the semantics
> required at gimplification time - there are too many transformations
> (folding etc.) that may happen on existing trees and no clear way to be
> confident that you can still identify all the operands accurately after
> such transformations.  That is, an ATOMIC_COMPOUND_MODIFY_EXPR or similar,
> whose operands are: the LHS of the assignment; a temporary variable, "old"
> in C11 footnote 113; the RHS; and the "old op val" expression complete
> with the conversion to the type of the LHS.  Gimplification would then
> (carry out the effects of stabilize_reference on the LHS and save_expr on
> the RHS and) do "old = LHS;" followed by the do-while compare-exchange
> loop.
In fact, after thinking about it overnight, I came to similar 
conclusions...  I believe it requires new builtin(s) for these 
operations.   Something like

   __atomic_compound_assign (&atomic_expr, enum atomic_operation_type, 
blah, blah,...)

A call to this builtin would be generated right from the parser when it 
sees the op= expression, and the built-in can then travel throughout 
gimple as a normal atomic built-in operation like the rest.  During 
expansion to RTL it can be turned into whatever sequence we happen to 
need.   This is what happens currently with the various 
__atomic_fetch_op and __atomic_op_fetch.  In fact, they are a subset of 
required operations, so I should be able to combine the implementation 
of those with this new one.

 Is C++ planning to match  these behaviours in the atomic library? It 
would need to access this builtin as well so that the C++ template code 
can invoke it.


> A flag on the expression could indicate that the floating-point semantics
> are required.  I'd guess back ends would need to provide three insn
> patterns, corresponding to feholdexcept, feclearexcept and feupdateenv,
> that there'd be corresponding built-in functions for these used at
> gimplification time, and that a target hook would give the type used for
> fenv_t by these built-in functions (*not* necessarily the same as the
> fenv_t used by any implementation of the functions in libm).  The target
> should also be able to declare that there's no support for floating-point
> exceptions (e.g. for soft-float) and so floating-point cases don't need
> any special handling.
I think the fact that it requires floating point sematics should be 
determinable from the types of the expressions involved.  If there is a 
floating point somewhere, then we'll need to utilize the patterns.  
we'll still have the types, although it would certainly be easy enough 
to add a flag to the builtin... and maybe thats the way to go after all.

THis also means that for the 3 floating point operations all we need are 
RTL insn patterns, no buitin.  And as with the other atomics, if the 
pattern doesnt exist, we just wont emit it.  we could add a warning 
easily enough in this case.

I think we're somewhere good now :-)

I guess I'll do the same thing for normal references to an atomic 
variable... issue the atomic load or atomic store directly from the 
parser...

Andrew