procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

ada: Atomic_Synchronization is not a user-visible check

Browse source 
Remove all user-level documentation of the check name
"Atomic_Synchronization". The documentation was confusing because
this check should never be used in source code, and because it
raises the question of whether All_Checks applies to it (it does
not).

Change the name Atomic_Synchronization to be _Atomic_Synchronization
(with a leading underscore) so that it cannot be used in source code.

This "check" is not really a check at all; it is used only internally in
the implementation of Disable/Enable_Atomic_Synchronization, because the
placement and scope of these pragmas match pragma Suppress.

gcc/ada/ChangeLog:

	* doc/gnat_rm/implementation_defined_characteristics.rst:
	Remove Atomic_Synchronization.
	* doc/gnat_ugn/building_executable_programs_with_gnat.rst:
	Likewise.
	* doc/gnat_rm/implementation_defined_pragmas.rst: DRY.
	Consolidate documentation of Disable/Enable_Atomic_Synchronization.
	* checks.adb: Comment fix.
	* exp_util.ads: Likewise.
	* targparm.ads: Likewise.
	* types.ads: Likewise.
	* gnat1drv.adb: Likewise. DRY.
	* sem_prag.adb (Process_Disable_Enable_Atomic_Sync):
	Change name of Atomic_Synchronization to start with
	underscore.
	(Process_Suppress_Unsuppress): No need to check Comes_From_Source for
	Atomic_Synchronization anymore; _Atomic_Synchronization can never
	come from source. (Anyway, it shouldn't be ignored; it should be
	an error.)
	* snames.ads-tmpl (Atomic_Synchronization):
	Change name to start with underscore.
	* switch-c.adb (Scan_Front_End_Switches):
	Minor cleanup: Use 'in'.
	* gnat_rm.texi: Regenerate.
	* gnat_ugn.texi: Regenerate.
This commit is contained in:
Bob Duff 2024-11-10 06:39:57 -05:00 • committed by Marc Poulhiès
parent 70faad1961
commit 4e23ce5070
13 changed files with 64 additions and 99 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
gcc/ada/checks.adb
View file

@ -3976,8 +3976,10 @@ package body Checks is
-------------------------------------
-- Note: internally Disable/Enable_Atomic_Synchronization is implemented
-- using a bogus check called Atomic_Synchronization. This is to make it
-- more convenient to get exactly the same semantics as [Un]Suppress.
-- using a pseudo-check called _Atomic_Synchronization. This is to make it
-- more convenient to get the same placement and scope rules as
-- [Un]Suppress. The check name has a leading underscore to make
-- it reserved by the implementation.
function Atomic_Synchronization_Disabled (E : Entity_Id) return Boolean is
begin

12
gcc/ada/doc/gnat_rm/implementation_defined_characteristics.rst
View file

@ -478,12 +478,12 @@ via compiler switches such as "-gnata".
*
"Implementation-defined check names. See 11.5(27)."
The implementation defined check names include Alignment_Check,
Atomic_Synchronization, Container_Checks, Duplicated_Tag_Check,
Predicate_Check, Raise_Check, Tampering_Check, and Validity_Check.
In addition, a user program can add implementation-defined check
names by means of the pragma Check_Name. See the description of
pragma ``Suppress`` for full details.
The implementation-defined check names include Alignment_Check,
Container_Checks, Duplicated_Tag_Check, Predicate_Check,
Raise_Check, Tampering_Check, and Validity_Check. In addition, a
user program can add implementation-defined check names by means
of the pragma Check_Name. See the description of pragma
``Suppress`` for details.
*
"Existence and meaning of second parameter of pragma Unsuppress.

33
gcc/ada/doc/gnat_rm/implementation_defined_pragmas.rst
View file

