X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=gcc%2Fstor-layout.c;h=cffb81c7f6277705e60a32deb95190d0369b0fc2;hp=0df34bd5a437dcd18c05ed0a4ea7cda43ba2e6dc;hb=82c07781b419f07a8100ca397c5b538ef932a0b5;hpb=5f1e93312ff619f3141a6f04f47792a2a9c90931 diff --git a/gcc/stor-layout.c b/gcc/stor-layout.c index 0df34bd5a43..cffb81c7f62 100644 --- a/gcc/stor-layout.c +++ b/gcc/stor-layout.c @@ -1,6 +1,6 @@ /* C-compiler utilities for types and variables storage layout Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1996, 1998, - 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. + 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. This file is part of GCC. @@ -34,13 +34,8 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "ggc.h" #include "target.h" #include "langhooks.h" - -/* Set to one when set_sizetype has been called. */ -static int sizetype_set; - -/* List of types created before set_sizetype has been called. We do not - make this a GGC root since we want these nodes to be reclaimed. */ -static tree early_type_list; +#include "regs.h" +#include "params.h" /* Data type for the expressions representing sizes of data types. It is the first integer type laid out. */ @@ -48,44 +43,33 @@ tree sizetype_tab[(int) TYPE_KIND_LAST]; /* If nonzero, this is an upper limit on alignment of structure fields. The value is measured in bits. */ -unsigned int maximum_field_alignment; - -/* If nonzero, the alignment of a bitstring or (power-)set value, in bits. - May be overridden by front-ends. */ -unsigned int set_alignment = 0; +unsigned int maximum_field_alignment = TARGET_DEFAULT_PACK_STRUCT * BITS_PER_UNIT; +/* ... and its original value in bytes, specified via -fpack-struct=. */ +unsigned int initial_max_fld_align = TARGET_DEFAULT_PACK_STRUCT; /* 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)); +static void finalize_record_size (record_layout_info); +static void finalize_type_size (tree); +static void place_union_field (record_layout_info, tree); #if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED) -static int excess_unit_span PARAMS ((HOST_WIDE_INT, HOST_WIDE_INT, - HOST_WIDE_INT, HOST_WIDE_INT, - tree)); +static int excess_unit_span (HOST_WIDE_INT, HOST_WIDE_INT, HOST_WIDE_INT, + HOST_WIDE_INT, tree); #endif -static unsigned int update_alignment_for_field - PARAMS ((record_layout_info, tree, - unsigned int)); -extern void debug_rli PARAMS ((record_layout_info)); +extern void debug_rli (record_layout_info); /* SAVE_EXPRs for sizes of types and decls, waiting to be expanded. */ 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 () +internal_reference_types (void) { reference_types_internal = 1; } @@ -93,38 +77,18 @@ internal_reference_types () /* Get a list of all the objects put on the pending sizes list. */ tree -get_pending_sizes () +get_pending_sizes (void) { tree chain = pending_sizes; - tree t; - - /* Put each SAVE_EXPR into the current function. */ - for (t = chain; t; t = TREE_CHAIN (t)) - SAVE_EXPR_CONTEXT (TREE_VALUE (t)) = current_function_decl; pending_sizes = 0; return chain; } -/* Return nonzero 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; +put_pending_size (tree expr) { /* Strip any simple arithmetic from EXPR to see if it has an underlying SAVE_EXPR. */ @@ -138,12 +102,9 @@ put_pending_size (expr) empty. */ void -put_pending_sizes (chain) - tree chain; +put_pending_sizes (tree chain) { - if (pending_sizes) - abort (); - + gcc_assert (!pending_sizes); pending_sizes = chain; } @@ -151,8 +112,7 @@ put_pending_sizes (chain) to serve as the actual size-expression for a type or decl. */ tree -variable_size (size) - tree size; +variable_size (tree size) { tree save; @@ -161,16 +121,11 @@ variable_size (size) just return SIZE unchanged. Likewise for self-referential sizes and constant sizes. */ if (TREE_CONSTANT (size) - || (*lang_hooks.decls.global_bindings_p) () < 0 - || contains_placeholder_p (size)) + || lang_hooks.decls.global_bindings_p () < 0 + || CONTAINS_PLACEHOLDER_P (size)) return size; - if (TREE_CODE (size) == MINUS_EXPR && integer_onep (TREE_OPERAND (size, 1))) - /* If this is the upper bound of a C array, leave the minus 1 outside - the SAVE_EXPR so it can be folded away. */ - TREE_OPERAND (size, 0) = save = save_expr (TREE_OPERAND (size, 0)); - else - size = save = save_expr (size); + size = save_expr (size); /* If an array with a variable number of elements is declared, and the elements require destruction, we will emit a cleanup for the @@ -180,27 +135,24 @@ variable_size (size) `unsaved', i.e., all SAVE_EXPRs are recalculated. However, we do not wish to do that here; the array-size is the same in both places. */ - if (TREE_CODE (save) == SAVE_EXPR) - SAVE_EXPR_PERSISTENT_P (save) = 1; + save = skip_simple_arithmetic (size); - if ((*lang_hooks.decls.global_bindings_p) ()) + if (cfun && 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. Trust it. */ + return size; + + if (lang_hooks.decls.global_bindings_p ()) { if (TREE_CONSTANT (size)) - error ("type size can't be explicitly evaluated"); + error ("type size can%'t be explicitly evaluated"); else error ("variable-size type declared outside of any function"); return size_one_node; } - if (immediate_size_expand) - expand_expr (save, const0_rtx, VOIDmode, 0); - 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 - put_pending_size (save); + put_pending_size (save); return size; } @@ -209,16 +161,13 @@ variable_size (size) #define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (DImode) #endif -/* Return the machine mode to use for a nonscalar of SIZE bits. - The mode must be in class CLASS, and have exactly that many bits. - If LIMIT is nonzero, modes of wider than MAX_FIXED_MODE_SIZE will not - be used. */ +/* Return the machine mode to use for a nonscalar of SIZE bits. The + mode must be in class CLASS, and have exactly that many value bits; + it may have padding as well. If LIMIT is nonzero, modes of wider + than MAX_FIXED_MODE_SIZE will not be used. */ enum machine_mode -mode_for_size (size, class, limit) - unsigned int size; - enum mode_class class; - int limit; +mode_for_size (unsigned int size, enum mode_class class, int limit) { enum machine_mode mode; @@ -228,7 +177,7 @@ mode_for_size (size, class, limit) /* Get the first mode which has this size, in the specified class. */ for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode)) - if (GET_MODE_BITSIZE (mode) == size) + if (GET_MODE_PRECISION (mode) == size) return mode; return BLKmode; @@ -237,12 +186,10 @@ mode_for_size (size, class, limit) /* Similar, except passed a tree node. */ enum machine_mode -mode_for_size_tree (size, class, limit) - tree size; - enum mode_class class; - int limit; +mode_for_size_tree (tree size, enum mode_class class, int limit) { if (TREE_CODE (size) != INTEGER_CST + || TREE_OVERFLOW (size) /* What we really want to say here is that the size can fit in a host integer, but we know there's no way we'd find a mode for this many bits, so there's no point in doing the precise test. */ @@ -253,12 +200,10 @@ mode_for_size_tree (size, class, limit) } /* Similar, but never return BLKmode; return the narrowest mode that - contains at least the requested number of bits. */ + contains at least the requested number of value bits. */ enum machine_mode -smallest_mode_for_size (size, class) - unsigned int size; - enum mode_class class; +smallest_mode_for_size (unsigned int size, enum mode_class class) { enum machine_mode mode; @@ -266,17 +211,16 @@ smallest_mode_for_size (size, class) specified class. */ for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode)) - if (GET_MODE_BITSIZE (mode) >= size) + if (GET_MODE_PRECISION (mode) >= size) return mode; - abort (); + gcc_unreachable (); } /* Find an integer mode of the exact same size, or BLKmode on failure. */ enum machine_mode -int_mode_for_mode (mode) - enum machine_mode mode; +int_mode_for_mode (enum machine_mode mode) { switch (GET_MODE_CLASS (mode)) { @@ -300,7 +244,7 @@ int_mode_for_mode (mode) case MODE_CC: default: - abort (); + gcc_unreachable (); } return mode; @@ -310,49 +254,11 @@ int_mode_for_mode (mode) BIGGEST_ALIGNMENT. */ unsigned int -get_mode_alignment (mode) - enum machine_mode mode; +get_mode_alignment (enum machine_mode mode) { - unsigned int alignment; - - if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT - || GET_MODE_CLASS (mode) == MODE_COMPLEX_INT) - alignment = GET_MODE_UNIT_SIZE (mode); - else - alignment = GET_MODE_SIZE (mode); - - /* Extract the LSB of the size. */ - alignment = alignment & -alignment; - alignment *= BITS_PER_UNIT; - - alignment = MIN (BIGGEST_ALIGNMENT, MAX (1, alignment)); - return alignment; -} - -/* Return the value of VALUE, rounded up to a multiple of DIVISOR. - This can only be applied to objects of a sizetype. */ - -tree -round_up (value, divisor) - tree value; - int divisor; -{ - tree arg = size_int_type (divisor, TREE_TYPE (value)); - - return size_binop (MULT_EXPR, size_binop (CEIL_DIV_EXPR, value, arg), arg); + return MIN (BIGGEST_ALIGNMENT, MAX (1, mode_base_align[mode]*BITS_PER_UNIT)); } -/* Likewise, but round down. */ - -tree -round_down (value, divisor) - tree value; - int divisor; -{ - tree arg = size_int_type (divisor, TREE_TYPE (value)); - - return size_binop (MULT_EXPR, size_binop (FLOOR_DIV_EXPR, value, arg), arg); -} /* Subroutine of layout_decl: Force alignment required for the data type. But if the decl itself wants greater alignment, don't override that. */ @@ -363,7 +269,8 @@ do_type_align (tree type, tree decl) if (TYPE_ALIGN (type) > DECL_ALIGN (decl)) { DECL_ALIGN (decl) = TYPE_ALIGN (type); - DECL_USER_ALIGN (decl) = TYPE_USER_ALIGN (type); + if (TREE_CODE (decl) == FIELD_DECL) + DECL_USER_ALIGN (decl) = TYPE_USER_ALIGN (type); } } @@ -381,9 +288,7 @@ do_type_align (tree type, tree decl) the record will be aligned to suit. */ void -layout_decl (decl, known_align) - tree decl; - unsigned int known_align; +layout_decl (tree decl, unsigned int known_align) { tree type = TREE_TYPE (decl); enum tree_code code = TREE_CODE (decl); @@ -391,10 +296,10 @@ layout_decl (decl, known_align) if (code == CONST_DECL) return; - else if (code != VAR_DECL && code != PARM_DECL && code != RESULT_DECL - && code != TYPE_DECL && code != FIELD_DECL) - abort (); - + + gcc_assert (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL + || code == TYPE_DECL ||code == FIELD_DECL); + rtl = DECL_RTL_IF_SET (decl); if (type == error_mark_node) @@ -410,7 +315,7 @@ layout_decl (decl, known_align) 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); + DECL_UNSIGNED (decl) = TYPE_UNSIGNED (type); if (DECL_MODE (decl) == VOIDmode) DECL_MODE (decl) = TYPE_MODE (type); @@ -421,8 +326,8 @@ layout_decl (decl, known_align) } else if (DECL_SIZE_UNIT (decl) == 0) DECL_SIZE_UNIT (decl) - = convert (sizetype, size_binop (CEIL_DIV_EXPR, DECL_SIZE (decl), - bitsize_unit_node)); + = fold_convert (sizetype, size_binop (CEIL_DIV_EXPR, DECL_SIZE (decl), + bitsize_unit_node)); if (code != FIELD_DECL) /* For non-fields, update the alignment from the type. */ @@ -430,6 +335,8 @@ layout_decl (decl, known_align) else /* For fields, it's a bit more complicated... */ { + bool old_user_align = DECL_USER_ALIGN (decl); + if (DECL_BIT_FIELD (decl)) { DECL_BIT_FIELD_TYPE (decl) = type; @@ -438,7 +345,7 @@ layout_decl (decl, known_align) field. */ if (integer_zerop (DECL_SIZE (decl)) && ! DECL_PACKED (decl) - && ! (*targetm.ms_bitfield_layout_p) (DECL_FIELD_CONTEXT (decl))) + && ! targetm.ms_bitfield_layout_p (DECL_FIELD_CONTEXT (decl))) { #ifdef PCC_BITFIELD_TYPE_MATTERS if (PCC_BITFIELD_TYPE_MATTERS) @@ -466,7 +373,9 @@ layout_decl (decl, known_align) enum machine_mode xmode = mode_for_size_tree (DECL_SIZE (decl), MODE_INT, 1); - if (xmode != BLKmode && known_align >= GET_MODE_ALIGNMENT (xmode)) + if (xmode != BLKmode + && (known_align == 0 + || known_align >= GET_MODE_ALIGNMENT (xmode))) { DECL_ALIGN (decl) = MAX (GET_MODE_ALIGNMENT (xmode), DECL_ALIGN (decl)); @@ -483,25 +392,27 @@ layout_decl (decl, known_align) } else if (DECL_PACKED (decl) && DECL_USER_ALIGN (decl)) /* Don't touch DECL_ALIGN. For other packed fields, go ahead and - round up; we'll reduce it again below. */; + round up; we'll reduce it again below. We want packing to + supersede USER_ALIGN inherited from the type, but defer to + alignment explicitly specified on the field decl. */; else do_type_align (type, decl); /* 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. */ + is of unknown size. + + Note that do_type_align may set DECL_USER_ALIGN, so we need to + check old_user_align instead. */ if (DECL_PACKED (decl) - && !DECL_USER_ALIGN (decl) + && !old_user_align && (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); - /* Should this be controlled by DECL_USER_ALIGN, too? */ - if (maximum_field_alignment != 0) - DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), maximum_field_alignment); - if (! DECL_USER_ALIGN (decl)) + if (! DECL_USER_ALIGN (decl) && ! DECL_PACKED (decl)) { /* Some targets (i.e. i386, VMS) limit struct field alignment to a lower boundary than alignment of variables unless @@ -514,6 +425,10 @@ layout_decl (decl, known_align) DECL_ALIGN (decl) = ADJUST_FIELD_ALIGN (decl, DECL_ALIGN (decl)); #endif } + + /* Should this be controlled by DECL_USER_ALIGN, too? */ + if (maximum_field_alignment != 0) + DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), maximum_field_alignment); } /* Evaluate nonconstant size only once, either now or as soon as safe. */ @@ -536,10 +451,10 @@ layout_decl (decl, known_align) 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); + warning (0, "%Jsize of %qD is %d bytes", decl, decl, size_as_int); else - warning_with_decl (decl, "size of `%s' is larger than %d bytes", - larger_than_size); + warning (0, "%Jsize of %qD is larger than %d bytes", + decl, decl, larger_than_size); } } @@ -552,15 +467,28 @@ layout_decl (decl, known_align) SET_DECL_RTL (decl, rtl); } } + +/* Given a VAR_DECL, PARM_DECL or RESULT_DECL, clears the results of + a previous call to layout_decl and calls it again. */ + +void +relayout_decl (tree decl) +{ + DECL_SIZE (decl) = DECL_SIZE_UNIT (decl) = 0; + DECL_MODE (decl) = VOIDmode; + DECL_ALIGN (decl) = 0; + SET_DECL_RTL (decl, 0); + + layout_decl (decl, 0); +} /* 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; +static void (*lang_adjust_rli) (record_layout_info) = 0; void -set_lang_adjust_rli (f) - void (*f) PARAMS ((record_layout_info)); +set_lang_adjust_rli (void (*f) (record_layout_info)) { lang_adjust_rli = f; } @@ -573,11 +501,9 @@ set_lang_adjust_rli (f) out the record. */ record_layout_info -start_record_layout (t) - tree t; +start_record_layout (tree t) { - record_layout_info rli - = (record_layout_info) xmalloc (sizeof (struct record_layout_info_s)); + record_layout_info rli = xmalloc (sizeof (struct record_layout_info_s)); rli->t = t; @@ -607,34 +533,31 @@ start_record_layout (t) the offset/bitpos forms and byte and bit offsets. */ tree -bit_from_pos (offset, bitpos) - tree offset, bitpos; +bit_from_pos (tree offset, tree bitpos) { return size_binop (PLUS_EXPR, bitpos, - size_binop (MULT_EXPR, convert (bitsizetype, offset), + size_binop (MULT_EXPR, + fold_convert (bitsizetype, offset), bitsize_unit_node)); } tree -byte_from_pos (offset, bitpos) - tree offset, bitpos; +byte_from_pos (tree offset, tree bitpos) { return size_binop (PLUS_EXPR, offset, - convert (sizetype, - size_binop (TRUNC_DIV_EXPR, bitpos, - bitsize_unit_node))); + fold_convert (sizetype, + size_binop (TRUNC_DIV_EXPR, bitpos, + bitsize_unit_node))); } void -pos_from_bit (poffset, pbitpos, off_align, pos) - tree *poffset, *pbitpos; - unsigned int off_align; - tree pos; +pos_from_bit (tree *poffset, tree *pbitpos, unsigned int off_align, + tree pos) { *poffset = size_binop (MULT_EXPR, - convert (sizetype, - size_binop (FLOOR_DIV_EXPR, pos, - bitsize_int (off_align))), + fold_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)); } @@ -643,9 +566,7 @@ pos_from_bit (poffset, pbitpos, off_align, pos) normalize the offsets so they are within the alignment. */ void -normalize_offset (poffset, pbitpos, off_align) - tree *poffset, *pbitpos; - unsigned int off_align; +normalize_offset (tree *poffset, tree *pbitpos, unsigned int off_align) { /* If the bit position is now larger than it should be, adjust it downwards. */ @@ -656,7 +577,8 @@ normalize_offset (poffset, pbitpos, off_align) *poffset = size_binop (PLUS_EXPR, *poffset, - size_binop (MULT_EXPR, convert (sizetype, extra_aligns), + size_binop (MULT_EXPR, + fold_convert (sizetype, extra_aligns), size_int (off_align / BITS_PER_UNIT))); *pbitpos @@ -667,8 +589,7 @@ normalize_offset (poffset, pbitpos, off_align) /* Print debugging information about the information in RLI. */ void -debug_rli (rli) - record_layout_info rli; +debug_rli (record_layout_info rli) { print_node_brief (stderr, "type", rli->t, 0); print_node_brief (stderr, "\noffset", rli->offset, 0); @@ -691,8 +612,7 @@ debug_rli (rli) BITPOS if necessary to keep BITPOS below OFFSET_ALIGN. */ void -normalize_rli (rli) - record_layout_info rli; +normalize_rli (record_layout_info rli) { normalize_offset (&rli->offset, &rli->bitpos, rli->offset_align); } @@ -700,8 +620,7 @@ normalize_rli (rli) /* Returns the size in bytes allocated so far. */ tree -rli_size_unit_so_far (rli) - record_layout_info rli; +rli_size_unit_so_far (record_layout_info rli) { return byte_from_pos (rli->offset, rli->bitpos); } @@ -709,22 +628,19 @@ rli_size_unit_so_far (rli) /* Returns the size in bits allocated so far. */ tree -rli_size_so_far (rli) - record_layout_info rli; +rli_size_so_far (record_layout_info rli) { return bit_from_pos (rli->offset, rli->bitpos); } /* FIELD is about to be added to RLI->T. The alignment (in bits) of - the next available location is given by KNOWN_ALIGN. Update the - variable alignment fields in RLI, and return the alignment to give - the FIELD. */ - -static unsigned int -update_alignment_for_field (rli, field, known_align) - record_layout_info rli; - tree field; - unsigned int known_align; + the next available location within the record is given by KNOWN_ALIGN. + Update the variable alignment fields in RLI, and return the alignment + to give the FIELD. */ + +unsigned int +update_alignment_for_field (record_layout_info rli, tree field, + unsigned int known_align) { /* The alignment required for FIELD. */ unsigned int desired_align; @@ -746,7 +662,7 @@ update_alignment_for_field (rli, field, known_align) /* Record must have at least as much alignment as any field. Otherwise, the alignment of the field within the record is meaningless. */ - if (is_bitfield && (* targetm.ms_bitfield_layout_p) (rli->t)) + if (is_bitfield && targetm.ms_bitfield_layout_p (rli->t)) { /* Here, the alignment of the underlying type of a bitfield can affect the alignment of a record; even a zero-sized field @@ -755,10 +671,10 @@ update_alignment_for_field (rli, field, known_align) applies if there was an immediately prior, nonzero-size bitfield. (That's the way it is, experimentally.) */ if (! integer_zerop (DECL_SIZE (field)) - ? ! DECL_PACKED (field) - : (rli->prev_field - && DECL_BIT_FIELD_TYPE (rli->prev_field) - && ! integer_zerop (DECL_SIZE (rli->prev_field)))) + ? ! DECL_PACKED (field) + : (rli->prev_field + && DECL_BIT_FIELD_TYPE (rli->prev_field) + && ! integer_zerop (DECL_SIZE (rli->prev_field)))) { unsigned int type_align = TYPE_ALIGN (type); type_align = MAX (type_align, desired_align); @@ -766,14 +682,28 @@ update_alignment_for_field (rli, field, known_align) type_align = MIN (type_align, maximum_field_alignment); rli->record_align = MAX (rli->record_align, type_align); rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type)); + /* If we start a new run, make sure we start it properly aligned. */ + if ((!rli->prev_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))) + || (rli->remaining_in_alignment + < tree_low_cst (DECL_SIZE (field), 0))) + && desired_align < type_align) + desired_align = type_align; } } #ifdef PCC_BITFIELD_TYPE_MATTERS else if (is_bitfield && PCC_BITFIELD_TYPE_MATTERS) { /* Named bit-fields cause the entire structure to have the - alignment implied by their type. */ - if (DECL_NAME (field) != 0) + alignment implied by their type. Some targets also apply the same + rules to unnamed bitfields. */ + if (DECL_NAME (field) != 0 + || targetm.align_anon_bitfield ()) { unsigned int type_align = TYPE_ALIGN (type); @@ -815,9 +745,7 @@ update_alignment_for_field (rli, field, known_align) /* Called from place_field to handle unions. */ static void -place_union_field (rli, field) - record_layout_info rli; - tree field; +place_union_field (record_layout_info rli, tree field) { update_alignment_for_field (rli, field, /*known_align=*/0); @@ -830,9 +758,9 @@ place_union_field (rli, field) if (TREE_CODE (rli->t) == UNION_TYPE) rli->offset = size_binop (MAX_EXPR, rli->offset, DECL_SIZE_UNIT (field)); else if (TREE_CODE (rli->t) == QUAL_UNION_TYPE) - rli->offset = fold (build (COND_EXPR, sizetype, + rli->offset = fold_build3 (COND_EXPR, sizetype, DECL_QUALIFIER (field), - DECL_SIZE_UNIT (field), rli->offset)); + DECL_SIZE_UNIT (field), rli->offset); } #if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED) @@ -840,9 +768,8 @@ place_union_field (rli, field) at BYTE_OFFSET / BIT_OFFSET. Return nonzero if the field would span more units of alignment than the underlying TYPE. */ static int -excess_unit_span (byte_offset, bit_offset, size, align, type) - HOST_WIDE_INT byte_offset, bit_offset, size, align; - tree type; +excess_unit_span (HOST_WIDE_INT byte_offset, HOST_WIDE_INT bit_offset, + HOST_WIDE_INT size, HOST_WIDE_INT align, tree type) { /* Note that the calculation of OFFSET might overflow; we calculate it so that we still get the right result as long as ALIGN is a power of two. */ @@ -861,9 +788,7 @@ excess_unit_span (byte_offset, bit_offset, size, align, type) callers that desire that behavior must manually perform that step.) */ void -place_field (rli, field) - record_layout_info rli; - tree field; +place_field (record_layout_info rli, tree field) { /* The alignment required for FIELD. */ unsigned int desired_align; @@ -907,15 +832,17 @@ place_field (rli, field) known_align = (tree_low_cst (rli->bitpos, 1) & - tree_low_cst (rli->bitpos, 1)); else if (integer_zerop (rli->offset)) - known_align = BIGGEST_ALIGNMENT; + known_align = 0; 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; - + desired_align = update_alignment_for_field (rli, field, known_align); + if (known_align == 0) + known_align = MAX (BIGGEST_ALIGNMENT, rli->record_align); if (warn_packed && DECL_PACKED (field)) { @@ -924,9 +851,11 @@ place_field (rli, field) if (TYPE_ALIGN (type) > desired_align) { if (STRICT_ALIGNMENT) - warning_with_decl (field, "packed attribute causes inefficient alignment for `%s'"); + warning (0, "%Jpacked attribute causes inefficient alignment " + "for %qD", field, field); else - warning_with_decl (field, "packed attribute is unnecessary for `%s'"); + warning (0, "%Jpacked attribute is unnecessary for %qD", + field, field); } } else @@ -941,7 +870,7 @@ place_field (rli, field) Bump the cumulative size to multiple of field alignment. */ if (warn_padded) - warning_with_decl (field, "padding struct to align `%s'"); + warning (0, "%Jpadding struct to align %qD", field, field); /* If the alignment is still within offset_align, just align the bit position. */ @@ -952,9 +881,9 @@ place_field (rli, field) /* 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))); + fold_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); @@ -969,7 +898,7 @@ place_field (rli, field) 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) + && ! targetm.ms_bitfield_layout_p (rli->t) && TREE_CODE (field) == FIELD_DECL && type != error_mark_node && DECL_BIT_FIELD (field) @@ -1002,7 +931,7 @@ place_field (rli, field) #ifdef BITFIELD_NBYTES_LIMITED if (BITFIELD_NBYTES_LIMITED - && ! (* targetm.ms_bitfield_layout_p) (rli->t) + && ! targetm.ms_bitfield_layout_p (rli->t) && TREE_CODE (field) == FIELD_DECL && type != error_mark_node && DECL_BIT_FIELD_TYPE (field) @@ -1053,9 +982,9 @@ place_field (rli, field) Note: for compatibility, we use the type size, not the type alignment to determine alignment, since that matches the documentation */ - if ((* targetm.ms_bitfield_layout_p) (rli->t) + if (targetm.ms_bitfield_layout_p (rli->t) && ((DECL_BIT_FIELD_TYPE (field) && ! DECL_PACKED (field)) - || (rli->prev_field && ! DECL_PACKED (rli->prev_field)))) + || (rli->prev_field && ! DECL_PACKED (rli->prev_field)))) { /* At this point, either the prior or current are bitfields, (possibly both), and we're dealing with MS packing. */ @@ -1086,18 +1015,30 @@ place_field (rli, field) 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 (type), - DECL_FIELD_BIT_OFFSET (rli->prev_field)); - rli->prev_field = field; - rli->remaining_in_alignment - = tree_low_cst (TYPE_SIZE (type), 0); + /* If PREV_FIELD is packed, and we haven't lumped + non-packed bitfields with it, treat this as if PREV_FIELD + was not a bitfield. This avoids anomalies where a packed + bitfield with long long base type can take up more + space than a same-size bitfield with base type short. */ + if (rli->prev_packed) + rli->prev_field = prev_saved = NULL; + else + { + /* out of bits; bump up to next 'word'. */ + rli->offset = DECL_FIELD_OFFSET (rli->prev_field); + 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_low_cst (TYPE_SIZE (type), 0) - bitsize; + } } - - rli->remaining_in_alignment -= bitsize; + else + rli->remaining_in_alignment -= bitsize; } + else if (rli->prev_packed) + rli->prev_field = prev_saved = NULL; else { /* End of a run: if leaving a run of bitfields of the same type @@ -1113,9 +1054,14 @@ place_field (rli, field) { tree type_size = TYPE_SIZE (TREE_TYPE (rli->prev_field)); - rli->bitpos - = size_binop (PLUS_EXPR, type_size, - DECL_FIELD_BIT_OFFSET (rli->prev_field)); + /* If the desired alignment is greater or equal to TYPE_SIZE, + we have already adjusted rli->bitpos / rli->offset above. + */ + if ((unsigned HOST_WIDE_INT) tree_low_cst (type_size, 0) + > desired_align) + 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 @@ -1129,6 +1075,7 @@ place_field (rli, field) rli->prev_field = NULL; } + rli->prev_packed = 0; normalize_rli (rli); } @@ -1201,20 +1148,59 @@ place_field (rli, 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; + actual_align = MAX (BIGGEST_ALIGNMENT, rli->record_align); 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); + /* ACTUAL_ALIGN is still the actual alignment *within the record* . + store / extract bit field operations will check the alignment of the + record against the mode of bit fields. */ if (known_align != actual_align) layout_decl (field, actual_align); - /* Only the MS bitfields use this. */ - if (rli->prev_field == NULL && DECL_BIT_FIELD_TYPE(field)) - rli->prev_field = field; + if (DECL_BIT_FIELD_TYPE (field)) + { + unsigned int type_align = TYPE_ALIGN (type); + + /* Only the MS bitfields use this. We used to also put any kind of + packed bit fields into prev_field, but that makes no sense, because + an 8 bit packed bit field shouldn't impose more restriction on + following fields than a char field, and the alignment requirements + are also not fulfilled. + There is no sane value to set rli->remaining_in_alignment to when + a packed bitfield in prev_field is unaligned. */ + if (maximum_field_alignment != 0) + type_align = MIN (type_align, maximum_field_alignment); + gcc_assert (rli->prev_field + || actual_align >= type_align || DECL_PACKED (field) + || integer_zerop (DECL_SIZE (field)) + || !targetm.ms_bitfield_layout_p (rli->t)); + if (rli->prev_field == NULL && actual_align >= type_align + && !integer_zerop (DECL_SIZE (field))) + { + rli->prev_field = field; + /* rli->remaining_in_alignment has not been set if the bitfield + has size zero, or if it is a packed bitfield. */ + rli->remaining_in_alignment + = (tree_low_cst (TYPE_SIZE (TREE_TYPE (field)), 0) + - tree_low_cst (DECL_SIZE (field), 0)); + rli->prev_packed = DECL_PACKED (field); + + } + else if (rli->prev_field && DECL_PACKED (field)) + { + HOST_WIDE_INT bitsize = tree_low_cst (DECL_SIZE (field), 0); + + if (rli->remaining_in_alignment < bitsize) + rli->prev_field = NULL; + else + rli->remaining_in_alignment -= bitsize; + } + } /* 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 @@ -1230,13 +1216,13 @@ place_field (rli, field) { rli->offset = size_binop (PLUS_EXPR, rli->offset, - convert (sizetype, - size_binop (CEIL_DIV_EXPR, rli->bitpos, - bitsize_unit_node))); + fold_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)); + rli->offset_align = MIN (rli->offset_align, desired_align); } else { @@ -1250,8 +1236,7 @@ place_field (rli, field) indicated by RLI. */ static void -finalize_record_size (rli) - record_layout_info rli; +finalize_record_size (record_layout_info rli) { tree unpadded_size, unpadded_size_unit; @@ -1277,22 +1262,14 @@ finalize_record_size (rli) unpadded_size_unit = size_binop (PLUS_EXPR, unpadded_size_unit, size_one_node); - /* 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, 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 (unpadded_size, TYPE_ALIGN (rli->t)); - TYPE_SIZE_UNIT (rli->t) = round_up (unpadded_size_unit, - TYPE_ALIGN (rli->t) / BITS_PER_UNIT); -#endif + TYPE_SIZE_UNIT (rli->t) + = round_up (unpadded_size_unit, TYPE_ALIGN_UNIT (rli->t)); if (warn_padded && TREE_CONSTANT (unpadded_size) && simple_cst_equal (unpadded_size, TYPE_SIZE (rli->t)) == 0) - warning ("padding struct size to alignment boundary"); + warning (0, "padding struct size to alignment boundary"); if (warn_packed && TREE_CODE (rli->t) == RECORD_TYPE && TYPE_PACKED (rli->t) && ! rli->packed_maybe_necessary @@ -1307,13 +1284,7 @@ finalize_record_size (rli) 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); -#else unpacked_size = round_up (TYPE_SIZE (rli->t), rli->unpacked_align); -#endif - if (simple_cst_equal (unpacked_size, TYPE_SIZE (rli->t))) { TYPE_PACKED (rli->t) = 0; @@ -1328,16 +1299,17 @@ finalize_record_size (rli) name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (rli->t))); if (STRICT_ALIGNMENT) - warning ("packed attribute causes inefficient alignment for `%s'", name); + warning (0, "packed attribute causes inefficient " + "alignment for %qs", name); else - warning ("packed attribute is unnecessary for `%s'", name); + warning (0, "packed attribute is unnecessary for %qs", name); } else { if (STRICT_ALIGNMENT) - warning ("packed attribute causes inefficient alignment"); + warning (0, "packed attribute causes inefficient alignment"); else - warning ("packed attribute is unnecessary"); + warning (0, "packed attribute is unnecessary"); } } } @@ -1346,8 +1318,7 @@ finalize_record_size (rli) /* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE). */ void -compute_record_mode (type) - tree type; +compute_record_mode (tree type) { tree field; enum machine_mode mode = VOIDmode; @@ -1366,30 +1337,19 @@ compute_record_mode (type) 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) continue; if (TREE_CODE (TREE_TYPE (field)) == ERROR_MARK || (TYPE_MODE (TREE_TYPE (field)) == BLKmode - && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field))) + && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field)) + && !(TYPE_SIZE (TREE_TYPE (field)) != 0 + && integer_zerop (TYPE_SIZE (TREE_TYPE (field))))) || ! 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. */ @@ -1405,12 +1365,14 @@ compute_record_mode (type) #endif /* MEMBER_TYPE_FORCES_BLK */ } - /* 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_for_size_tree (TYPE_SIZE (type), MODE_INT, 1); + + /* If we only have one real field; use its mode if that mode's size + matches the type's size. This only applies to RECORD_TYPE. This + does not apply to unions. */ + if (TREE_CODE (type) == RECORD_TYPE && mode != VOIDmode + && GET_MODE_SIZE (mode) == GET_MODE_SIZE (TYPE_MODE (type))) 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. */ @@ -1430,8 +1392,7 @@ compute_record_mode (type) out. */ static void -finalize_type_size (type) - tree type; +finalize_type_size (tree type) { /* Normally, use the alignment corresponding to the mode chosen. However, where strict alignment is not required, avoid @@ -1461,23 +1422,15 @@ finalize_type_size (type) result will fit in sizetype. We will get more efficient code using sizetype, so we force a conversion. */ TYPE_SIZE_UNIT (type) - = convert (sizetype, - size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (type), - bitsize_unit_node)); + = fold_convert (sizetype, + size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (type), + bitsize_unit_node)); 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 + TYPE_SIZE_UNIT (type) = round_up (TYPE_SIZE_UNIT (type), + TYPE_ALIGN_UNIT (type)); } /* Evaluate nonconstant sizes only once, either now or as soon as safe. */ @@ -1520,9 +1473,7 @@ finalize_type_size (type) G++ 3.2 ABI. */ void -finish_record_layout (rli, free_p) - record_layout_info rli; - int free_p; +finish_record_layout (record_layout_info rli, int free_p) { /* Compute the final size. */ finalize_record_size (rli); @@ -1554,11 +1505,8 @@ finish_record_layout (rli, free_p) ALIGN_TYPE. */ void -finish_builtin_struct (type, name, fields, align_type) - tree type; - const char *name; - tree fields; - tree align_type; +finish_builtin_struct (tree type, const char *name, tree fields, + tree align_type) { tree tail, next; @@ -1597,11 +1545,12 @@ finish_builtin_struct (type, name, fields, align_type) If the type is incomplete, its TYPE_SIZE remains zero. */ void -layout_type (type) - tree type; +layout_type (tree type) { - if (type == 0) - abort (); + gcc_assert (type); + + if (type == error_mark_node) + return; /* Do nothing if type has been laid out before. */ if (TYPE_SIZE (type)) @@ -1612,7 +1561,7 @@ layout_type (type) case LANG_TYPE: /* This kind of type is the responsibility of the language-specific code. */ - abort (); + gcc_unreachable (); case BOOLEAN_TYPE: /* Used for Java, Pascal, and Chill. */ if (TYPE_PRECISION (type) == 0) @@ -1625,7 +1574,7 @@ layout_type (type) case CHAR_TYPE: if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0) - TREE_UNSIGNED (type) = 1; + TYPE_UNSIGNED (type) = 1; TYPE_MODE (type) = smallest_mode_for_size (TYPE_PRECISION (type), MODE_INT); @@ -1640,11 +1589,11 @@ layout_type (type) break; case COMPLEX_TYPE: - TREE_UNSIGNED (type) = TREE_UNSIGNED (TREE_TYPE (type)); + TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TREE_TYPE (type)); TYPE_MODE (type) = mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type)), - (TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE - ? MODE_COMPLEX_INT : MODE_COMPLEX_FLOAT), + (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE + ? MODE_COMPLEX_FLOAT : MODE_COMPLEX_INT), 0); TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type))); TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type))); @@ -1652,14 +1601,54 @@ layout_type (type) case VECTOR_TYPE: { - tree subtype; + int nunits = TYPE_VECTOR_SUBPARTS (type); + tree nunits_tree = build_int_cst (NULL_TREE, nunits); + tree innertype = TREE_TYPE (type); + + gcc_assert (!(nunits & (nunits - 1))); - 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))); + /* Find an appropriate mode for the vector type. */ + if (TYPE_MODE (type) == VOIDmode) + { + enum machine_mode innermode = TYPE_MODE (innertype); + enum machine_mode mode; + + /* First, look for a supported vector type. */ + if (GET_MODE_CLASS (innermode) == MODE_FLOAT) + mode = MIN_MODE_VECTOR_FLOAT; + else + mode = MIN_MODE_VECTOR_INT; + + for (; mode != VOIDmode ; mode = GET_MODE_WIDER_MODE (mode)) + if (GET_MODE_NUNITS (mode) == nunits + && GET_MODE_INNER (mode) == innermode + && targetm.vector_mode_supported_p (mode)) + break; + + /* For integers, try mapping it to a same-sized scalar mode. */ + if (mode == VOIDmode + && GET_MODE_CLASS (innermode) == MODE_INT) + mode = mode_for_size (nunits * GET_MODE_BITSIZE (innermode), + MODE_INT, 0); + + if (mode == VOIDmode || !have_regs_of_mode[mode]) + TYPE_MODE (type) = BLKmode; + else + TYPE_MODE (type) = mode; + } + + TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TREE_TYPE (type)); + TYPE_SIZE_UNIT (type) = int_const_binop (MULT_EXPR, + TYPE_SIZE_UNIT (innertype), + nunits_tree, 0); + TYPE_SIZE (type) = int_const_binop (MULT_EXPR, TYPE_SIZE (innertype), + nunits_tree, 0); + + /* Always naturally align vectors. This prevents ABI changes + depending on whether or not native vector modes are supported. */ + TYPE_ALIGN (type) = tree_low_cst (TYPE_SIZE (type), 0); + break; } - break; case VOID_TYPE: /* This is an incomplete type and so doesn't have a size. */ @@ -1678,9 +1667,12 @@ layout_type (type) case FUNCTION_TYPE: case METHOD_TYPE: - TYPE_MODE (type) = mode_for_size (2 * POINTER_SIZE, MODE_INT, 0); - TYPE_SIZE (type) = bitsize_int (2 * POINTER_SIZE); - TYPE_SIZE_UNIT (type) = size_int ((2 * POINTER_SIZE) / BITS_PER_UNIT); + /* It's hard to see what the mode and size of a function ought to + be, but we do know the alignment is FUNCTION_BOUNDARY, so + make it consistent with that. */ + TYPE_MODE (type) = mode_for_size (FUNCTION_BOUNDARY, MODE_INT, 0); + TYPE_SIZE (type) = bitsize_int (FUNCTION_BOUNDARY); + TYPE_SIZE_UNIT (type) = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT); break; case POINTER_TYPE: @@ -1695,7 +1687,7 @@ layout_type (type) TYPE_SIZE (type) = bitsize_int (nbits); TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (mode)); - TREE_UNSIGNED (type) = 1; + TYPE_UNSIGNED (type) = 1; TYPE_PRECISION (type) = nbits; } break; @@ -1719,10 +1711,10 @@ layout_type (type) /* 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, - convert (sizetype, - fold (build (MINUS_EXPR, - TREE_TYPE (lb), - ub, lb)))); + fold_convert (sizetype, + fold_build2 (MINUS_EXPR, + TREE_TYPE (lb), + ub, lb))); /* Special handling for arrays of bits (for Chill). */ element_size = TYPE_SIZE (element); @@ -1745,13 +1737,14 @@ layout_type (type) 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) + if (!TYPE_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); TYPE_SIZE (type) = size_binop (MULT_EXPR, element_size, - convert (bitsizetype, length)); + fold_convert (bitsizetype, + length)); /* If we know the size of the element, calculate the total size directly, rather than do some division thing below. @@ -1776,22 +1769,6 @@ layout_type (type) 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) - { - tree tmp - = ROUND_TYPE_SIZE (type, TYPE_SIZE (type), TYPE_ALIGN (type)); - - /* If the rounding changed the size of the type, remove any - pre-calculated TYPE_SIZE_UNIT. */ - if (simple_cst_equal (TYPE_SIZE (type), tmp) != 1) - TYPE_SIZE_UNIT (type) = NULL; - - TYPE_SIZE (type) = tmp; - } -#endif - TYPE_MODE (type) = BLKmode; if (TYPE_SIZE (type) != 0 #ifdef MEMBER_TYPE_FORCES_BLK @@ -1853,46 +1830,8 @@ layout_type (type) } break; - 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 (); - else - { -#ifndef SET_WORD_SIZE -#define SET_WORD_SIZE BITS_PER_WORD -#endif - unsigned int alignment - = set_alignment ? set_alignment : SET_WORD_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) - TYPE_MODE (type) = BLKmode; - else - TYPE_MODE (type) = mode_for_size (alignment, MODE_INT, 1); - - 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; - - case FILE_TYPE: - /* 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; - default: - abort (); + gcc_unreachable (); } /* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE. For @@ -1903,11 +1842,6 @@ layout_type (type) && TREE_CODE (type) != QUAL_UNION_TYPE) finalize_type_size (type); - /* If this type is created before sizetype has been permanently set, - record it so set_sizetype can fix it up. */ - if (! sizetype_set) - 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 @@ -1920,8 +1854,7 @@ layout_type (type) /* Create and return a type for signed integers of PRECISION bits. */ tree -make_signed_type (precision) - int precision; +make_signed_type (int precision) { tree type = make_node (INTEGER_TYPE); @@ -1934,8 +1867,7 @@ make_signed_type (precision) /* Create and return a type for unsigned integers of PRECISION bits. */ tree -make_unsigned_type (precision) - int precision; +make_unsigned_type (int precision) { tree type = make_node (INTEGER_TYPE); @@ -1949,41 +1881,36 @@ make_unsigned_type (precision) value to enable integer types to be created. */ void -initialize_sizetypes () +initialize_sizetypes (bool signed_p) { tree t = make_node (INTEGER_TYPE); - /* Set this so we do something reasonable for the build_int_2 calls - below. */ - integer_type_node = t; - 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; + TYPE_UNSIGNED (t) = !signed_p; + TYPE_SIZE (t) = build_int_cst (t, GET_MODE_BITSIZE (SImode)); + TYPE_SIZE_UNIT (t) = build_int_cst (t, GET_MODE_SIZE (SImode)); + TYPE_PRECISION (t) = GET_MODE_BITSIZE (SImode); + TYPE_MIN_VALUE (t) = build_int_cst (t, 0); /* 1000 avoids problems with possible overflow and is certainly larger than any size value we'd want to be storing. */ - TYPE_MAX_VALUE (t) = build_int_2 (1000, 0); + TYPE_MAX_VALUE (t) = build_int_cst (t, 1000); - /* These two must be different nodes because of the caching done in - size_int_wide. */ sizetype = t; - bitsizetype = copy_node (t); - integer_type_node = 0; + bitsizetype = build_distinct_type_copy (t); } -/* Set sizetype to TYPE, and initialize *sizetype accordingly. - Also update the type of any standard type's sizes made so far. */ +/* Make sizetype a version of TYPE, and initialize *sizetype + accordingly. We do this by overwriting the stub sizetype and + bitsizetype nodes created by initialize_sizetypes. This makes sure + that (a) anything stubby about them no longer exists, (b) any + INTEGER_CSTs created with such a type, remain valid. */ void -set_sizetype (type) - tree type; +set_sizetype (tree type) { int oprecision = TYPE_PRECISION (type); /* The *bitsizetype types use a precision that avoids overflows when @@ -1992,78 +1919,113 @@ set_sizetype (type) precision. */ int precision = MIN (oprecision + BITS_PER_UNIT_LOG + 1, 2 * HOST_BITS_PER_WIDE_INT); - unsigned int i; 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); - else - fixup_signed_type (bitsizetype); - - layout_type (bitsizetype); + gcc_assert (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (sizetype)); - if (TREE_UNSIGNED (type)) + t = build_distinct_type_copy (type); + /* We do want to use sizetype's cache, as we will be replacing that + type. */ + TYPE_CACHED_VALUES (t) = TYPE_CACHED_VALUES (sizetype); + TYPE_CACHED_VALUES_P (t) = TYPE_CACHED_VALUES_P (sizetype); + TREE_TYPE (TYPE_CACHED_VALUES (t)) = type; + TYPE_UID (t) = TYPE_UID (sizetype); + TYPE_IS_SIZETYPE (t) = 1; + + /* Replace our original stub sizetype. */ + memcpy (sizetype, t, tree_size (sizetype)); + TYPE_MAIN_VARIANT (sizetype) = sizetype; + + t = make_node (INTEGER_TYPE); + TYPE_NAME (t) = get_identifier ("bit_size_type"); + /* We do want to use bitsizetype's cache, as we will be replacing that + type. */ + TYPE_CACHED_VALUES (t) = TYPE_CACHED_VALUES (bitsizetype); + TYPE_CACHED_VALUES_P (t) = TYPE_CACHED_VALUES_P (bitsizetype); + TYPE_PRECISION (t) = precision; + TYPE_UID (t) = TYPE_UID (bitsizetype); + TYPE_IS_SIZETYPE (t) = 1; + /* Replace our original stub bitsizetype. */ + memcpy (bitsizetype, t, tree_size (bitsizetype)); + + if (TYPE_UNSIGNED (type)) { - usizetype = sizetype; - ubitsizetype = bitsizetype; - ssizetype = copy_node (make_signed_type (oprecision)); - sbitsizetype = copy_node (make_signed_type (precision)); + fixup_unsigned_type (bitsizetype); + ssizetype = build_distinct_type_copy (make_signed_type (oprecision)); + TYPE_IS_SIZETYPE (ssizetype) = 1; + sbitsizetype = build_distinct_type_copy (make_signed_type (precision)); + TYPE_IS_SIZETYPE (sbitsizetype) = 1; } else { + fixup_signed_type (bitsizetype); ssizetype = sizetype; sbitsizetype = bitsizetype; - usizetype = copy_node (make_unsigned_type (oprecision)); - ubitsizetype = copy_node (make_unsigned_type (precision)); } +} + +/* TYPE is an integral type, i.e., an INTEGRAL_TYPE, ENUMERAL_TYPE, + BOOLEAN_TYPE, or CHAR_TYPE. Set TYPE_MIN_VALUE and TYPE_MAX_VALUE + for TYPE, based on the PRECISION and whether or not the TYPE + IS_UNSIGNED. PRECISION need not correspond to a width supported + natively by the hardware; for example, on a machine with 8-bit, + 16-bit, and 32-bit register modes, PRECISION might be 7, 23, or + 61. */ - TYPE_NAME (bitsizetype) = get_identifier ("bit_size_type"); +void +set_min_and_max_values_for_integral_type (tree type, + int precision, + bool is_unsigned) +{ + tree min_value; + tree max_value; - /* Show is a sizetype, is a main type, and has no pointers to it. */ - for (i = 0; i < ARRAY_SIZE (sizetype_tab); i++) + if (is_unsigned) { - TYPE_IS_SIZETYPE (sizetype_tab[i]) = 1; - TYPE_MAIN_VARIANT (sizetype_tab[i]) = sizetype_tab[i]; - TYPE_NEXT_VARIANT (sizetype_tab[i]) = 0; - TYPE_POINTER_TO (sizetype_tab[i]) = 0; - TYPE_REFERENCE_TO (sizetype_tab[i]) = 0; + min_value = build_int_cst (type, 0); + max_value + = build_int_cst_wide (type, precision - HOST_BITS_PER_WIDE_INT >= 0 + ? -1 + : ((HOST_WIDE_INT) 1 << precision) - 1, + precision - HOST_BITS_PER_WIDE_INT > 0 + ? ((unsigned HOST_WIDE_INT) ~0 + >> (HOST_BITS_PER_WIDE_INT + - (precision - HOST_BITS_PER_WIDE_INT))) + : 0); } - - /* 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 = TREE_CHAIN (t)) + else { - if (TREE_CODE (TREE_VALUE (t)) != INTEGER_TYPE) - abort (); - - TREE_TYPE (TYPE_SIZE (TREE_VALUE (t))) = bitsizetype; - TREE_TYPE (TYPE_SIZE_UNIT (TREE_VALUE (t))) = sizetype; + min_value + = build_int_cst_wide (type, + (precision - HOST_BITS_PER_WIDE_INT > 0 + ? 0 + : (HOST_WIDE_INT) (-1) << (precision - 1)), + (((HOST_WIDE_INT) (-1) + << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0 + ? precision - HOST_BITS_PER_WIDE_INT - 1 + : 0)))); + max_value + = build_int_cst_wide (type, + (precision - HOST_BITS_PER_WIDE_INT > 0 + ? -1 + : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1), + (precision - HOST_BITS_PER_WIDE_INT - 1 > 0 + ? (((HOST_WIDE_INT) 1 + << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1 + : 0)); } - early_type_list = 0; - sizetype_set = 1; + TYPE_MIN_VALUE (type) = min_value; + TYPE_MAX_VALUE (type) = max_value; } - + /* Set the extreme values of TYPE based on its precision in bits, then lay it out. Used when make_signed_type won't do because the tree code is not INTEGER_TYPE. E.g. for Pascal, when the -fsigned-char option is given. */ void -fixup_signed_type (type) - tree type; +fixup_signed_type (tree type) { int precision = TYPE_PRECISION (type); @@ -2073,23 +2035,8 @@ fixup_signed_type (type) 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 - ? 0 : (HOST_WIDE_INT) (-1) << (precision - 1)), - (((HOST_WIDE_INT) (-1) - << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0 - ? precision - HOST_BITS_PER_WIDE_INT - 1 - : 0)))); - TYPE_MAX_VALUE (type) - = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0 - ? -1 : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1), - (precision - HOST_BITS_PER_WIDE_INT - 1 > 0 - ? (((HOST_WIDE_INT) 1 - << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1 - : 0)); - - TREE_TYPE (TYPE_MIN_VALUE (type)) = type; - TREE_TYPE (TYPE_MAX_VALUE (type)) = type; + set_min_and_max_values_for_integral_type (type, precision, + /*is_unsigned=*/false); /* Lay out the type: set its alignment, size, etc. */ layout_type (type); @@ -2100,8 +2047,7 @@ fixup_signed_type (type) and for enumeral types. */ void -fixup_unsigned_type (type) - tree type; +fixup_unsigned_type (tree type) { int precision = TYPE_PRECISION (type); @@ -2111,17 +2057,10 @@ fixup_unsigned_type (type) 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) - = build_int_2 (precision - HOST_BITS_PER_WIDE_INT >= 0 - ? -1 : ((HOST_WIDE_INT) 1 << precision) - 1, - precision - HOST_BITS_PER_WIDE_INT > 0 - ? ((unsigned HOST_WIDE_INT) ~0 - >> (HOST_BITS_PER_WIDE_INT - - (precision - HOST_BITS_PER_WIDE_INT))) - : 0); - TREE_TYPE (TYPE_MIN_VALUE (type)) = type; - TREE_TYPE (TYPE_MAX_VALUE (type)) = type; + TYPE_UNSIGNED (type) = 1; + + set_min_and_max_values_for_integral_type (type, precision, + /*is_unsigned=*/true); /* Lay out the type: set its alignment, size, etc. */ layout_type (type); @@ -2143,11 +2082,8 @@ fixup_unsigned_type (type) all the conditions. */ enum machine_mode -get_best_mode (bitsize, bitpos, align, largest_mode, volatilep) - int bitsize, bitpos; - unsigned int align; - enum machine_mode largest_mode; - int volatilep; +get_best_mode (int bitsize, int bitpos, unsigned int align, + enum machine_mode largest_mode, int volatilep) { enum machine_mode mode; unsigned int unit = 0; @@ -2196,4 +2132,32 @@ get_best_mode (bitsize, bitpos, align, largest_mode, volatilep) return mode; } +/* Gets minimal and maximal values for MODE (signed or unsigned depending on + SIGN). The returned constants are made to be usable in TARGET_MODE. */ + +void +get_mode_bounds (enum machine_mode mode, int sign, + enum machine_mode target_mode, + rtx *mmin, rtx *mmax) +{ + unsigned size = GET_MODE_BITSIZE (mode); + unsigned HOST_WIDE_INT min_val, max_val; + + gcc_assert (size <= HOST_BITS_PER_WIDE_INT); + + if (sign) + { + min_val = -((unsigned HOST_WIDE_INT) 1 << (size - 1)); + max_val = ((unsigned HOST_WIDE_INT) 1 << (size - 1)) - 1; + } + else + { + min_val = 0; + max_val = ((unsigned HOST_WIDE_INT) 1 << (size - 1) << 1) - 1; + } + + *mmin = gen_int_mode (min_val, target_mode); + *mmax = gen_int_mode (max_val, target_mode); +} + #include "gt-stor-layout.h"