C.6 Shared Variable Control
This clause specifies representation pragmas that
control the use of shared variables.
The form for
pragmas Atomic, Volatile, Atomic_Components, and Volatile_Components
is as follows:
type is one
to which a pragma Atomic applies. An atomic
a component) is one to which a pragma Atomic applies, or a component
of an array to which a pragma Atomic_Components applies, or any object
of an atomic type, other than objects obtained by evaluating a slice.
type is one
to which a pragma Volatile applies. A volatile
a component) is one to which a pragma Volatile applies, or a component
of an array to which a pragma Volatile_Components applies, or any object
of a volatile type. In addition, every atomic type or object is also
defined to be volatile. Finally, if an object is volatile, then so are
all of its subcomponents (the same does not apply to atomic).
Name Resolution Rules
It is illegal to apply either
an Atomic or Atomic_Components pragma to an object or type if the implementation
cannot support the indivisible reads and updates required by the pragma
It is illegal to specify the Size attribute of an
atomic object, the Component_Size attribute for an array type with atomic
components, or the layout attributes of an atomic component, in a way
that prevents the implementation from performing the required indivisible
reads and updates.
If an atomic object is passed as a parameter, then
the type of the formal parameter shall either be atomic or allow pass
by copy (that is, not be a nonatomic by-reference type). If an atomic
object is used as an actual for a generic formal object of mode in
, then the type of the generic formal object shall be atomic.
If the prefix
of an attribute_reference
for an Access attribute denotes an atomic object (including a component),
then the designated type of the resulting access type shall be atomic.
If an atomic type is used as an actual for a generic formal derived type,
then the ancestor of the formal type shall be atomic or allow pass by
copy. Corresponding rules apply to volatile objects and types.
If a pragma Volatile, Volatile_Components, Atomic,
or Atomic_Components applies to a stand-alone constant object, then a
pragma Import shall also apply to it.
representation pragmas (see 13.1
For an atomic object (including an atomic component)
all reads and updates of the object as a whole are indivisible.
For a volatile object all reads and updates of the
object as a whole are performed directly to memory.
Two actions are sequential (see
) if each is the read or update of the
same atomic object.
If a type is atomic or volatile
and it is not a by-copy type, then the type is defined to be a by-reference
type. If any subcomponent of a type is atomic or volatile, then the type
is defined to be a by-reference type.
If an actual parameter is atomic or volatile, and
the corresponding formal parameter is not, then the parameter is passed
The external effect of a program
) is defined to include each read
and update of a volatile or atomic object. The implementation shall not
generate any memory reads or updates of atomic or volatile objects other
than those specified by the program.
If a pragma Pack applies to a type any of whose subcomponents
are atomic, the implementation shall not pack the atomic subcomponents
more tightly than that for which it can support indivisible reads and
A load or store of a volatile object whose size
is a multiple of System.Storage_Unit and whose alignment is nonzero,
should be implemented by accessing exactly the bits of the object and
A load or store of an atomic object should, where
possible, be implemented by a single load or store instruction.
9 An imported volatile or atomic constant
behaves as a constant (i.e. read-only) with respect to other parts of
the Ada program, but can still be modified by an “external source.”