+2012-12-05 Robert Dewar <dewar@adacore.com>
+
+ * gnat_rm.texi: Update overflow description. Pragma Overflow_Checks
+ changed to Overflow_Mode.
+
+2012-12-05 Robert Dewar <dewar@adacore.com>
+
+ * checks.ads, exp_ch4.adb, gnat1drv.adb, par-prag.adb, sem_prag.adb,
+ snames.ads-tmpl, switch-c.adb, types.ads, checks.adb: Change pragma
+ Overflow_Checks to Overflow_Mode.
+ Separate overflow checking from overflow mode.
+ Several name changes to reflect this separation.
+ CHECKED mode is renamed STRICT mode.
+
2012-12-05 Yannick Moy <moy@adacore.com>
* gnat1drv.adb (Adjust_Global_Switches): Move setting of flags for
Result_Type : constant Entity_Id := Etype (Op);
-- Original result type
- Check_Mode : constant Overflow_Check_Type := Overflow_Check_Mode;
+ Check_Mode : constant Overflow_Mode_Type := Overflow_Check_Mode;
pragma Assert (Check_Mode in Minimized_Or_Eliminated);
Lo, Hi : Uint;
Left : constant Node_Id := Left_Opnd (N);
Right : constant Node_Id := Right_Opnd (N);
- Mode : constant Overflow_Check_Type := Overflow_Check_Mode;
+ Mode : constant Overflow_Mode_Type := Overflow_Check_Mode;
-- Current overflow checking mode
LLB : Uint;
procedure Enable_Overflow_Check (N : Node_Id) is
Typ : constant Entity_Id := Base_Type (Etype (N));
- Mode : constant Overflow_Check_Type := Overflow_Check_Mode;
+ Mode : constant Overflow_Mode_Type := Overflow_Check_Mode;
Chk : Nat;
OK : Boolean;
Ent : Entity_Id;
pragma Assert (Is_Signed_Integer_Type (Rtyp));
-- Result type, must be a signed integer type
- Check_Mode : constant Overflow_Check_Type := Overflow_Check_Mode;
+ Check_Mode : constant Overflow_Mode_Type := Overflow_Check_Mode;
pragma Assert (Check_Mode in Minimized_Or_Eliminated);
Loc : constant Source_Ptr := Sloc (N);
---------------
procedure Reanalyze (Typ : Entity_Id; Suppress : Boolean := False) is
- Svg : constant Overflow_Check_Type :=
- Scope_Suppress.Overflow_Checks_General;
- Sva : constant Overflow_Check_Type :=
- Scope_Suppress.Overflow_Checks_Assertions;
+ Svg : constant Overflow_Mode_Type :=
+ Scope_Suppress.Overflow_Mode_General;
+ Sva : constant Overflow_Mode_Type :=
+ Scope_Suppress.Overflow_Mode_Assertions;
Svo : constant Boolean :=
Scope_Suppress.Suppress (Overflow_Check);
begin
- Scope_Suppress.Overflow_Checks_General := Strict;
- Scope_Suppress.Overflow_Checks_Assertions := Strict;
+ Scope_Suppress.Overflow_Mode_General := Strict;
+ Scope_Suppress.Overflow_Mode_Assertions := Strict;
if Suppress then
Scope_Suppress.Suppress (Overflow_Check) := True;
Analyze_And_Resolve (N, Typ);
Scope_Suppress.Suppress (Overflow_Check) := Svo;
- Scope_Suppress.Overflow_Checks_General := Svg;
- Scope_Suppress.Overflow_Checks_Assertions := Sva;
+ Scope_Suppress.Overflow_Mode_General := Svg;
+ Scope_Suppress.Overflow_Mode_Assertions := Sva;
end Reanalyze;
--------------
--------------
procedure Reexpand (Suppress : Boolean := False) is
- Svg : constant Overflow_Check_Type :=
- Scope_Suppress.Overflow_Checks_General;
- Sva : constant Overflow_Check_Type :=
- Scope_Suppress.Overflow_Checks_Assertions;
+ Svg : constant Overflow_Mode_Type :=
+ Scope_Suppress.Overflow_Mode_General;
+ Sva : constant Overflow_Mode_Type :=
+ Scope_Suppress.Overflow_Mode_Assertions;
Svo : constant Boolean :=
Scope_Suppress.Suppress (Overflow_Check);
begin
- Scope_Suppress.Overflow_Checks_General := Strict;
- Scope_Suppress.Overflow_Checks_Assertions := Strict;
+ Scope_Suppress.Overflow_Mode_General := Strict;
+ Scope_Suppress.Overflow_Mode_Assertions := Strict;
Set_Analyzed (N, False);
if Suppress then
Expand (N);
Scope_Suppress.Suppress (Overflow_Check) := Svo;
- Scope_Suppress.Overflow_Checks_General := Svg;
- Scope_Suppress.Overflow_Checks_Assertions := Sva;
+ Scope_Suppress.Overflow_Mode_General := Svg;
+ Scope_Suppress.Overflow_Mode_Assertions := Sva;
end Reexpand;
-- Start of processing for Minimize_Eliminate_Overflows
-- MINIMIZED/ELIMINATED handling, since we are now done with that!
declare
- SG : constant Overflow_Check_Type :=
- Scope_Suppress.Overflow_Checks_General;
- SA : constant Overflow_Check_Type :=
- Scope_Suppress.Overflow_Checks_Assertions;
+ SG : constant Overflow_Mode_Type :=
+ Scope_Suppress.Overflow_Mode_General;
+ SA : constant Overflow_Mode_Type :=
+ Scope_Suppress.Overflow_Mode_Assertions;
begin
- Scope_Suppress.Overflow_Checks_General := Strict;
- Scope_Suppress.Overflow_Checks_Assertions := Strict;
+ Scope_Suppress.Overflow_Mode_General := Strict;
+ Scope_Suppress.Overflow_Mode_Assertions := Strict;
if not Do_Overflow_Check (N) then
Reanalyze (LLIB, Suppress => True);
Reanalyze (LLIB);
end if;
- Scope_Suppress.Overflow_Checks_General := SG;
- Scope_Suppress.Overflow_Checks_Assertions := SA;
+ Scope_Suppress.Overflow_Mode_General := SG;
+ Scope_Suppress.Overflow_Mode_Assertions := SA;
end;
end Minimize_Eliminate_Overflows;
-- Overflow_Check_Mode --
-------------------------
- function Overflow_Check_Mode return Overflow_Check_Type is
+ function Overflow_Check_Mode return Overflow_Mode_Type is
begin
if In_Assertion_Expr = 0 then
- return Scope_Suppress.Overflow_Checks_General;
+ return Scope_Suppress.Overflow_Mode_General;
else
- return Scope_Suppress.Overflow_Checks_Assertions;
+ return Scope_Suppress.Overflow_Mode_Assertions;
end if;
end Overflow_Check_Mode;
-- is False, then the status of the check can be determined simply by
-- examining Scope_Suppress, so this routine is not called in that case.
- function Overflow_Check_Mode return Overflow_Check_Type;
+ function Overflow_Check_Mode return Overflow_Mode_Type;
-- Returns current overflow checking mode, taking into account whether
-- we are inside an assertion expression.
LLIB : constant Entity_Id := Base_Type (Standard_Long_Long_Integer);
-- Entity for Long_Long_Integer'Base
- Check : constant Overflow_Check_Type := Overflow_Check_Mode;
+ Check : constant Overflow_Mode_Type := Overflow_Check_Mode;
-- Current overflow checking mode
procedure Set_True;
-- prevents suppressing of overflow checks by default, in code down
-- below.
- if Suppress_Options.Overflow_Checks_General = Not_Set then
- Suppress_Options.Overflow_Checks_General := Strict;
- Suppress_Options.Overflow_Checks_Assertions := Strict;
+ if Suppress_Options.Overflow_Mode_General = Not_Set then
+ Suppress_Options.Overflow_Mode_General := Strict;
+ Suppress_Options.Overflow_Mode_Assertions := Strict;
end if;
-- Kill debug of generated code, since it messes up sloc values
-- prevents suppressing of overflow checks by default, in code down
-- below.
- if Suppress_Options.Overflow_Checks_General = Not_Set then
- Suppress_Options.Overflow_Checks_General := Strict;
- Suppress_Options.Overflow_Checks_Assertions := Strict;
+ if Suppress_Options.Overflow_Mode_General = Not_Set then
+ Suppress_Options.Overflow_Mode_General := Strict;
+ Suppress_Options.Overflow_Mode_Assertions := Strict;
end if;
-- Kill debug of generated code, since it messes up sloc values
-- If already set (by -gnato or above in Alfa or CodePeer mode) then we
-- have nothing to do.
- if Opt.Suppress_Options.Overflow_Checks_General /= Not_Set then
+ if Opt.Suppress_Options.Overflow_Mode_General /= Not_Set then
null;
-- Otherwise set overflow mode defaults
-- By default set STRICT mode if -gnatg in effect
if GNAT_Mode then
- Suppress_Options.Overflow_Checks_General := Strict;
- Suppress_Options.Overflow_Checks_Assertions := Strict;
+ Suppress_Options.Overflow_Mode_General := Strict;
+ Suppress_Options.Overflow_Mode_Assertions := Strict;
-- If we have backend divide and overflow checks, then by default
-- overflow checks are STRICT. Historically this code used to also
and
Targparm.Backend_Overflow_Checks_On_Target
then
- Suppress_Options.Overflow_Checks_General := Strict;
- Suppress_Options.Overflow_Checks_Assertions := Strict;
+ Suppress_Options.Overflow_Mode_General := Strict;
+ Suppress_Options.Overflow_Mode_Assertions := Strict;
-- Otherwise for now, default is STRICT mode. This may change in the
-- future, but for now this is the compatible behavior with previous
-- versions of GNAT.
else
- Suppress_Options.Overflow_Checks_General := Strict;
- Suppress_Options.Overflow_Checks_Assertions := Strict;
+ Suppress_Options.Overflow_Mode_General := Strict;
+ Suppress_Options.Overflow_Mode_Assertions := Strict;
end if;
end if;
* Pragma Obsolescent::
* Pragma Optimize_Alignment::
* Pragma Ordered::
-* Pragma Overflow_Checks::
+* Pragma Overflow_Mode::
* Pragma Passive::
* Pragma Persistent_BSS::
* Pragma Polling::
* Pragma Obsolescent::
* Pragma Optimize_Alignment::
* Pragma Ordered::
-* Pragma Overflow_Checks::
+* Pragma Overflow_Mode::
* Pragma Passive::
* Pragma Persistent_BSS::
* Pragma Polling::
For additional information please refer to the description of the
@option{-gnatw.u} switch in the @value{EDITION} User's Guide.
-@node Pragma Overflow_Checks
-@unnumberedsec Pragma Overflow_Checks
+@node Pragma Overflow_Mode
+@unnumberedsec Pragma Overflow_Mode
@findex Overflow checks
-@findex pragma @code{Overflow_Checks}
+@findex Overflow mode
+@findex pragma @code{Overflow_Mode}
@noindent
Syntax:
@smallexample @c ada
-pragma Overflow_Checks
+pragma Overflow_Mode
( [General =>] MODE
[,[Assertions =>] MODE]);
-MODE ::= SUPPRESSED | CHECKED | MINIMIZED | ELIMINATED
+MODE ::= STRICT | MINIMIZED | ELIMINATED
@end smallexample
@noindent
-This pragma sets the current overflow mode to the given mode. For details
+This pragma sets the current overflow mode to the given setting. For details
of the meaning of these modes, please refer to the
``Overflow Check Handling in GNAT'' appendix in the
@value{EDITION} User's Guide. If only the @code{General} parameter is present,
so @code{MINIMIZED}, @code{Minimized} and
@code{minimized} all have the same effect.
-The @code{Overflow_Checks} pragma has the same scoping and placement
+The @code{Overflow_Mode} pragma has the same scoping and placement
rules as pragma @code{Suppress}, so it can occur either as a
configuration pragma, specifying a default for the whole
program, or in a declarative scope, where it applies to the
remaining declarations and statements in that scope.
-The pragma @code{Suppress (Overflow_Check)} sets mode
-
-@smallexample @c ada
- General => Suppressed
-@end smallexample
-
-@noindent
-suppressing all overflow checking within and outside
-assertions.
-
-The pragam @code{Unsuppress (Overflow_Check)} sets mode
-
-@smallexample @c ada
- General => Checked
-@end smallexample
-
-@noindent
-which causes overflow checking of all intermediate overflows.
-This applies both inside and outside assertions.
+The pragma @code{Suppress (Overflow_Check)} suppresses
+overflow checking, but does not affect the overflow mode.
+The pragam @code{Unsuppress (Overflow_Check)} unsuppresses (enables)
+overflow checking, but does not affect the overflow mode.
@node Pragma Passive
@unnumberedsec Pragma Passive
Pragma_Ordered |
Pragma_Optimize |
Pragma_Optimize_Alignment |
- Pragma_Overflow_Checks |
+ Pragma_Overflow_Mode |
Pragma_Pack |
Pragma_Partition_Elaboration_Policy |
Pragma_Passive |
Optimize_Alignment_Local := True;
end Optimize_Alignment;
- ---------------------
- -- Overflow_Checks --
- ---------------------
+ -------------------
+ -- Overflow_Mode --
+ -------------------
- -- pragma Overflow_Checks
+ -- pragma Overflow_Mode
-- ([General => ] MODE [, [Assertions => ] MODE]);
-- MODE := STRICT | MINIMIZED | ELIMINATED
-- since System.Bignums makes this assumption. This is true of nearly
-- all (all?) targets.
- when Pragma_Overflow_Checks => Overflow_Checks : declare
- function Get_Check_Mode
+ when Pragma_Overflow_Mode => Overflow_Mode : declare
+ function Get_Overflow_Mode
(Name : Name_Id;
- Arg : Node_Id) return Overflow_Check_Type;
+ Arg : Node_Id) return Overflow_Mode_Type;
-- Function to process one pragma argument, Arg. If an identifier
- -- is present, it must be Name. Check type is returned if a valid
+ -- is present, it must be Name. Mode type is returned if a valid
-- argument exists, otherwise an error is signalled.
- --------------------
- -- Get_Check_Mode --
- --------------------
+ -----------------------
+ -- Get_Overflow_Mode --
+ -----------------------
- function Get_Check_Mode
+ function Get_Overflow_Mode
(Name : Name_Id;
- Arg : Node_Id) return Overflow_Check_Type
+ Arg : Node_Id) return Overflow_Mode_Type
is
Argx : constant Node_Id := Get_Pragma_Arg (Arg);
else
Error_Pragma_Arg ("invalid argument for pragma%", Argx);
end if;
- end Get_Check_Mode;
+ end Get_Overflow_Mode;
- -- Start of processing for Overflow_Checks
+ -- Start of processing for Overflow_Mode
begin
GNAT_Pragma;
-- Process first argument
- Scope_Suppress.Overflow_Checks_General :=
- Get_Check_Mode (Name_General, Arg1);
+ Scope_Suppress.Overflow_Mode_General :=
+ Get_Overflow_Mode (Name_General, Arg1);
-- Case of only one argument
if Arg_Count = 1 then
- Scope_Suppress.Overflow_Checks_Assertions :=
- Scope_Suppress.Overflow_Checks_General;
+ Scope_Suppress.Overflow_Mode_Assertions :=
+ Scope_Suppress.Overflow_Mode_General;
-- Case of two arguments present
else
- Scope_Suppress.Overflow_Checks_Assertions :=
- Get_Check_Mode (Name_Assertions, Arg2);
+ Scope_Suppress.Overflow_Mode_Assertions :=
+ Get_Overflow_Mode (Name_Assertions, Arg2);
end if;
- end Overflow_Checks;
+ end Overflow_Mode;
-------------
-- Ordered --
Pragma_Obsolescent => 0,
Pragma_Optimize => -1,
Pragma_Optimize_Alignment => -1,
- Pragma_Overflow_Checks => 0,
+ Pragma_Overflow_Mode => 0,
Pragma_Ordered => 0,
Pragma_Pack => 0,
Pragma_Page => -1,
Name_No_Strict_Aliasing : constant Name_Id := N + $; -- GNAT
Name_Normalize_Scalars : constant Name_Id := N + $;
Name_Optimize_Alignment : constant Name_Id := N + $; -- GNAT
- Name_Overflow_Checks : constant Name_Id := N + $; -- GNAT
+ Name_Overflow_Mode : constant Name_Id := N + $; -- GNAT
Name_Partition_Elaboration_Policy : constant Name_Id := N + $; -- Ada 05
Name_Persistent_BSS : constant Name_Id := N + $; -- GNAT
Name_Polling : constant Name_Id := N + $; -- GNAT
Pragma_No_Strict_Aliasing,
Pragma_Normalize_Scalars,
Pragma_Optimize_Alignment,
- Pragma_Overflow_Checks,
+ Pragma_Overflow_Mode,
Pragma_Partition_Elaboration_Policy,
Pragma_Persistent_BSS,
Pragma_Polling,
new Ada.Unchecked_Deallocation (String_List, String_List_Access);
-- Avoid using System.Strings.Free, which also frees the designated strings
- function Get_Overflow_Mode (C : Character) return Overflow_Check_Type;
+ function Get_Overflow_Mode (C : Character) return Overflow_Mode_Type;
-- Given a digit in the range 0 .. 3, returns the corresponding value of
- -- Overflow_Check_Type. Raises Program_Error if C is outside this range.
+ -- Overflow_Mode_Type. Raises Program_Error if C is outside this range.
function Switch_Subsequently_Cancelled
(C : String;
-- Get_Overflow_Mode --
-----------------------
- function Get_Overflow_Mode (C : Character) return Overflow_Check_Type is
+ function Get_Overflow_Mode (C : Character) return Overflow_Mode_Type is
begin
case C is
when '1' =>
-- Case of no digits after the -gnato
if Ptr > Max or else Switch_Chars (Ptr) not in '1' .. '3' then
- Suppress_Options.Overflow_Checks_General := Strict;
- Suppress_Options.Overflow_Checks_Assertions := Strict;
+ Suppress_Options.Overflow_Mode_General := Strict;
+ Suppress_Options.Overflow_Mode_Assertions := Strict;
-- At least one digit after the -gnato
else
-- Handle first digit after -gnato
- Suppress_Options.Overflow_Checks_General :=
+ Suppress_Options.Overflow_Mode_General :=
Get_Overflow_Mode (Switch_Chars (Ptr));
Ptr := Ptr + 1;
if Ptr > Max
or else Switch_Chars (Ptr) not in '1' .. '3'
then
- Suppress_Options.Overflow_Checks_Assertions :=
- Suppress_Options.Overflow_Checks_General;
+ Suppress_Options.Overflow_Mode_Assertions :=
+ Suppress_Options.Overflow_Mode_General;
-- Process second digit after -gnato
else
- Suppress_Options.Overflow_Checks_Assertions :=
+ Suppress_Options.Overflow_Mode_Assertions :=
Get_Overflow_Mode (Switch_Chars (Ptr));
Ptr := Ptr + 1;
end if;
-- 5. Add appropriate checks for the new test
-- The following provides precise details on the mode used to generate
- -- code for intermediate overflows in expressions for signed integer
+ -- code for intermediate operations in expressions for signed integer
-- arithmetic (and how to generate overflow checks if enabled). Note
-- that this only affects handling of intermediate results. The final
-- result must always fit within the target range, and if overflow
-- checking is enabled, the check on the final result is against this
-- target range.
- type Overflow_Check_Type is (
+ type Overflow_Mode_Type is (
Not_Set,
-- Dummy value used during initialization process to show that the
-- corresponding value has not yet been initialized.
-- the overflow checking mode, since overflows are eliminated.
subtype Minimized_Or_Eliminated is
- Overflow_Check_Type range Minimized .. Eliminated;
+ Overflow_Mode_Type range Minimized .. Eliminated;
-- Define subtype so that clients don't need to know ordering. Note that
- -- Overflow_Check_Type is not marked as an ordered enumeration type.
+ -- Overflow_Mode_Type is not marked as an ordered enumeration type.
-- The following structure captures the state of check suppression or
-- activation at a particular point in the program execution.
Suppress : Suppress_Array;
-- Indicates suppression status of each possible check
- Overflow_Checks_General : Overflow_Check_Type;
+ Overflow_Mode_General : Overflow_Mode_Type;
-- This field indicates the mode for handling code generation and
-- overflow checking (if enabled) for intermediate expression values.
-- This applies to general expressions outside assertions.
- Overflow_Checks_Assertions : Overflow_Check_Type;
+ Overflow_Mode_Assertions : Overflow_Mode_Type;
-- This field indicates the mode for handling code generation and
-- overflow checking (if enabled) for intermediate expression values.
-- This applies to any expression occuring inside assertions.
OSDN Git Service
