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

stor-layout.c (mode_for_size_tree): Use tree_low_cst.

Browse Source 
* stor-layout.c (mode_for_size_tree): Use tree_low_cst.
	(layout_decl, place_field): Likewise.
	Also make minor type and whitespace changes.

From-SVN: r66268
This commit is contained in:
Richard Kenner 2003-04-29 22:48:55 +00:00 committed by Richard Kenner
parent 7f78b6caa0
commit 0384674ecf
2 changed files with 42 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
gcc/ChangeLog
View File

@ -10,6 +10,10 @@
2003-04-29 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
* stor-layout.c (mode_for_size_tree): Use tree_low_cst.
(layout_decl, place_field): Likewise.
Also make minor type and whitespace changes.
* tree.c (save_expr): Don't fold a COMPONENT_REF.
2003-04-29 Olivier Hainque <hainque@act-europe.fr>

48
gcc/stor-layout.c
View File

@ -249,7 +249,7 @@ mode_for_size_tree (size, class, limit)
|| compare_tree_int (size, 1000) > 0)
return BLKmode;
else
return mode_for_size (TREE_INT_CST_LOW (size), class, limit);
return mode_for_size (tree_low_cst (size, 1), class, limit);
}
/* Similar, but never return BLKmode; return the narrowest mode that
@ -533,7 +533,7 @@ layout_decl (decl, known_align)
if (size != 0 && TREE_CODE (size) == INTEGER_CST
&& compare_tree_int (size, larger_than_size) > 0)
{
unsigned int size_as_int = TREE_INT_CST_LOW (size);
int size_as_int = TREE_INT_CST_LOW (size);
if (compare_tree_int (size, size_as_int) == 0)
warning_with_decl (decl, "size of `%s' is %d bytes", size_as_int);
@ -1074,25 +1074,28 @@ place_field (rli, field)
if (DECL_BIT_FIELD_TYPE (field)
&& !integer_zerop (DECL_SIZE (field))
&& !integer_zerop (DECL_SIZE (rli->prev_field))
&& host_integerp (DECL_SIZE (rli->prev_field), 0)
&& host_integerp (TYPE_SIZE (type), 0)
&& simple_cst_equal (TYPE_SIZE (type),
TYPE_SIZE (TREE_TYPE (rli->prev_field))))
{
/* We're in the middle of a run of equal type size fields; make
sure we realign if we run out of bits. (Not decl size,
type size!) */
int bitsize = TREE_INT_CST_LOW (DECL_SIZE (field));
tree type_size = TYPE_SIZE(TREE_TYPE(rli->prev_field));
HOST_WIDE_INT bitsize = tree_low_cst (DECL_SIZE (field), 0);
if (rli->remaining_in_alignment < bitsize)
{
/* out of bits; bump up to next 'word'. */
rli->offset = DECL_FIELD_OFFSET (rli->prev_field);
rli->bitpos = size_binop (PLUS_EXPR,
type_size,
rli->bitpos
= size_binop (PLUS_EXPR, TYPE_SIZE (type),
DECL_FIELD_BIT_OFFSET (rli->prev_field));
rli->prev_field = field;
rli->remaining_in_alignment = TREE_INT_CST_LOW (type_size);
rli->remaining_in_alignment
= tree_low_cst (TYPE_SIZE (type), 0);
}
rli->remaining_in_alignment -= bitsize;
}
else
@ -1109,25 +1112,23 @@ place_field (rli, field)
if (!integer_zerop (DECL_SIZE (rli->prev_field)))
{
tree type_size = TYPE_SIZE (TREE_TYPE (rli->prev_field));
rli->bitpos = size_binop (PLUS_EXPR,
type_size,
rli->bitpos
= size_binop (PLUS_EXPR, type_size,
DECL_FIELD_BIT_OFFSET (rli->prev_field));
}
else
{
/* We "use up" size zero fields; the code below should behave
as if the prior field was not a bitfield. */
prev_saved = NULL;
}
/* Cause a new bitfield to be captured, either this time (if
currently a bitfield) or next time we see one. */
if (!DECL_BIT_FIELD_TYPE(field)
|| integer_zerop (DECL_SIZE (field)))
{
rli->prev_field = NULL;
}
}
normalize_rli (rli);
}
@ -1149,17 +1150,19 @@ place_field (rli, field)
TYPE_SIZE (TREE_TYPE (prev_saved)))
: !integer_zerop (DECL_SIZE (field)) ))
{
unsigned int type_align = 8; /* Never below 8 for compatibility */
/* Never smaller than a byte for compatibility. */
unsigned int type_align = BITS_PER_UNIT;
/* (When not a bitfield), we could be seeing a flex array (with
no DECL_SIZE). Since we won't be using remaining_in_alignment
until we see a bitfield (and come by here again) we just skip
calculating it. */
if (DECL_SIZE (field) != NULL)
if (DECL_SIZE (field) != NULL
&& host_integerp (TYPE_SIZE (TREE_TYPE (field)), 0)
&& host_integerp (DECL_SIZE (field), 0))
rli->remaining_in_alignment
= TREE_INT_CST_LOW (TYPE_SIZE(TREE_TYPE(field)))
- TREE_INT_CST_LOW (DECL_SIZE (field));
= tree_low_cst (TYPE_SIZE (TREE_TYPE(field)), 0)
- tree_low_cst (DECL_SIZE (field), 0);
/* Now align (conventionally) for the new type. */
if (!DECL_PACKED(field))
@ -1178,6 +1181,7 @@ place_field (rli, field)
type_align = MIN (type_align, maximum_field_alignment);
rli->bitpos = round_up (rli->bitpos, type_align);
/* If we really aligned, don't allow subsequent bitfields
to undo that. */
rli->prev_field = NULL;
@ -1860,10 +1864,10 @@ layout_type (type)
#endif
unsigned int alignment
= set_alignment ? set_alignment : SET_WORD_SIZE;
int size_in_bits
= (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
- TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) + 1);
int rounded_size
HOST_WIDE_INT size_in_bits
= (tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0)
- tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0) + 1);
HOST_WIDE_INT rounded_size
= ((size_in_bits + alignment - 1) / alignment) * alignment;
if (rounded_size > (int) alignment)