@ -1662,18 +1662,20 @@ Syntax:
pragma Disable_Atomic_Synchronization [(Entity)];
pragma Enable_Atomic_Synchronization [(Entity)];
Ada requires that accesses (reads or writes) of an atomic variable be
regarded as synchronization points in the case of multiple tasks.
Particularly in the case of multi-processors this may require special
handling, e.g. the generation of memory barriers. This capability may
be turned off using this pragma in cases where it is known not to be
required.
handling, e.g. the generation of memory barriers. This synchronization
is performed by default, but can be turned off using pragma
``Disable_Atomic_Synchronization``.
The ``Enable_Atomic_Synchronization`` pragma turns it back on.
The placement and scope rules for this pragma are the same as those
for ``pragma Suppress``. In particular it can be used as a
configuration pragma, or in a declaration sequence where it applies
till the end of the scope. If an ``Entity`` argument is present,
The placement and scope rules for these pragmas are the same as those
for ``pragma Suppress``. In particular they can be used as
configuration pragmas, or in a declaration sequence where they apply
until the end of the scope. If an ``Entity`` argument is present,
the action applies only to that entity.
Pragma Dispatching_Domain
@ -1903,21 +1905,8 @@ Syntax:
pragma Enable_Atomic_Synchronization [(Entity)];
Ada requires that accesses (reads or writes) of an atomic variable be
regarded as synchronization points in the case of multiple tasks.
Particularly in the case of multi-processors this may require special
handling, e.g. the generation of memory barriers. This synchronization
is performed by default, but can be turned off using
``pragma Disable_Atomic_Synchronization``. The
``Enable_Atomic_Synchronization`` pragma can be used to turn
it back on.
The placement and scope rules for this pragma are the same as those
for ``pragma Unsuppress``. In particular it can be used as a
configuration pragma, or in a declaration sequence where it applies
till the end of the scope. If an ``Entity`` argument is present,
the action applies only to that entity.
Reenables atomic synchronization; see ``pragma Disable_Atomic_Synchronization``
for details.
Pragma Exceptional_Cases
========================

6
gcc/ada/doc/gnat_ugn/building_executable_programs_with_gnat.rst
View file

@ -5379,10 +5379,8 @@ switches refine this default behavior.
execution if that assumption is wrong.
The checks subject to suppression include all the checks defined by the Ada
standard, the additional implementation defined checks ``Alignment_Check``,
``Duplicated_Tag_Check``, ``Predicate_Check``, ``Container_Checks``, ``Tampering_Check``,
and ``Validity_Check``, as well as any checks introduced using ``pragma Check_Name``.
Note that ``Atomic_Synchronization`` is not automatically suppressed by use of this option.
standard, as well as all implementation-defined checks,
including any checks introduced using ``pragma Check_Name``.
If the code depends on certain checks being active, you can use
pragma ``Unsuppress`` either as a configuration pragma or as

6
gcc/ada/exp_util.ads
View file

@ -182,9 +182,9 @@ package Exp_Util is
-- N is a node for which atomic synchronization may be required (it is
-- either an identifier, expanded name, or selected/indexed component or
-- an explicit dereference). The caller has checked the basic conditions
-- (atomic variable appearing and Atomic_Sync not disabled). This function
-- checks if atomic synchronization is required and if so sets the flag
-- and if appropriate generates a warning (in -gnatw.n mode).
-- (atomic variable appearing and Atomic_Synchronization enabled). This
-- function checks if atomic synchronization is required and if so sets
-- the flag and (in -gnatw.n mode) generates a warning.
procedure Adjust_Condition (N : Node_Id);
-- The node N is an expression whose root-type is Boolean, and which

5
gcc/ada/gnat1drv.adb
View file

@ -654,10 +654,7 @@ procedure Gnat1drv is
end if;
end if;
-- Set default for atomic synchronization. As this synchronization
-- between atomic accesses can be expensive, and not typically needed
-- on some targets, an optional target parameter can turn the option
-- off. Note Atomic Synchronization is implemented as check.
-- Set default for atomic synchronization
Suppress_Options.Suppress (Atomic_Synchronization) :=
not Atomic_Sync_Default_On_Target;

47
gcc/ada/gnat_rm.texi
View file

