Skip to content

R
riscv-gcc-1
Commit acad3c0a by Arnaud Charlet
Options

[multiple changes] 

2012-10-01  Robert Dewar  <dewar@adacore.com>

	* checks.adb (Overflow_Check_Mode): New function
	(Apply_Overflow_Check): New procedure (Is_Check_Suppressed):
	Moved here from Sem, Overflow_Check case now specially treated.
	* checks.ads (Overflow_Check_Mode): New function
	(Is_Check_Suppressed): Moved here from Sem (more logical)
	* exp_ch4.adb (Substitute_Valid_Check): Suppress warning about
	optimization if we are in MINIMIZED or ELIMINATED overflow
	checking mode and within an assertiom expression.
	* rtsfind.ads: Add entries for Bignum stuff.
	* s-bignum.ads, s-bignum.adb: New files.
	* sem.ads, sem.adb (Is_Check_Suppressed): Moved to Checks, more logical.
	* sem_prag.adb (Process_Suppress_Unsuppress): New behavior for
	Unsuppress of Overflow_Check (sets Checked instead of Minimized)
	* sem_res.adb: Update comments.
	* sinfo.ads (N_Op): Add documentation on overflow handling.
	* tbuild.ads, tbuild.adb (Convert_To_And_Rewrite): New procedure.
	* types.ads (Minimized_Or_Eliminated): New subtype.

2012-10-01  Eric Botcazou  <ebotcazou@adacore.com>

	* layout.adb (Layout_Type): Do not set twice the address size
	on an access-to-unconstrained array if Debug_Flag_6 is set.

