OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

decl.c (gnat_to_gnu_entity): Use TREE_OVERFLOW instead of TREE_CONSTANT_OVERFLOW.

Browse Source 
* decl.c (gnat_to_gnu_entity): Use TREE_OVERFLOW instead of
	TREE_CONSTANT_OVERFLOW.
	(allocatable_size_p, annotate_value): Likewise.
	* trans.c (gnat_to_gnu): Likewise.
	* utils.c (unchecked_convert): Likewise.
	* utils2.c (build_simple_component_ref): Likewise.

From-SVN: r121177
This commit is contained in:
Roger Sayle 2007-01-25 16:58:26 +00:00 committed by Roger Sayle
parent d6efbf5a88
commit cd259a9825
5 changed files with 28 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
gcc/ada/ChangeLog
View File

@ -1,3 +1,12 @@
2007-01-24 Roger Sayle <roger@eyesopen.com>
* decl.c (gnat_to_gnu_entity): Use TREE_OVERFLOW instead of
TREE_CONSTANT_OVERFLOW.
(allocatable_size_p, annotate_value): Likewise.
* trans.c (gnat_to_gnu): Likewise.
* utils.c (unchecked_convert): Likewise.
* utils2.c (build_simple_component_ref): Likewise.
2007-01-23 Richard Guenther <rguenther@suse.de>
PR bootstrap/30541

22
gcc/ada/decl.c
View File