@ -19,7 +19,7 @@
@copying
@quotation
GNAT Reference Manual , Nov 08, 2024
GNAT Reference Manual , Nov 18, 2024
AdaCore
@ -3142,19 +3142,22 @@ Syntax:
@example
pragma Disable_Atomic_Synchronization [(Entity)];
pragma Enable_Atomic_Synchronization [(Entity)];
@end example
Ada requires that accesses (reads or writes) of an atomic variable be
regarded as synchronization points in the case of multiple tasks.
Particularly in the case of multi-processors this may require special
handling, e.g. the generation of memory barriers. This capability may
be turned off using this pragma in cases where it is known not to be
required.
handling, e.g. the generation of memory barriers. This synchronization
is performed by default, but can be turned off using pragma
@code{Disable_Atomic_Synchronization}.
The @code{Enable_Atomic_Synchronization} pragma turns it back on.
The placement and scope rules for this pragma are the same as those
for @code{pragma Suppress}. In particular it can be used as a
configuration pragma, or in a declaration sequence where it applies
till the end of the scope. If an @code{Entity} argument is present,
The placement and scope rules for these pragmas are the same as those
for @code{pragma Suppress}. In particular they can be used as
configuration pragmas, or in a declaration sequence where they apply
until the end of the scope. If an @code{Entity} argument is present,
the action applies only to that entity.
@node Pragma Dispatching_Domain,Pragma Effective_Reads,Pragma Disable_Atomic_Synchronization,Implementation Defined Pragmas
@ -3417,20 +3420,8 @@ Syntax:
pragma Enable_Atomic_Synchronization [(Entity)];
@end example
Ada requires that accesses (reads or writes) of an atomic variable be
regarded as synchronization points in the case of multiple tasks.
Particularly in the case of multi-processors this may require special
handling, e.g. the generation of memory barriers. This synchronization
is performed by default, but can be turned off using
@code{pragma Disable_Atomic_Synchronization}. The
@code{Enable_Atomic_Synchronization} pragma can be used to turn
it back on.
The placement and scope rules for this pragma are the same as those
for @code{pragma Unsuppress}. In particular it can be used as a
configuration pragma, or in a declaration sequence where it applies
till the end of the scope. If an @code{Entity} argument is present,
the action applies only to that entity.
Reenables atomic synchronization; see @code{pragma Disable_Atomic_Synchronization}
for details.
@node Pragma Exceptional_Cases,Pragma Export_Function,Pragma Enable_Atomic_Synchronization,Implementation Defined Pragmas
@anchor{gnat_rm/implementation_defined_pragmas pragma-exceptional-cases}@anchor{61}
@ -16815,12 +16806,12 @@ via compiler switches such as “-gnata”.
“Implementation-defined check names. See 11.5(27).”
@end itemize
The implementation defined check names include Alignment_Check,
Atomic_Synchronization, Container_Checks, Duplicated_Tag_Check,
Predicate_Check, Raise_Check, Tampering_Check, and Validity_Check.
In addition, a user program can add implementation-defined check
names by means of the pragma Check_Name. See the description of
pragma @code{Suppress} for full details.
The implementation-defined check names include Alignment_Check,
Container_Checks, Duplicated_Tag_Check, Predicate_Check,
Raise_Check, Tampering_Check, and Validity_Check. In addition, a
user program can add implementation-defined check names by means
of the pragma Check_Name. See the description of pragma
@code{Suppress} for details.
@itemize *

10
gcc/ada/gnat_ugn.texi
View file

@ -19,7 +19,7 @@
@copying
@quotation
GNAT User's Guide for Native Platforms , Nov 08, 2024
GNAT User's Guide for Native Platforms , Nov 18, 2024
AdaCore
@ -14249,10 +14249,8 @@ the condition being checked is true, which can result in erroneous
execution if that assumption is wrong.
The checks subject to suppression include all the checks defined by the Ada
standard, the additional implementation defined checks @code{Alignment_Check},
@code{Duplicated_Tag_Check}, @code{Predicate_Check}, @code{Container_Checks}, @code{Tampering_Check},
and @code{Validity_Check}, as well as any checks introduced using @code{pragma Check_Name}.
Note that @code{Atomic_Synchronization} is not automatically suppressed by use of this option.
standard, as well as all implementation-defined checks,
including any checks introduced using @code{pragma Check_Name}.
If the code depends on certain checks being active, you can use
pragma @code{Unsuppress} either as a configuration pragma or as
@ -29841,8 +29839,8 @@ to permit their use in free software.
@printindex ge
@anchor{gnat_ugn/gnat_utility_programs switches-related-to-project-files}@w{ }
@anchor{d2}@w{ }
@anchor{gnat_ugn/gnat_utility_programs switches-related-to-project-files}@w{ }
@c %**end of body
@bye

19
gcc/ada/sem_prag.adb
View file

