diff options
Diffstat (limited to 'gcc-4.2.1-5666.3/gcc/stor-layout.c')
| -rw-r--r-- | gcc-4.2.1-5666.3/gcc/stor-layout.c | 2402 |
1 files changed, 0 insertions, 2402 deletions
diff --git a/gcc-4.2.1-5666.3/gcc/stor-layout.c b/gcc-4.2.1-5666.3/gcc/stor-layout.c deleted file mode 100644 index 1c9b56bbc..000000000 --- a/gcc-4.2.1-5666.3/gcc/stor-layout.c +++ /dev/null @@ -1,2402 +0,0 @@ -/* 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, 2004, 2005, 2006 - Free Software Foundation, Inc. - -This file is part of GCC. - -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. - -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 GCC; see the file COPYING. If not, write to the Free -Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA -02110-1301, USA. */ - - -#include "config.h" -#include "system.h" -#include "coretypes.h" -#include "tm.h" -#include "tree.h" -#include "rtl.h" -#include "tm_p.h" -#include "flags.h" -#include "function.h" -#include "expr.h" -#include "output.h" -#include "toplev.h" -#include "ggc.h" -#include "target.h" -#include "langhooks.h" -#include "regs.h" -#include "params.h" - -/* Data type for the expressions representing sizes of data types. - It is the first integer type laid out. */ -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 = TARGET_DEFAULT_PACK_STRUCT * BITS_PER_UNIT; -/* ... and its original value in bytes, specified via -fpack-struct=<value>. */ -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 (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 (HOST_WIDE_INT, HOST_WIDE_INT, HOST_WIDE_INT, - HOST_WIDE_INT, tree); -#endif -extern void debug_rli (record_layout_info); - -/* SAVE_EXPRs for sizes of types and decls, waiting to be expanded. */ - -static GTY(()) tree pending_sizes; - -/* Show that REFERENCE_TYPES are internal and should be Pmode. Called only - by front end. */ - -void -internal_reference_types (void) -{ - reference_types_internal = 1; -} - -/* Get a list of all the objects put on the pending sizes list. */ - -tree -get_pending_sizes (void) -{ - tree chain = pending_sizes; - - pending_sizes = 0; - return chain; -} - -/* Add EXPR to the pending sizes list. */ - -void -put_pending_size (tree expr) -{ - /* Strip any simple arithmetic from EXPR to see if it has an underlying - SAVE_EXPR. */ - expr = skip_simple_arithmetic (expr); - - 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 (tree chain) -{ - gcc_assert (!pending_sizes); - pending_sizes = chain; -} - -/* Given a size SIZE that may not be a constant, return a SAVE_EXPR - to serve as the actual size-expression for a type or decl. */ - -tree -variable_size (tree size) -{ - tree save; - - /* 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 and - constant sizes. */ - if (TREE_CONSTANT (size) - || lang_hooks.decls.global_bindings_p () < 0 - || CONTAINS_PLACEHOLDER_P (size)) - return 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 - array. That cleanup is run both on normal exit from the block - and in the exception-handler for the block. Normally, when code - is used in both ordinary code and in an exception handler it is - `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. */ - save = skip_simple_arithmetic (size); - - 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"); - else - error ("variable-size type declared outside of any function"); - - return size_one_node; - } - - put_pending_size (save); - - return size; -} - -#ifndef MAX_FIXED_MODE_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 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 (unsigned int size, enum mode_class class, int limit) -{ - enum machine_mode mode; - - if (limit && size > MAX_FIXED_MODE_SIZE) - return BLKmode; - - /* 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_PRECISION (mode) == size) - return mode; - - return BLKmode; -} - -/* Similar, except passed a tree node. */ - -enum machine_mode -mode_for_size_tree (tree size, enum mode_class class, int limit) -{ - unsigned HOST_WIDE_INT uhwi; - unsigned int ui; - - if (!host_integerp (size, 1)) - return BLKmode; - uhwi = tree_low_cst (size, 1); - ui = uhwi; - if (uhwi != ui) - return BLKmode; - return mode_for_size (ui, class, limit); -} - -/* Similar, but never return BLKmode; return the narrowest mode that - contains at least the requested number of value bits. */ - -enum machine_mode -smallest_mode_for_size (unsigned int size, enum mode_class class) -{ - enum machine_mode mode; - - /* Get the first mode which has at least this size, in the - specified class. */ - for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode; - mode = GET_MODE_WIDER_MODE (mode)) - if (GET_MODE_PRECISION (mode) >= size) - return mode; - - gcc_unreachable (); -} - -/* Find an integer mode of the exact same size, or BLKmode on failure. */ - -enum machine_mode -int_mode_for_mode (enum machine_mode mode) -{ - switch (GET_MODE_CLASS (mode)) - { - case MODE_INT: - case MODE_PARTIAL_INT: - break; - - case MODE_COMPLEX_INT: - case MODE_COMPLEX_FLOAT: - case MODE_FLOAT: - case MODE_DECIMAL_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; - - /* ... fall through ... */ - - case MODE_CC: - default: - gcc_unreachable (); - } - - return mode; -} - -/* Return the alignment of MODE. This will be bounded by 1 and - BIGGEST_ALIGNMENT. */ - -unsigned int -get_mode_alignment (enum machine_mode mode) -{ - return MIN (BIGGEST_ALIGNMENT, MAX (1, mode_base_align[mode]*BITS_PER_UNIT)); -} - - -/* Subroutine of layout_decl: Force alignment required for the data type. - But if the decl itself wants greater alignment, don't override that. */ - -static inline void -do_type_align (tree type, tree decl) -{ - if (TYPE_ALIGN (type) > DECL_ALIGN (decl)) - { - DECL_ALIGN (decl) = TYPE_ALIGN (type); - if (TREE_CODE (decl) == FIELD_DECL) - DECL_USER_ALIGN (decl) = TYPE_USER_ALIGN (type); - } -} - -/* Set the size, mode and alignment of a ..._DECL node. - TYPE_DECL does need this for C++. - Note that LABEL_DECL and CONST_DECL nodes do not need this, - and FUNCTION_DECL nodes have them set up in a special (and simple) way. - Don't call layout_decl for them. - - KNOWN_ALIGN is the amount of alignment we can assume this - decl has with no special effort. It is relevant only for FIELD_DECLs - and depends on the previous fields. - All that matters about KNOWN_ALIGN is which powers of 2 divide it. - If KNOWN_ALIGN is 0, it means, "as much alignment as you like": - the record will be aligned to suit. */ - -void -layout_decl (tree decl, unsigned int known_align) -{ - tree type = TREE_TYPE (decl); - enum tree_code code = TREE_CODE (decl); - rtx rtl = NULL_RTX; - - if (code == CONST_DECL) - return; - - 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) - type = void_type_node; - - /* 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. */ - - DECL_UNSIGNED (decl) = TYPE_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 (DECL_SIZE_UNIT (decl) == 0) - DECL_SIZE_UNIT (decl) - = 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. */ - do_type_align (type, decl); - else - /* For fields, it's a bit more complicated... */ - { - bool old_user_align = DECL_USER_ALIGN (decl); - bool zero_bitfield = false; - bool packed_p = DECL_PACKED (decl); - unsigned int mfa; - - if (DECL_BIT_FIELD (decl)) - { - DECL_BIT_FIELD_TYPE (decl) = type; - - /* A zero-length bit-field affects the alignment of the next - field. In essence such bit-fields are not influenced by - any packing due to #pragma pack or attribute packed. */ - if (integer_zerop (DECL_SIZE (decl)) - && ! targetm.ms_bitfield_layout_p (DECL_FIELD_CONTEXT (decl))) - { - zero_bitfield = true; - packed_p = false; -#ifdef PCC_BITFIELD_TYPE_MATTERS - if (PCC_BITFIELD_TYPE_MATTERS) - do_type_align (type, decl); - else -#endif - { -#ifdef EMPTY_FIELD_BOUNDARY - if (EMPTY_FIELD_BOUNDARY > DECL_ALIGN (decl)) - { - DECL_ALIGN (decl) = EMPTY_FIELD_BOUNDARY; - DECL_USER_ALIGN (decl) = 0; - } -#endif - } - } - - /* 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 (TYPE_SIZE (type) != 0 - && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST - && GET_MODE_CLASS (TYPE_MODE (type)) == MODE_INT) - { - enum machine_mode xmode - = mode_for_size_tree (DECL_SIZE (decl), MODE_INT, 1); - - if (xmode != BLKmode - && (known_align == 0 - || known_align >= GET_MODE_ALIGNMENT (xmode))) - { - DECL_ALIGN (decl) = MAX (GET_MODE_ALIGNMENT (xmode), - DECL_ALIGN (decl)); - DECL_MODE (decl) = xmode; - DECL_BIT_FIELD (decl) = 0; - } - } - - /* Turn off DECL_BIT_FIELD if we won't need it set. */ - if (TYPE_MODE (type) == BLKmode && DECL_MODE (decl) == BLKmode - && known_align >= TYPE_ALIGN (type) - && DECL_ALIGN (decl) >= TYPE_ALIGN (type)) - DECL_BIT_FIELD (decl) = 0; - } - else if (packed_p && DECL_USER_ALIGN (decl)) - /* Don't touch DECL_ALIGN. For other packed fields, go ahead and - 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. - - Note that do_type_align may set DECL_USER_ALIGN, so we need to - check old_user_align instead. */ - if (packed_p - && !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); -/* APPLE LOCAL begin Macintosh alignment 2002-2-12 --ff */ -#ifdef PEG_ALIGN_FOR_MAC68K - else if (OPTION_ALIGN_MAC68K) - DECL_ALIGN (decl) = PEG_ALIGN_FOR_MAC68K (DECL_ALIGN (decl)); -#endif -/* APPLE LOCAL end Macintosh alignment 2002-2-12 --ff */ - - if (! packed_p && ! DECL_USER_ALIGN (decl)) - { - /* 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 - DECL_ALIGN (decl) - = MIN (DECL_ALIGN (decl), (unsigned) BIGGEST_FIELD_ALIGNMENT); -#endif -#ifdef ADJUST_FIELD_ALIGN - DECL_ALIGN (decl) = ADJUST_FIELD_ALIGN (decl, DECL_ALIGN (decl)); -#endif - } - - if (zero_bitfield) - mfa = initial_max_fld_align * BITS_PER_UNIT; - else - mfa = maximum_field_alignment; - /* Should this be controlled by DECL_USER_ALIGN, too? */ - if (mfa != 0) - DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), mfa); - } - - /* Evaluate nonconstant size only once, either now or as soon as safe. */ - if (DECL_SIZE (decl) != 0 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST) - DECL_SIZE (decl) = variable_size (DECL_SIZE (decl)); - if (DECL_SIZE_UNIT (decl) != 0 - && TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST) - DECL_SIZE_UNIT (decl) = variable_size (DECL_SIZE_UNIT (decl)); - - /* If requested, warn about definitions of large data objects. */ - if (warn_larger_than - && (code == VAR_DECL || code == PARM_DECL) - && ! DECL_EXTERNAL (decl)) - { - tree size = DECL_SIZE_UNIT (decl); - - if (size != 0 && TREE_CODE (size) == INTEGER_CST - && compare_tree_int (size, larger_than_size) > 0) - { - int size_as_int = TREE_INT_CST_LOW (size); - - if (compare_tree_int (size, size_as_int) == 0) - warning (0, "size of %q+D is %d bytes", decl, size_as_int); - else - warning (0, "size of %q+D is larger than %wd bytes", - decl, larger_than_size); - } - } - - /* If the RTL was already set, update its mode and mem attributes. */ - if (rtl) - { - PUT_MODE (rtl, DECL_MODE (decl)); - SET_DECL_RTL (decl, 0); - set_mem_attributes (rtl, decl, 1); - 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; - if (!DECL_USER_ALIGN (decl)) - 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. */ - -static void (*lang_adjust_rli) (record_layout_info) = 0; - -void -set_lang_adjust_rli (void (*f) (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 -start_record_layout (tree t) -{ - record_layout_info rli = xmalloc (sizeof (struct record_layout_info_s)); - /* APPLE LOCAL begin 5946347 ms_struct support */ - unsigned biggest_alignment = targetm.ms_bitfield_layout_p (t) ? - BIGGEST_MS_STRUCT_ALIGNMENT - : BIGGEST_ALIGNMENT; - - 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->offset_align = MAX (rli->record_align, biggest_alignment); - /* APPLE LOCAL end 5946347 ms_struct support */ - -#ifdef STRUCTURE_SIZE_BOUNDARY -/* APPLE LOCAL begin ARM Macintosh alignment */ -#ifdef PEG_ALIGN_FOR_MAC68K - if (! OPTION_ALIGN_MAC68K) -#endif -/* APPLE LOCAL end ARM Macintosh alignment */ - /* Packed structures don't need to have minimum size. */ - if (! TYPE_PACKED (t)) - rli->record_align = MAX (rli->record_align, (unsigned) 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; - rli->remaining_in_alignment = 0; - - return rli; -} - -/* These four routines perform computations that convert between - the offset/bitpos forms and byte and bit offsets. */ - -tree -bit_from_pos (tree offset, tree bitpos) -{ - return size_binop (PLUS_EXPR, bitpos, - size_binop (MULT_EXPR, - fold_convert (bitsizetype, offset), - bitsize_unit_node)); -} - -tree -byte_from_pos (tree offset, tree bitpos) -{ - return size_binop (PLUS_EXPR, offset, - fold_convert (sizetype, - size_binop (TRUNC_DIV_EXPR, bitpos, - bitsize_unit_node))); -} - -void -pos_from_bit (tree *poffset, tree *pbitpos, unsigned int off_align, - tree pos) -{ - *poffset = size_binop (MULT_EXPR, - 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)); -} - -/* Given a pointer to bit and byte offsets and an offset alignment, - normalize the offsets so they are within the alignment. */ - -void -normalize_offset (tree *poffset, tree *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, - fold_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 (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, off = %u\n", - rli->record_align, rli->unpacked_align, - rli->offset_align); - - /* The ms_struct code is the only that uses this. */ - if (targetm.ms_bitfield_layout_p (rli->t)) - fprintf (stderr, "remaining in alignment = %u\n", rli->remaining_in_alignment); - - 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 (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 (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 (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 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; - /* The type of this field. */ - tree type = TREE_TYPE (field); - /* True if the field was explicitly aligned by the user. */ - bool user_align; - bool is_bitfield; - - /* Do not attempt to align an ERROR_MARK node */ - if (TREE_CODE (type) == ERROR_MARK) - return 0; - - /* Lay out the field so we know what alignment it needs. */ - layout_decl (field, known_align); - desired_align = DECL_ALIGN (field); - user_align = DECL_USER_ALIGN (field); - - is_bitfield = (type != error_mark_node - && DECL_BIT_FIELD_TYPE (field) - && ! integer_zerop (TYPE_SIZE (type))); - - /* APPLE LOCAL begin Macintosh alignment 2002-5-24 --ff */ -#ifdef ADJUST_FIELD_ALIGN - if (! user_align && TREE_CODE (rli->t) == RECORD_TYPE) - desired_align = - ADJUST_FIELD_ALIGN (field, desired_align); -#endif - /* APPLE LOCAL end Macintosh alignment 2002-5-24 --ff */ - - /* 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)) - { - /* Here, the alignment of the underlying type of a bitfield can - affect the alignment of a record; even a zero-sized field - can do this. The alignment should be to the alignment of - the type, except that for zero-size bitfields this only - applies if there was an immediately prior, nonzero-size - bitfield. (That's the way it is, experimentally.) */ - if ((!is_bitfield && !DECL_PACKED (field)) - || (!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))))) - { - /* APPLE LOCAL 5946347 ms_struct support */ - unsigned int type_align = TARGET_FIELD_MS_STRUCT_ALIGN (field); - type_align = MAX (type_align, desired_align); - if (maximum_field_alignment != 0) - 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)); - } - } -#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. 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); - -#ifdef ADJUST_FIELD_ALIGN - if (! TYPE_USER_ALIGN (type)) - type_align = ADJUST_FIELD_ALIGN (field, type_align); -#endif - - /* Targets might chose to handle unnamed and hence possibly - zero-width bitfield. Those are not influenced by #pragmas - or packed attributes. */ - if (integer_zerop (DECL_SIZE (field))) - { - if (initial_max_fld_align) - type_align = MIN (type_align, - initial_max_fld_align * BITS_PER_UNIT); - } - else if (maximum_field_alignment != 0) - type_align = MIN (type_align, maximum_field_alignment); - else if (DECL_PACKED (field)) - type_align = MIN (type_align, BITS_PER_UNIT); -/* APPLE LOCAL begin Macintosh alignment 2002-2-12 --ff */ -#ifdef PEG_ALIGN_FOR_MAC68K - else if (OPTION_ALIGN_MAC68K) - type_align = PEG_ALIGN_FOR_MAC68K (type_align); -#endif -/* APPLE LOCAL end Macintosh alignment 2002-2-12 --ff */ - - /* The alignment of the record is increased to the maximum - of the current alignment, the alignment indicated on the - field (i.e., the alignment specified by an __aligned__ - attribute), and the alignment indicated by the type of - the field. */ - rli->record_align = MAX (rli->record_align, desired_align); - rli->record_align = MAX (rli->record_align, type_align); - - if (warn_packed) - rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type)); - user_align |= TYPE_USER_ALIGN (type); - } - } -#endif - else - { - rli->record_align = MAX (rli->record_align, desired_align); - rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type)); - } - - TYPE_USER_ALIGN (rli->t) |= user_align; - - return desired_align; -} - -/* Called from place_field to handle unions. */ - -static void -place_union_field (record_layout_info rli, tree field) -{ - update_alignment_for_field (rli, field, /*known_align=*/0); - - DECL_FIELD_OFFSET (field) = size_zero_node; - DECL_FIELD_BIT_OFFSET (field) = bitsize_zero_node; - SET_DECL_OFFSET_ALIGN (field, BIGGEST_ALIGNMENT); - - /* If this is an ERROR_MARK return *after* having set the - field at the start of the union. This helps when parsing - invalid fields. */ - if (TREE_CODE (TREE_TYPE (field)) == ERROR_MARK) - return; - - /* 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) - rli->offset = size_binop (MAX_EXPR, rli->offset, DECL_SIZE_UNIT (field)); - else if (TREE_CODE (rli->t) == QUAL_UNION_TYPE) - rli->offset = fold_build3 (COND_EXPR, sizetype, - DECL_QUALIFIER (field), - DECL_SIZE_UNIT (field), rli->offset); -} - -#if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED) -/* A bitfield of SIZE with a required access alignment of ALIGN is allocated - 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 (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. */ - unsigned HOST_WIDE_INT offset = byte_offset * BITS_PER_UNIT + bit_offset; - - offset = offset % align; - return ((offset + size + align - 1) / align - > ((unsigned HOST_WIDE_INT) tree_low_cst (TYPE_SIZE (type), 1) - / align)); -} -#endif - -/* RLI contains information about the layout of a RECORD_TYPE. FIELD - is a FIELD_DECL to be added after those fields already present in - T. (FIELD is not actually added to the TYPE_FIELDS list here; - callers that desire that behavior must manually perform that step.) */ - -void -place_field (record_layout_info rli, tree field) -{ - /* The alignment required for FIELD. */ - unsigned int desired_align; - /* 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; - /* The type of this field. */ - tree type = TREE_TYPE (field); - - gcc_assert (TREE_CODE (field) != ERROR_MARK); - - /* 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 - method. In both cases, all we do is lay out the decl, and we do - it *after* the record is laid out. */ - if (TREE_CODE (field) == VAR_DECL) - { - rli->pending_statics = tree_cons (NULL_TREE, field, - 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; - - /* Unions are laid out very differently than records, so split - that code off to another function. */ - else if (TREE_CODE (rli->t) != RECORD_TYPE) - { - place_union_field (rli, field); - return; - } - - else if (TREE_CODE (type) == ERROR_MARK) - { - /* Place this field at the current allocation position, so we - maintain monotonicity. */ - DECL_FIELD_OFFSET (field) = rli->offset; - DECL_FIELD_BIT_OFFSET (field) = rli->bitpos; - SET_DECL_OFFSET_ALIGN (field, rli->offset_align); - return; - } - - /* Work out the known alignment so far. Note that A & (-A) is the - value of the least-significant bit in A that is one. */ - /* APPLE LOCAL begin reverse_bitfields */ - if (! integer_zerop (rli->bitpos)) - { - int realoffset = tree_low_cst (rli->bitpos, 1); - - if (targetm.reverse_bitfields_p (rli->t)) - realoffset += rli->remaining_in_alignment; - - known_align = realoffset & -realoffset; - } - /* APPLE LOCAL end reverse_bitfields */ - else if (integer_zerop (rli->offset)) - 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)) - { - if (known_align >= TYPE_ALIGN (type)) - { - if (TYPE_ALIGN (type) > desired_align) - { - if (STRICT_ALIGNMENT) - warning (OPT_Wattributes, "packed attribute causes " - "inefficient alignment for %q+D", field); - else - warning (OPT_Wattributes, "packed attribute is " - "unnecessary for %q+D", field); - } - } - else - rli->packed_maybe_necessary = 1; - } - - /* Does this field automatically have alignment it needs by virtue - of the fields that precede it and the record's own alignment? - We already align ms_struct fields, so don't re-align them. */ - if (known_align < desired_align - && !targetm.ms_bitfield_layout_p (rli->t)) - { - /* No, we need to skip space before this field. - Bump the cumulative size to multiple of field alignment. */ - - warning (OPT_Wpadded, "padding struct to align %q+D", field); - - /* 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 - { - /* First adjust OFFSET by the partial bits, then align. */ - rli->offset - = size_binop (PLUS_EXPR, rli->offset, - 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); - } - - 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 (field) - && ! DECL_PACKED (field) - && maximum_field_alignment == 0 -/* APPLE LOCAL begin Macintosh alignment 2002-2-12 --ff */ -#ifdef PEG_ALIGN_FOR_MAC68K - && ! OPTION_ALIGN_MAC68K -#endif -/* APPLE LOCAL end Macintosh alignment 2002-2-12 --ff */ - && ! 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); - 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); - -#ifdef ADJUST_FIELD_ALIGN - if (! TYPE_USER_ALIGN (type)) - type_align = ADJUST_FIELD_ALIGN (field, type_align); -#endif - - /* A bit field may not span more units of alignment of its type - than its type itself. Advance to next boundary if necessary. */ - if (excess_unit_span (offset, bit_offset, field_size, type_align, type)) - rli->bitpos = round_up (rli->bitpos, type_align); - - TYPE_USER_ALIGN (rli->t) |= TYPE_USER_ALIGN (type); - } -#endif - -#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)) - && host_integerp (DECL_SIZE (field), 1) - && host_integerp (rli->offset, 1) - && host_integerp (TYPE_SIZE (type), 1)) - { - unsigned int type_align = TYPE_ALIGN (type); - 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); - -#ifdef ADJUST_FIELD_ALIGN - if (! TYPE_USER_ALIGN (type)) - type_align = ADJUST_FIELD_ALIGN (field, type_align); -#endif - - if (maximum_field_alignment != 0) - type_align = MIN (type_align, maximum_field_alignment); - /* ??? This test is opposite the test in the containing if - statement, so this code is unreachable currently. */ - else if (DECL_PACKED (field)) - type_align = MIN (type_align, BITS_PER_UNIT); -/* APPLE LOCAL begin Macintosh alignment 2002-2-12 --ff */ -#ifdef PEG_ALIGN_FOR_MAC68K - else if (OPTION_ALIGN_MAC68K) - type_align = PEG_ALIGN_FOR_MAC68K (type_align); -#endif -/* APPLE LOCAL end Macintosh alignment 2002-2-12 --ff */ - - /* A bit field may not span the unit of alignment of its type. - Advance to next boundary if necessary. */ - if (excess_unit_span (offset, bit_offset, field_size, type_align, type)) - rli->bitpos = round_up (rli->bitpos, type_align); - - TYPE_USER_ALIGN (rli->t) |= TYPE_USER_ALIGN (type); - } -#endif - - /* See the docs for TARGET_MS_BITFIELD_LAYOUT_P for details. - A subtlety: - When a bit field is inserted into a packed record, the whole - size of the underlying type is used by one or more same-size - adjacent bitfields. (That is, if its long:3, 32 bits is - used in the record, and any additional adjacent long bitfields are - packed into the same chunk of 32 bits. However, if the size - changes, a new field of that size is allocated.) In an unpacked - record, this is the same as using alignment, but not equivalent - when packing. - - 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)) - { - tree prev_saved = rli->prev_field; - tree prev_type = prev_saved ? DECL_BIT_FIELD_TYPE (prev_saved) : NULL; - - /* This is a bitfield if it exists. */ - if (rli->prev_field) - { - /* If both are bitfields, nonzero, and the same size, this is - the middle of a run. Zero declared size fields are special - and handled as "end of run". (Note: it's nonzero declared - size, but equal type sizes!) (Since we know that both - the current and previous fields are bitfields by the - time we check it, DECL_SIZE must be present for both.) */ - if (DECL_BIT_FIELD_TYPE (field) - && !integer_zerop (DECL_SIZE (field)) - && !integer_zerop (DECL_SIZE (rli->prev_field)) - && host_integerp (DECL_SIZE (rli->prev_field), 0) - && host_integerp (TYPE_SIZE (type), 0) - && simple_cst_equal (TYPE_SIZE (type), TYPE_SIZE (prev_type))) - { - /* We're in the middle of a run of equal type size fields; make - sure we realign if we run out of bits. (Not decl size, - type size!) */ - HOST_WIDE_INT bitsize = tree_low_cst (DECL_SIZE (field), 1); - - if (rli->remaining_in_alignment < bitsize) - { - HOST_WIDE_INT typesize = tree_low_cst (TYPE_SIZE (type), 1); - - /* APPLE LOCAL begin reverse_bitfields */ - if (!targetm.reverse_bitfields_p (rli->t)) - { - /* APPLE LOCAL end reverse_bitfields */ - /* out of bits; bump up to next 'word'. */ - rli->bitpos - = size_binop (PLUS_EXPR, rli->bitpos, - bitsize_int (rli->remaining_in_alignment)); - rli->prev_field = field; - if (typesize < bitsize) - rli->remaining_in_alignment = 0; - else - rli->remaining_in_alignment = typesize - bitsize; - /* APPLE LOCAL begin reverse_bitfields */ - } - else - { - /* "Use up" the remaining bits. */ - rli->bitpos - = size_binop (PLUS_EXPR, - rli->bitpos, - size_binop - (MINUS_EXPR, - TYPE_SIZE (type), - bitsize_int (rli->remaining_in_alignment))); - rli->prev_field = field; - if (typesize < bitsize) - rli->remaining_in_alignment = 0; - else - rli->remaining_in_alignment = typesize - bitsize; - - /* Move to the top end of the range. We'll add the bitfield - below. */ - rli->bitpos - = size_binop (PLUS_EXPR, - rli->bitpos, - TYPE_SIZE (type)); - } - } - else - rli->remaining_in_alignment -= bitsize; - - /* We handle this here instead of later at the end of - field placement. */ - if (targetm.reverse_bitfields_p (rli->t)) - { - /* If we normalized within rli->remaining_in_alignment we'll - possibly need to add some bits. */ - while ((tree_low_cst (rli->bitpos, 0) - bitsize) < 0) - { - rli->offset - = size_binop (MINUS_EXPR, - rli->offset, - fold_convert (sizetype, bitsize_one_node)); - rli->bitpos - = size_binop (PLUS_EXPR, - rli->bitpos, - bitsize_int (BITS_PER_UNIT)); - } - - rli->bitpos = size_binop (MINUS_EXPR, - rli->bitpos, - bitsize_int (bitsize)); - - /* Ensure we don't go negative. */ - gcc_assert (tree_low_cst (rli->bitpos, 0) >= 0); - } - /* APPLE LOCAL end reverse_bitfields */ - } - else - { - /* End of a run: if leaving a run of bitfields of the same type - size, we have to "use up" the rest of the bits of the type - size. - - Compute the new position as the sum of the size for the prior - type and where we first started working on that type. - Note: since the beginning of the field was aligned then - of course the end will be too. No round needed. */ - /* APPLE LOCAL begin reverse_bitfields */ - if (!targetm.reverse_bitfields_p (rli->t)) - { - - if (!integer_zerop (DECL_SIZE (rli->prev_field))) - { - rli->bitpos - = size_binop (PLUS_EXPR, rli->bitpos, - bitsize_int (rli->remaining_in_alignment)); - } - else - /* We "use up" size zero fields; the code below should behave - as if the prior field was not a bitfield. */ - prev_saved = NULL; - } - else - { - /* Difference from above - even if we don't have anything - left in the alignment we should move up to the top of - the word. */ - if (!integer_zerop (DECL_SIZE (rli->prev_field))) - { - rli->bitpos - = size_binop - (PLUS_EXPR, rli->bitpos, - size_binop (MINUS_EXPR, - TYPE_SIZE (TREE_TYPE (rli->prev_field)), - bitsize_int (rli->remaining_in_alignment))); - - /* We'll reset this when we have bits to add. */ - rli->remaining_in_alignment = 0; - } - else - prev_saved = NULL; - } - /* APPLE LOCAL end reverse_bitfields */ - /* Cause a new bitfield to be captured, either this time (if - currently a bitfield) or next time we see one. */ - if (!DECL_BIT_FIELD_TYPE(field) - || integer_zerop (DECL_SIZE (field))) - rli->prev_field = NULL; - } - - normalize_rli (rli); - } - - /* If we're starting a new run of same size type bitfields - (or a run of non-bitfields), set up the "first of the run" - fields. - - That is, if the current field is not a bitfield, or if there - was a prior bitfield the type sizes differ, or if there wasn't - a prior bitfield the size of the current field is nonzero. - - Note: we must be sure to test ONLY the type size if there was - a prior bitfield and ONLY for the current field being zero if - there wasn't. */ - - if (!DECL_BIT_FIELD_TYPE (field) - || (prev_saved != NULL - ? !simple_cst_equal (TYPE_SIZE (type), TYPE_SIZE (prev_type)) - : !integer_zerop (DECL_SIZE (field)) )) - { - /* Never smaller than a byte for compatibility. */ - unsigned int type_align = BITS_PER_UNIT; - - /* (When not a bitfield), we could be seeing a flex array (with - no DECL_SIZE). Since we won't be using remaining_in_alignment - until we see a bitfield (and come by here again) we just skip - calculating it. */ - if (DECL_SIZE (field) != NULL - && host_integerp (TYPE_SIZE (TREE_TYPE (field)), 0) - && host_integerp (DECL_SIZE (field), 0)) - { - HOST_WIDE_INT bitsize = tree_low_cst (DECL_SIZE (field), 1); - HOST_WIDE_INT typesize - = tree_low_cst (TYPE_SIZE (TREE_TYPE (field)), 1); - - if (typesize < bitsize) - rli->remaining_in_alignment = 0; - else - rli->remaining_in_alignment = typesize - bitsize; - } - - /* Now align (conventionally) for the new type. */ - /* APPLE LOCAL 5946347 ms_struct support */ - type_align = TARGET_FIELD_MS_STRUCT_ALIGN (field); - - if (maximum_field_alignment != 0) - type_align = MIN (type_align, maximum_field_alignment); - - rli->bitpos = round_up (rli->bitpos, type_align); - - /* APPLE LOCAL begin reverse_bitfields */ - /* If we're reversing add this to the field starting at the - "right" end of the alignment. */ - if (targetm.reverse_bitfields_p (rli->t) - && DECL_BIT_FIELD_TYPE (field) - && !integer_zerop (DECL_SIZE (field))) - { - rli->bitpos = size_binop (MINUS_EXPR, - size_binop (PLUS_EXPR, - rli->bitpos, - TYPE_SIZE (type)), - DECL_SIZE (field)); - } - /* APPLE LOCAL end reverse_bitfields */ - - /* If we really aligned, don't allow subsequent bitfields - to undo that. */ - rli->prev_field = NULL; - } - } - - /* 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); - - /* 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 = 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); - - if (rli->prev_field == NULL && DECL_BIT_FIELD_TYPE (field)) - rli->prev_field = field; - - /* 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 (DECL_SIZE (field)) != INTEGER_CST - || TREE_CONSTANT_OVERFLOW (DECL_SIZE (field))) - { - rli->offset - = size_binop (PLUS_EXPR, rli->offset, - 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, desired_align); - } - else if (targetm.ms_bitfield_layout_p (rli->t)) - { - /* APPLE LOCAL begin reverse_bitfields */ - if (!targetm.reverse_bitfields_p (rli->t)) - { - /* APPLE LOCAL end reverse_bitfields */ - rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, DECL_SIZE (field)); - - /* If we ended a bitfield before the full length of the type then - pad the struct out to the full length of the last type. */ - if ((TREE_CHAIN (field) == NULL - || TREE_CODE (TREE_CHAIN (field)) != FIELD_DECL) - && DECL_BIT_FIELD_TYPE (field) - && !integer_zerop (DECL_SIZE (field))) - rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, - bitsize_int (rli->remaining_in_alignment)); - /* APPLE LOCAL begin reverse_bitfields */ - } - else - { - unsigned int extension = 0; - - if (integer_zerop (DECL_SIZE (field)) - && rli->remaining_in_alignment - && rli->prev_field - && DECL_BIT_FIELD_TYPE (rli->prev_field) - && !integer_zerop (DECL_SIZE (rli->prev_field))) - extension = - tree_low_cst (TYPE_SIZE (TREE_TYPE (rli->prev_field)), 1) - - rli->remaining_in_alignment; - else if (!integer_zerop (DECL_SIZE (field))) - extension = - tree_low_cst (TYPE_SIZE (TREE_TYPE (field)), 1) - - rli->remaining_in_alignment; - - /* For bitfields we handled the adding of the type earlier. */ - if (!DECL_BIT_FIELD_TYPE (field)) - rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, DECL_SIZE (field)); - - /* For reverse bitfields we need to go back to the end of the type. */ - if (extension - && (TREE_CHAIN (field) == NULL - || TREE_CODE (TREE_CHAIN (field)) != FIELD_DECL) - && DECL_BIT_FIELD_TYPE (field)) - rli->bitpos = size_binop (PLUS_EXPR, - rli->bitpos, - bitsize_int (extension)); - } - /* APPLE LOCAL end reverse_bitfields */ - - normalize_rli (rli); - } - else - { - rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, DECL_SIZE (field)); - normalize_rli (rli); - } -} - -/* Assuming that all the fields have been laid out, this function uses - RLI to compute the final TYPE_SIZE, TYPE_ALIGN, etc. for the type - indicated by RLI. */ - -static void -finalize_record_size (record_layout_info rli) -{ - 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) = 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 - - /* 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); - - /* 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_UNIT (rli->t)); - - if (TREE_CONSTANT (unpadded_size) - && simple_cst_equal (unpadded_size, TYPE_SIZE (rli->t)) == 0) - warning (OPT_Wpadded, "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; - -#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 - - unpacked_size = round_up (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)) - { - 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 (OPT_Wpacked, "packed attribute causes inefficient " - "alignment for %qs", name); - else - warning (OPT_Wpacked, - "packed attribute is unnecessary for %qs", name); - } - else - { - if (STRICT_ALIGNMENT) - warning (OPT_Wpacked, - "packed attribute causes inefficient alignment"); - else - warning (OPT_Wpacked, "packed attribute is unnecessary"); - } - } - } -} - -/* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE). */ - -void -compute_record_mode (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 (! 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)) - { - 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_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; - - /* 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. */ - - if (MEMBER_TYPE_FORCES_BLK (field, mode)) - return; -#endif /* MEMBER_TYPE_FORCES_BLK */ - } - - /* APPLE LOCAL begin 8-byte-struct hack */ - /* 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 - && host_integerp (TYPE_SIZE (type), 1) - && GET_MODE_SIZE (mode) == GET_MODE_SIZE (mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1))) - TYPE_MODE (type) = mode; -/* APPLE LOCAL radar 4859753 */ -#if defined RS6000_8BYTE_STRUCT_HACK - /* Make 8-byte structs BLKmode instead of DImode, which fixes both - struct-return methods and attempts to use floats in kernel code. - This should probably become a generic macro similar to - MEMBER_TYPE_FORCES_BLK above. */ - else if (mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1) == DImode) - ; -#endif - else - TYPE_MODE (type) = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1); - /* APPLE LOCAL end 8-byte-struct hack */ - - /* 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; - } -} - -/* Compute TYPE_SIZE and TYPE_ALIGN for TYPE, once it has been laid - out. */ - -static void -finalize_type_size (tree type) -{ - /* Normally, use the alignment corresponding to the mode chosen. - However, where strict alignment is not required, avoid - over-aligning structures, since most compilers do not do this - alignment. */ - - if (TYPE_MODE (type) != BLKmode && TYPE_MODE (type) != VOIDmode - && (STRICT_ALIGNMENT - || (TREE_CODE (type) != RECORD_TYPE && TREE_CODE (type) != UNION_TYPE - && TREE_CODE (type) != QUAL_UNION_TYPE - && TREE_CODE (type) != ARRAY_TYPE))) - { - unsigned mode_align = GET_MODE_ALIGNMENT (TYPE_MODE (type)); - - /* Don't override a larger alignment requirement coming from a user - alignment of one of the fields. */ - if (mode_align >= TYPE_ALIGN (type)) - { - TYPE_ALIGN (type) = mode_align; - TYPE_USER_ALIGN (type) = 0; - } - } - - /* Do machine-dependent extra alignment. */ -#ifdef ROUND_TYPE_ALIGN - TYPE_ALIGN (type) - = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (type), BITS_PER_UNIT); -#endif - - /* If we failed to find a simple way to calculate the unit size - 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 - sizetype, so we force a conversion. */ - TYPE_SIZE_UNIT (type) - = fold_convert (sizetype, - size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (type), - bitsize_unit_node)); - - if (TYPE_SIZE (type) != 0) - { - TYPE_SIZE (type) = round_up (TYPE_SIZE (type), TYPE_ALIGN (type)); - 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. */ - 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)); - - /* Also layout any other variants of the type. */ - if (TYPE_NEXT_VARIANT (type) - || type != TYPE_MAIN_VARIANT (type)) - { - tree variant; - /* Record layout info of this variant. */ - 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. */ - for (variant = TYPE_MAIN_VARIANT (type); - variant != 0; - variant = TYPE_NEXT_VARIANT (variant)) - { - TYPE_SIZE (variant) = size; - TYPE_SIZE_UNIT (variant) = size_unit; - TYPE_ALIGN (variant) = align; - TYPE_USER_ALIGN (variant) = user_align; - TYPE_MODE (variant) = mode; - } - } -} - -/* Do all of the work required to layout the type indicated by RLI, - once the fields have been laid out. This function will call `free' - for RLI, unless FREE_P is false. Passing a value other than false - for FREE_P is bad practice; this option only exists to support the - G++ 3.2 ABI. */ - -void -finish_record_layout (record_layout_info rli, int free_p) -{ - tree variant; - - /* 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); - - /* Propagate TYPE_PACKED to variants. With C++ templates, - handle_packed_attribute is too early to do this. */ - for (variant = TYPE_NEXT_VARIANT (rli->t); variant; - variant = TYPE_NEXT_VARIANT (variant)) - TYPE_PACKED (variant) = TYPE_PACKED (rli->t); - - /* Lay out any static members. This is done now because their type - may use the record's type. */ - while (rli->pending_statics) - { - layout_decl (TREE_VALUE (rli->pending_statics), 0); - rli->pending_statics = TREE_CHAIN (rli->pending_statics); - } - - /* Clean up. */ - if (free_p) - free (rli); -} - - -/* Finish processing a builtin RECORD_TYPE type TYPE. It's name is - NAME, its fields are chained in reverse on FIELDS. - - If ALIGN_TYPE is non-null, it is given the same alignment as - ALIGN_TYPE. */ - -void -finish_builtin_struct (tree type, const char *name, tree fields, - tree align_type) -{ - tree tail, next; - - for (tail = NULL_TREE; fields; tail = fields, fields = next) - { - DECL_FIELD_CONTEXT (fields) = type; - next = TREE_CHAIN (fields); - TREE_CHAIN (fields) = tail; - } - TYPE_FIELDS (type) = tail; - - if (align_type) - { - TYPE_ALIGN (type) = TYPE_ALIGN (align_type); - TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (align_type); - } - - layout_type (type); -#if 0 /* not yet, should get fixed properly later */ - TYPE_NAME (type) = make_type_decl (get_identifier (name), type); -#else - TYPE_NAME (type) = build_decl (TYPE_DECL, get_identifier (name), type); -#endif - TYPE_STUB_DECL (type) = TYPE_NAME (type); - layout_decl (TYPE_NAME (type), 0); -} - -/* Calculate the mode, size, and alignment for TYPE. - For an array type, calculate the element separation as well. - Record TYPE on the chain of permanent or temporary types - so that dbxout will find out about it. - - TYPE_SIZE of a type is nonzero if the type has been laid out already. - layout_type does nothing on such a type. - - If the type is incomplete, its TYPE_SIZE remains zero. */ - -void -layout_type (tree type) -{ - gcc_assert (type); - - if (type == error_mark_node) - return; - - /* Do nothing if type has been laid out before. */ - if (TYPE_SIZE (type)) - return; - - switch (TREE_CODE (type)) - { - case LANG_TYPE: - /* This kind of type is the responsibility - of the language-specific code. */ - gcc_unreachable (); - - case BOOLEAN_TYPE: /* Used for Java, Pascal, and Chill. */ - if (TYPE_PRECISION (type) == 0) - TYPE_PRECISION (type) = 1; /* default to one byte/boolean. */ - - /* ... fall through ... */ - - case INTEGER_TYPE: - case ENUMERAL_TYPE: - if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST - && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0) - TYPE_UNSIGNED (type) = 1; - - TYPE_MODE (type) = smallest_mode_for_size (TYPE_PRECISION (type), - MODE_INT); - 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 REAL_TYPE: - TYPE_MODE (type) = mode_for_size (TYPE_PRECISION (type), MODE_FLOAT, 0); - 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 COMPLEX_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)) == 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))); - break; - - case VECTOR_TYPE: - { - 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))); - - /* 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 (SCALAR_FLOAT_MODE_P (innermode)) - 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; - } - - case VOID_TYPE: - /* 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); - /* 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 METHOD_TYPE: - /* 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: - case REFERENCE_TYPE: - /* APPLE LOCAL blocks */ - case BLOCK_POINTER_TYPE: - { - - enum machine_mode mode = ((TREE_CODE (type) == REFERENCE_TYPE - && reference_types_internal) - ? Pmode : TYPE_MODE (type)); - - int nbits = GET_MODE_BITSIZE (mode); - - TYPE_SIZE (type) = bitsize_int (nbits); - TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (mode)); - TYPE_UNSIGNED (type) = 1; - TYPE_PRECISION (type) = nbits; - } - break; - - case ARRAY_TYPE: - { - tree index = TYPE_DOMAIN (type); - tree element = TREE_TYPE (type); - - build_pointer_type (element); - - /* We need to know both bounds in order to compute the size. */ - if (index && TYPE_MAX_VALUE (index) && TYPE_MIN_VALUE (index) - && TYPE_SIZE (element)) - { - tree ub = TYPE_MAX_VALUE (index); - tree lb = TYPE_MIN_VALUE (index); - tree length; - tree element_size; - - /* 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, - 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); - 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_low_cst (TYPE_MAX_VALUE (element), 1); - HOST_WIDE_INT minvalue - = tree_low_cst (TYPE_MIN_VALUE (element), 1); - - if (maxvalue - minvalue == 1 - && (maxvalue == 1 || maxvalue == 0)) - element_size = integer_one_node; - } - - /* 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 (!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, - fold_convert (bitsizetype, - length)); - - /* If we know the size of the element, calculate the total - size directly, rather than do some division thing below. - This optimization helps Fortran assumed-size arrays - (where the size of the array is determined at runtime) - substantially. - Note that we can't do this in the case where the size of - the elements is one bit since TYPE_SIZE_UNIT cannot be - set correctly in that case. */ - if (TYPE_SIZE_UNIT (element) != 0 && ! integer_onep (element_size)) - TYPE_SIZE_UNIT (type) - = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (element), length); - } - - /* Now round the alignment and size, - using machine-dependent criteria if any. */ - -#ifdef ROUND_TYPE_ALIGN - TYPE_ALIGN (type) - = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (element), BITS_PER_UNIT); -#else - TYPE_ALIGN (type) = MAX (TYPE_ALIGN (element), BITS_PER_UNIT); -#endif - TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (element); - TYPE_MODE (type) = BLKmode; - if (TYPE_SIZE (type) != 0 -#ifdef MEMBER_TYPE_FORCES_BLK - && ! MEMBER_TYPE_FORCES_BLK (type, VOIDmode) -#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)))) - { - /* 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 - && TYPE_ALIGN (type) < GET_MODE_ALIGNMENT (TYPE_MODE (type)) - && TYPE_MODE (type) != BLKmode) - { - TYPE_NO_FORCE_BLK (type) = 1; - TYPE_MODE (type) = BLKmode; - } - } - /* When the element size is constant, check that it is at least as - large as the element alignment. */ - if (TYPE_SIZE_UNIT (element) - && TREE_CODE (TYPE_SIZE_UNIT (element)) == INTEGER_CST - /* If TYPE_SIZE_UNIT overflowed, then it is certainly larger than - TYPE_ALIGN_UNIT. */ - && !TREE_CONSTANT_OVERFLOW (TYPE_SIZE_UNIT (element)) - && !integer_zerop (TYPE_SIZE_UNIT (element)) - && compare_tree_int (TYPE_SIZE_UNIT (element), - TYPE_ALIGN_UNIT (element)) < 0) - error ("alignment of array elements is greater than element size"); - break; - } - - case RECORD_TYPE: - case UNION_TYPE: - case QUAL_UNION_TYPE: - { - tree field; - record_layout_info rli; - - /* Initialize the layout information. */ - 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)); - - /* Place all the fields. */ - for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (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, /*free_p=*/true); - } - break; - - default: - gcc_unreachable (); - } - - /* 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 - && TREE_CODE (type) != UNION_TYPE - && TREE_CODE (type) != QUAL_UNION_TYPE) - finalize_type_size (type); - - /* 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; -} - -/* Create and return a type for signed integers of PRECISION bits. */ - -tree -make_signed_type (int precision) -{ - tree type = make_node (INTEGER_TYPE); - - TYPE_PRECISION (type) = precision; - - fixup_signed_type (type); - return type; -} - -/* Create and return a type for unsigned integers of PRECISION bits. */ - -tree -make_unsigned_type (int precision) -{ - tree type = make_node (INTEGER_TYPE); - - TYPE_PRECISION (type) = precision; - - fixup_unsigned_type (type); - return type; -} - -/* Initialize sizetype and bitsizetype to a reasonable and temporary - value to enable integer types to be created. */ - -void -initialize_sizetypes (bool signed_p) -{ - tree t = make_node (INTEGER_TYPE); - int precision = GET_MODE_BITSIZE (SImode); - - TYPE_MODE (t) = SImode; - TYPE_ALIGN (t) = GET_MODE_ALIGNMENT (SImode); - TYPE_USER_ALIGN (t) = 0; - TYPE_IS_SIZETYPE (t) = 1; - TYPE_UNSIGNED (t) = !signed_p; - TYPE_SIZE (t) = build_int_cst (t, precision); - TYPE_SIZE_UNIT (t) = build_int_cst (t, GET_MODE_SIZE (SImode)); - TYPE_PRECISION (t) = precision; - - /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE. */ - set_min_and_max_values_for_integral_type (t, precision, !signed_p); - - sizetype = t; - bitsizetype = build_distinct_type_copy (t); -} - -/* 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 (tree type) -{ - int oprecision = TYPE_PRECISION (type); - /* The *bitsizetype types use a precision that avoids overflows when - calculating signed sizes / offsets in bits. However, when - cross-compiling from a 32 bit to a 64 bit host, we are limited to 64 bit - precision. */ - int precision = MIN (MIN (oprecision + BITS_PER_UNIT_LOG + 1, - MAX_FIXED_MODE_SIZE), - 2 * HOST_BITS_PER_WIDE_INT); - tree t; - - gcc_assert (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (sizetype)); - - 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)); - TYPE_MAIN_VARIANT (bitsizetype) = bitsizetype; - - if (TYPE_UNSIGNED (type)) - { - 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; - } - - /* If SIZETYPE is unsigned, we need to fix TYPE_MAX_VALUE so that - it is sign extended in a way consistent with force_fit_type. */ - if (TYPE_UNSIGNED (type)) - { - tree orig_max, new_max; - - orig_max = TYPE_MAX_VALUE (sizetype); - - /* Build a new node with the same values, but a different type. */ - new_max = build_int_cst_wide (sizetype, - TREE_INT_CST_LOW (orig_max), - TREE_INT_CST_HIGH (orig_max)); - - /* Now sign extend it using force_fit_type to ensure - consistency. */ - new_max = force_fit_type (new_max, 0, 0, 0); - TYPE_MAX_VALUE (sizetype) = new_max; - } -} - -/* TYPE is an integral type, i.e., an INTEGRAL_TYPE, ENUMERAL_TYPE - or BOOLEAN_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. */ - -void -set_min_and_max_values_for_integral_type (tree type, - int precision, - bool is_unsigned) -{ - tree min_value; - tree max_value; - - if (is_unsigned) - { - 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); - } - else - { - 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)); - } - - 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 (tree 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; - - 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); -} - -/* Set the extreme values of TYPE based on its precision in bits, - then lay it out. This is used both in `make_unsigned_type' - and for enumeral types. */ - -void -fixup_unsigned_type (tree 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_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); -} - -/* Find the best machine mode to use when referencing a bit field of length - BITSIZE bits starting at BITPOS. - - The underlying object is known to be aligned to a boundary of ALIGN bits. - If LARGEST_MODE is not VOIDmode, it means that we should not use a mode - larger than LARGEST_MODE (usually SImode). - - If no mode meets all these conditions, we return VOIDmode. - - If VOLATILEP is false and SLOW_BYTE_ACCESS is false, we return the - smallest mode meeting these conditions. - - If VOLATILEP is false and SLOW_BYTE_ACCESS is true, we return the - largest mode (but a mode no wider than UNITS_PER_WORD) that meets - all the conditions. - - If VOLATILEP is true the narrow_volatile_bitfields target hook is used to - decide which of the above modes should be used. */ - -enum machine_mode -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; - - /* Find the narrowest integer mode that contains the bit field. */ - for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode; - mode = GET_MODE_WIDER_MODE (mode)) - { - unit = GET_MODE_BITSIZE (mode); - if ((bitpos % unit) + bitsize <= unit) - break; - } - - if (mode == VOIDmode - /* It is tempting to omit the following line - if STRICT_ALIGNMENT is true. - But that is incorrect, since if the bitfield uses part of 3 bytes - and we use a 4-byte mode, we could get a spurious segv - 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) > align - || (largest_mode != VOIDmode && unit > GET_MODE_BITSIZE (largest_mode))) - return VOIDmode; - - if ((SLOW_BYTE_ACCESS && ! volatilep) - || (volatilep && !targetm.narrow_volatile_bitfield())) - { - enum machine_mode wide_mode = VOIDmode, tmode; - - for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT); tmode != VOIDmode; - tmode = GET_MODE_WIDER_MODE (tmode)) - { - unit = GET_MODE_BITSIZE (tmode); - if (bitpos / unit == (bitpos + bitsize - 1) / unit - && unit <= BITS_PER_WORD - && unit <= MIN (align, BIGGEST_ALIGNMENT) - && (largest_mode == VOIDmode - || unit <= GET_MODE_BITSIZE (largest_mode))) - wide_mode = tmode; - } - - if (wide_mode != VOIDmode) - return wide_mode; - } - - 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" |