@ -6,7 +6,7 @@
* *
* C Implementation File *
* *
* Copyright (C) 1992-2006, Free Software Foundation, Inc. *
* Copyright (C) 1992-2007, 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- *
@ -1044,7 +1044,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
}
if (TREE_CODE (TYPE_SIZE_UNIT (gnu_alloc_type)) == INTEGER_CST
&& TREE_CONSTANT_OVERFLOW (TYPE_SIZE_UNIT (gnu_alloc_type))
&& TREE_OVERFLOW (TYPE_SIZE_UNIT (gnu_alloc_type))
&& !Is_Imported (gnat_entity))
post_error ("Storage_Error will be raised at run-time?",
gnat_entity);
@ -1907,9 +1907,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
(fold (build2 (MINUS_EXPR, gnu_index_subtype,
TYPE_MAX_VALUE (gnu_index_subtype),
TYPE_MIN_VALUE (gnu_index_subtype))))))
TREE_OVERFLOW (gnu_min) = TREE_OVERFLOW (gnu_max)
= TREE_CONSTANT_OVERFLOW (gnu_min)
= TREE_CONSTANT_OVERFLOW (gnu_max) = 0;
TREE_OVERFLOW (gnu_min) = TREE_OVERFLOW (gnu_max) = 0;
/* Similarly, if the range is null, use bounds of 1..0 for
the sizetype bounds. */
@ -1939,8 +1937,8 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
code below to malfunction if we don't handle it specially. */
if (TREE_CODE (gnu_base_min) == INTEGER_CST
&& TREE_CODE (gnu_base_max) == INTEGER_CST
&& !TREE_CONSTANT_OVERFLOW (gnu_base_min)
&& !TREE_CONSTANT_OVERFLOW (gnu_base_max)
&& !TREE_OVERFLOW (gnu_base_min)
&& !TREE_OVERFLOW (gnu_base_max)
&& tree_int_cst_lt (gnu_base_max, gnu_base_min))
gnu_high = size_zero_node, gnu_min = size_one_node;
@ -1986,10 +1984,10 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
gnu_base_max = gnu_max;
if ((TREE_CODE (gnu_base_min) == INTEGER_CST
&& TREE_CONSTANT_OVERFLOW (gnu_base_min))
&& TREE_OVERFLOW (gnu_base_min))
|| operand_equal_p (gnu_base_min, gnu_base_base_min, 0)
|| (TREE_CODE (gnu_base_max) == INTEGER_CST
&& TREE_CONSTANT_OVERFLOW (gnu_base_max))
&& TREE_OVERFLOW (gnu_base_max))
|| operand_equal_p (gnu_base_max, gnu_base_base_max, 0))
max_overflow = true;
@ -2004,7 +2002,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
size_zero_node);
if (TREE_CODE (gnu_this_max) == INTEGER_CST
&& TREE_CONSTANT_OVERFLOW (gnu_this_max))
&& TREE_OVERFLOW (gnu_this_max))
max_overflow = true;
gnu_max_size
@ -4590,7 +4588,7 @@ allocatable_size_p (tree gnu_size, bool static_p)
Storage_Error. */
if (!static_p)
return !(TREE_CODE (gnu_size) == INTEGER_CST
&& TREE_CONSTANT_OVERFLOW (gnu_size));
&& TREE_OVERFLOW (gnu_size));
/* Otherwise, we need to deal with both variable sizes and constant
sizes that won't fit in a host int. We use int instead of HOST_WIDE_INT
@ -5906,7 +5904,7 @@ annotate_value (tree gnu_size)
bool adjust = false;
tree temp;
if (TREE_CONSTANT_OVERFLOW (negative_size))
if (TREE_OVERFLOW (negative_size))
{
negative_size
= size_binop (MINUS_EXPR, bitsize_zero_node,

14
gcc/ada/trans.c
View File

@ -6,7 +6,7 @@
* *
* C Implementation File *
* *
* Copyright (C) 1992-2006, Free Software Foundation, Inc. *
* Copyright (C) 1992-2007, 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- *
@ -2714,7 +2714,7 @@ gnat_to_gnu (Node_Id gnat_node)
of the subtype, but that causes problems with subtypes whose usage
will raise Constraint_Error and with biased representation, so
we don't. */
gcc_assert (!TREE_CONSTANT_OVERFLOW (gnu_result));
gcc_assert (!TREE_OVERFLOW (gnu_result));
}
break;
@ -2741,7 +2741,7 @@ gnat_to_gnu (Node_Id gnat_node)
gnu_result_type = get_unpadded_type (Etype (gnat_node));
gnu_result = UI_To_gnu (Corresponding_Integer_Value (gnat_node),
gnu_result_type);
gcc_assert (!TREE_CONSTANT_OVERFLOW (gnu_result));
gcc_assert (!TREE_OVERFLOW (gnu_result));
}
/* We should never see a Vax_Float type literal, since the front end
@ -3440,11 +3440,7 @@ gnat_to_gnu (Node_Id gnat_node)
tree gnu_old_lhs = gnu_lhs;
gnu_lhs = convert (gnu_type, gnu_lhs);
if (TREE_CODE (gnu_lhs) == INTEGER_CST && ignore_lhs_overflow)
{
TREE_OVERFLOW (gnu_lhs) = TREE_OVERFLOW (gnu_old_lhs);
TREE_CONSTANT_OVERFLOW (gnu_lhs)
= TREE_CONSTANT_OVERFLOW (gnu_old_lhs);
}
TREE_OVERFLOW (gnu_lhs) = TREE_OVERFLOW (gnu_old_lhs);
gnu_rhs = convert (gnu_type, gnu_rhs);
}
@ -4343,7 +4339,7 @@ gnat_to_gnu (Node_Id gnat_node)
/* If the result is a constant that overflows, raise constraint error. */
else if (TREE_CODE (gnu_result) == INTEGER_CST
&& TREE_CONSTANT_OVERFLOW (gnu_result))
&& TREE_OVERFLOW (gnu_result))
{
post_error ("Constraint_Error will be raised at run-time?", gnat_node);

4
gcc/ada/utils.c
View File

@ -6,7 +6,7 @@
* *
* C Implementation File *
* *
* Copyright (C) 1992-2006, Free Software Foundation, Inc. *
* Copyright (C) 1992-2007, 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- *
@ -3680,7 +3680,7 @@ unchecked_convert (tree type, tree expr, bool notrunc_p)
when it is false, we can rely on the fact that such conversions are
erroneous anyway. */
if (TREE_CODE (expr) == INTEGER_CST)
TREE_OVERFLOW (expr) = TREE_CONSTANT_OVERFLOW (expr) = 0;
TREE_OVERFLOW (expr) = 0;
/* If the sizes of the types differ and this is an VIEW_CONVERT_EXPR,
show no longer constant. */

4
gcc/ada/utils2.c
View File

@ -6,7 +6,7 @@
* *
* C Implementation File *
* *
* Copyright (C) 1992-2006, Free Software Foundation, Inc. *
* Copyright (C) 1992-2007, 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- *
@ -1649,7 +1649,7 @@ build_simple_component_ref (tree record_variable, tree component,
Note that we don't need to warn since this will be done on trying
to declare the object. */
if (TREE_CODE (DECL_FIELD_OFFSET (field)) == INTEGER_CST
&& TREE_CONSTANT_OVERFLOW (DECL_FIELD_OFFSET (field)))
&& TREE_OVERFLOW (DECL_FIELD_OFFSET (field)))
return NULL_TREE;
/* It would be nice to call "fold" here, but that can lose a type