@ -9020,8 +9020,8 @@ package body Sem_Prag is
Check_No_Identifiers;
Check_At_Most_N_Arguments (1);
-- Modeled internally as
-- pragma Suppress/Unsuppress (Atomic_Synchronization [,Entity])
-- Implemented internally as
-- pragma Suppress/Unsuppress (_Atomic_Synchronization [,Entity])
Rewrite (N,
Make_Pragma (Loc,
@ -9029,7 +9029,7 @@ package body Sem_Prag is
Pragma_Argument_Associations => New_List (
Make_Pragma_Argument_Association (Loc,
Expression =>
Make_Identifier (Loc, Name_Atomic_Synchronization)))));
Make_Identifier (Loc, Name_uAtomic_Synchronization)))));
if Present (Arg1) then
Append_To (Pragma_Argument_Associations (N), New_Copy (Arg1));
@ -11416,23 +11416,16 @@ package body Sem_Prag is
-- not a real check.
for J in Scope_Suppress.Suppress'Range loop
if J /= Elaboration_Check
and then
J /= Atomic_Synchronization
then
if J not in Elaboration_Check | Atomic_Synchronization then
Scope_Suppress.Suppress (J) := Suppress_Case;
end if;
end loop;
-- If not All_Checks, and predefined check, then set appropriate
-- scope entry. Note that we will set Elaboration_Check if this
-- is explicitly specified. Atomic_Synchronization is allowed
-- only if internally generated and entity is atomic.
-- is explicitly specified.
elsif C in Predefined_Check_Id
and then (not Comes_From_Source (N)
or else C /= Atomic_Synchronization)
then
elsif C in Predefined_Check_Id then
Scope_Suppress.Suppress (C) := Suppress_Case;
end if;

6
gcc/ada/snames.ads-tmpl
View file

@ -1226,15 +1226,15 @@ package Snames is
-- Names of recognized checks for pragma Suppress
-- Note: the name Atomic_Synchronization can only be specified internally
-- as a result of using pragma Enable/Disable_Atomic_Synchronization.
-- Note: the name _Atomic_Synchronization is used only internally
-- as a result of using pragmas Disable/Enable_Atomic_Synchronization.
First_Check_Name : constant Name_Id := N + $;
Name_Access_Check : constant Name_Id := N + $;
Name_Accessibility_Check : constant Name_Id := N + $;
Name_Alignment_Check : constant Name_Id := N + $; -- GNAT
Name_Allocation_Check : constant Name_Id := N + $;
Name_Atomic_Synchronization : constant Name_Id := N + $; -- GNAT
Name_uAtomic_Synchronization : constant Name_Id := N + $; -- GNAT
Name_Characters_Assertion_Check : constant Name_Id := N + $;
Name_Containers_Assertion_Check : constant Name_Id := N + $;
Name_Discriminant_Check : constant Name_Id := N + $;

4
gcc/ada/switch-c.adb
View file

@ -1154,9 +1154,7 @@ package body Switch.C is
-- check.
for J in Suppress_Options.Suppress'Range loop
if J /= Elaboration_Check
and then
J /= Atomic_Synchronization
if J not in Elaboration_Check | Atomic_Synchronization
then
Suppress_Options.Suppress (J) := True;
end if;

6
gcc/ada/targparm.ads
View file

@ -325,14 +325,14 @@ package Targparm is
Atomic_Sync_Default_On_Target : Boolean := True;
-- Access to atomic variables requires memory barrier synchronization in
-- the general case to ensure proper behavior when such accesses are used
-- on a multi-processor to synchronize tasks (e.g. by using spin locks).
-- on a multiprocessor to synchronize tasks (e.g. by using spin locks).
-- The setting of this flag determines the default behavior. Normally this
-- is True, which will mean that appropriate synchronization instructions
-- are generated by default. If it is False, then the default will be that
-- these synchronization instructions are not generated. This may be a more
-- appropriate default in some cases, e.g. on embedded targets which do not
-- allow the possibility of multi-processors. The default can be overridden
-- using pragmas Enable/Disable_Atomic_Synchronization and also by use of
-- allow the possibility of multiprocessors. The default can be overridden
-- using pragmas Disable/Enable_Atomic_Synchronization and also by use of
-- the corresponding debug flags -gnatd.e and -gnatd.d.
Support_Aggregates_On_Target : Boolean := True;

3
gcc/ada/types.ads
View file

@ -707,8 +707,7 @@ package Types is
Tasking_Check : constant := 28;
Raise_Check : constant := 29;
-- Values used to represent individual predefined checks (including the
-- setting of Atomic_Synchronization, which is implemented internally using
-- a "check" whose name is Atomic_Synchronization).
-- pseudo-check _Atomic_Synchronization).
All_Checks : constant := 30;
-- Value used to represent All_Checks value