1 /* C-compiler utilities for types and variables storage layout
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1996, 1998,
3 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
34 #include "langhooks.h"
36 /* Set to one when set_sizetype has been called. */
37 static int sizetype_set;
39 /* List of types created before set_sizetype has been called. We do not
40 make this a GGC root since we want these nodes to be reclaimed. */
41 static tree early_type_list;
43 /* Data type for the expressions representing sizes of data types.
44 It is the first integer type laid out. */
45 tree sizetype_tab[(int) TYPE_KIND_LAST];
47 /* If nonzero, this is an upper limit on alignment of structure fields.
48 The value is measured in bits. */
49 unsigned int maximum_field_alignment;
51 /* If nonzero, the alignment of a bitstring or (power-)set value, in bits.
52 May be overridden by front-ends. */
53 unsigned int set_alignment = 0;
55 /* Nonzero if all REFERENCE_TYPEs are internal and hence should be
56 allocated in Pmode, not ptr_mode. Set only by internal_reference_types
57 called only by a front end. */
58 static int reference_types_internal = 0;
60 static void finalize_record_size PARAMS ((record_layout_info));
61 static void finalize_type_size PARAMS ((tree));
62 static void place_union_field PARAMS ((record_layout_info, tree));
63 static unsigned int update_alignment_for_field
64 PARAMS ((record_layout_info, tree,
66 extern void debug_rli PARAMS ((record_layout_info));
68 /* SAVE_EXPRs for sizes of types and decls, waiting to be expanded. */
70 static GTY(()) tree pending_sizes;
72 /* Nonzero means cannot safely call expand_expr now,
73 so put variable sizes onto `pending_sizes' instead. */
75 int immediate_size_expand;
77 /* Show that REFERENCE_TYPES are internal and should be Pmode. Called only
81 internal_reference_types ()
83 reference_types_internal = 1;
86 /* Get a list of all the objects put on the pending sizes list. */
91 tree chain = pending_sizes;
94 /* Put each SAVE_EXPR into the current function. */
95 for (t = chain; t; t = TREE_CHAIN (t))
96 SAVE_EXPR_CONTEXT (TREE_VALUE (t)) = current_function_decl;
102 /* Return nonzero if EXPR is present on the pending sizes list. */
105 is_pending_size (expr)
110 for (t = pending_sizes; t; t = TREE_CHAIN (t))
111 if (TREE_VALUE (t) == expr)
116 /* Add EXPR to the pending sizes list. */
119 put_pending_size (expr)
122 /* Strip any simple arithmetic from EXPR to see if it has an underlying
124 while (TREE_CODE_CLASS (TREE_CODE (expr)) == '1'
125 || (TREE_CODE_CLASS (TREE_CODE (expr)) == '2'
126 && TREE_CONSTANT (TREE_OPERAND (expr, 1))))
127 expr = TREE_OPERAND (expr, 0);
129 if (TREE_CODE (expr) == SAVE_EXPR)
130 pending_sizes = tree_cons (NULL_TREE, expr, pending_sizes);
133 /* Put a chain of objects into the pending sizes list, which must be
137 put_pending_sizes (chain)
143 pending_sizes = chain;
146 /* Given a size SIZE that may not be a constant, return a SAVE_EXPR
147 to serve as the actual size-expression for a type or decl. */
153 /* If the language-processor is to take responsibility for variable-sized
154 items (e.g., languages which have elaboration procedures like Ada),
155 just return SIZE unchanged. Likewise for self-referential sizes and
157 if (TREE_CONSTANT (size)
158 || (*lang_hooks.decls.global_bindings_p) () < 0
159 || contains_placeholder_p (size))
162 size = save_expr (size);
164 /* If an array with a variable number of elements is declared, and
165 the elements require destruction, we will emit a cleanup for the
166 array. That cleanup is run both on normal exit from the block
167 and in the exception-handler for the block. Normally, when code
168 is used in both ordinary code and in an exception handler it is
169 `unsaved', i.e., all SAVE_EXPRs are recalculated. However, we do
170 not wish to do that here; the array-size is the same in both
172 if (TREE_CODE (size) == SAVE_EXPR)
173 SAVE_EXPR_PERSISTENT_P (size) = 1;
175 if ((*lang_hooks.decls.global_bindings_p) ())
177 if (TREE_CONSTANT (size))
178 error ("type size can't be explicitly evaluated");
180 error ("variable-size type declared outside of any function");
182 return size_one_node;
185 if (immediate_size_expand)
186 /* NULL_RTX is not defined; neither is the rtx type.
187 Also, we would like to pass const0_rtx here, but don't have it. */
188 expand_expr (size, expand_expr (integer_zero_node, NULL_RTX, VOIDmode, 0),
190 else if (cfun != 0 && cfun->x_dont_save_pending_sizes_p)
191 /* The front-end doesn't want us to keep a list of the expressions
192 that determine sizes for variable size objects. */
195 put_pending_size (size);
200 #ifndef MAX_FIXED_MODE_SIZE
201 #define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (DImode)
204 /* Return the machine mode to use for a nonscalar of SIZE bits.
205 The mode must be in class CLASS, and have exactly that many bits.
206 If LIMIT is nonzero, modes of wider than MAX_FIXED_MODE_SIZE will not
210 mode_for_size (size, class, limit)
212 enum mode_class class;
215 enum machine_mode mode;
217 if (limit && size > MAX_FIXED_MODE_SIZE)
220 /* Get the first mode which has this size, in the specified class. */
221 for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode;
222 mode = GET_MODE_WIDER_MODE (mode))
223 if (GET_MODE_BITSIZE (mode) == size)
229 /* Similar, except passed a tree node. */
232 mode_for_size_tree (size, class, limit)
234 enum mode_class class;
237 if (TREE_CODE (size) != INTEGER_CST
238 /* What we really want to say here is that the size can fit in a
239 host integer, but we know there's no way we'd find a mode for
240 this many bits, so there's no point in doing the precise test. */
241 || compare_tree_int (size, 1000) > 0)
244 return mode_for_size (TREE_INT_CST_LOW (size), class, limit);
247 /* Similar, but never return BLKmode; return the narrowest mode that
248 contains at least the requested number of bits. */
251 smallest_mode_for_size (size, class)
253 enum mode_class class;
255 enum machine_mode mode;
257 /* Get the first mode which has at least this size, in the
259 for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode;
260 mode = GET_MODE_WIDER_MODE (mode))
261 if (GET_MODE_BITSIZE (mode) >= size)
267 /* Find an integer mode of the exact same size, or BLKmode on failure. */
270 int_mode_for_mode (mode)
271 enum machine_mode mode;
273 switch (GET_MODE_CLASS (mode))
276 case MODE_PARTIAL_INT:
279 case MODE_COMPLEX_INT:
280 case MODE_COMPLEX_FLOAT:
282 case MODE_VECTOR_INT:
283 case MODE_VECTOR_FLOAT:
284 mode = mode_for_size (GET_MODE_BITSIZE (mode), MODE_INT, 0);
291 /* ... fall through ... */
301 /* Return the value of VALUE, rounded up to a multiple of DIVISOR.
302 This can only be applied to objects of a sizetype. */
305 round_up (value, divisor)
309 tree arg = size_int_type (divisor, TREE_TYPE (value));
311 return size_binop (MULT_EXPR, size_binop (CEIL_DIV_EXPR, value, arg), arg);
314 /* Likewise, but round down. */
317 round_down (value, divisor)
321 tree arg = size_int_type (divisor, TREE_TYPE (value));
323 return size_binop (MULT_EXPR, size_binop (FLOOR_DIV_EXPR, value, arg), arg);
326 /* Set the size, mode and alignment of a ..._DECL node.
327 TYPE_DECL does need this for C++.
328 Note that LABEL_DECL and CONST_DECL nodes do not need this,
329 and FUNCTION_DECL nodes have them set up in a special (and simple) way.
330 Don't call layout_decl for them.
332 KNOWN_ALIGN is the amount of alignment we can assume this
333 decl has with no special effort. It is relevant only for FIELD_DECLs
334 and depends on the previous fields.
335 All that matters about KNOWN_ALIGN is which powers of 2 divide it.
336 If KNOWN_ALIGN is 0, it means, "as much alignment as you like":
337 the record will be aligned to suit. */
340 layout_decl (decl, known_align)
342 unsigned int known_align;
344 tree type = TREE_TYPE (decl);
345 enum tree_code code = TREE_CODE (decl);
347 if (code == CONST_DECL)
349 else if (code != VAR_DECL && code != PARM_DECL && code != RESULT_DECL
350 && code != TYPE_DECL && code != FIELD_DECL)
353 if (type == error_mark_node)
354 type = void_type_node;
356 /* Usually the size and mode come from the data type without change,
357 however, the front-end may set the explicit width of the field, so its
358 size may not be the same as the size of its type. This happens with
359 bitfields, of course (an `int' bitfield may be only 2 bits, say), but it
360 also happens with other fields. For example, the C++ front-end creates
361 zero-sized fields corresponding to empty base classes, and depends on
362 layout_type setting DECL_FIELD_BITPOS correctly for the field. Set the
363 size in bytes from the size in bits. If we have already set the mode,
364 don't set it again since we can be called twice for FIELD_DECLs. */
366 TREE_UNSIGNED (decl) = TREE_UNSIGNED (type);
367 if (DECL_MODE (decl) == VOIDmode)
368 DECL_MODE (decl) = TYPE_MODE (type);
370 if (DECL_SIZE (decl) == 0)
372 DECL_SIZE (decl) = TYPE_SIZE (type);
373 DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (type);
376 DECL_SIZE_UNIT (decl)
377 = convert (sizetype, size_binop (CEIL_DIV_EXPR, DECL_SIZE (decl),
380 /* Force alignment required for the data type.
381 But if the decl itself wants greater alignment, don't override that.
382 Likewise, if the decl is packed, don't override it. */
383 if (! (code == FIELD_DECL && DECL_BIT_FIELD (decl))
384 && (DECL_ALIGN (decl) == 0
385 || (! (code == FIELD_DECL && DECL_PACKED (decl))
386 && TYPE_ALIGN (type) > DECL_ALIGN (decl))))
388 DECL_ALIGN (decl) = TYPE_ALIGN (type);
389 DECL_USER_ALIGN (decl) = 0;
392 /* For fields, set the bit field type and update the alignment. */
393 if (code == FIELD_DECL)
395 DECL_BIT_FIELD_TYPE (decl) = DECL_BIT_FIELD (decl) ? type : 0;
396 if (maximum_field_alignment != 0)
397 DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), maximum_field_alignment);
399 /* If the field is of variable size, we can't misalign it since we
400 have no way to make a temporary to align the result. But this
401 isn't an issue if the decl is not addressable. Likewise if it
402 is of unknown size. */
403 else if (DECL_PACKED (decl)
404 && (DECL_NONADDRESSABLE_P (decl)
405 || DECL_SIZE_UNIT (decl) == 0
406 || TREE_CODE (DECL_SIZE_UNIT (decl)) == INTEGER_CST))
408 DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), BITS_PER_UNIT);
409 DECL_USER_ALIGN (decl) = 0;
413 /* See if we can use an ordinary integer mode for a bit-field.
414 Conditions are: a fixed size that is correct for another mode
415 and occupying a complete byte or bytes on proper boundary. */
416 if (code == FIELD_DECL && DECL_BIT_FIELD (decl)
417 && TYPE_SIZE (type) != 0
418 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
419 && GET_MODE_CLASS (TYPE_MODE (type)) == MODE_INT)
421 enum machine_mode xmode
422 = mode_for_size_tree (DECL_SIZE (decl), MODE_INT, 1);
424 if (xmode != BLKmode && known_align >= GET_MODE_ALIGNMENT (xmode))
426 DECL_ALIGN (decl) = MAX (GET_MODE_ALIGNMENT (xmode),
428 DECL_MODE (decl) = xmode;
429 DECL_BIT_FIELD (decl) = 0;
433 /* Turn off DECL_BIT_FIELD if we won't need it set. */
434 if (code == FIELD_DECL && DECL_BIT_FIELD (decl)
435 && TYPE_MODE (type) == BLKmode && DECL_MODE (decl) == BLKmode
436 && known_align >= TYPE_ALIGN (type)
437 && DECL_ALIGN (decl) >= TYPE_ALIGN (type)
438 && DECL_SIZE_UNIT (decl) != 0)
439 DECL_BIT_FIELD (decl) = 0;
441 /* Evaluate nonconstant size only once, either now or as soon as safe. */
442 if (DECL_SIZE (decl) != 0 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
443 DECL_SIZE (decl) = variable_size (DECL_SIZE (decl));
444 if (DECL_SIZE_UNIT (decl) != 0
445 && TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST)
446 DECL_SIZE_UNIT (decl) = variable_size (DECL_SIZE_UNIT (decl));
448 /* If requested, warn about definitions of large data objects. */
450 && (code == VAR_DECL || code == PARM_DECL)
451 && ! DECL_EXTERNAL (decl))
453 tree size = DECL_SIZE_UNIT (decl);
455 if (size != 0 && TREE_CODE (size) == INTEGER_CST
456 && compare_tree_int (size, larger_than_size) > 0)
458 unsigned int size_as_int = TREE_INT_CST_LOW (size);
460 if (compare_tree_int (size, size_as_int) == 0)
461 warning_with_decl (decl, "size of `%s' is %d bytes", size_as_int);
463 warning_with_decl (decl, "size of `%s' is larger than %d bytes",
469 /* Hook for a front-end function that can modify the record layout as needed
470 immediately before it is finalized. */
472 void (*lang_adjust_rli) PARAMS ((record_layout_info)) = 0;
475 set_lang_adjust_rli (f)
476 void (*f) PARAMS ((record_layout_info));
481 /* Begin laying out type T, which may be a RECORD_TYPE, UNION_TYPE, or
482 QUAL_UNION_TYPE. Return a pointer to a struct record_layout_info which
483 is to be passed to all other layout functions for this record. It is the
484 responsibility of the caller to call `free' for the storage returned.
485 Note that garbage collection is not permitted until we finish laying
489 start_record_layout (t)
492 record_layout_info rli
493 = (record_layout_info) xmalloc (sizeof (struct record_layout_info_s));
497 /* If the type has a minimum specified alignment (via an attribute
498 declaration, for example) use it -- otherwise, start with a
499 one-byte alignment. */
500 rli->record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (t));
501 rli->unpacked_align = rli->unpadded_align = rli->record_align;
502 rli->offset_align = MAX (rli->record_align, BIGGEST_ALIGNMENT);
504 #ifdef STRUCTURE_SIZE_BOUNDARY
505 /* Packed structures don't need to have minimum size. */
506 if (! TYPE_PACKED (t))
507 rli->record_align = MAX (rli->record_align, STRUCTURE_SIZE_BOUNDARY);
510 rli->offset = size_zero_node;
511 rli->bitpos = bitsize_zero_node;
513 rli->pending_statics = 0;
514 rli->packed_maybe_necessary = 0;
519 /* These four routines perform computations that convert between
520 the offset/bitpos forms and byte and bit offsets. */
523 bit_from_pos (offset, bitpos)
526 return size_binop (PLUS_EXPR, bitpos,
527 size_binop (MULT_EXPR, convert (bitsizetype, offset),
532 byte_from_pos (offset, bitpos)
535 return size_binop (PLUS_EXPR, offset,
537 size_binop (TRUNC_DIV_EXPR, bitpos,
538 bitsize_unit_node)));
542 pos_from_byte (poffset, pbitpos, off_align, pos)
543 tree *poffset, *pbitpos;
544 unsigned int off_align;
548 = size_binop (MULT_EXPR,
550 size_binop (FLOOR_DIV_EXPR, pos,
551 bitsize_int (off_align
553 size_int (off_align / BITS_PER_UNIT));
554 *pbitpos = size_binop (MULT_EXPR,
555 size_binop (FLOOR_MOD_EXPR, pos,
556 bitsize_int (off_align / BITS_PER_UNIT)),
561 pos_from_bit (poffset, pbitpos, off_align, pos)
562 tree *poffset, *pbitpos;
563 unsigned int off_align;
566 *poffset = size_binop (MULT_EXPR,
568 size_binop (FLOOR_DIV_EXPR, pos,
569 bitsize_int (off_align))),
570 size_int (off_align / BITS_PER_UNIT));
571 *pbitpos = size_binop (FLOOR_MOD_EXPR, pos, bitsize_int (off_align));
574 /* Given a pointer to bit and byte offsets and an offset alignment,
575 normalize the offsets so they are within the alignment. */
578 normalize_offset (poffset, pbitpos, off_align)
579 tree *poffset, *pbitpos;
580 unsigned int off_align;
582 /* If the bit position is now larger than it should be, adjust it
584 if (compare_tree_int (*pbitpos, off_align) >= 0)
586 tree extra_aligns = size_binop (FLOOR_DIV_EXPR, *pbitpos,
587 bitsize_int (off_align));
590 = size_binop (PLUS_EXPR, *poffset,
591 size_binop (MULT_EXPR, convert (sizetype, extra_aligns),
592 size_int (off_align / BITS_PER_UNIT)));
595 = size_binop (FLOOR_MOD_EXPR, *pbitpos, bitsize_int (off_align));
599 /* Print debugging information about the information in RLI. */
603 record_layout_info rli;
605 print_node_brief (stderr, "type", rli->t, 0);
606 print_node_brief (stderr, "\noffset", rli->offset, 0);
607 print_node_brief (stderr, " bitpos", rli->bitpos, 0);
609 fprintf (stderr, "\naligns: rec = %u, unpack = %u, unpad = %u, off = %u\n",
610 rli->record_align, rli->unpacked_align, rli->unpadded_align,
612 if (rli->packed_maybe_necessary)
613 fprintf (stderr, "packed may be necessary\n");
615 if (rli->pending_statics)
617 fprintf (stderr, "pending statics:\n");
618 debug_tree (rli->pending_statics);
622 /* Given an RLI with a possibly-incremented BITPOS, adjust OFFSET and
623 BITPOS if necessary to keep BITPOS below OFFSET_ALIGN. */
627 record_layout_info rli;
629 normalize_offset (&rli->offset, &rli->bitpos, rli->offset_align);
632 /* Returns the size in bytes allocated so far. */
635 rli_size_unit_so_far (rli)
636 record_layout_info rli;
638 return byte_from_pos (rli->offset, rli->bitpos);
641 /* Returns the size in bits allocated so far. */
644 rli_size_so_far (rli)
645 record_layout_info rli;
647 return bit_from_pos (rli->offset, rli->bitpos);
650 /* FIELD is about to be added to RLI->T. The alignment (in bits) of
651 the next available location is given by KNOWN_ALIGN. Update the
652 variable alignment fields in RLI, and return the alignment to give
656 update_alignment_for_field (rli, field, known_align)
657 record_layout_info rli;
659 unsigned int known_align;
661 /* The alignment required for FIELD. */
662 unsigned int desired_align;
663 /* The type of this field. */
664 tree type = TREE_TYPE (field);
665 /* True if the field was explicitly aligned by the user. */
668 /* Lay out the field so we know what alignment it needs. For a
669 packed field, use the alignment as specified, disregarding what
670 the type would want. */
671 desired_align = DECL_ALIGN (field);
672 user_align = DECL_USER_ALIGN (field);
673 layout_decl (field, known_align);
674 if (! DECL_PACKED (field))
676 desired_align = DECL_ALIGN (field);
677 user_align = DECL_USER_ALIGN (field);
680 /* Some targets (i.e. i386, VMS) limit struct field alignment
681 to a lower boundary than alignment of variables unless
682 it was overridden by attribute aligned. */
683 #ifdef BIGGEST_FIELD_ALIGNMENT
686 = MIN (desired_align, (unsigned) BIGGEST_FIELD_ALIGNMENT);
689 #ifdef ADJUST_FIELD_ALIGN
691 desired_align = ADJUST_FIELD_ALIGN (field, desired_align);
694 /* Record must have at least as much alignment as any field.
695 Otherwise, the alignment of the field within the record is
697 if ((* targetm.ms_bitfield_layout_p) (rli->t)
698 && type != error_mark_node
699 && DECL_BIT_FIELD_TYPE (field)
700 && ! integer_zerop (TYPE_SIZE (type)))
702 /* Here, the alignment of the underlying type of a bitfield can
703 affect the alignment of a record; even a zero-sized field
704 can do this. The alignment should be to the alignment of
705 the type, except that for zero-size bitfields this only
706 applies if there was an immediately prior, nonzero-size
707 bitfield. (That's the way it is, experimentally.) */
708 if (! integer_zerop (DECL_SIZE (field))
709 ? ! DECL_PACKED (field)
711 && DECL_BIT_FIELD_TYPE (rli->prev_field)
712 && ! integer_zerop (DECL_SIZE (rli->prev_field))))
714 unsigned int type_align = TYPE_ALIGN (type);
715 type_align = MAX (type_align, desired_align);
716 if (maximum_field_alignment != 0)
717 type_align = MIN (type_align, maximum_field_alignment);
718 rli->record_align = MAX (rli->record_align, type_align);
719 rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type));
720 rli->unpadded_align = MAX (rli->unpadded_align, DECL_ALIGN (field));
726 #ifdef PCC_BITFIELD_TYPE_MATTERS
727 if (PCC_BITFIELD_TYPE_MATTERS && type != error_mark_node
728 && ! (* targetm.ms_bitfield_layout_p) (rli->t)
729 && DECL_BIT_FIELD_TYPE (field)
730 && ! integer_zerop (TYPE_SIZE (type)))
732 /* For these machines, a zero-length field does not
733 affect the alignment of the structure as a whole.
734 It does, however, affect the alignment of the next field
735 within the structure. */
736 if (! integer_zerop (DECL_SIZE (field)))
737 rli->record_align = MAX (rli->record_align, desired_align);
738 else if (! DECL_PACKED (field))
739 desired_align = TYPE_ALIGN (type);
741 /* A named bit field of declared type `int'
742 forces the entire structure to have `int' alignment. */
743 if (DECL_NAME (field) != 0)
745 unsigned int type_align = TYPE_ALIGN (type);
747 #ifdef ADJUST_FIELD_ALIGN
748 if (! TYPE_USER_ALIGN (type))
749 type_align = ADJUST_FIELD_ALIGN (field, type_align);
752 if (maximum_field_alignment != 0)
753 type_align = MIN (type_align, maximum_field_alignment);
754 else if (DECL_PACKED (field))
755 type_align = MIN (type_align, BITS_PER_UNIT);
757 rli->record_align = MAX (rli->record_align, type_align);
758 rli->unpadded_align = MAX (rli->unpadded_align, DECL_ALIGN (field));
760 rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type));
761 user_align |= TYPE_USER_ALIGN (type);
767 rli->record_align = MAX (rli->record_align, desired_align);
768 rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type));
769 rli->unpadded_align = MAX (rli->unpadded_align, DECL_ALIGN (field));
772 TYPE_USER_ALIGN (rli->t) |= user_align;
774 return desired_align;
777 /* Called from place_field to handle unions. */
780 place_union_field (rli, field)
781 record_layout_info rli;
784 update_alignment_for_field (rli, field, /*known_align=*/0);
786 DECL_FIELD_OFFSET (field) = size_zero_node;
787 DECL_FIELD_BIT_OFFSET (field) = bitsize_zero_node;
788 SET_DECL_OFFSET_ALIGN (field, BIGGEST_ALIGNMENT);
790 /* We assume the union's size will be a multiple of a byte so we don't
791 bother with BITPOS. */
792 if (TREE_CODE (rli->t) == UNION_TYPE)
793 rli->offset = size_binop (MAX_EXPR, rli->offset, DECL_SIZE_UNIT (field));
794 else if (TREE_CODE (rli->t) == QUAL_UNION_TYPE)
795 rli->offset = fold (build (COND_EXPR, sizetype,
796 DECL_QUALIFIER (field),
797 DECL_SIZE_UNIT (field), rli->offset));
800 /* RLI contains information about the layout of a RECORD_TYPE. FIELD
801 is a FIELD_DECL to be added after those fields already present in
802 T. (FIELD is not actually added to the TYPE_FIELDS list here;
803 callers that desire that behavior must manually perform that step.) */
806 place_field (rli, field)
807 record_layout_info rli;
810 /* The alignment required for FIELD. */
811 unsigned int desired_align;
812 /* The alignment FIELD would have if we just dropped it into the
813 record as it presently stands. */
814 unsigned int known_align;
815 unsigned int actual_align;
816 /* The type of this field. */
817 tree type = TREE_TYPE (field);
819 if (TREE_CODE (field) == ERROR_MARK || TREE_CODE (type) == ERROR_MARK)
822 /* If FIELD is static, then treat it like a separate variable, not
823 really like a structure field. If it is a FUNCTION_DECL, it's a
824 method. In both cases, all we do is lay out the decl, and we do
825 it *after* the record is laid out. */
826 if (TREE_CODE (field) == VAR_DECL)
828 rli->pending_statics = tree_cons (NULL_TREE, field,
829 rli->pending_statics);
833 /* Enumerators and enum types which are local to this class need not
834 be laid out. Likewise for initialized constant fields. */
835 else if (TREE_CODE (field) != FIELD_DECL)
838 /* Unions are laid out very differently than records, so split
839 that code off to another function. */
840 else if (TREE_CODE (rli->t) != RECORD_TYPE)
842 place_union_field (rli, field);
846 /* Work out the known alignment so far. Note that A & (-A) is the
847 value of the least-significant bit in A that is one. */
848 if (! integer_zerop (rli->bitpos))
849 known_align = (tree_low_cst (rli->bitpos, 1)
850 & - tree_low_cst (rli->bitpos, 1));
851 else if (integer_zerop (rli->offset))
852 known_align = BIGGEST_ALIGNMENT;
853 else if (host_integerp (rli->offset, 1))
854 known_align = (BITS_PER_UNIT
855 * (tree_low_cst (rli->offset, 1)
856 & - tree_low_cst (rli->offset, 1)));
858 known_align = rli->offset_align;
860 desired_align = update_alignment_for_field (rli, field, known_align);
862 if (warn_packed && DECL_PACKED (field))
864 if (known_align > TYPE_ALIGN (type))
866 if (TYPE_ALIGN (type) > desired_align)
868 if (STRICT_ALIGNMENT)
869 warning_with_decl (field, "packed attribute causes inefficient alignment for `%s'");
871 warning_with_decl (field, "packed attribute is unnecessary for `%s'");
875 rli->packed_maybe_necessary = 1;
878 /* Does this field automatically have alignment it needs by virtue
879 of the fields that precede it and the record's own alignment? */
880 if (known_align < desired_align)
882 /* No, we need to skip space before this field.
883 Bump the cumulative size to multiple of field alignment. */
886 warning_with_decl (field, "padding struct to align `%s'");
888 /* If the alignment is still within offset_align, just align
890 if (desired_align < rli->offset_align)
891 rli->bitpos = round_up (rli->bitpos, desired_align);
894 /* First adjust OFFSET by the partial bits, then align. */
896 = size_binop (PLUS_EXPR, rli->offset,
898 size_binop (CEIL_DIV_EXPR, rli->bitpos,
899 bitsize_unit_node)));
900 rli->bitpos = bitsize_zero_node;
902 rli->offset = round_up (rli->offset, desired_align / BITS_PER_UNIT);
905 if (! TREE_CONSTANT (rli->offset))
906 rli->offset_align = desired_align;
910 /* Handle compatibility with PCC. Note that if the record has any
911 variable-sized fields, we need not worry about compatibility. */
912 #ifdef PCC_BITFIELD_TYPE_MATTERS
913 if (PCC_BITFIELD_TYPE_MATTERS
914 && ! (* targetm.ms_bitfield_layout_p) (rli->t)
915 && TREE_CODE (field) == FIELD_DECL
916 && type != error_mark_node
917 && DECL_BIT_FIELD (field)
918 && ! DECL_PACKED (field)
919 && maximum_field_alignment == 0
920 && ! integer_zerop (DECL_SIZE (field))
921 && host_integerp (DECL_SIZE (field), 1)
922 && host_integerp (rli->offset, 1)
923 && host_integerp (TYPE_SIZE (type), 1))
925 unsigned int type_align = TYPE_ALIGN (type);
926 tree dsize = DECL_SIZE (field);
927 HOST_WIDE_INT field_size = tree_low_cst (dsize, 1);
928 HOST_WIDE_INT offset = tree_low_cst (rli->offset, 0);
929 HOST_WIDE_INT bit_offset = tree_low_cst (rli->bitpos, 0);
931 #ifdef ADJUST_FIELD_ALIGN
932 if (! TYPE_USER_ALIGN (type))
933 type_align = ADJUST_FIELD_ALIGN (field, type_align);
936 /* A bit field may not span more units of alignment of its type
937 than its type itself. Advance to next boundary if necessary. */
938 if ((((offset * BITS_PER_UNIT + bit_offset + field_size +
941 - (offset * BITS_PER_UNIT + bit_offset) / type_align)
942 > tree_low_cst (TYPE_SIZE (type), 1) / type_align)
943 rli->bitpos = round_up (rli->bitpos, type_align);
945 TYPE_USER_ALIGN (rli->t) |= TYPE_USER_ALIGN (type);
949 #ifdef BITFIELD_NBYTES_LIMITED
950 if (BITFIELD_NBYTES_LIMITED
951 && ! (* targetm.ms_bitfield_layout_p) (rli->t)
952 && TREE_CODE (field) == FIELD_DECL
953 && type != error_mark_node
954 && DECL_BIT_FIELD_TYPE (field)
955 && ! DECL_PACKED (field)
956 && ! integer_zerop (DECL_SIZE (field))
957 && host_integerp (DECL_SIZE (field), 1)
958 && host_integerp (rli->offset, 1)
959 && host_integerp (TYPE_SIZE (type), 1))
961 unsigned int type_align = TYPE_ALIGN (type);
962 tree dsize = DECL_SIZE (field);
963 HOST_WIDE_INT field_size = tree_low_cst (dsize, 1);
964 HOST_WIDE_INT offset = tree_low_cst (rli->offset, 0);
965 HOST_WIDE_INT bit_offset = tree_low_cst (rli->bitpos, 0);
967 #ifdef ADJUST_FIELD_ALIGN
968 if (! TYPE_USER_ALIGN (type))
969 type_align = ADJUST_FIELD_ALIGN (field, type_align);
972 if (maximum_field_alignment != 0)
973 type_align = MIN (type_align, maximum_field_alignment);
974 /* ??? This test is opposite the test in the containing if
975 statement, so this code is unreachable currently. */
976 else if (DECL_PACKED (field))
977 type_align = MIN (type_align, BITS_PER_UNIT);
979 /* A bit field may not span the unit of alignment of its type.
980 Advance to next boundary if necessary. */
981 /* ??? This code should match the code above for the
982 PCC_BITFIELD_TYPE_MATTERS case. */
983 if ((offset * BITS_PER_UNIT + bit_offset) / type_align
984 != ((offset * BITS_PER_UNIT + bit_offset + field_size - 1)
986 rli->bitpos = round_up (rli->bitpos, type_align);
988 TYPE_USER_ALIGN (rli->t) |= TYPE_USER_ALIGN (type);
992 /* See the docs for TARGET_MS_BITFIELD_LAYOUT_P for details.
994 When a bit field is inserted into a packed record, the whole
995 size of the underlying type is used by one or more same-size
996 adjacent bitfields. (That is, if its long:3, 32 bits is
997 used in the record, and any additional adjacent long bitfields are
998 packed into the same chunk of 32 bits. However, if the size
999 changes, a new field of that size is allocated.) In an unpacked
1000 record, this is the same as using alignment, but not eqivalent
1003 Note: for compatability, we use the type size, not the type alignment
1004 to determine alignment, since that matches the documentation */
1006 if ((* targetm.ms_bitfield_layout_p) (rli->t)
1007 && ((DECL_BIT_FIELD_TYPE (field) && ! DECL_PACKED (field))
1008 || (rli->prev_field && ! DECL_PACKED (rli->prev_field))))
1010 /* At this point, either the prior or current are bitfields,
1011 (possibly both), and we're dealing with MS packing. */
1012 tree prev_saved = rli->prev_field;
1014 /* Is the prior field a bitfield? If so, handle "runs" of same
1015 type size fields. */
1016 if (rli->prev_field /* necessarily a bitfield if it exists. */)
1018 /* If both are bitfields, nonzero, and the same size, this is
1019 the middle of a run. Zero declared size fields are special
1020 and handled as "end of run". (Note: it's nonzero declared
1021 size, but equal type sizes!) (Since we know that both
1022 the current and previous fields are bitfields by the
1023 time we check it, DECL_SIZE must be present for both.) */
1024 if (DECL_BIT_FIELD_TYPE (field)
1025 && !integer_zerop (DECL_SIZE (field))
1026 && !integer_zerop (DECL_SIZE (rli->prev_field))
1027 && simple_cst_equal (TYPE_SIZE (type),
1028 TYPE_SIZE (TREE_TYPE (rli->prev_field))) )
1030 /* We're in the middle of a run of equal type size fields; make
1031 sure we realign if we run out of bits. (Not decl size,
1033 int bitsize = TREE_INT_CST_LOW (DECL_SIZE (field));
1034 tree type_size = TYPE_SIZE(TREE_TYPE(rli->prev_field));
1036 if (rli->remaining_in_alignment < bitsize)
1038 /* out of bits; bump up to next 'word'. */
1039 rli->offset = DECL_FIELD_OFFSET (rli->prev_field);
1040 rli->bitpos = size_binop (PLUS_EXPR,
1042 DECL_FIELD_BIT_OFFSET(rli->prev_field));
1043 rli->prev_field = field;
1044 rli->remaining_in_alignment = TREE_INT_CST_LOW (type_size);
1046 rli->remaining_in_alignment -= bitsize;
1050 /* End of a run: if leaving a run of bitfields of the same type
1051 size, we have to "use up" the rest of the bits of the type
1054 Compute the new position as the sum of the size for the prior
1055 type and where we first started working on that type.
1056 Note: since the beginning of the field was aligned then
1057 of course the end will be too. No round needed. */
1059 if (!integer_zerop (DECL_SIZE (rli->prev_field)))
1061 tree type_size = TYPE_SIZE(TREE_TYPE(rli->prev_field));
1062 rli->bitpos = size_binop (PLUS_EXPR,
1064 DECL_FIELD_BIT_OFFSET(rli->prev_field));
1068 /* We "use up" size zero fields; the code below should behave
1069 as if the prior field was not a bitfield. */
1073 /* Cause a new bitfield to be captured, either this time (if
1074 currently a bitfield) or next time we see one. */
1075 if (!DECL_BIT_FIELD_TYPE(field)
1076 || integer_zerop (DECL_SIZE (field)))
1078 rli->prev_field = NULL;
1081 normalize_rli (rli);
1084 /* If we're starting a new run of same size type bitfields
1085 (or a run of non-bitfields), set up the "first of the run"
1088 That is, if the current field is not a bitfield, or if there
1089 was a prior bitfield the type sizes differ, or if there wasn't
1090 a prior bitfield the size of the current field is nonzero.
1092 Note: we must be sure to test ONLY the type size if there was
1093 a prior bitfield and ONLY for the current field being zero if
1096 if (!DECL_BIT_FIELD_TYPE (field)
1097 || ( prev_saved != NULL
1098 ? !simple_cst_equal (TYPE_SIZE (type),
1099 TYPE_SIZE (TREE_TYPE (prev_saved)))
1100 : !integer_zerop (DECL_SIZE (field)) ))
1102 unsigned int type_align = 8; /* Never below 8 for compatability */
1104 /* (When not a bitfield), we could be seeing a flex array (with
1105 no DECL_SIZE). Since we won't be using remaining_in_alignment
1106 until we see a bitfield (and come by here again) we just skip
1109 if (DECL_SIZE (field) != NULL)
1110 rli->remaining_in_alignment
1111 = TREE_INT_CST_LOW (TYPE_SIZE(TREE_TYPE(field)))
1112 - TREE_INT_CST_LOW (DECL_SIZE (field));
1114 /* Now align (conventionally) for the new type. */
1115 if (!DECL_PACKED(field))
1116 type_align = MAX(TYPE_ALIGN (type), type_align);
1119 && DECL_BIT_FIELD_TYPE (prev_saved)
1120 /* If the previous bit-field is zero-sized, we've already
1121 accounted for its alignment needs (or ignored it, if
1122 appropriate) while placing it. */
1123 && ! integer_zerop (DECL_SIZE (prev_saved)))
1124 type_align = MAX (type_align,
1125 TYPE_ALIGN (TREE_TYPE (prev_saved)));
1127 if (maximum_field_alignment != 0)
1128 type_align = MIN (type_align, maximum_field_alignment);
1130 rli->bitpos = round_up (rli->bitpos, type_align);
1131 /* If we really aligned, don't allow subsequent bitfields
1133 rli->prev_field = NULL;
1137 /* Offset so far becomes the position of this field after normalizing. */
1138 normalize_rli (rli);
1139 DECL_FIELD_OFFSET (field) = rli->offset;
1140 DECL_FIELD_BIT_OFFSET (field) = rli->bitpos;
1141 SET_DECL_OFFSET_ALIGN (field, rli->offset_align);
1143 /* If this field ended up more aligned than we thought it would be (we
1144 approximate this by seeing if its position changed), lay out the field
1145 again; perhaps we can use an integral mode for it now. */
1146 if (! integer_zerop (DECL_FIELD_BIT_OFFSET (field)))
1147 actual_align = (tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1148 & - tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1));
1149 else if (integer_zerop (DECL_FIELD_OFFSET (field)))
1150 actual_align = BIGGEST_ALIGNMENT;
1151 else if (host_integerp (DECL_FIELD_OFFSET (field), 1))
1152 actual_align = (BITS_PER_UNIT
1153 * (tree_low_cst (DECL_FIELD_OFFSET (field), 1)
1154 & - tree_low_cst (DECL_FIELD_OFFSET (field), 1)));
1156 actual_align = DECL_OFFSET_ALIGN (field);
1158 if (known_align != actual_align)
1159 layout_decl (field, actual_align);
1161 /* Only the MS bitfields use this. */
1162 if (rli->prev_field == NULL && DECL_BIT_FIELD_TYPE(field))
1163 rli->prev_field = field;
1165 /* Now add size of this field to the size of the record. If the size is
1166 not constant, treat the field as being a multiple of bytes and just
1167 adjust the offset, resetting the bit position. Otherwise, apportion the
1168 size amongst the bit position and offset. First handle the case of an
1169 unspecified size, which can happen when we have an invalid nested struct
1170 definition, such as struct j { struct j { int i; } }. The error message
1171 is printed in finish_struct. */
1172 if (DECL_SIZE (field) == 0)
1174 else if (TREE_CODE (DECL_SIZE_UNIT (field)) != INTEGER_CST
1175 || TREE_CONSTANT_OVERFLOW (DECL_SIZE_UNIT (field)))
1178 = size_binop (PLUS_EXPR, rli->offset,
1180 size_binop (CEIL_DIV_EXPR, rli->bitpos,
1181 bitsize_unit_node)));
1183 = size_binop (PLUS_EXPR, rli->offset, DECL_SIZE_UNIT (field));
1184 rli->bitpos = bitsize_zero_node;
1185 rli->offset_align = MIN (rli->offset_align, DECL_ALIGN (field));
1189 rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, DECL_SIZE (field));
1190 normalize_rli (rli);
1194 /* Assuming that all the fields have been laid out, this function uses
1195 RLI to compute the final TYPE_SIZE, TYPE_ALIGN, etc. for the type
1196 inidicated by RLI. */
1199 finalize_record_size (rli)
1200 record_layout_info rli;
1202 tree unpadded_size, unpadded_size_unit;
1204 /* Now we want just byte and bit offsets, so set the offset alignment
1205 to be a byte and then normalize. */
1206 rli->offset_align = BITS_PER_UNIT;
1207 normalize_rli (rli);
1209 /* Determine the desired alignment. */
1210 #ifdef ROUND_TYPE_ALIGN
1211 TYPE_ALIGN (rli->t) = ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t),
1214 TYPE_ALIGN (rli->t) = MAX (TYPE_ALIGN (rli->t), rli->record_align);
1217 /* Compute the size so far. Be sure to allow for extra bits in the
1218 size in bytes. We have guaranteed above that it will be no more
1219 than a single byte. */
1220 unpadded_size = rli_size_so_far (rli);
1221 unpadded_size_unit = rli_size_unit_so_far (rli);
1222 if (! integer_zerop (rli->bitpos))
1224 = size_binop (PLUS_EXPR, unpadded_size_unit, size_one_node);
1226 /* Record the un-rounded size in the binfo node. But first we check
1227 the size of TYPE_BINFO to make sure that BINFO_SIZE is available. */
1228 if (TYPE_BINFO (rli->t) && TREE_VEC_LENGTH (TYPE_BINFO (rli->t)) > 6)
1230 TYPE_BINFO_SIZE (rli->t) = unpadded_size;
1231 TYPE_BINFO_SIZE_UNIT (rli->t) = unpadded_size_unit;
1234 /* Round the size up to be a multiple of the required alignment */
1235 #ifdef ROUND_TYPE_SIZE
1236 TYPE_SIZE (rli->t) = ROUND_TYPE_SIZE (rli->t, unpadded_size,
1237 TYPE_ALIGN (rli->t));
1238 TYPE_SIZE_UNIT (rli->t)
1239 = ROUND_TYPE_SIZE_UNIT (rli->t, unpadded_size_unit,
1240 TYPE_ALIGN (rli->t) / BITS_PER_UNIT);
1242 TYPE_SIZE (rli->t) = round_up (unpadded_size, TYPE_ALIGN (rli->t));
1243 TYPE_SIZE_UNIT (rli->t) = round_up (unpadded_size_unit,
1244 TYPE_ALIGN (rli->t) / BITS_PER_UNIT);
1247 if (warn_padded && TREE_CONSTANT (unpadded_size)
1248 && simple_cst_equal (unpadded_size, TYPE_SIZE (rli->t)) == 0)
1249 warning ("padding struct size to alignment boundary");
1251 if (warn_packed && TREE_CODE (rli->t) == RECORD_TYPE
1252 && TYPE_PACKED (rli->t) && ! rli->packed_maybe_necessary
1253 && TREE_CONSTANT (unpadded_size))
1257 #ifdef ROUND_TYPE_ALIGN
1259 = ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t), rli->unpacked_align);
1261 rli->unpacked_align = MAX (TYPE_ALIGN (rli->t), rli->unpacked_align);
1264 #ifdef ROUND_TYPE_SIZE
1265 unpacked_size = ROUND_TYPE_SIZE (rli->t, TYPE_SIZE (rli->t),
1266 rli->unpacked_align);
1268 unpacked_size = round_up (TYPE_SIZE (rli->t), rli->unpacked_align);
1271 if (simple_cst_equal (unpacked_size, TYPE_SIZE (rli->t)))
1273 TYPE_PACKED (rli->t) = 0;
1275 if (TYPE_NAME (rli->t))
1279 if (TREE_CODE (TYPE_NAME (rli->t)) == IDENTIFIER_NODE)
1280 name = IDENTIFIER_POINTER (TYPE_NAME (rli->t));
1282 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (rli->t)));
1284 if (STRICT_ALIGNMENT)
1285 warning ("packed attribute causes inefficient alignment for `%s'", name);
1287 warning ("packed attribute is unnecessary for `%s'", name);
1291 if (STRICT_ALIGNMENT)
1292 warning ("packed attribute causes inefficient alignment");
1294 warning ("packed attribute is unnecessary");
1300 /* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE). */
1303 compute_record_mode (type)
1307 enum machine_mode mode = VOIDmode;
1309 /* Most RECORD_TYPEs have BLKmode, so we start off assuming that.
1310 However, if possible, we use a mode that fits in a register
1311 instead, in order to allow for better optimization down the
1313 TYPE_MODE (type) = BLKmode;
1315 if (! host_integerp (TYPE_SIZE (type), 1))
1318 /* A record which has any BLKmode members must itself be
1319 BLKmode; it can't go in a register. Unless the member is
1320 BLKmode only because it isn't aligned. */
1321 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1323 unsigned HOST_WIDE_INT bitpos;
1325 if (TREE_CODE (field) != FIELD_DECL)
1328 if (TREE_CODE (TREE_TYPE (field)) == ERROR_MARK
1329 || (TYPE_MODE (TREE_TYPE (field)) == BLKmode
1330 && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field)))
1331 || ! host_integerp (bit_position (field), 1)
1332 || DECL_SIZE (field) == 0
1333 || ! host_integerp (DECL_SIZE (field), 1))
1336 bitpos = int_bit_position (field);
1338 /* Must be BLKmode if any field crosses a word boundary,
1339 since extract_bit_field can't handle that in registers. */
1340 if (bitpos / BITS_PER_WORD
1341 != ((tree_low_cst (DECL_SIZE (field), 1) + bitpos - 1)
1343 /* But there is no problem if the field is entire words. */
1344 && tree_low_cst (DECL_SIZE (field), 1) % BITS_PER_WORD != 0)
1347 /* If this field is the whole struct, remember its mode so
1348 that, say, we can put a double in a class into a DF
1349 register instead of forcing it to live in the stack. */
1350 if (simple_cst_equal (TYPE_SIZE (type), DECL_SIZE (field)))
1351 mode = DECL_MODE (field);
1353 #ifdef MEMBER_TYPE_FORCES_BLK
1354 /* With some targets, eg. c4x, it is sub-optimal
1355 to access an aligned BLKmode structure as a scalar. */
1357 if (MEMBER_TYPE_FORCES_BLK (field, mode))
1359 #endif /* MEMBER_TYPE_FORCES_BLK */
1362 /* If we only have one real field; use its mode. This only applies to
1363 RECORD_TYPE. This does not apply to unions. */
1364 if (TREE_CODE (type) == RECORD_TYPE && mode != VOIDmode)
1365 TYPE_MODE (type) = mode;
1367 TYPE_MODE (type) = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1);
1369 /* If structure's known alignment is less than what the scalar
1370 mode would need, and it matters, then stick with BLKmode. */
1371 if (TYPE_MODE (type) != BLKmode
1373 && ! (TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT
1374 || TYPE_ALIGN (type) >= GET_MODE_ALIGNMENT (TYPE_MODE (type))))
1376 /* If this is the only reason this type is BLKmode, then
1377 don't force containing types to be BLKmode. */
1378 TYPE_NO_FORCE_BLK (type) = 1;
1379 TYPE_MODE (type) = BLKmode;
1383 /* Compute TYPE_SIZE and TYPE_ALIGN for TYPE, once it has been laid
1387 finalize_type_size (type)
1390 /* Normally, use the alignment corresponding to the mode chosen.
1391 However, where strict alignment is not required, avoid
1392 over-aligning structures, since most compilers do not do this
1395 if (TYPE_MODE (type) != BLKmode && TYPE_MODE (type) != VOIDmode
1396 && (STRICT_ALIGNMENT
1397 || (TREE_CODE (type) != RECORD_TYPE && TREE_CODE (type) != UNION_TYPE
1398 && TREE_CODE (type) != QUAL_UNION_TYPE
1399 && TREE_CODE (type) != ARRAY_TYPE)))
1401 TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type));
1402 TYPE_USER_ALIGN (type) = 0;
1405 /* Do machine-dependent extra alignment. */
1406 #ifdef ROUND_TYPE_ALIGN
1408 = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (type), BITS_PER_UNIT);
1411 /* If we failed to find a simple way to calculate the unit size
1412 of the type, find it by division. */
1413 if (TYPE_SIZE_UNIT (type) == 0 && TYPE_SIZE (type) != 0)
1414 /* TYPE_SIZE (type) is computed in bitsizetype. After the division, the
1415 result will fit in sizetype. We will get more efficient code using
1416 sizetype, so we force a conversion. */
1417 TYPE_SIZE_UNIT (type)
1418 = convert (sizetype,
1419 size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (type),
1420 bitsize_unit_node));
1422 if (TYPE_SIZE (type) != 0)
1424 #ifdef ROUND_TYPE_SIZE
1426 = ROUND_TYPE_SIZE (type, TYPE_SIZE (type), TYPE_ALIGN (type));
1427 TYPE_SIZE_UNIT (type)
1428 = ROUND_TYPE_SIZE_UNIT (type, TYPE_SIZE_UNIT (type),
1429 TYPE_ALIGN (type) / BITS_PER_UNIT);
1431 TYPE_SIZE (type) = round_up (TYPE_SIZE (type), TYPE_ALIGN (type));
1432 TYPE_SIZE_UNIT (type)
1433 = round_up (TYPE_SIZE_UNIT (type), TYPE_ALIGN (type) / BITS_PER_UNIT);
1437 /* Evaluate nonconstant sizes only once, either now or as soon as safe. */
1438 if (TYPE_SIZE (type) != 0 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1439 TYPE_SIZE (type) = variable_size (TYPE_SIZE (type));
1440 if (TYPE_SIZE_UNIT (type) != 0
1441 && TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST)
1442 TYPE_SIZE_UNIT (type) = variable_size (TYPE_SIZE_UNIT (type));
1444 /* Also layout any other variants of the type. */
1445 if (TYPE_NEXT_VARIANT (type)
1446 || type != TYPE_MAIN_VARIANT (type))
1449 /* Record layout info of this variant. */
1450 tree size = TYPE_SIZE (type);
1451 tree size_unit = TYPE_SIZE_UNIT (type);
1452 unsigned int align = TYPE_ALIGN (type);
1453 unsigned int user_align = TYPE_USER_ALIGN (type);
1454 enum machine_mode mode = TYPE_MODE (type);
1456 /* Copy it into all variants. */
1457 for (variant = TYPE_MAIN_VARIANT (type);
1459 variant = TYPE_NEXT_VARIANT (variant))
1461 TYPE_SIZE (variant) = size;
1462 TYPE_SIZE_UNIT (variant) = size_unit;
1463 TYPE_ALIGN (variant) = align;
1464 TYPE_USER_ALIGN (variant) = user_align;
1465 TYPE_MODE (variant) = mode;
1470 /* Do all of the work required to layout the type indicated by RLI,
1471 once the fields have been laid out. This function will call `free'
1472 for RLI, unless FREE_P is false. Passing a value other than false
1473 for FREE_P is bad practice; this option only exists to support the
1477 finish_record_layout (rli, free_p)
1478 record_layout_info rli;
1481 /* Compute the final size. */
1482 finalize_record_size (rli);
1484 /* Compute the TYPE_MODE for the record. */
1485 compute_record_mode (rli->t);
1487 /* Perform any last tweaks to the TYPE_SIZE, etc. */
1488 finalize_type_size (rli->t);
1490 /* Lay out any static members. This is done now because their type
1491 may use the record's type. */
1492 while (rli->pending_statics)
1494 layout_decl (TREE_VALUE (rli->pending_statics), 0);
1495 rli->pending_statics = TREE_CHAIN (rli->pending_statics);
1503 /* Calculate the mode, size, and alignment for TYPE.
1504 For an array type, calculate the element separation as well.
1505 Record TYPE on the chain of permanent or temporary types
1506 so that dbxout will find out about it.
1508 TYPE_SIZE of a type is nonzero if the type has been laid out already.
1509 layout_type does nothing on such a type.
1511 If the type is incomplete, its TYPE_SIZE remains zero. */
1520 /* Do nothing if type has been laid out before. */
1521 if (TYPE_SIZE (type))
1524 switch (TREE_CODE (type))
1527 /* This kind of type is the responsibility
1528 of the language-specific code. */
1531 case BOOLEAN_TYPE: /* Used for Java, Pascal, and Chill. */
1532 if (TYPE_PRECISION (type) == 0)
1533 TYPE_PRECISION (type) = 1; /* default to one byte/boolean. */
1535 /* ... fall through ... */
1540 if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
1541 && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0)
1542 TREE_UNSIGNED (type) = 1;
1544 TYPE_MODE (type) = smallest_mode_for_size (TYPE_PRECISION (type),
1546 TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
1547 TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
1551 TYPE_MODE (type) = mode_for_size (TYPE_PRECISION (type), MODE_FLOAT, 0);
1552 TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
1553 TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
1557 TREE_UNSIGNED (type) = TREE_UNSIGNED (TREE_TYPE (type));
1559 = mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type)),
1560 (TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE
1561 ? MODE_COMPLEX_INT : MODE_COMPLEX_FLOAT),
1563 TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
1564 TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
1571 subtype = TREE_TYPE (type);
1572 TREE_UNSIGNED (type) = TREE_UNSIGNED (subtype);
1573 TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
1574 TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
1579 /* This is an incomplete type and so doesn't have a size. */
1580 TYPE_ALIGN (type) = 1;
1581 TYPE_USER_ALIGN (type) = 0;
1582 TYPE_MODE (type) = VOIDmode;
1586 TYPE_SIZE (type) = bitsize_int (POINTER_SIZE);
1587 TYPE_SIZE_UNIT (type) = size_int (POINTER_SIZE / BITS_PER_UNIT);
1588 /* A pointer might be MODE_PARTIAL_INT,
1589 but ptrdiff_t must be integral. */
1590 TYPE_MODE (type) = mode_for_size (POINTER_SIZE, MODE_INT, 0);
1595 TYPE_MODE (type) = mode_for_size (2 * POINTER_SIZE, MODE_INT, 0);
1596 TYPE_SIZE (type) = bitsize_int (2 * POINTER_SIZE);
1597 TYPE_SIZE_UNIT (type) = size_int ((2 * POINTER_SIZE) / BITS_PER_UNIT);
1601 case REFERENCE_TYPE:
1603 int nbits = ((TREE_CODE (type) == REFERENCE_TYPE
1604 && reference_types_internal)
1605 ? GET_MODE_BITSIZE (Pmode) : POINTER_SIZE);
1607 TYPE_MODE (type) = nbits == POINTER_SIZE ? ptr_mode : Pmode;
1608 TYPE_SIZE (type) = bitsize_int (nbits);
1609 TYPE_SIZE_UNIT (type) = size_int (nbits / BITS_PER_UNIT);
1610 TREE_UNSIGNED (type) = 1;
1611 TYPE_PRECISION (type) = nbits;
1617 tree index = TYPE_DOMAIN (type);
1618 tree element = TREE_TYPE (type);
1620 build_pointer_type (element);
1622 /* We need to know both bounds in order to compute the size. */
1623 if (index && TYPE_MAX_VALUE (index) && TYPE_MIN_VALUE (index)
1624 && TYPE_SIZE (element))
1626 tree ub = TYPE_MAX_VALUE (index);
1627 tree lb = TYPE_MIN_VALUE (index);
1631 /* The initial subtraction should happen in the original type so
1632 that (possible) negative values are handled appropriately. */
1633 length = size_binop (PLUS_EXPR, size_one_node,
1635 fold (build (MINUS_EXPR,
1639 /* Special handling for arrays of bits (for Chill). */
1640 element_size = TYPE_SIZE (element);
1641 if (TYPE_PACKED (type) && INTEGRAL_TYPE_P (element)
1642 && (integer_zerop (TYPE_MAX_VALUE (element))
1643 || integer_onep (TYPE_MAX_VALUE (element)))
1644 && host_integerp (TYPE_MIN_VALUE (element), 1))
1646 HOST_WIDE_INT maxvalue
1647 = tree_low_cst (TYPE_MAX_VALUE (element), 1);
1648 HOST_WIDE_INT minvalue
1649 = tree_low_cst (TYPE_MIN_VALUE (element), 1);
1651 if (maxvalue - minvalue == 1
1652 && (maxvalue == 1 || maxvalue == 0))
1653 element_size = integer_one_node;
1656 TYPE_SIZE (type) = size_binop (MULT_EXPR, element_size,
1657 convert (bitsizetype, length));
1659 /* If we know the size of the element, calculate the total
1660 size directly, rather than do some division thing below.
1661 This optimization helps Fortran assumed-size arrays
1662 (where the size of the array is determined at runtime)
1664 Note that we can't do this in the case where the size of
1665 the elements is one bit since TYPE_SIZE_UNIT cannot be
1666 set correctly in that case. */
1667 if (TYPE_SIZE_UNIT (element) != 0 && ! integer_onep (element_size))
1668 TYPE_SIZE_UNIT (type)
1669 = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (element), length);
1672 /* Now round the alignment and size,
1673 using machine-dependent criteria if any. */
1675 #ifdef ROUND_TYPE_ALIGN
1677 = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (element), BITS_PER_UNIT);
1679 TYPE_ALIGN (type) = MAX (TYPE_ALIGN (element), BITS_PER_UNIT);
1681 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (element);
1683 #ifdef ROUND_TYPE_SIZE
1684 if (TYPE_SIZE (type) != 0)
1687 = ROUND_TYPE_SIZE (type, TYPE_SIZE (type), TYPE_ALIGN (type));
1689 /* If the rounding changed the size of the type, remove any
1690 pre-calculated TYPE_SIZE_UNIT. */
1691 if (simple_cst_equal (TYPE_SIZE (type), tmp) != 1)
1692 TYPE_SIZE_UNIT (type) = NULL;
1694 TYPE_SIZE (type) = tmp;
1698 TYPE_MODE (type) = BLKmode;
1699 if (TYPE_SIZE (type) != 0
1700 #ifdef MEMBER_TYPE_FORCES_BLK
1701 && ! MEMBER_TYPE_FORCES_BLK (type, VOIDmode)
1703 /* BLKmode elements force BLKmode aggregate;
1704 else extract/store fields may lose. */
1705 && (TYPE_MODE (TREE_TYPE (type)) != BLKmode
1706 || TYPE_NO_FORCE_BLK (TREE_TYPE (type))))
1708 /* One-element arrays get the component type's mode. */
1709 if (simple_cst_equal (TYPE_SIZE (type),
1710 TYPE_SIZE (TREE_TYPE (type))))
1711 TYPE_MODE (type) = TYPE_MODE (TREE_TYPE (type));
1714 = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1);
1716 if (TYPE_MODE (type) != BLKmode
1717 && STRICT_ALIGNMENT && TYPE_ALIGN (type) < BIGGEST_ALIGNMENT
1718 && TYPE_ALIGN (type) < GET_MODE_ALIGNMENT (TYPE_MODE (type))
1719 && TYPE_MODE (type) != BLKmode)
1721 TYPE_NO_FORCE_BLK (type) = 1;
1722 TYPE_MODE (type) = BLKmode;
1730 case QUAL_UNION_TYPE:
1733 record_layout_info rli;
1735 /* Initialize the layout information. */
1736 rli = start_record_layout (type);
1738 /* If this is a QUAL_UNION_TYPE, we want to process the fields
1739 in the reverse order in building the COND_EXPR that denotes
1740 its size. We reverse them again later. */
1741 if (TREE_CODE (type) == QUAL_UNION_TYPE)
1742 TYPE_FIELDS (type) = nreverse (TYPE_FIELDS (type));
1744 /* Place all the fields. */
1745 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1746 place_field (rli, field);
1748 if (TREE_CODE (type) == QUAL_UNION_TYPE)
1749 TYPE_FIELDS (type) = nreverse (TYPE_FIELDS (type));
1751 if (lang_adjust_rli)
1752 (*lang_adjust_rli) (rli);
1754 /* Finish laying out the record. */
1755 finish_record_layout (rli, /*free_p=*/true);
1759 case SET_TYPE: /* Used by Chill and Pascal. */
1760 if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST
1761 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST)
1765 #ifndef SET_WORD_SIZE
1766 #define SET_WORD_SIZE BITS_PER_WORD
1768 unsigned int alignment
1769 = set_alignment ? set_alignment : SET_WORD_SIZE;
1771 = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
1772 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) + 1);
1774 = ((size_in_bits + alignment - 1) / alignment) * alignment;
1776 if (rounded_size > (int) alignment)
1777 TYPE_MODE (type) = BLKmode;
1779 TYPE_MODE (type) = mode_for_size (alignment, MODE_INT, 1);
1781 TYPE_SIZE (type) = bitsize_int (rounded_size);
1782 TYPE_SIZE_UNIT (type) = size_int (rounded_size / BITS_PER_UNIT);
1783 TYPE_ALIGN (type) = alignment;
1784 TYPE_USER_ALIGN (type) = 0;
1785 TYPE_PRECISION (type) = size_in_bits;
1790 /* The size may vary in different languages, so the language front end
1791 should fill in the size. */
1792 TYPE_ALIGN (type) = BIGGEST_ALIGNMENT;
1793 TYPE_USER_ALIGN (type) = 0;
1794 TYPE_MODE (type) = BLKmode;
1801 /* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE. For
1802 records and unions, finish_record_layout already called this
1804 if (TREE_CODE (type) != RECORD_TYPE
1805 && TREE_CODE (type) != UNION_TYPE
1806 && TREE_CODE (type) != QUAL_UNION_TYPE)
1807 finalize_type_size (type);
1809 /* If this type is created before sizetype has been permanently set,
1810 record it so set_sizetype can fix it up. */
1812 early_type_list = tree_cons (NULL_TREE, type, early_type_list);
1814 /* If an alias set has been set for this aggregate when it was incomplete,
1815 force it into alias set 0.
1816 This is too conservative, but we cannot call record_component_aliases
1817 here because some frontends still change the aggregates after
1819 if (AGGREGATE_TYPE_P (type) && TYPE_ALIAS_SET_KNOWN_P (type))
1820 TYPE_ALIAS_SET (type) = 0;
1823 /* Create and return a type for signed integers of PRECISION bits. */
1826 make_signed_type (precision)
1829 tree type = make_node (INTEGER_TYPE);
1831 TYPE_PRECISION (type) = precision;
1833 fixup_signed_type (type);
1837 /* Create and return a type for unsigned integers of PRECISION bits. */
1840 make_unsigned_type (precision)
1843 tree type = make_node (INTEGER_TYPE);
1845 TYPE_PRECISION (type) = precision;
1847 fixup_unsigned_type (type);
1851 /* Initialize sizetype and bitsizetype to a reasonable and temporary
1852 value to enable integer types to be created. */
1855 initialize_sizetypes ()
1857 tree t = make_node (INTEGER_TYPE);
1859 /* Set this so we do something reasonable for the build_int_2 calls
1861 integer_type_node = t;
1863 TYPE_MODE (t) = SImode;
1864 TYPE_ALIGN (t) = GET_MODE_ALIGNMENT (SImode);
1865 TYPE_USER_ALIGN (t) = 0;
1866 TYPE_SIZE (t) = build_int_2 (GET_MODE_BITSIZE (SImode), 0);
1867 TYPE_SIZE_UNIT (t) = build_int_2 (GET_MODE_SIZE (SImode), 0);
1868 TREE_UNSIGNED (t) = 1;
1869 TYPE_PRECISION (t) = GET_MODE_BITSIZE (SImode);
1870 TYPE_MIN_VALUE (t) = build_int_2 (0, 0);
1871 TYPE_IS_SIZETYPE (t) = 1;
1873 /* 1000 avoids problems with possible overflow and is certainly
1874 larger than any size value we'd want to be storing. */
1875 TYPE_MAX_VALUE (t) = build_int_2 (1000, 0);
1877 /* These two must be different nodes because of the caching done in
1880 bitsizetype = copy_node (t);
1881 integer_type_node = 0;
1884 /* Set sizetype to TYPE, and initialize *sizetype accordingly.
1885 Also update the type of any standard type's sizes made so far. */
1891 int oprecision = TYPE_PRECISION (type);
1892 /* The *bitsizetype types use a precision that avoids overflows when
1893 calculating signed sizes / offsets in bits. However, when
1894 cross-compiling from a 32 bit to a 64 bit host, we are limited to 64 bit
1896 int precision = MIN (oprecision + BITS_PER_UNIT_LOG + 1,
1897 2 * HOST_BITS_PER_WIDE_INT);
1904 /* Make copies of nodes since we'll be setting TYPE_IS_SIZETYPE. */
1905 sizetype = copy_node (type);
1906 TYPE_DOMAIN (sizetype) = type;
1907 TYPE_IS_SIZETYPE (sizetype) = 1;
1908 bitsizetype = make_node (INTEGER_TYPE);
1909 TYPE_NAME (bitsizetype) = TYPE_NAME (type);
1910 TYPE_PRECISION (bitsizetype) = precision;
1911 TYPE_IS_SIZETYPE (bitsizetype) = 1;
1913 if (TREE_UNSIGNED (type))
1914 fixup_unsigned_type (bitsizetype);
1916 fixup_signed_type (bitsizetype);
1918 layout_type (bitsizetype);
1920 if (TREE_UNSIGNED (type))
1922 usizetype = sizetype;
1923 ubitsizetype = bitsizetype;
1924 ssizetype = copy_node (make_signed_type (oprecision));
1925 sbitsizetype = copy_node (make_signed_type (precision));
1929 ssizetype = sizetype;
1930 sbitsizetype = bitsizetype;
1931 usizetype = copy_node (make_unsigned_type (oprecision));
1932 ubitsizetype = copy_node (make_unsigned_type (precision));
1935 TYPE_NAME (bitsizetype) = get_identifier ("bit_size_type");
1937 /* Show is a sizetype, is a main type, and has no pointers to it. */
1938 for (i = 0; i < ARRAY_SIZE (sizetype_tab); i++)
1940 TYPE_IS_SIZETYPE (sizetype_tab[i]) = 1;
1941 TYPE_MAIN_VARIANT (sizetype_tab[i]) = sizetype_tab[i];
1942 TYPE_NEXT_VARIANT (sizetype_tab[i]) = 0;
1943 TYPE_POINTER_TO (sizetype_tab[i]) = 0;
1944 TYPE_REFERENCE_TO (sizetype_tab[i]) = 0;
1947 /* Go down each of the types we already made and set the proper type
1948 for the sizes in them. */
1949 for (t = early_type_list; t != 0; t = TREE_CHAIN (t))
1951 if (TREE_CODE (TREE_VALUE (t)) != INTEGER_TYPE)
1954 TREE_TYPE (TYPE_SIZE (TREE_VALUE (t))) = bitsizetype;
1955 TREE_TYPE (TYPE_SIZE_UNIT (TREE_VALUE (t))) = sizetype;
1958 early_type_list = 0;
1962 /* Set the extreme values of TYPE based on its precision in bits,
1963 then lay it out. Used when make_signed_type won't do
1964 because the tree code is not INTEGER_TYPE.
1965 E.g. for Pascal, when the -fsigned-char option is given. */
1968 fixup_signed_type (type)
1971 int precision = TYPE_PRECISION (type);
1973 /* We can not represent properly constants greater then
1974 2 * HOST_BITS_PER_WIDE_INT, still we need the types
1975 as they are used by i386 vector extensions and friends. */
1976 if (precision > HOST_BITS_PER_WIDE_INT * 2)
1977 precision = HOST_BITS_PER_WIDE_INT * 2;
1979 TYPE_MIN_VALUE (type)
1980 = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
1981 ? 0 : (HOST_WIDE_INT) (-1) << (precision - 1)),
1982 (((HOST_WIDE_INT) (-1)
1983 << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
1984 ? precision - HOST_BITS_PER_WIDE_INT - 1
1986 TYPE_MAX_VALUE (type)
1987 = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
1988 ? -1 : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1),
1989 (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
1990 ? (((HOST_WIDE_INT) 1
1991 << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1
1994 TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
1995 TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
1997 /* Lay out the type: set its alignment, size, etc. */
2001 /* Set the extreme values of TYPE based on its precision in bits,
2002 then lay it out. This is used both in `make_unsigned_type'
2003 and for enumeral types. */
2006 fixup_unsigned_type (type)
2009 int precision = TYPE_PRECISION (type);
2011 /* We can not represent properly constants greater then
2012 2 * HOST_BITS_PER_WIDE_INT, still we need the types
2013 as they are used by i386 vector extensions and friends. */
2014 if (precision > HOST_BITS_PER_WIDE_INT * 2)
2015 precision = HOST_BITS_PER_WIDE_INT * 2;
2017 TYPE_MIN_VALUE (type) = build_int_2 (0, 0);
2018 TYPE_MAX_VALUE (type)
2019 = build_int_2 (precision - HOST_BITS_PER_WIDE_INT >= 0
2020 ? -1 : ((HOST_WIDE_INT) 1 << precision) - 1,
2021 precision - HOST_BITS_PER_WIDE_INT > 0
2022 ? ((unsigned HOST_WIDE_INT) ~0
2023 >> (HOST_BITS_PER_WIDE_INT
2024 - (precision - HOST_BITS_PER_WIDE_INT)))
2026 TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
2027 TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
2029 /* Lay out the type: set its alignment, size, etc. */
2033 /* Find the best machine mode to use when referencing a bit field of length
2034 BITSIZE bits starting at BITPOS.
2036 The underlying object is known to be aligned to a boundary of ALIGN bits.
2037 If LARGEST_MODE is not VOIDmode, it means that we should not use a mode
2038 larger than LARGEST_MODE (usually SImode).
2040 If no mode meets all these conditions, we return VOIDmode. Otherwise, if
2041 VOLATILEP is true or SLOW_BYTE_ACCESS is false, we return the smallest
2042 mode meeting these conditions.
2044 Otherwise (VOLATILEP is false and SLOW_BYTE_ACCESS is true), we return
2045 the largest mode (but a mode no wider than UNITS_PER_WORD) that meets
2046 all the conditions. */
2049 get_best_mode (bitsize, bitpos, align, largest_mode, volatilep)
2050 int bitsize, bitpos;
2052 enum machine_mode largest_mode;
2055 enum machine_mode mode;
2056 unsigned int unit = 0;
2058 /* Find the narrowest integer mode that contains the bit field. */
2059 for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
2060 mode = GET_MODE_WIDER_MODE (mode))
2062 unit = GET_MODE_BITSIZE (mode);
2063 if ((bitpos % unit) + bitsize <= unit)
2067 if (mode == VOIDmode
2068 /* It is tempting to omit the following line
2069 if STRICT_ALIGNMENT is true.
2070 But that is incorrect, since if the bitfield uses part of 3 bytes
2071 and we use a 4-byte mode, we could get a spurious segv
2072 if the extra 4th byte is past the end of memory.
2073 (Though at least one Unix compiler ignores this problem:
2074 that on the Sequent 386 machine. */
2075 || MIN (unit, BIGGEST_ALIGNMENT) > align
2076 || (largest_mode != VOIDmode && unit > GET_MODE_BITSIZE (largest_mode)))
2079 if (SLOW_BYTE_ACCESS && ! volatilep)
2081 enum machine_mode wide_mode = VOIDmode, tmode;
2083 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT); tmode != VOIDmode;
2084 tmode = GET_MODE_WIDER_MODE (tmode))
2086 unit = GET_MODE_BITSIZE (tmode);
2087 if (bitpos / unit == (bitpos + bitsize - 1) / unit
2088 && unit <= BITS_PER_WORD
2089 && unit <= MIN (align, BIGGEST_ALIGNMENT)
2090 && (largest_mode == VOIDmode
2091 || unit <= GET_MODE_BITSIZE (largest_mode)))
2095 if (wide_mode != VOIDmode)
2102 #include "gt-stor-layout.h"