/* C-compiler utilities for types and variables storage layout
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1996, 1998,
- 1999, 2000 Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
-This file is part of GNU CC.
+This file is part of GCC.
-GNU CC is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
-any later version.
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2, or (at your option) any later
+version.
-GNU CC is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
You should have received a copy of the GNU General Public License
-along with GNU CC; see the file COPYING. If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+along with GCC; see the file COPYING. If not, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA. */
#include "config.h"
#include "expr.h"
#include "toplev.h"
#include "ggc.h"
+#include "target.h"
+#include "langhooks.h"
/* Set to one when set_sizetype has been called. */
static int sizetype_set;
May be overridden by front-ends. */
unsigned int set_alignment = 0;
-static void finalize_record_size PARAMS ((record_layout_info));
-static void compute_record_mode PARAMS ((tree));
-static void finalize_type_size PARAMS ((tree));
-static void layout_union_field PARAMS ((record_layout_info, tree));
-static void finish_union_layout PARAMS ((record_layout_info));
+/* Nonzero if all REFERENCE_TYPEs are internal and hence should be
+ allocated in Pmode, not ptr_mode. Set only by internal_reference_types
+ called only by a front end. */
+static int reference_types_internal = 0;
+
+static void finalize_record_size PARAMS ((record_layout_info));
+static void finalize_type_size PARAMS ((tree));
+static void place_union_field PARAMS ((record_layout_info, tree));
+extern void debug_rli PARAMS ((record_layout_info));
\f
/* SAVE_EXPRs for sizes of types and decls, waiting to be expanded. */
-static tree pending_sizes;
+static GTY(()) tree pending_sizes;
/* Nonzero means cannot safely call expand_expr now,
so put variable sizes onto `pending_sizes' instead. */
int immediate_size_expand;
+/* Show that REFERENCE_TYPES are internal and should be Pmode. Called only
+ by front end. */
+
+void
+internal_reference_types ()
+{
+ reference_types_internal = 1;
+}
+
+/* Get a list of all the objects put on the pending sizes list. */
+
tree
get_pending_sizes ()
{
return chain;
}
+/* Return non-zero if EXPR is present on the pending sizes list. */
+
+int
+is_pending_size (expr)
+ tree expr;
+{
+ tree t;
+
+ for (t = pending_sizes; t; t = TREE_CHAIN (t))
+ if (TREE_VALUE (t) == expr)
+ return 1;
+ return 0;
+}
+
+/* Add EXPR to the pending sizes list. */
+
+void
+put_pending_size (expr)
+ tree expr;
+{
+ /* Strip any simple arithmetic from EXPR to see if it has an underlying
+ SAVE_EXPR. */
+ while (TREE_CODE_CLASS (TREE_CODE (expr)) == '1'
+ || (TREE_CODE_CLASS (TREE_CODE (expr)) == '2'
+ && TREE_CONSTANT (TREE_OPERAND (expr, 1))))
+ expr = TREE_OPERAND (expr, 0);
+
+ if (TREE_CODE (expr) == SAVE_EXPR)
+ pending_sizes = tree_cons (NULL_TREE, expr, pending_sizes);
+}
+
+/* Put a chain of objects into the pending sizes list, which must be
+ empty. */
+
void
put_pending_sizes (chain)
tree chain;
{
/* If the language-processor is to take responsibility for variable-sized
items (e.g., languages which have elaboration procedures like Ada),
- just return SIZE unchanged. Likewise for self-referential sizes. */
+ just return SIZE unchanged. Likewise for self-referential sizes and
+ constant sizes. */
if (TREE_CONSTANT (size)
- || global_bindings_p () < 0 || contains_placeholder_p (size))
+ || (*lang_hooks.decls.global_bindings_p) () < 0
+ || contains_placeholder_p (size))
return size;
size = save_expr (size);
if (TREE_CODE (size) == SAVE_EXPR)
SAVE_EXPR_PERSISTENT_P (size) = 1;
- if (global_bindings_p ())
+ if ((*lang_hooks.decls.global_bindings_p) ())
{
if (TREE_CONSTANT (size))
error ("type size can't be explicitly evaluated");
}
if (immediate_size_expand)
- /* NULL_RTX is not defined; neither is the rtx type.
+ /* NULL_RTX is not defined; neither is the rtx type.
Also, we would like to pass const0_rtx here, but don't have it. */
- expand_expr (size, expand_expr (integer_zero_node, NULL_PTR, VOIDmode, 0),
+ expand_expr (size, expand_expr (integer_zero_node, NULL_RTX, VOIDmode, 0),
VOIDmode, 0);
- else if (cfun != 0
- && cfun->x_dont_save_pending_sizes_p)
+ else if (cfun != 0 && cfun->x_dont_save_pending_sizes_p)
/* The front-end doesn't want us to keep a list of the expressions
that determine sizes for variable size objects. */
;
else
- pending_sizes = tree_cons (NULL_TREE, size, pending_sizes);
+ put_pending_size (size);
return size;
}
enum machine_mode
mode_for_size (size, class, limit)
- int size;
+ unsigned int size;
enum mode_class class;
int limit;
{
- register enum machine_mode mode;
+ enum machine_mode mode;
if (limit && size > MAX_FIXED_MODE_SIZE)
return BLKmode;
enum machine_mode
smallest_mode_for_size (size, class)
- int size;
+ unsigned int size;
enum mode_class class;
{
- register enum machine_mode mode;
+ enum machine_mode mode;
/* Get the first mode which has at least this size, in the
specified class. */
case MODE_COMPLEX_INT:
case MODE_COMPLEX_FLOAT:
case MODE_FLOAT:
+ case MODE_VECTOR_INT:
+ case MODE_VECTOR_FLOAT:
mode = mode_for_size (GET_MODE_BITSIZE (mode), MODE_INT, 0);
break;
case MODE_RANDOM:
if (mode == BLKmode)
- break;
+ break;
- /* ... fall through ... */
+ /* ... fall through ... */
case MODE_CC:
default:
tree decl;
unsigned int known_align;
{
- register tree type = TREE_TYPE (decl);
- register enum tree_code code = TREE_CODE (decl);
+ tree type = TREE_TYPE (decl);
+ enum tree_code code = TREE_CODE (decl);
if (code == CONST_DECL)
return;
if (type == error_mark_node)
type = void_type_node;
- /* Usually the size and mode come from the data type without change. */
- DECL_MODE (decl) = TYPE_MODE (type);
+ /* Usually the size and mode come from the data type without change,
+ however, the front-end may set the explicit width of the field, so its
+ size may not be the same as the size of its type. This happens with
+ bitfields, of course (an `int' bitfield may be only 2 bits, say), but it
+ also happens with other fields. For example, the C++ front-end creates
+ zero-sized fields corresponding to empty base classes, and depends on
+ layout_type setting DECL_FIELD_BITPOS correctly for the field. Set the
+ size in bytes from the size in bits. If we have already set the mode,
+ don't set it again since we can be called twice for FIELD_DECLs. */
+
TREE_UNSIGNED (decl) = TREE_UNSIGNED (type);
+ if (DECL_MODE (decl) == VOIDmode)
+ DECL_MODE (decl) = TYPE_MODE (type);
+
if (DECL_SIZE (decl) == 0)
{
DECL_SIZE (decl) = TYPE_SIZE (type);
DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (type);
}
- else if (code == FIELD_DECL)
- {
- HOST_WIDE_INT spec_size;
-
- /* The front-end may set the explicit width of the field, so its
- size may not be the same as the size of its type. This happens
- with bitfields, of course (an `int' bitfield may be only 2 bits,
- say), but it also happens with other fields. For example, the
- C++ front-end creates zero-sized fields corresponding to empty
- base classes, and depends on layout_type setting
- DECL_FIELD_BITPOS correctly for the field. */
- if (integer_zerop (DECL_SIZE (decl))
- && DECL_NAME (decl) != NULL_TREE)
- abort ();
-
- /* Size is specified in number of bits. */
- spec_size = TREE_INT_CST_LOW (DECL_SIZE (decl));
- if (spec_size % BITS_PER_UNIT == 0)
- DECL_SIZE_UNIT (decl) = size_int (spec_size / BITS_PER_UNIT);
- else
- DECL_SIZE_UNIT (decl) = 0;
- }
+ else
+ DECL_SIZE_UNIT (decl)
+ = convert (sizetype, size_binop (CEIL_DIV_EXPR, DECL_SIZE (decl),
+ bitsize_unit_node));
/* Force alignment required for the data type.
But if the decl itself wants greater alignment, don't override that.
Likewise, if the decl is packed, don't override it. */
- if (!(code == FIELD_DECL && DECL_BIT_FIELD (decl))
+ if (! (code == FIELD_DECL && DECL_BIT_FIELD (decl))
&& (DECL_ALIGN (decl) == 0
- || (! DECL_PACKED (decl) && TYPE_ALIGN (type) > DECL_ALIGN (decl))))
- DECL_ALIGN (decl) = TYPE_ALIGN (type);
+ || (! (code == FIELD_DECL && DECL_PACKED (decl))
+ && TYPE_ALIGN (type) > DECL_ALIGN (decl))))
+ {
+ DECL_ALIGN (decl) = TYPE_ALIGN (type);
+ DECL_USER_ALIGN (decl) = 0;
+ }
- /* See if we can use an ordinary integer mode for a bit-field.
- Conditions are: a fixed size that is correct for another mode
- and occupying a complete byte or bytes on proper boundary. */
+ /* For fields, set the bit field type and update the alignment. */
if (code == FIELD_DECL)
{
DECL_BIT_FIELD_TYPE (decl) = DECL_BIT_FIELD (decl) ? type : 0;
if (maximum_field_alignment != 0)
DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), maximum_field_alignment);
- else if (DECL_PACKED (decl))
- DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), BITS_PER_UNIT);
+
+ /* If the field is of variable size, we can't misalign it since we
+ have no way to make a temporary to align the result. But this
+ isn't an issue if the decl is not addressable. Likewise if it
+ is of unknown size. */
+ else if (DECL_PACKED (decl)
+ && (DECL_NONADDRESSABLE_P (decl)
+ || DECL_SIZE_UNIT (decl) == 0
+ || TREE_CODE (DECL_SIZE_UNIT (decl)) == INTEGER_CST))
+ {
+ DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), BITS_PER_UNIT);
+ DECL_USER_ALIGN (decl) = 0;
+ }
}
- if (DECL_BIT_FIELD (decl)
+ /* See if we can use an ordinary integer mode for a bit-field.
+ Conditions are: a fixed size that is correct for another mode
+ and occupying a complete byte or bytes on proper boundary. */
+ if (code == FIELD_DECL && DECL_BIT_FIELD (decl)
&& TYPE_SIZE (type) != 0
&& TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
&& GET_MODE_CLASS (TYPE_MODE (type)) == MODE_INT)
{
- register enum machine_mode xmode
+ enum machine_mode xmode
= mode_for_size_tree (DECL_SIZE (decl), MODE_INT, 1);
- if (xmode != BLKmode
- && known_align % GET_MODE_ALIGNMENT (xmode) == 0)
+ if (xmode != BLKmode && known_align >= GET_MODE_ALIGNMENT (xmode))
{
DECL_ALIGN (decl) = MAX (GET_MODE_ALIGNMENT (xmode),
DECL_ALIGN (decl));
DECL_MODE (decl) = xmode;
- DECL_SIZE (decl) = bitsize_int (GET_MODE_BITSIZE (xmode));
- DECL_SIZE_UNIT (decl) = size_int (GET_MODE_SIZE (xmode));
- /* This no longer needs to be accessed as a bit field. */
DECL_BIT_FIELD (decl) = 0;
}
}
/* Turn off DECL_BIT_FIELD if we won't need it set. */
- if (DECL_BIT_FIELD (decl) && TYPE_MODE (type) == BLKmode
- && known_align % TYPE_ALIGN (type) == 0
- && DECL_SIZE_UNIT (decl) != 0
- && DECL_ALIGN (decl) >= TYPE_ALIGN (type))
+ if (code == FIELD_DECL && DECL_BIT_FIELD (decl)
+ && TYPE_MODE (type) == BLKmode && DECL_MODE (decl) == BLKmode
+ && known_align >= TYPE_ALIGN (type)
+ && DECL_ALIGN (decl) >= TYPE_ALIGN (type)
+ && DECL_SIZE_UNIT (decl) != 0)
DECL_BIT_FIELD (decl) = 0;
/* Evaluate nonconstant size only once, either now or as soon as safe. */
/* If requested, warn about definitions of large data objects. */
if (warn_larger_than
- && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
+ && (code == VAR_DECL || code == PARM_DECL)
&& ! DECL_EXTERNAL (decl))
{
tree size = DECL_SIZE_UNIT (decl);
}
}
\f
-/* Create a new record_layout_info for T, which may be a RECORD_TYPE,
- UNION_TYPE, or QUAL_UNION_TYPE. It is the responsibility of the
- caller to call `free' for the storage the returned. */
+/* Hook for a front-end function that can modify the record layout as needed
+ immediately before it is finalized. */
+
+void (*lang_adjust_rli) PARAMS ((record_layout_info)) = 0;
+
+void
+set_lang_adjust_rli (f)
+ void (*f) PARAMS ((record_layout_info));
+{
+ lang_adjust_rli = f;
+}
+
+/* Begin laying out type T, which may be a RECORD_TYPE, UNION_TYPE, or
+ QUAL_UNION_TYPE. Return a pointer to a struct record_layout_info which
+ is to be passed to all other layout functions for this record. It is the
+ responsibility of the caller to call `free' for the storage returned.
+ Note that garbage collection is not permitted until we finish laying
+ out the record. */
record_layout_info
-new_record_layout_info (t)
+start_record_layout (t)
tree t;
{
- record_layout_info rli
- = (record_layout_info) xcalloc (1, sizeof (struct record_layout_info_s));
+ record_layout_info rli
+ = (record_layout_info) xmalloc (sizeof (struct record_layout_info_s));
rli->t = t;
+
/* If the type has a minimum specified alignment (via an attribute
declaration, for example) use it -- otherwise, start with a
one-byte alignment. */
rli->record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (t));
- rli->unpacked_align = rli->record_align;
+ rli->unpacked_align = rli->unpadded_align = rli->record_align;
+ rli->offset_align = MAX (rli->record_align, BIGGEST_ALIGNMENT);
#ifdef STRUCTURE_SIZE_BOUNDARY
/* Packed structures don't need to have minimum size. */
rli->record_align = MAX (rli->record_align, STRUCTURE_SIZE_BOUNDARY);
#endif
+ rli->offset = size_zero_node;
+ rli->bitpos = bitsize_zero_node;
+ rli->prev_field = 0;
+ rli->pending_statics = 0;
+ rli->packed_maybe_necessary = 0;
+
return rli;
}
-/* Like layout_field, but for unions. */
+/* These four routines perform computations that convert between
+ the offset/bitpos forms and byte and bit offsets. */
+
+tree
+bit_from_pos (offset, bitpos)
+ tree offset, bitpos;
+{
+ return size_binop (PLUS_EXPR, bitpos,
+ size_binop (MULT_EXPR, convert (bitsizetype, offset),
+ bitsize_unit_node));
+}
+
+tree
+byte_from_pos (offset, bitpos)
+ tree offset, bitpos;
+{
+ return size_binop (PLUS_EXPR, offset,
+ convert (sizetype,
+ size_binop (TRUNC_DIV_EXPR, bitpos,
+ bitsize_unit_node)));
+}
+
+void
+pos_from_byte (poffset, pbitpos, off_align, pos)
+ tree *poffset, *pbitpos;
+ unsigned int off_align;
+ tree pos;
+{
+ *poffset
+ = size_binop (MULT_EXPR,
+ convert (sizetype,
+ size_binop (FLOOR_DIV_EXPR, pos,
+ bitsize_int (off_align
+ / BITS_PER_UNIT))),
+ size_int (off_align / BITS_PER_UNIT));
+ *pbitpos = size_binop (MULT_EXPR,
+ size_binop (FLOOR_MOD_EXPR, pos,
+ bitsize_int (off_align / BITS_PER_UNIT)),
+ bitsize_unit_node);
+}
+
+void
+pos_from_bit (poffset, pbitpos, off_align, pos)
+ tree *poffset, *pbitpos;
+ unsigned int off_align;
+ tree pos;
+{
+ *poffset = size_binop (MULT_EXPR,
+ convert (sizetype,
+ size_binop (FLOOR_DIV_EXPR, pos,
+ bitsize_int (off_align))),
+ size_int (off_align / BITS_PER_UNIT));
+ *pbitpos = size_binop (FLOOR_MOD_EXPR, pos, bitsize_int (off_align));
+}
+
+/* Given a pointer to bit and byte offsets and an offset alignment,
+ normalize the offsets so they are within the alignment. */
+
+void
+normalize_offset (poffset, pbitpos, off_align)
+ tree *poffset, *pbitpos;
+ unsigned int off_align;
+{
+ /* If the bit position is now larger than it should be, adjust it
+ downwards. */
+ if (compare_tree_int (*pbitpos, off_align) >= 0)
+ {
+ tree extra_aligns = size_binop (FLOOR_DIV_EXPR, *pbitpos,
+ bitsize_int (off_align));
+
+ *poffset
+ = size_binop (PLUS_EXPR, *poffset,
+ size_binop (MULT_EXPR, convert (sizetype, extra_aligns),
+ size_int (off_align / BITS_PER_UNIT)));
+
+ *pbitpos
+ = size_binop (FLOOR_MOD_EXPR, *pbitpos, bitsize_int (off_align));
+ }
+}
+
+/* Print debugging information about the information in RLI. */
+
+void
+debug_rli (rli)
+ record_layout_info rli;
+{
+ print_node_brief (stderr, "type", rli->t, 0);
+ print_node_brief (stderr, "\noffset", rli->offset, 0);
+ print_node_brief (stderr, " bitpos", rli->bitpos, 0);
+
+ fprintf (stderr, "\naligns: rec = %u, unpack = %u, unpad = %u, off = %u\n",
+ rli->record_align, rli->unpacked_align, rli->unpadded_align,
+ rli->offset_align);
+ if (rli->packed_maybe_necessary)
+ fprintf (stderr, "packed may be necessary\n");
+
+ if (rli->pending_statics)
+ {
+ fprintf (stderr, "pending statics:\n");
+ debug_tree (rli->pending_statics);
+ }
+}
+
+/* Given an RLI with a possibly-incremented BITPOS, adjust OFFSET and
+ BITPOS if necessary to keep BITPOS below OFFSET_ALIGN. */
+
+void
+normalize_rli (rli)
+ record_layout_info rli;
+{
+ normalize_offset (&rli->offset, &rli->bitpos, rli->offset_align);
+}
+
+/* Returns the size in bytes allocated so far. */
+
+tree
+rli_size_unit_so_far (rli)
+ record_layout_info rli;
+{
+ return byte_from_pos (rli->offset, rli->bitpos);
+}
+
+/* Returns the size in bits allocated so far. */
+
+tree
+rli_size_so_far (rli)
+ record_layout_info rli;
+{
+ return bit_from_pos (rli->offset, rli->bitpos);
+}
+
+/* Called from place_field to handle unions. */
static void
-layout_union_field (rli, field)
+place_union_field (rli, field)
record_layout_info rli;
tree field;
{
- tree dsize;
-
- /* This function should only be used for unions; use layout_field
- for RECORD_TYPEs. */
- if (TREE_CODE (rli->t) != UNION_TYPE
- && TREE_CODE (rli->t) != QUAL_UNION_TYPE)
- abort ();
-
- /* By now, we should only be seeing FIELD_DECLs. */
- if (TREE_CODE (field) != FIELD_DECL)
- abort ();
+ unsigned int desired_align;
layout_decl (field, 0);
- DECL_FIELD_BITPOS (field) = bitsize_int (0);
+
+ DECL_FIELD_OFFSET (field) = size_zero_node;
+ DECL_FIELD_BIT_OFFSET (field) = bitsize_zero_node;
+ SET_DECL_OFFSET_ALIGN (field, BIGGEST_ALIGNMENT);
+
+ desired_align = DECL_ALIGN (field);
+
+#ifdef BIGGEST_FIELD_ALIGNMENT
+ /* Some targets (i.e. i386) limit union field alignment
+ to a lower boundary than alignment of variables unless
+ it was overridden by attribute aligned. */
+ if (! DECL_USER_ALIGN (field))
+ desired_align =
+ MIN (desired_align, (unsigned) BIGGEST_FIELD_ALIGNMENT);
+#endif
+
+#ifdef ADJUST_FIELD_ALIGN
+ desired_align = ADJUST_FIELD_ALIGN (field, desired_align);
+#endif
+
+ TYPE_USER_ALIGN (rli->t) |= DECL_USER_ALIGN (field);
/* Union must be at least as aligned as any field requires. */
- rli->record_align = MAX (rli->record_align, DECL_ALIGN (field));
+ rli->record_align = MAX (rli->record_align, desired_align);
+ rli->unpadded_align = MAX (rli->unpadded_align, desired_align);
#ifdef PCC_BITFIELD_TYPE_MATTERS
/* On the m88000, a bit field of declare type `int' forces the
entire union to have `int' alignment. */
if (PCC_BITFIELD_TYPE_MATTERS && DECL_BIT_FIELD_TYPE (field))
- rli->record_align = MAX (rli->record_align,
- TYPE_ALIGN (TREE_TYPE (field)));
+ {
+ rli->record_align = MAX (rli->record_align,
+ TYPE_ALIGN (TREE_TYPE (field)));
+ rli->unpadded_align = MAX (rli->unpadded_align,
+ TYPE_ALIGN (TREE_TYPE (field)));
+ }
#endif
- dsize = DECL_SIZE (field);
+ /* We assume the union's size will be a multiple of a byte so we don't
+ bother with BITPOS. */
if (TREE_CODE (rli->t) == UNION_TYPE)
- {
- /* Set union_size to max (decl_size, union_size). There are
- more and less general ways to do this. Use only CONST_SIZE
- unless forced to use VAR_SIZE. */
-
- if (TREE_CODE (dsize) == INTEGER_CST
- && ! TREE_CONSTANT_OVERFLOW (dsize)
- && TREE_INT_CST_HIGH (dsize) == 0)
- rli->const_size
- = MAX (rli->const_size, TREE_INT_CST_LOW (dsize));
- else if (rli->var_size == 0)
- rli->var_size = dsize;
- else
- rli->var_size = size_binop (MAX_EXPR, rli->var_size, dsize);
- }
+ rli->offset = size_binop (MAX_EXPR, rli->offset, DECL_SIZE_UNIT (field));
else if (TREE_CODE (rli->t) == QUAL_UNION_TYPE)
- rli->var_size = fold (build (COND_EXPR, bitsizetype,
- DECL_QUALIFIER (field),
- DECL_SIZE (field),
- (rli->var_size
- ? rli->var_size
- : bitsize_int (0))));
+ rli->offset = fold (build (COND_EXPR, sizetype,
+ DECL_QUALIFIER (field),
+ DECL_SIZE_UNIT (field), rli->offset));
}
/* RLI contains information about the layout of a RECORD_TYPE. FIELD
callers that desire that behavior must manually perform that step.) */
void
-layout_field (rli, field)
+place_field (rli, field)
record_layout_info rli;
tree field;
{
/* The alignment FIELD would have if we just dropped it into the
record as it presently stands. */
unsigned int known_align;
+ unsigned int actual_align;
+ unsigned int user_align;
/* The type of this field. */
tree type = TREE_TYPE (field);
- /* The size of this field, in bits. */
- tree dsize;
+
+ if (TREE_CODE (field) == ERROR_MARK || TREE_CODE (type) == ERROR_MARK)
+ return;
/* If FIELD is static, then treat it like a separate variable, not
really like a structure field. If it is a FUNCTION_DECL, it's a
rli->pending_statics);
return;
}
+
/* Enumerators and enum types which are local to this class need not
be laid out. Likewise for initialized constant fields. */
else if (TREE_CODE (field) != FIELD_DECL)
return;
- /* This function should only be used for records; use
- layout_union_field for unions. */
+
+ /* Unions are laid out very differently than records, so split
+ that code off to another function. */
else if (TREE_CODE (rli->t) != RECORD_TYPE)
{
- layout_union_field (rli, field);
+ place_union_field (rli, field);
return;
}
- /* Work out the known alignment so far. */
- known_align = rli->var_size ? rli->var_align : rli->const_size;
+ /* Work out the known alignment so far. Note that A & (-A) is the
+ value of the least-significant bit in A that is one. */
+ if (! integer_zerop (rli->bitpos))
+ known_align = (tree_low_cst (rli->bitpos, 1)
+ & - tree_low_cst (rli->bitpos, 1));
+ else if (integer_zerop (rli->offset))
+ known_align = BIGGEST_ALIGNMENT;
+ else if (host_integerp (rli->offset, 1))
+ known_align = (BITS_PER_UNIT
+ * (tree_low_cst (rli->offset, 1)
+ & - tree_low_cst (rli->offset, 1)));
+ else
+ known_align = rli->offset_align;
/* Lay out the field so we know what alignment it needs. For a
packed field, use the alignment as specified, disregarding what
the type would want. */
- if (DECL_PACKED (field))
- desired_align = DECL_ALIGN (field);
+ desired_align = DECL_ALIGN (field);
+ user_align = DECL_USER_ALIGN (field);
layout_decl (field, known_align);
if (! DECL_PACKED (field))
- desired_align = DECL_ALIGN (field);
- /* Some targets (i.e. VMS) limit struct field alignment
- to a lower boundary than alignment of variables. */
+ {
+ desired_align = DECL_ALIGN (field);
+ user_align = DECL_USER_ALIGN (field);
+ }
+
+ /* Some targets (i.e. i386, VMS) limit struct field alignment
+ to a lower boundary than alignment of variables unless
+ it was overridden by attribute aligned. */
#ifdef BIGGEST_FIELD_ALIGNMENT
- desired_align = MIN (desired_align, BIGGEST_FIELD_ALIGNMENT);
+ if (! user_align)
+ desired_align
+ = MIN (desired_align, (unsigned) BIGGEST_FIELD_ALIGNMENT);
#endif
+
#ifdef ADJUST_FIELD_ALIGN
desired_align = ADJUST_FIELD_ALIGN (field, desired_align);
#endif
/* Record must have at least as much alignment as any field.
Otherwise, the alignment of the field within the record is
meaningless. */
+ if ((* targetm.ms_bitfield_layout_p) (rli->t)
+ && type != error_mark_node
+ && DECL_BIT_FIELD_TYPE (field)
+ && ! integer_zerop (TYPE_SIZE (type))
+ && integer_zerop (DECL_SIZE (field)))
+ {
+ if (rli->prev_field
+ && DECL_BIT_FIELD_TYPE (rli->prev_field)
+ && ! integer_zerop (DECL_SIZE (rli->prev_field)))
+ {
+ rli->record_align = MAX (rli->record_align, desired_align);
+ rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type));
+ }
+ else
+ desired_align = 1;
+ }
+ else
#ifdef PCC_BITFIELD_TYPE_MATTERS
if (PCC_BITFIELD_TYPE_MATTERS && type != error_mark_node
+ && ! (* targetm.ms_bitfield_layout_p) (rli->t)
&& DECL_BIT_FIELD_TYPE (field)
&& ! integer_zerop (TYPE_SIZE (type)))
{
rli->record_align = MAX (rli->record_align, desired_align);
else if (! DECL_PACKED (field))
desired_align = TYPE_ALIGN (type);
+
/* A named bit field of declared type `int'
forces the entire structure to have `int' alignment. */
if (DECL_NAME (field) != 0)
type_align = MIN (type_align, BITS_PER_UNIT);
rli->record_align = MAX (rli->record_align, type_align);
+ rli->unpadded_align = MAX (rli->unpadded_align, DECL_ALIGN (field));
if (warn_packed)
- rli->unpacked_align = MAX (rli->unpacked_align,
- TYPE_ALIGN (type));
+ rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type));
}
}
else
#endif
{
rli->record_align = MAX (rli->record_align, desired_align);
- if (warn_packed)
- rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type));
+ rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type));
+ rli->unpadded_align = MAX (rli->unpadded_align, DECL_ALIGN (field));
}
if (warn_packed && DECL_PACKED (field))
{
- if (rli->const_size % TYPE_ALIGN (type) == 0
- || (rli->var_align % TYPE_ALIGN (type) == 0
- && rli->var_size != NULL_TREE))
+ if (known_align > TYPE_ALIGN (type))
{
if (TYPE_ALIGN (type) > desired_align)
{
/* Does this field automatically have alignment it needs by virtue
of the fields that precede it and the record's own alignment? */
- if (rli->const_size % desired_align != 0
- || (rli->var_align % desired_align != 0
- && rli->var_size != NULL_TREE))
+ if (known_align < desired_align)
{
/* No, we need to skip space before this field.
Bump the cumulative size to multiple of field alignment. */
if (warn_padded)
warning_with_decl (field, "padding struct to align `%s'");
- if (rli->var_size == NULL_TREE || rli->var_align % desired_align == 0)
- rli->const_size
- = CEIL (rli->const_size, desired_align) * desired_align;
+ /* If the alignment is still within offset_align, just align
+ the bit position. */
+ if (desired_align < rli->offset_align)
+ rli->bitpos = round_up (rli->bitpos, desired_align);
else
{
- if (rli->const_size > 0)
- rli->var_size = size_binop (PLUS_EXPR, rli->var_size,
- bitsize_int (rli->const_size));
- rli->const_size = 0;
- rli->var_size = round_up (rli->var_size, desired_align);
- rli->var_align = MIN (rli->var_align, desired_align);
+ /* First adjust OFFSET by the partial bits, then align. */
+ rli->offset
+ = size_binop (PLUS_EXPR, rli->offset,
+ convert (sizetype,
+ size_binop (CEIL_DIV_EXPR, rli->bitpos,
+ bitsize_unit_node)));
+ rli->bitpos = bitsize_zero_node;
+
+ rli->offset = round_up (rli->offset, desired_align / BITS_PER_UNIT);
}
+
+ if (! TREE_CONSTANT (rli->offset))
+ rli->offset_align = desired_align;
+
}
+ /* Handle compatibility with PCC. Note that if the record has any
+ variable-sized fields, we need not worry about compatibility. */
#ifdef PCC_BITFIELD_TYPE_MATTERS
if (PCC_BITFIELD_TYPE_MATTERS
+ && ! (* targetm.ms_bitfield_layout_p) (rli->t)
&& TREE_CODE (field) == FIELD_DECL
&& type != error_mark_node
- && DECL_BIT_FIELD_TYPE (field)
- && !DECL_PACKED (field)
+ && DECL_BIT_FIELD (field)
+ && ! DECL_PACKED (field)
&& maximum_field_alignment == 0
- && !integer_zerop (DECL_SIZE (field)))
+ && ! integer_zerop (DECL_SIZE (field))
+ && host_integerp (DECL_SIZE (field), 1)
+ && host_integerp (rli->offset, 1)
+ && host_integerp (TYPE_SIZE (type), 1))
{
unsigned int type_align = TYPE_ALIGN (type);
- register tree dsize = DECL_SIZE (field);
- unsigned int field_size = TREE_INT_CST_LOW (dsize);
+ tree dsize = DECL_SIZE (field);
+ HOST_WIDE_INT field_size = tree_low_cst (dsize, 1);
+ HOST_WIDE_INT offset = tree_low_cst (rli->offset, 0);
+ HOST_WIDE_INT bit_offset = tree_low_cst (rli->bitpos, 0);
/* A bit field may not span more units of alignment of its type
than its type itself. Advance to next boundary if necessary. */
- if (((rli->const_size + field_size + type_align - 1) / type_align
- - rli->const_size / type_align)
- > TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (field))) / type_align)
- rli->const_size = CEIL (rli->const_size, type_align) * type_align;
+ if ((((offset * BITS_PER_UNIT + bit_offset + field_size +
+ type_align - 1)
+ / type_align)
+ - (offset * BITS_PER_UNIT + bit_offset) / type_align)
+ > tree_low_cst (TYPE_SIZE (type), 1) / type_align)
+ rli->bitpos = round_up (rli->bitpos, type_align);
}
#endif
- /* No existing machine description uses this parameter. So I have
- made it in this aspect identical to PCC_BITFIELD_TYPE_MATTERS. */
#ifdef BITFIELD_NBYTES_LIMITED
if (BITFIELD_NBYTES_LIMITED
+ && ! (* targetm.ms_bitfield_layout_p) (rli->t)
&& TREE_CODE (field) == FIELD_DECL
&& type != error_mark_node
&& DECL_BIT_FIELD_TYPE (field)
- && !DECL_PACKED (field)
- && !integer_zerop (DECL_SIZE (field)))
+ && ! DECL_PACKED (field)
+ && ! integer_zerop (DECL_SIZE (field))
+ && host_integerp (DECL_SIZE (field), 1)
+ && host_integerp (rli->offset, 1)
+ && host_integerp (TYPE_SIZE (type), 1))
{
unsigned int type_align = TYPE_ALIGN (type);
- register tree dsize = DECL_SIZE (field);
- int field_size = TREE_INT_CST_LOW (dsize);
+ tree dsize = DECL_SIZE (field);
+ HOST_WIDE_INT field_size = tree_low_cst (dsize, 1);
+ HOST_WIDE_INT offset = tree_low_cst (rli->offset, 0);
+ HOST_WIDE_INT bit_offset = tree_low_cst (rli->bitpos, 0);
if (maximum_field_alignment != 0)
type_align = MIN (type_align, maximum_field_alignment);
Advance to next boundary if necessary. */
/* ??? This code should match the code above for the
PCC_BITFIELD_TYPE_MATTERS case. */
- if (rli->const_size / type_align
- != (rli->const_size + field_size - 1) / type_align)
- rli->const_size = CEIL (rli->const_size, type_align) * type_align;
+ if ((offset * BITS_PER_UNIT + bit_offset) / type_align
+ != ((offset * BITS_PER_UNIT + bit_offset + field_size - 1)
+ / type_align))
+ rli->bitpos = round_up (rli->bitpos, type_align);
}
#endif
- /* Size so far becomes the position of this field. */
-
- if (rli->var_size && rli->const_size)
- DECL_FIELD_BITPOS (field)
- = size_binop (PLUS_EXPR, rli->var_size, bitsize_int (rli->const_size));
- else if (rli->var_size)
- DECL_FIELD_BITPOS (field) = rli->var_size;
- else
+ /* See the docs for TARGET_MS_BITFIELD_LAYOUT_P for details. */
+ if ((* targetm.ms_bitfield_layout_p) (rli->t)
+ && TREE_CODE (field) == FIELD_DECL
+ && type != error_mark_node
+ && ! DECL_PACKED (field)
+ && rli->prev_field
+ && DECL_SIZE (field)
+ && host_integerp (DECL_SIZE (field), 1)
+ && DECL_SIZE (rli->prev_field)
+ && host_integerp (DECL_SIZE (rli->prev_field), 1)
+ && host_integerp (rli->offset, 1)
+ && host_integerp (TYPE_SIZE (type), 1)
+ && host_integerp (TYPE_SIZE (TREE_TYPE (rli->prev_field)), 1)
+ && ((DECL_BIT_FIELD_TYPE (rli->prev_field)
+ && ! integer_zerop (DECL_SIZE (rli->prev_field)))
+ || (DECL_BIT_FIELD_TYPE (field)
+ && ! integer_zerop (DECL_SIZE (field))))
+ && (! simple_cst_equal (TYPE_SIZE (type),
+ TYPE_SIZE (TREE_TYPE (rli->prev_field)))
+ /* If the previous field was a zero-sized bit-field, either
+ it was ignored, in which case we must ensure the proper
+ alignment of this field here, or it already forced the
+ alignment of this field, in which case forcing the
+ alignment again is harmless. So, do it in both cases. */
+ || (DECL_BIT_FIELD_TYPE (rli->prev_field)
+ && integer_zerop (DECL_SIZE (rli->prev_field)))))
{
- DECL_FIELD_BITPOS (field) = bitsize_int (rli->const_size);
-
- /* If this field ended up more aligned than we thought it
- would be (we approximate this by seeing if its position
- changed), lay out the field again; perhaps we can use an
- integral mode for it now. */
- if (known_align != rli->const_size)
- layout_decl (field, rli->const_size);
+ unsigned int type_align = TYPE_ALIGN (type);
+
+ if (rli->prev_field
+ && DECL_BIT_FIELD_TYPE (rli->prev_field)
+ /* If the previous bit-field is zero-sized, we've already
+ accounted for its alignment needs (or ignored it, if
+ appropriate) while placing it. */
+ && ! integer_zerop (DECL_SIZE (rli->prev_field)))
+ type_align = MAX (type_align,
+ TYPE_ALIGN (TREE_TYPE (rli->prev_field)));
+
+ if (maximum_field_alignment != 0)
+ type_align = MIN (type_align, maximum_field_alignment);
+
+ rli->bitpos = round_up (rli->bitpos, type_align);
}
- /* Now add size of this field to the size of the record. */
- dsize = DECL_SIZE (field);
+ /* Offset so far becomes the position of this field after normalizing. */
+ normalize_rli (rli);
+ DECL_FIELD_OFFSET (field) = rli->offset;
+ DECL_FIELD_BIT_OFFSET (field) = rli->bitpos;
+ SET_DECL_OFFSET_ALIGN (field, rli->offset_align);
+
+ TYPE_USER_ALIGN (rli->t) |= user_align;
+
+ /* If this field ended up more aligned than we thought it would be (we
+ approximate this by seeing if its position changed), lay out the field
+ again; perhaps we can use an integral mode for it now. */
+ if (! integer_zerop (DECL_FIELD_BIT_OFFSET (field)))
+ actual_align = (tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
+ & - tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1));
+ else if (integer_zerop (DECL_FIELD_OFFSET (field)))
+ actual_align = BIGGEST_ALIGNMENT;
+ else if (host_integerp (DECL_FIELD_OFFSET (field), 1))
+ actual_align = (BITS_PER_UNIT
+ * (tree_low_cst (DECL_FIELD_OFFSET (field), 1)
+ & - tree_low_cst (DECL_FIELD_OFFSET (field), 1)));
+ else
+ actual_align = DECL_OFFSET_ALIGN (field);
+
+ if (known_align != actual_align)
+ layout_decl (field, actual_align);
+
+ rli->prev_field = field;
- /* This can happen when we have an invalid nested struct definition,
- such as struct j { struct j { int i; } }. The error message is
- printed in finish_struct. */
- if (dsize == 0)
+ /* Now add size of this field to the size of the record. If the size is
+ not constant, treat the field as being a multiple of bytes and just
+ adjust the offset, resetting the bit position. Otherwise, apportion the
+ size amongst the bit position and offset. First handle the case of an
+ unspecified size, which can happen when we have an invalid nested struct
+ definition, such as struct j { struct j { int i; } }. The error message
+ is printed in finish_struct. */
+ if (DECL_SIZE (field) == 0)
/* Do nothing. */;
- else if (TREE_CODE (dsize) == INTEGER_CST
- && ! TREE_CONSTANT_OVERFLOW (dsize)
- && TREE_INT_CST_HIGH (dsize) == 0
- && TREE_INT_CST_LOW (dsize) + rli->const_size >= rli->const_size)
- /* Use const_size if there's no overflow. */
- rli->const_size += TREE_INT_CST_LOW (dsize);
+ else if (TREE_CODE (DECL_SIZE_UNIT (field)) != INTEGER_CST
+ || TREE_CONSTANT_OVERFLOW (DECL_SIZE_UNIT (field)))
+ {
+ rli->offset
+ = size_binop (PLUS_EXPR, rli->offset,
+ convert (sizetype,
+ size_binop (CEIL_DIV_EXPR, rli->bitpos,
+ bitsize_unit_node)));
+ rli->offset
+ = size_binop (PLUS_EXPR, rli->offset, DECL_SIZE_UNIT (field));
+ rli->bitpos = bitsize_zero_node;
+ rli->offset_align = MIN (rli->offset_align, DECL_ALIGN (field));
+ }
else
{
- if (rli->var_size == NULL_TREE)
- rli->var_size = dsize;
- else
- rli->var_size = size_binop (PLUS_EXPR, rli->var_size, dsize);
+ rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, DECL_SIZE (field));
+ normalize_rli (rli);
}
}
finalize_record_size (rli)
record_layout_info rli;
{
- /* Work out the total size and alignment of the record as one
- expression and store in the record type. Round it up to a
- multiple of the record's alignment. */
- if (rli->var_size == NULL_TREE)
- TYPE_SIZE (rli->t) = bitsize_int (rli->const_size);
- else
- {
- if (rli->const_size)
- rli->var_size = size_binop (PLUS_EXPR, rli->var_size,
- bitsize_int (rli->const_size));
- TYPE_SIZE (rli->t) = rli->var_size;
- }
+ tree unpadded_size, unpadded_size_unit;
+
+ /* Now we want just byte and bit offsets, so set the offset alignment
+ to be a byte and then normalize. */
+ rli->offset_align = BITS_PER_UNIT;
+ normalize_rli (rli);
/* Determine the desired alignment. */
#ifdef ROUND_TYPE_ALIGN
TYPE_ALIGN (rli->t) = MAX (TYPE_ALIGN (rli->t), rli->record_align);
#endif
+ /* Compute the size so far. Be sure to allow for extra bits in the
+ size in bytes. We have guaranteed above that it will be no more
+ than a single byte. */
+ unpadded_size = rli_size_so_far (rli);
+ unpadded_size_unit = rli_size_unit_so_far (rli);
+ if (! integer_zerop (rli->bitpos))
+ unpadded_size_unit
+ = size_binop (PLUS_EXPR, unpadded_size_unit, size_one_node);
+
/* Record the un-rounded size in the binfo node. But first we check
the size of TYPE_BINFO to make sure that BINFO_SIZE is available. */
if (TYPE_BINFO (rli->t) && TREE_VEC_LENGTH (TYPE_BINFO (rli->t)) > 6)
{
- TYPE_BINFO_SIZE (rli->t) = TYPE_SIZE (rli->t);
- TYPE_BINFO_SIZE_UNIT (rli->t)
- = convert (sizetype,
- size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (rli->t),
- bitsize_int (BITS_PER_UNIT)));
+ TYPE_BINFO_SIZE (rli->t) = unpadded_size;
+ TYPE_BINFO_SIZE_UNIT (rli->t) = unpadded_size_unit;
}
-
- {
- tree unpadded_size = TYPE_SIZE (rli->t);
+ /* Round the size up to be a multiple of the required alignment */
#ifdef ROUND_TYPE_SIZE
- TYPE_SIZE (rli->t) = ROUND_TYPE_SIZE (rli->t, TYPE_SIZE (rli->t),
- TYPE_ALIGN (rli->t));
+ TYPE_SIZE (rli->t) = ROUND_TYPE_SIZE (rli->t, unpadded_size,
+ TYPE_ALIGN (rli->t));
+ TYPE_SIZE_UNIT (rli->t)
+ = ROUND_TYPE_SIZE_UNIT (rli->t, unpadded_size_unit,
+ TYPE_ALIGN (rli->t) / BITS_PER_UNIT);
#else
- /* Round the size up to be a multiple of the required alignment */
- TYPE_SIZE (rli->t) = round_up (TYPE_SIZE (rli->t), TYPE_ALIGN (rli->t));
+ TYPE_SIZE (rli->t) = round_up (unpadded_size, TYPE_ALIGN (rli->t));
+ TYPE_SIZE_UNIT (rli->t) = round_up (unpadded_size_unit,
+ TYPE_ALIGN (rli->t) / BITS_PER_UNIT);
#endif
- if (warn_padded && rli->var_size == NULL_TREE
- && simple_cst_equal (unpadded_size, TYPE_SIZE (rli->t)) == 0)
- warning ("padding struct size to alignment boundary");
- }
-
- if (warn_packed && TYPE_PACKED (rli->t) && !rli->packed_maybe_necessary
- && rli->var_size == NULL_TREE)
+ if (warn_padded && TREE_CONSTANT (unpadded_size)
+ && simple_cst_equal (unpadded_size, TYPE_SIZE (rli->t)) == 0)
+ warning ("padding struct size to alignment boundary");
+
+ if (warn_packed && TREE_CODE (rli->t) == RECORD_TYPE
+ && TYPE_PACKED (rli->t) && ! rli->packed_maybe_necessary
+ && TREE_CONSTANT (unpadded_size))
{
tree unpacked_size;
- TYPE_PACKED (rli->t) = 0;
#ifdef ROUND_TYPE_ALIGN
rli->unpacked_align
= ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t), rli->unpacked_align);
#else
rli->unpacked_align = MAX (TYPE_ALIGN (rli->t), rli->unpacked_align);
#endif
+
#ifdef ROUND_TYPE_SIZE
unpacked_size = ROUND_TYPE_SIZE (rli->t, TYPE_SIZE (rli->t),
rli->unpacked_align);
if (simple_cst_equal (unpacked_size, TYPE_SIZE (rli->t)))
{
+ TYPE_PACKED (rli->t) = 0;
+
if (TYPE_NAME (rli->t))
{
- char *name;
+ const char *name;
if (TREE_CODE (TYPE_NAME (rli->t)) == IDENTIFIER_NODE)
name = IDENTIFIER_POINTER (TYPE_NAME (rli->t));
else
name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (rli->t)));
+
if (STRICT_ALIGNMENT)
warning ("packed attribute causes inefficient alignment for `%s'", name);
else
warning ("packed attribute is unnecessary");
}
}
- TYPE_PACKED (rli->t) = 1;
}
}
/* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE). */
-static void
+void
compute_record_mode (type)
tree type;
{
+ tree field;
+ enum machine_mode mode = VOIDmode;
+
/* Most RECORD_TYPEs have BLKmode, so we start off assuming that.
However, if possible, we use a mode that fits in a register
instead, in order to allow for better optimization down the
line. */
TYPE_MODE (type) = BLKmode;
- if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
- {
- tree field;
- enum machine_mode mode = VOIDmode;
- /* A record which has any BLKmode members must itself be
- BLKmode; it can't go in a register. Unless the member is
- BLKmode only because it isn't aligned. */
- for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
- {
- unsigned HOST_WIDE_INT bitpos;
+ if (! host_integerp (TYPE_SIZE (type), 1))
+ return;
+
+ /* A record which has any BLKmode members must itself be
+ BLKmode; it can't go in a register. Unless the member is
+ BLKmode only because it isn't aligned. */
+ for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
+ {
+ unsigned HOST_WIDE_INT bitpos;
- if (TREE_CODE (field) != FIELD_DECL
- || TREE_CODE (TREE_TYPE (field)) == ERROR_MARK)
- continue;
+ if (TREE_CODE (field) != FIELD_DECL)
+ continue;
- if (TYPE_MODE (TREE_TYPE (field)) == BLKmode
+ if (TREE_CODE (TREE_TYPE (field)) == ERROR_MARK
+ || (TYPE_MODE (TREE_TYPE (field)) == BLKmode
&& ! TYPE_NO_FORCE_BLK (TREE_TYPE (field)))
- return;
-
- if (TREE_CODE (DECL_FIELD_BITPOS (field)) != INTEGER_CST)
- return;
-
- bitpos = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field));
-
- /* Must be BLKmode if any field crosses a word boundary,
- since extract_bit_field can't handle that in registers. */
- if (bitpos / BITS_PER_WORD
- != ((TREE_INT_CST_LOW (DECL_SIZE (field)) + bitpos - 1)
- / BITS_PER_WORD)
- /* But there is no problem if the field is entire words. */
- && TREE_INT_CST_LOW (DECL_SIZE (field)) % BITS_PER_WORD != 0)
- return;
-
- /* If this field is the whole struct, remember its mode so
- that, say, we can put a double in a class into a DF
- register instead of forcing it to live in the stack. */
- if (simple_cst_equal (TYPE_SIZE (type), DECL_SIZE (field)))
- mode = DECL_MODE (field);
-
-#ifdef STRUCT_FORCE_BLK
- /* With some targets, eg. c4x, it is sub-optimal
- to access an aligned BLKmode structure as a scalar. */
- if (mode == VOIDmode && STRUCT_FORCE_BLK (field))
- return;
-#endif /* STRUCT_FORCE_BLK */
- }
+ || ! host_integerp (bit_position (field), 1)
+ || DECL_SIZE (field) == 0
+ || ! host_integerp (DECL_SIZE (field), 1))
+ return;
+
+ bitpos = int_bit_position (field);
+
+ /* Must be BLKmode if any field crosses a word boundary,
+ since extract_bit_field can't handle that in registers. */
+ if (bitpos / BITS_PER_WORD
+ != ((tree_low_cst (DECL_SIZE (field), 1) + bitpos - 1)
+ / BITS_PER_WORD)
+ /* But there is no problem if the field is entire words. */
+ && tree_low_cst (DECL_SIZE (field), 1) % BITS_PER_WORD != 0)
+ return;
+
+ /* If this field is the whole struct, remember its mode so
+ that, say, we can put a double in a class into a DF
+ register instead of forcing it to live in the stack. */
+ if (simple_cst_equal (TYPE_SIZE (type), DECL_SIZE (field)))
+ mode = DECL_MODE (field);
+
+#ifdef MEMBER_TYPE_FORCES_BLK
+ /* With some targets, eg. c4x, it is sub-optimal
+ to access an aligned BLKmode structure as a scalar. */
+
+ /* On ia64-*-hpux we need to ensure that we don't change the
+ mode of a structure containing a single field or else we
+ will pass it incorrectly. Since a structure with a single
+ field causes mode to get set above we can't allow the
+ check for mode == VOIDmode in this case. Perhaps
+ MEMBER_TYPE_FORCES_BLK should be extended to include mode
+ as an argument and the check could be put in there for c4x. */
+
+ if ((mode == VOIDmode || FUNCTION_ARG_REG_LITTLE_ENDIAN)
+ && MEMBER_TYPE_FORCES_BLK (field))
+ return;
+#endif /* MEMBER_TYPE_FORCES_BLK */
+ }
- if (mode != VOIDmode)
- /* We only have one real field; use its mode. */
- TYPE_MODE (type) = mode;
- else
- TYPE_MODE (type)
- = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1);
-
- /* If structure's known alignment is less than what the scalar
- mode would need, and it matters, then stick with BLKmode. */
- if (TYPE_MODE (type) != BLKmode
- && STRICT_ALIGNMENT
- && ! (TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT
- || (TYPE_ALIGN (type) >=
- GET_MODE_ALIGNMENT (TYPE_MODE (type)))))
- {
- /* If this is the only reason this type is BLKmode, then
- don't force containing types to be BLKmode. */
- TYPE_NO_FORCE_BLK (type) = 1;
- TYPE_MODE (type) = BLKmode;
- }
+ /* If we only have one real field; use its mode. This only applies to
+ RECORD_TYPE. This does not apply to unions. */
+ if (TREE_CODE (type) == RECORD_TYPE && mode != VOIDmode)
+ TYPE_MODE (type) = mode;
+ else
+ TYPE_MODE (type) = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1);
+
+ /* If structure's known alignment is less than what the scalar
+ mode would need, and it matters, then stick with BLKmode. */
+ if (TYPE_MODE (type) != BLKmode
+ && STRICT_ALIGNMENT
+ && ! (TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT
+ || TYPE_ALIGN (type) >= GET_MODE_ALIGNMENT (TYPE_MODE (type))))
+ {
+ /* If this is the only reason this type is BLKmode, then
+ don't force containing types to be BLKmode. */
+ TYPE_NO_FORCE_BLK (type) = 1;
+ TYPE_MODE (type) = BLKmode;
}
}
|| (TREE_CODE (type) != RECORD_TYPE && TREE_CODE (type) != UNION_TYPE
&& TREE_CODE (type) != QUAL_UNION_TYPE
&& TREE_CODE (type) != ARRAY_TYPE)))
- TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type));
+ {
+ TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type));
+ TYPE_USER_ALIGN (type) = 0;
+ }
/* Do machine-dependent extra alignment. */
#ifdef ROUND_TYPE_ALIGN
= ROUND_TYPE_ALIGN (type, TYPE_ALIGN (type), BITS_PER_UNIT);
#endif
-#ifdef ROUND_TYPE_SIZE
- if (TYPE_SIZE (type) != 0)
- TYPE_SIZE (type)
- = ROUND_TYPE_SIZE (type, TYPE_SIZE (type), TYPE_ALIGN (type));
-#endif
-
- /* Evaluate nonconstant size only once, either now or as soon as safe. */
- if (TYPE_SIZE (type) != 0 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
- TYPE_SIZE (type) = variable_size (TYPE_SIZE (type));
-
/* If we failed to find a simple way to calculate the unit size
- of the type above, find it by division. */
+ of the type, find it by division. */
if (TYPE_SIZE_UNIT (type) == 0 && TYPE_SIZE (type) != 0)
/* TYPE_SIZE (type) is computed in bitsizetype. After the division, the
result will fit in sizetype. We will get more efficient code using
TYPE_SIZE_UNIT (type)
= convert (sizetype,
size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (type),
- bitsize_int (BITS_PER_UNIT)));
+ bitsize_unit_node));
- /* Once again evaluate only once, either now or as soon as safe. */
+ if (TYPE_SIZE (type) != 0)
+ {
+#ifdef ROUND_TYPE_SIZE
+ TYPE_SIZE (type)
+ = ROUND_TYPE_SIZE (type, TYPE_SIZE (type), TYPE_ALIGN (type));
+ TYPE_SIZE_UNIT (type)
+ = ROUND_TYPE_SIZE_UNIT (type, TYPE_SIZE_UNIT (type),
+ TYPE_ALIGN (type) / BITS_PER_UNIT);
+#else
+ TYPE_SIZE (type) = round_up (TYPE_SIZE (type), TYPE_ALIGN (type));
+ TYPE_SIZE_UNIT (type)
+ = round_up (TYPE_SIZE_UNIT (type), TYPE_ALIGN (type) / BITS_PER_UNIT);
+#endif
+ }
+
+ /* Evaluate nonconstant sizes only once, either now or as soon as safe. */
+ if (TYPE_SIZE (type) != 0 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
+ TYPE_SIZE (type) = variable_size (TYPE_SIZE (type));
if (TYPE_SIZE_UNIT (type) != 0
&& TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST)
TYPE_SIZE_UNIT (type) = variable_size (TYPE_SIZE_UNIT (type));
tree size = TYPE_SIZE (type);
tree size_unit = TYPE_SIZE_UNIT (type);
unsigned int align = TYPE_ALIGN (type);
+ unsigned int user_align = TYPE_USER_ALIGN (type);
enum machine_mode mode = TYPE_MODE (type);
/* Copy it into all variants. */
TYPE_SIZE (variant) = size;
TYPE_SIZE_UNIT (variant) = size_unit;
TYPE_ALIGN (variant) = align;
+ TYPE_USER_ALIGN (variant) = user_align;
TYPE_MODE (variant) = mode;
}
}
finish_record_layout (rli)
record_layout_info rli;
{
- /* Use finish_union_layout for unions. */
- if (TREE_CODE (rli->t) != RECORD_TYPE)
- finish_union_layout (rli);
- else
- {
- /* Compute the final size. */
- finalize_record_size (rli);
- /* Compute the TYPE_MODE for the record. */
- compute_record_mode (rli->t);
- }
+ /* Compute the final size. */
+ finalize_record_size (rli);
+
+ /* Compute the TYPE_MODE for the record. */
+ compute_record_mode (rli->t);
+
+ /* Perform any last tweaks to the TYPE_SIZE, etc. */
+ finalize_type_size (rli->t);
/* Lay out any static members. This is done now because their type
may use the record's type. */
rli->pending_statics = TREE_CHAIN (rli->pending_statics);
}
- /* Perform any last tweaks to the TYPE_SIZE, etc. */
- finalize_type_size (rli->t);
/* Clean up. */
free (rli);
}
-
-/* Like finish_record_layout, but for unions. */
-
-static void
-finish_union_layout (rli)
- record_layout_info rli;
-{
- /* This function should only be used for unions; use
- finish_record_layout for RECORD_TYPEs. */
- if (TREE_CODE (rli->t) != UNION_TYPE
- && TREE_CODE (rli->t) != QUAL_UNION_TYPE)
- abort ();
-
- /* Determine the ultimate size of the union (in bytes). */
- if (NULL == rli->var_size)
- TYPE_SIZE (rli->t)
- = bitsize_int (CEIL (rli->const_size, BITS_PER_UNIT) * BITS_PER_UNIT);
-
- else if (rli->const_size == 0)
- TYPE_SIZE (rli->t) = rli->var_size;
- else
- TYPE_SIZE (rli->t) = size_binop (MAX_EXPR, rli->var_size,
- round_up (bitsize_int (rli->const_size),
- BITS_PER_UNIT));
-
- /* Determine the desired alignment. */
-#ifdef ROUND_TYPE_ALIGN
- TYPE_ALIGN (rli->t) = ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t),
- rli->record_align);
-#else
- TYPE_ALIGN (rli->t) = MAX (TYPE_ALIGN (rli->t), rli->record_align);
-#endif
-
-#ifdef ROUND_TYPE_SIZE
- TYPE_SIZE (rli->t) = ROUND_TYPE_SIZE (rli->t, TYPE_SIZE (rli->t),
- TYPE_ALIGN (rli->t));
-#else
- /* Round the size up to be a multiple of the required alignment */
- TYPE_SIZE (rli->t) = round_up (TYPE_SIZE (rli->t),
- TYPE_ALIGN (rli->t));
-#endif
-
- TYPE_MODE (rli->t) = BLKmode;
- if (TREE_CODE (TYPE_SIZE (rli->t)) == INTEGER_CST
- /* If structure's known alignment is less than
- what the scalar mode would need, and it matters,
- then stick with BLKmode. */
- && (! STRICT_ALIGNMENT
- || TYPE_ALIGN (rli->t) >= BIGGEST_ALIGNMENT
- || compare_tree_int (TYPE_SIZE (rli->t),
- TYPE_ALIGN (rli->t)) <= 0))
- {
- tree field;
-
- /* A union which has any BLKmode members must itself be BLKmode;
- it can't go in a register.
- Unless the member is BLKmode only because it isn't aligned. */
- for (field = TYPE_FIELDS (rli->t);
- field;
- field = TREE_CHAIN (field))
- {
- if (TREE_CODE (field) != FIELD_DECL)
- continue;
-
- if (TYPE_MODE (TREE_TYPE (field)) == BLKmode
- && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field)))
- return;
- }
-
- TYPE_MODE (rli->t)
- = mode_for_size_tree (TYPE_SIZE (rli->t), MODE_INT, 1);
- }
-}
-
\f
/* Calculate the mode, size, and alignment for TYPE.
For an array type, calculate the element separation as well.
layout_type (type)
tree type;
{
- int old;
-
if (type == 0)
abort ();
if (TYPE_SIZE (type))
return;
- /* Make sure all nodes we allocate are not momentary; they must last
- past the current statement. */
- old = suspend_momentary ();
-
- /* Put all our nodes into the same obstack as the type. Also,
- make expressions saveable (this is a no-op for permanent types). */
-
- push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type));
- saveable_allocation ();
-
switch (TREE_CODE (type))
{
case LANG_TYPE:
of the language-specific code. */
abort ();
- case BOOLEAN_TYPE: /* Used for Java, Pascal, and Chill. */
+ case BOOLEAN_TYPE: /* Used for Java, Pascal, and Chill. */
if (TYPE_PRECISION (type) == 0)
- TYPE_PRECISION (type) = 1; /* default to one byte/boolean. */
+ TYPE_PRECISION (type) = 1; /* default to one byte/boolean. */
- /* ... fall through ... */
+ /* ... fall through ... */
case INTEGER_TYPE:
case ENUMERAL_TYPE:
TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
break;
+ case VECTOR_TYPE:
+ {
+ tree subtype;
+
+ subtype = TREE_TYPE (type);
+ TREE_UNSIGNED (type) = TREE_UNSIGNED (subtype);
+ TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
+ TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
+ }
+ break;
+
case VOID_TYPE:
- TYPE_SIZE (type) = bitsize_int (0);
- TYPE_SIZE_UNIT (type) = size_zero_node;
+ /* This is an incomplete type and so doesn't have a size. */
TYPE_ALIGN (type) = 1;
+ TYPE_USER_ALIGN (type) = 0;
TYPE_MODE (type) = VOIDmode;
break;
case OFFSET_TYPE:
TYPE_SIZE (type) = bitsize_int (POINTER_SIZE);
TYPE_SIZE_UNIT (type) = size_int (POINTER_SIZE / BITS_PER_UNIT);
- TYPE_MODE (type) = ptr_mode;
+ /* A pointer might be MODE_PARTIAL_INT,
+ but ptrdiff_t must be integral. */
+ TYPE_MODE (type) = mode_for_size (POINTER_SIZE, MODE_INT, 0);
break;
case FUNCTION_TYPE:
case POINTER_TYPE:
case REFERENCE_TYPE:
- TYPE_MODE (type) = ptr_mode;
- TYPE_SIZE (type) = bitsize_int (POINTER_SIZE);
- TYPE_SIZE_UNIT (type) = size_int (POINTER_SIZE / BITS_PER_UNIT);
- TREE_UNSIGNED (type) = 1;
- TYPE_PRECISION (type) = POINTER_SIZE;
+ {
+ int nbits = ((TREE_CODE (type) == REFERENCE_TYPE
+ && reference_types_internal)
+ ? GET_MODE_BITSIZE (Pmode) : POINTER_SIZE);
+
+ TYPE_MODE (type) = nbits == POINTER_SIZE ? ptr_mode : Pmode;
+ TYPE_SIZE (type) = bitsize_int (nbits);
+ TYPE_SIZE_UNIT (type) = size_int (nbits / BITS_PER_UNIT);
+ TREE_UNSIGNED (type) = 1;
+ TYPE_PRECISION (type) = nbits;
+ }
break;
case ARRAY_TYPE:
{
- register tree index = TYPE_DOMAIN (type);
- register tree element = TREE_TYPE (type);
+ tree index = TYPE_DOMAIN (type);
+ tree element = TREE_TYPE (type);
build_pointer_type (element);
tree length;
tree element_size;
- /* If UB is max (lb - 1, x), remove the MAX_EXPR since the
- test for negative below covers it. */
- if (TREE_CODE (ub) == MAX_EXPR
- && TREE_CODE (TREE_OPERAND (ub, 0)) == MINUS_EXPR
- && integer_onep (TREE_OPERAND (TREE_OPERAND (ub, 0), 1))
- && operand_equal_p (TREE_OPERAND (TREE_OPERAND (ub, 0), 0),
- lb, 0))
- ub = TREE_OPERAND (ub, 1);
- else if (TREE_CODE (ub) == MAX_EXPR
- && TREE_CODE (TREE_OPERAND (ub, 1)) == MINUS_EXPR
- && integer_onep (TREE_OPERAND (TREE_OPERAND (ub, 1), 1))
- && operand_equal_p (TREE_OPERAND (TREE_OPERAND (ub, 1),
- 0),
- lb, 0))
- ub = TREE_OPERAND (ub, 0);
-
/* The initial subtraction should happen in the original type so
that (possible) negative values are handled appropriately. */
length = size_binop (PLUS_EXPR, size_one_node,
TREE_TYPE (lb),
ub, lb))));
- /* If neither bound is a constant and sizetype is signed, make
- sure the size is never negative. We should really do this
- if *either* bound is non-constant, but this is the best
- compromise between C and Ada. */
- if (! TREE_UNSIGNED (sizetype)
- && TREE_CODE (TYPE_MIN_VALUE (index)) != INTEGER_CST
- && TREE_CODE (TYPE_MAX_VALUE (index)) != INTEGER_CST)
- length = size_binop (MAX_EXPR, length, size_zero_node);
-
/* Special handling for arrays of bits (for Chill). */
element_size = TYPE_SIZE (element);
- if (TYPE_PACKED (type) && INTEGRAL_TYPE_P (element))
+ if (TYPE_PACKED (type) && INTEGRAL_TYPE_P (element)
+ && (integer_zerop (TYPE_MAX_VALUE (element))
+ || integer_onep (TYPE_MAX_VALUE (element)))
+ && host_integerp (TYPE_MIN_VALUE (element), 1))
{
HOST_WIDE_INT maxvalue
- = TREE_INT_CST_LOW (TYPE_MAX_VALUE (element));
+ = tree_low_cst (TYPE_MAX_VALUE (element), 1);
HOST_WIDE_INT minvalue
- = TREE_INT_CST_LOW (TYPE_MIN_VALUE (element));
+ = tree_low_cst (TYPE_MIN_VALUE (element), 1);
if (maxvalue - minvalue == 1
&& (maxvalue == 1 || maxvalue == 0))
#else
TYPE_ALIGN (type) = MAX (TYPE_ALIGN (element), BITS_PER_UNIT);
#endif
+ TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (element);
#ifdef ROUND_TYPE_SIZE
if (TYPE_SIZE (type) != 0)
TYPE_MODE (type) = BLKmode;
if (TYPE_SIZE (type) != 0
+#ifdef MEMBER_TYPE_FORCES_BLK
+ && ! MEMBER_TYPE_FORCES_BLK (type)
+#endif
/* BLKmode elements force BLKmode aggregate;
else extract/store fields may lose. */
&& (TYPE_MODE (TREE_TYPE (type)) != BLKmode
|| TYPE_NO_FORCE_BLK (TREE_TYPE (type))))
{
- TYPE_MODE (type)
- = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1);
+ /* One-element arrays get the component type's mode. */
+ if (simple_cst_equal (TYPE_SIZE (type),
+ TYPE_SIZE (TREE_TYPE (type))))
+ TYPE_MODE (type) = TYPE_MODE (TREE_TYPE (type));
+ else
+ TYPE_MODE (type)
+ = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1);
if (TYPE_MODE (type) != BLKmode
&& STRICT_ALIGNMENT && TYPE_ALIGN (type) < BIGGEST_ALIGNMENT
record_layout_info rli;
/* Initialize the layout information. */
- rli = new_record_layout_info (type);
+ rli = start_record_layout (type);
+
/* If this is a QUAL_UNION_TYPE, we want to process the fields
in the reverse order in building the COND_EXPR that denotes
its size. We reverse them again later. */
if (TREE_CODE (type) == QUAL_UNION_TYPE)
TYPE_FIELDS (type) = nreverse (TYPE_FIELDS (type));
- /* Layout all the fields. */
+
+ /* Place all the fields. */
for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
- layout_field (rli, field);
+ place_field (rli, field);
+
if (TREE_CODE (type) == QUAL_UNION_TYPE)
TYPE_FIELDS (type) = nreverse (TYPE_FIELDS (type));
+
+ if (lang_adjust_rli)
+ (*lang_adjust_rli) (rli);
+
/* Finish laying out the record. */
finish_record_layout (rli);
}
break;
- case SET_TYPE: /* Used by Chill and Pascal. */
+ case SET_TYPE: /* Used by Chill and Pascal. */
if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST
|| TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST)
- abort();
+ abort ();
else
{
#ifndef SET_WORD_SIZE
TYPE_SIZE (type) = bitsize_int (rounded_size);
TYPE_SIZE_UNIT (type) = size_int (rounded_size / BITS_PER_UNIT);
TYPE_ALIGN (type) = alignment;
+ TYPE_USER_ALIGN (type) = 0;
TYPE_PRECISION (type) = size_in_bits;
}
break;
/* The size may vary in different languages, so the language front end
should fill in the size. */
TYPE_ALIGN (type) = BIGGEST_ALIGNMENT;
+ TYPE_USER_ALIGN (type) = 0;
TYPE_MODE (type) = BLKmode;
break;
/* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE. For
records and unions, finish_record_layout already called this
function. */
- if (TREE_CODE (type) != RECORD_TYPE
+ if (TREE_CODE (type) != RECORD_TYPE
&& TREE_CODE (type) != UNION_TYPE
&& TREE_CODE (type) != QUAL_UNION_TYPE)
finalize_type_size (type);
- pop_obstacks ();
- resume_momentary (old);
-
/* If this type is created before sizetype has been permanently set,
record it so set_sizetype can fix it up. */
if (! sizetype_set)
- {
- TREE_CHAIN (type) = early_type_list;
- early_type_list = type;
- }
+ early_type_list = tree_cons (NULL_TREE, type, early_type_list);
+
+ /* If an alias set has been set for this aggregate when it was incomplete,
+ force it into alias set 0.
+ This is too conservative, but we cannot call record_component_aliases
+ here because some frontends still change the aggregates after
+ layout_type. */
+ if (AGGREGATE_TYPE_P (type) && TYPE_ALIAS_SET_KNOWN_P (type))
+ TYPE_ALIAS_SET (type) = 0;
}
\f
/* Create and return a type for signed integers of PRECISION bits. */
make_signed_type (precision)
int precision;
{
- register tree type = make_node (INTEGER_TYPE);
+ tree type = make_node (INTEGER_TYPE);
TYPE_PRECISION (type) = precision;
make_unsigned_type (precision)
int precision;
{
- register tree type = make_node (INTEGER_TYPE);
+ tree type = make_node (INTEGER_TYPE);
TYPE_PRECISION (type) = precision;
TYPE_MODE (t) = SImode;
TYPE_ALIGN (t) = GET_MODE_ALIGNMENT (SImode);
+ TYPE_USER_ALIGN (t) = 0;
TYPE_SIZE (t) = build_int_2 (GET_MODE_BITSIZE (SImode), 0);
TYPE_SIZE_UNIT (t) = build_int_2 (GET_MODE_SIZE (SImode), 0);
TREE_UNSIGNED (t) = 1;
TYPE_PRECISION (t) = GET_MODE_BITSIZE (SImode);
TYPE_MIN_VALUE (t) = build_int_2 (0, 0);
+ TYPE_IS_SIZETYPE (t) = 1;
/* 1000 avoids problems with possible overflow and is certainly
larger than any size value we'd want to be storing. */
int precision = MIN (oprecision + BITS_PER_UNIT_LOG + 1,
2 * HOST_BITS_PER_WIDE_INT);
unsigned int i;
- tree t, next;
+ tree t;
if (sizetype_set)
abort ();
/* Make copies of nodes since we'll be setting TYPE_IS_SIZETYPE. */
sizetype = copy_node (type);
TYPE_DOMAIN (sizetype) = type;
+ TYPE_IS_SIZETYPE (sizetype) = 1;
bitsizetype = make_node (INTEGER_TYPE);
TYPE_NAME (bitsizetype) = TYPE_NAME (type);
TYPE_PRECISION (bitsizetype) = precision;
+ TYPE_IS_SIZETYPE (bitsizetype) = 1;
if (TREE_UNSIGNED (type))
fixup_unsigned_type (bitsizetype);
TYPE_NAME (bitsizetype) = get_identifier ("bit_size_type");
/* Show is a sizetype, is a main type, and has no pointers to it. */
- for (i = 0; i < sizeof sizetype_tab / sizeof sizetype_tab[0]; i++)
+ for (i = 0; i < ARRAY_SIZE (sizetype_tab); i++)
{
TYPE_IS_SIZETYPE (sizetype_tab[i]) = 1;
TYPE_MAIN_VARIANT (sizetype_tab[i]) = sizetype_tab[i];
TYPE_REFERENCE_TO (sizetype_tab[i]) = 0;
}
- ggc_add_tree_root ((tree *) &sizetype_tab,
- sizeof sizetype_tab / sizeof (tree));
-
/* Go down each of the types we already made and set the proper type
for the sizes in them. */
- for (t = early_type_list; t != 0; t = next)
+ for (t = early_type_list; t != 0; t = TREE_CHAIN (t))
{
- next = TREE_CHAIN (t);
- TREE_CHAIN (t) = 0;
-
- if (TREE_CODE (t) != INTEGER_TYPE)
+ if (TREE_CODE (TREE_VALUE (t)) != INTEGER_TYPE)
abort ();
- TREE_TYPE (TYPE_SIZE (t)) = bitsizetype;
- TREE_TYPE (TYPE_SIZE_UNIT (t)) = sizetype;
+ TREE_TYPE (TYPE_SIZE (TREE_VALUE (t))) = bitsizetype;
+ TREE_TYPE (TYPE_SIZE_UNIT (TREE_VALUE (t))) = sizetype;
}
early_type_list = 0;
fixup_signed_type (type)
tree type;
{
- register int precision = TYPE_PRECISION (type);
+ int precision = TYPE_PRECISION (type);
+
+ /* We can not represent properly constants greater then
+ 2 * HOST_BITS_PER_WIDE_INT, still we need the types
+ as they are used by i386 vector extensions and friends. */
+ if (precision > HOST_BITS_PER_WIDE_INT * 2)
+ precision = HOST_BITS_PER_WIDE_INT * 2;
TYPE_MIN_VALUE (type)
= build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
fixup_unsigned_type (type)
tree type;
{
- register int precision = TYPE_PRECISION (type);
+ int precision = TYPE_PRECISION (type);
+
+ /* We can not represent properly constants greater then
+ 2 * HOST_BITS_PER_WIDE_INT, still we need the types
+ as they are used by i386 vector extensions and friends. */
+ if (precision > HOST_BITS_PER_WIDE_INT * 2)
+ precision = HOST_BITS_PER_WIDE_INT * 2;
TYPE_MIN_VALUE (type) = build_int_2 (0, 0);
TYPE_MAX_VALUE (type)
int volatilep;
{
enum machine_mode mode;
- int unit = 0;
+ unsigned int unit = 0;
/* Find the narrowest integer mode that contains the bit field. */
for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
if the extra 4th byte is past the end of memory.
(Though at least one Unix compiler ignores this problem:
that on the Sequent 386 machine. */
- || MIN (unit, BIGGEST_ALIGNMENT) > (int) align
+ || MIN (unit, BIGGEST_ALIGNMENT) > align
|| (largest_mode != VOIDmode && unit > GET_MODE_BITSIZE (largest_mode)))
return VOIDmode;
unit = GET_MODE_BITSIZE (tmode);
if (bitpos / unit == (bitpos + bitsize - 1) / unit
&& unit <= BITS_PER_WORD
- && unit <= (int) MIN (align, BIGGEST_ALIGNMENT)
+ && unit <= MIN (align, BIGGEST_ALIGNMENT)
&& (largest_mode == VOIDmode
|| unit <= GET_MODE_BITSIZE (largest_mode)))
wide_mode = tmode;
return mode;
}
-/* Return the alignment of MODE. This will be bounded by 1 and
- BIGGEST_ALIGNMENT. */
-
-unsigned int
-get_mode_alignment (mode)
- enum machine_mode mode;
-{
- unsigned alignment = GET_MODE_UNIT_SIZE (mode);
-
- /* Extract the LSB of the size. */
- alignment = alignment & -alignment;
-
- alignment *= BITS_PER_UNIT;
-
- alignment = MIN (BIGGEST_ALIGNMENT, MAX (1, alignment));
- return alignment;
-}
-
-/* This function is run once to initialize stor-layout.c. */
-
-void
-init_stor_layout_once ()
-{
- ggc_add_tree_root (&pending_sizes, 1);
-}
+#include "gt-stor-layout.h"
OSDN Git Service