From-SVN: r191912
parent d976bf74
Showing with 346 additions and 84 deletions
gcc/ada/ChangeLog
2012-10-01 Robert Dewar <dewar@adacore.com>
* checks.adb (Overflow_Check_Mode): New function
(Apply_Overflow_Check): New procedure (Is_Check_Suppressed):
Moved here from Sem, Overflow_Check case now specially treated.
* checks.ads (Overflow_Check_Mode): New function
(Is_Check_Suppressed): Moved here from Sem (more logical)
* exp_ch4.adb (Substitute_Valid_Check): Suppress warning about
optimization if we are in MINIMIZED or ELIMINATED overflow
checking mode and within an assertiom expression.
* rtsfind.ads: Add entries for Bignum stuff.
* s-bignum.ads, s-bignum.adb: New files.
* sem.ads, sem.adb (Is_Check_Suppressed): Moved to Checks, more logical.
* sem_prag.adb (Process_Suppress_Unsuppress): New behavior for
Unsuppress of Overflow_Check (sets Checked instead of Minimized)
* sem_res.adb: Update comments.
* sinfo.ads (N_Op): Add documentation on overflow handling.
* tbuild.ads, tbuild.adb (Convert_To_And_Rewrite): New procedure.
* types.ads (Minimized_Or_Eliminated): New subtype.
2012-10-01 Eric Botcazou <ebotcazou@adacore.com>
* layout.adb (Layout_Type): Do not set twice the address size
on an access-to-unconstrained array if Debug_Flag_6 is set.
2012-10-01 Hristian Kirtchev <kirtchev@adacore.com>
* sem_ch3.adb (Analyze_Declarations): Remove the specialized
......
gcc/ada/checks.ads
......@@ -67,6 +67,18 @@ package Checks is
-- reason we insist on specifying Empty is to force the caller to think
-- about whether there is any relevant entity that should be checked.
function Is_Check_Suppressed (E : Entity_Id; C : Check_Id) return Boolean;
-- This function is called if Checks_May_Be_Suppressed (E) is True to
-- determine whether check C is suppressed either on the entity E or
-- as the result of a scope suppress pragma. If Checks_May_Be_Suppressed
-- is False, then the status of the check can be determined simply by
-- examining Scope_Checks (C), so this routine is not called in that case.
function Overflow_Check_Mode (E : Entity_Id) return Overflow_Check_Type;
-- Returns current overflow checking mode, taking into account whether
-- we are inside an assertion expression. Always returns Suppressed if
-- overflow checks are suppressed for entity E.
-------------------------------------------
-- Procedures to Activate Checking Flags --
-------------------------------------------
......@@ -164,14 +176,6 @@ package Checks is
-- for Typ, if Typ has a predicate function. The check is applied only
-- if the type of N does not match Typ.
function Build_Discriminant_Checks
(N : Node_Id;
T_Typ : Entity_Id)
return Node_Id;
-- Subsidiary routine for Apply_Discriminant_Check. Builds the expression
-- that compares discriminants of the expression with discriminants of the
-- type. Also used directly for membership tests (see Exp_Ch4.Expand_N_In).
procedure Apply_Divide_Check (N : Node_Id);
-- The node kind is N_Op_Divide, N_Op_Mod, or N_Op_Rem. An appropriate
-- check is generated to ensure that the right operand is non-zero. In
......@@ -194,6 +198,25 @@ package Checks is
-- result type. This routine deals with range and overflow checks needed
-- to make sure that the universal result is in range.
function Build_Discriminant_Checks
(N : Node_Id;
T_Typ : Entity_Id)
return Node_Id;
-- Subsidiary routine for Apply_Discriminant_Check. Builds the expression
-- that compares discriminants of the expression with discriminants of the
-- type. Also used directly for membership tests (see Exp_Ch4.Expand_N_In).
function Convert_From_Bignum (N : Node_Id) return Node_Id;
-- Returns result of converting node N from Bignum. The returned value is
-- not analyzed, the caller takes responsibility for this. Node N must be
-- a subexpression node of type Bignum. The result is Long_Long_Integer.
function Convert_To_Bignum (N : Node_Id) return Node_Id;
-- Returns result of converting node N to Bignum. The returned value is not
-- analyzed, the caller takes responsibility for this. Node N must be a
-- subexpression node of a signed integer type or Bignum type (if it is
-- already a Bignnum, the returned value is Relocate_Node (N).
procedure Determine_Range
(N : Node_Id;
OK : out Boolean;
......@@ -218,6 +241,86 @@ package Checks is
-- Determines whether an access node requires a runtime access check and
-- if so inserts the appropriate run-time check.
function Make_Bignum_Block (Loc : Source_Ptr) return Node_Id;
-- This function is used by top level overflow checking routines to do a
-- mark/release operation on the secondary stack around bignum operations.
-- The block created looks like:
--
-- declare
-- M : Mark_Id := SS_Mark;
-- begin
-- SS_Release (M);
-- end;
--
-- The idea is that the caller will insert any needed extra declarations
-- after the declaration of M, and any needed statements (in particular
-- the bignum operations) before the call to SS_Release, and then do an
-- Insert_Action of the whole block (it is returned unanalyzed). The Loc
-- parameter is used to supply Sloc values for the constructed tree.
procedure Minimize_Eliminate_Overflow_Checks
(N : Node_Id;
Lo : out Uint;
Hi : out Uint);
-- This is the main routine for handling MINIMIZED and ELIMINATED overflow
-- checks. On entry N is a node whose result is a signed integer subtype.
-- If the node is an artihmetic operation, then a range analysis is carried
-- out, and there are three possibilities:
--
-- The node is left unchanged (apart from expansion of an exponentiation
-- operation). This happens if the routine can determine that the result
-- is definitely in range. The Do_Overflow_Check flag is turned off in
-- this case.
--
-- The node is transformed into an arithmetic operation with a result
-- type of Long_Long_Integer.
--
-- The node is transformed into a function call that calls an appropriate
-- function in the System.Bignums package to compute a Bignum result.
--
-- In the first two cases, Lo and Hi are set to the bounds of the possible
-- range of results, computed as accurately as possible. In the third case
-- Lo and Hi are set to No_Uint (there are some cases where we cold get an
-- advantage from keeping result ranges for Bignum values, but it could use
-- a lot of space and is very unlikely to be valuable).
--
-- If the node is not an arithmetic operation, then it is unchanged but
-- Lo and Hi are still set (to the bounds of the result subtype if nothing
-- better can be determined.
--
-- Note: this function is recursive, if called with an arithmetic operator,
-- recursive calls are made to process the operands using this procedure.
-- So we end up doing things top down. Nothing happens to an arithmetic
-- expression until this procedure is called on the top level node and
-- then the recursive calls process all the children. We have to do it
-- this way. If we try to do it bottom up in natural expansion order, then
-- there are two problems. First, where do we stash the bounds, and more
-- importantly, semantic processing will be messed up. Consider A+B+C where
-- A,B,C are all of type integer, if we processed A+B before doing semantic
-- analysis of the addition of this result to C, that addition could end up
-- with a Long_Long_Integer left operand and an Integer right operand, and
-- we would get a semantic error.
--
-- The routine is called in three situations if we are operating in
-- either MINIMIZED or ELIMINATED modes.
--
-- Overflow checks applied to the top node of an expression tree when
-- that node is an arithmetic operator. In this case the result is
-- converted to the appropriate result type (there is special processing
-- when the parent is a conversion, see body for details).
--
-- Overflow checks are applied to the operands of a comparison operation.
-- In this case, the comparison is done on the result Long_Long_Integer
-- or Bignum values, without raising any exceptions.
--
-- Overflow checks are applied to the left operand of a membership test.
-- In this case no exception is raised if a Long_Long_Integer or Bignum
-- result is outside the range of the type of that left operand (it is
-- just that the result of IN is false in that case).
--
-- Note that if Bignum values appear, the caller must take care of doing
-- the appropriate mark/release operation on the secondary stack.
-------------------------------------------------------
-- Control and Optimization of Range/Overflow Checks --
-------------------------------------------------------
......@@ -248,7 +351,9 @@ package Checks is
-- has no effect. If a check is needed then this routine sets the flag
-- Do_Overflow_Check in node N to True, unless it can be determined that
-- the check is not needed. The only condition under which this is the
-- case is if there was an identical check earlier on.
-- case is if there was an identical check earlier on. These optimziations
-- apply to CHECKED mode, but not to MINIMIZED/ELIMINATED modes. See the
-- body for a full explanation.
procedure Enable_Range_Check (N : Node_Id);
-- Set Do_Range_Check flag in node N True, unless it can be determined
......
gcc/ada/exp_ch4.adb
......@@ -4867,9 +4867,16 @@ package body Exp_Ch4 is
Analyze_And_Resolve (N, Restyp);
Error_Msg_N ("?explicit membership test may be optimized away", N);
Error_Msg_N -- CODEFIX
("\?use ''Valid attribute instead", N);
-- Give warning unless overflow checking is MINIMIZED or ELIMINATED,
-- in which case, this usage makes sense, and in any case, we have
-- actually eliminated the danger of optimization above.
if Overflow_Check_Mode (Restyp) not in Minimized_Or_Eliminated then
Error_Msg_N ("?explicit membership test may be optimized away", N);
Error_Msg_N -- CODEFIX
("\?use ''Valid attribute instead", N);
end if;
return;
end Substitute_Valid_Check;
......
gcc/ada/layout.adb
......@@ -2448,6 +2448,7 @@ package body Layout is
and then
Nkind (Type_Definition (Parent (Desig_Type)))
= N_Unconstrained_Array_Definition
and then not Debug_Flag_6
then
Init_Size (E, 2 * System_Address_Size);
......
gcc/ada/rtsfind.ads
......@@ -213,6 +213,7 @@ package Rtsfind is
System_Assertions,
System_Atomic_Primitives,
System_Aux_DEC,
System_Bignums,
System_Bit_Ops,
System_Boolean_Array_Operations,
System_Byte_Swapping,
......@@ -759,6 +760,27 @@ package Rtsfind is
RE_Type_Class_Task, -- System.Aux_DEC
RE_Type_Class_Address, -- System.Aux_DEC
RE_Big_Abs, -- System.Bignums
RE_Big_Add, -- System.Bignums
RE_Big_Div, -- System.Bignums
RE_Big_Exp, -- System.Bignums
RE_Big_Mod, -- System.Bignums
RE_Big_Mul, -- System.Bignums
RE_Big_Neg, -- System.Bignums
RE_Big_Rem, -- System.Bignums
RE_Big_Sub, -- System.Bignums
RE_Big_EQ, -- System.Bignums
RE_Big_GE, -- System.Bignums
RE_Big_GT, -- System.Bignums
RE_Big_LE, -- System.Bignums
RE_Big_LT, -- System.Bignums
RE_Big_NE, -- System.Bignums
RE_Bignum, -- System.Bignums
RE_To_Bignum, -- System.Bignums
RE_From_Bignum, -- System.Bignums
RE_Bit_And, -- System.Bit_Ops
RE_Bit_Eq, -- System.Bit_Ops
RE_Bit_Not, -- System.Bit_Ops
......@@ -783,18 +805,14 @@ package Rtsfind is
RE_Compare_Array_S8_Unaligned, -- System.Compare_Array_Signed_8
RE_Compare_Array_S16, -- System.Compare_Array_Signed_16
RE_Compare_Array_S32, -- System.Compare_Array_Signed_16
RE_Compare_Array_S64, -- System.Compare_Array_Signed_16
RE_Compare_Array_U8, -- System.Compare_Array_Unsigned_8
RE_Compare_Array_U8_Unaligned, -- System.Compare_Array_Unsigned_8
RE_Compare_Array_U16, -- System.Compare_Array_Unsigned_16
RE_Compare_Array_U32, -- System.Compare_Array_Unsigned_16
RE_Compare_Array_U64, -- System.Compare_Array_Unsigned_16
RE_Str_Concat_2, -- System.Concat_2
......@@ -1985,6 +2003,27 @@ package Rtsfind is
RE_Type_Class_Task => System_Aux_DEC,
RE_Type_Class_Address => System_Aux_DEC,
RE_Big_Abs => System_Bignums,
RE_Big_Add => System_Bignums,
RE_Big_Div => System_Bignums,
RE_Big_Exp => System_Bignums,
RE_Big_Mod => System_Bignums,
RE_Big_Mul => System_Bignums,
RE_Big_Neg => System_Bignums,
RE_Big_Rem => System_Bignums,
RE_Big_Sub => System_Bignums,
RE_Big_EQ => System_Bignums,
RE_Big_GE => System_Bignums,
RE_Big_GT => System_Bignums,
RE_Big_LE => System_Bignums,
RE_Big_LT => System_Bignums,
RE_Big_NE => System_Bignums,
RE_Bignum => System_Bignums,
RE_To_Bignum => System_Bignums,
RE_From_Bignum => System_Bignums,
RE_Bit_And => System_Bit_Ops,
RE_Bit_Eq => System_Bit_Ops,
RE_Bit_Not => System_Bit_Ops,
......
gcc/ada/s-bignum.ads 0 → 100644
------------------------------------------------------------------------------
-- --
-- GNAT COMPILER COMPONENTS --
-- --
-- S Y S T E M . B I G N U M S --
-- --
-- S p e c --
-- --
-- Copyright (C) 2012, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
-- ware Foundation; either version 3, or (at your option) any later ver- --
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE. --
-- --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception, --
-- version 3.1, as published by the Free Software Foundation. --
-- --
-- You should have received a copy of the GNU General Public License and --
-- a copy of the GCC Runtime Library Exception along with this program; --
-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
-- <http://www.gnu.org/licenses/>. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
-- This package provides arbitrary precision signed integer arithmetic for
-- use in computing intermediate values in expressions for the case where
-- pragma Overflow_Check (Eliminate) is in effect.
with Interfaces;
package System.Bignums is
subtype Length is Natural range 0 .. 2 ** 23 - 1;
-- Represent number of words in Digit_Vector
Base : constant := 2 ** 32;
-- Digit vectors use this base
subtype SD is Interfaces.Unsigned_32;
-- Single length digit
type Digit_Vector is array (Length range <>) of SD;
-- Represent digits of a number (most significant digit first)
type Bignum_Data (Len : Length) is record
Neg : Boolean;
-- Set if value is negative, never set for zero
D : Digit_Vector (1 .. Len);
-- Digits of number, most significant first, represented in base
-- 2**Base. No leading zeroes are stored, and the value of zero is
-- represented using an empty vector for D.
end record;
for Bignum_Data use record
Len at 0 range 0 .. 23;
Neg at 3 range 0 .. 7;
end record;
type Bignum is access all Bignum_Data;
-- Note: none of the subprograms in this package modify the Bignum_Data
-- records referenced by Bignum arguments of mode IN.
function Big_Add (X, Y : Bignum) return Bignum; -- "+"
function Big_Sub (X, Y : Bignum) return Bignum; -- "-"
function Big_Mul (X, Y : Bignum) return Bignum; -- "*"
function Big_Div (X, Y : Bignum) return Bignum; -- "/"
function Big_Exp (X, Y : Bignum) return Bignum; -- "**"
function Big_Mod (X, Y : Bignum) return Bignum; -- "mod"
function Big_Rem (X, Y : Bignum) return Bignum; -- "rem"
function Big_Neg (X : Bignum) return Bignum; -- "-"
function Big_Abs (X : Bignum) return Bignum; -- "abs"
-- Perform indicated arithmetic operation on bignum values. No exception
-- raised except for Div/Mod/Rem by 0 which raises Constraint_Error with
-- an appropriate message.
function Big_EQ (X, Y : Bignum) return Boolean; -- "="
function Big_NE (X, Y : Bignum) return Boolean; -- "/="
function Big_GE (X, Y : Bignum) return Boolean; -- ">="
function Big_LE (X, Y : Bignum) return Boolean; -- "<="
function Big_GT (X, Y : Bignum) return Boolean; -- ">"
function Big_LT (X, Y : Bignum) return Boolean; -- "<"
-- Perform indicated comparison on bignums, returning result as Boolean.
-- No exception raised for any input arguments.
function To_Bignum (X : Long_Long_Integer) return Bignum;
-- Convert Long_Long_Integer to Bignum. No exception can be raised for any
-- input argument.
function From_Bignum (X : Bignum) return Long_Long_Integer;
-- Convert Bignum to Long_Long_Integer. Constraint_Error raised with
-- appropriate message if value is out of range of Long_Long_Integer.
end System.Bignums;
gcc/ada/sem.adb
......@@ -1218,59 +1218,6 @@ package body Sem is
end if;
end Insert_List_Before_And_Analyze;
-------------------------
-- Is_Check_Suppressed --
-------------------------
function Is_Check_Suppressed (E : Entity_Id; C : Check_Id) return Boolean is
Ptr : Suppress_Stack_Entry_Ptr;
begin
-- First search the local entity suppress stack. We search this from the
-- top of the stack down so that we get the innermost entry that applies
-- to this case if there are nested entries.
Ptr := Local_Suppress_Stack_Top;
while Ptr /= null loop
if (Ptr.Entity = Empty or else Ptr.Entity = E)
and then (Ptr.Check = All_Checks or else Ptr.Check = C)
then
return Ptr.Suppress;
end if;
Ptr := Ptr.Prev;
end loop;
-- Now search the global entity suppress table for a matching entry.
-- We also search this from the top down so that if there are multiple
-- pragmas for the same entity, the last one applies (not clear what
-- or whether the RM specifies this handling, but it seems reasonable).
Ptr := Global_Suppress_Stack_Top;
while Ptr /= null loop
if (Ptr.Entity = Empty or else Ptr.Entity = E)
and then (Ptr.Check = All_Checks or else Ptr.Check = C)
then
return Ptr.Suppress;
end if;
Ptr := Ptr.Prev;
end loop;
-- If we did not find a matching entry, then use the normal scope
-- suppress value after all (actually this will be the global setting
-- since it clearly was not overridden at any point). For a predefined
-- check, we test the specific flag. For a user defined check, we check
-- the All_Checks flag.
if C in Predefined_Check_Id then
return Scope_Suppress.Suppress (C);
else
return Scope_Suppress.Suppress (All_Checks);
end if;
end Is_Check_Suppressed;
----------
-- Lock --
----------
......
gcc/ada/sem.ads
......@@ -641,13 +641,6 @@ package Sem is
-- This function returns True if an explicit pragma Suppress for check C
-- is present in the package defining E.
function Is_Check_Suppressed (E : Entity_Id; C : Check_Id) return Boolean;
-- This function is called if Checks_May_Be_Suppressed (E) is True to
-- determine whether check C is suppressed either on the entity E or
-- as the result of a scope suppress pragma. If Checks_May_Be_Suppressed
-- is False, then the status of the check can be determined simply by
-- examining Scope_Checks (C), so this routine is not called in that case.
procedure Preanalyze (N : Node_Id);
-- Performs a pre-analysis of node N. During pre-analysis no expansion is
-- carried out for N or its children. For more info on pre-analysis read
......
gcc/ada/sem_prag.adb
......@@ -5685,8 +5685,8 @@ package body Sem_Prag is
Scope_Suppress.Overflow_Checks_General := Suppressed;
Scope_Suppress.Overflow_Checks_Assertions := Suppressed;
else
Scope_Suppress.Overflow_Checks_General := Minimized;
Scope_Suppress.Overflow_Checks_Assertions := Minimized;
Scope_Suppress.Overflow_Checks_General := Checked;
Scope_Suppress.Overflow_Checks_Assertions := Checked;
end if;
end if;
......
gcc/ada/sem_res.adb
......@@ -4965,10 +4965,7 @@ package body Sem_Res is
("operation should be qualified or explicitly converted", N);
end if;
-- Set overflow and division checking bit. Much cleverer code needed
-- here eventually and perhaps the Resolve routines should be separated
-- for the various arithmetic operations, since they will need
-- different processing. ???
-- Set overflow and division checking bit
if Nkind (N) in N_Op then
if not Overflow_Checks_Suppressed (Etype (N)) then
......
gcc/ada/sinfo.ads
......@@ -408,6 +408,14 @@ package Sinfo is
-- Do_Overflow_Check (Flag17-Sem) set if overflow check needed
-- Has_Private_View (Flag11-Sem) set in generic units.
-- Note on use of entity field. This field is set during analysis
-- and is used in carrying out semantic checking, but it has no
-- significance to the back end, which is driven by the Etype's
-- of the operands, and the Etype of the result. During processing
-- in the exapander for overflow checks, these types may be modified
-- and there is no point in trying to set a proper Entity value, so
-- it just gets cleared to Empty in this situation.
-- "plus fields for unary operator"
-- Chars (Name1) Name_Id for the operator
-- Right_Opnd (Node3) right operand expression
......@@ -416,6 +424,8 @@ package Sinfo is
-- Do_Overflow_Check (Flag17-Sem) set if overflow check needed
-- Has_Private_View (Flag11-Sem) set in generic units.
-- See note on use of Entity field above (same situation).
-- "plus fields for expression"
-- Paren_Count number of parentheses levels
-- Etype (Node5-Sem) type of the expression
......@@ -3849,6 +3859,22 @@ package Sinfo is
-- point operands if the Treat_Fixed_As_Integer flag is set and will
-- thus treat these nodes in identical manner, ignoring small values.
-- Note on overflow handling: When the overflow checking mode is set to
-- MINIMIZED or ELIMINATED, nodes for signed arithmetic operations may
-- be modified to use a larger type for the operands and result. In
-- these cases, the back end does not need the Entity field anyway, so
-- there is no point in setting it. In fact we reuse the Entity field to
-- record the possible range of the result. Entity points to an N_Range
-- node whose Low_Bound and High_Bound fields point to integer literal
-- nodes containing the computed bounds. These range nodes are only set
-- for intermediate nodes whose parents are themselves either arithmetic
-- operators, or comparison or membership tests. The computed ranges are
-- then used in processing the parent operation. In the case where the
-- computed range exceeds that of Long_Long_Integer, and we are running
-- in ELIMINATED mode, the operator node will be changed to be a call to
-- the appropriate routine in System.Bignums, and in this case we forget
-- about keeping track of the range.
---------------------------------
-- 4.5.9 Quantified Expression --
---------------------------------
......
gcc/ada/tbuild.adb
......@@ -6,7 +6,7 @@
-- --
-- B o d y --
-- --
-- Copyright (C) 1992-2011, Free Software Foundation, Inc. --
-- Copyright (C) 1992-2012, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
......@@ -129,6 +129,15 @@ package body Tbuild is
end if;
end Convert_To;
----------------------------
-- Convert_To_And_Rewrite --
----------------------------
procedure Convert_To_And_Rewrite (Typ : Entity_Id; Expr : Node_Id) is
begin
Rewrite (Expr, Convert_To (Typ, Expr));
end Convert_To_And_Rewrite;
------------------
-- Discard_List --
------------------
......
gcc/ada/tbuild.ads
......@@ -6,7 +6,7 @@
-- --
-- S p e c --
-- --
-- Copyright (C) 1992-2011, Free Software Foundation, Inc. --
-- Copyright (C) 1992-2012, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
......@@ -48,6 +48,12 @@ package Tbuild is
-- Exp. This means that it is safe to replace a node by a Convert_To
-- of itself to some other type.
procedure Convert_To_And_Rewrite (Typ : Entity_Id; Expr : Node_Id);
pragma Inline (Convert_To_And_Rewrite);
-- Like the function, except that there is an extra step of calling
-- Rewrite on the Expr node and replacing it with the converted result.
-- As noted above, this is safe, because Relocate_Node is called.
procedure Discard_Node (N : Node_Or_Entity_Id);
pragma Inline (Discard_Node);
-- This is a dummy procedure that simply returns and does nothing. It is
......
gcc/ada/types.ads
......@@ -735,6 +735,11 @@ package Types is
-- overflow. Again the final value of an expression must fit in the base
-- type of the whole expression.
subtype Minimized_Or_Eliminated is
Overflow_Check_Type range Minimized .. Eliminated;
-- Definte subtypes so that clients don't need to know ordering. Note that
-- Overflow_Check_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.
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment