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, 2003, 2004 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
25 #include "coretypes.h"
36 #include "langhooks.h"
38 /* Set to one when set_sizetype has been called. */
39 static int sizetype_set
;
41 /* List of types created before set_sizetype has been called. We do not
42 make this a GGC root since we want these nodes to be reclaimed. */
43 static tree early_type_list
;
45 /* Data type for the expressions representing sizes of data types.
46 It is the first integer type laid out. */
47 tree sizetype_tab
[(int) TYPE_KIND_LAST
];
49 /* If nonzero, this is an upper limit on alignment of structure fields.
50 The value is measured in bits. */
51 unsigned int maximum_field_alignment
;
53 /* If nonzero, the alignment of a bitstring or (power-)set value, in bits.
54 May be overridden by front-ends. */
55 unsigned int set_alignment
= 0;
57 /* Nonzero if all REFERENCE_TYPEs are internal and hence should be
58 allocated in Pmode, not ptr_mode. Set only by internal_reference_types
59 called only by a front end. */
60 static int reference_types_internal
= 0;
62 static void finalize_record_size (record_layout_info
);
63 static void finalize_type_size (tree
);
64 static void place_union_field (record_layout_info
, tree
);
65 #if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED)
66 static int excess_unit_span (HOST_WIDE_INT
, HOST_WIDE_INT
, HOST_WIDE_INT
,
69 static void force_type_save_exprs_1 (tree
);
70 extern void debug_rli (record_layout_info
);
72 /* SAVE_EXPRs for sizes of types and decls, waiting to be expanded. */
74 static GTY(()) tree pending_sizes
;
76 /* Nonzero means cannot safely call expand_expr now,
77 so put variable sizes onto `pending_sizes' instead. */
79 int immediate_size_expand
;
81 /* Show that REFERENCE_TYPES are internal and should be Pmode. Called only
85 internal_reference_types (void)
87 reference_types_internal
= 1;
90 /* Get a list of all the objects put on the pending sizes list. */
93 get_pending_sizes (void)
95 tree chain
= pending_sizes
;
101 /* Add EXPR to the pending sizes list. */
104 put_pending_size (tree expr
)
106 /* Strip any simple arithmetic from EXPR to see if it has an underlying
108 expr
= skip_simple_arithmetic (expr
);
110 if (TREE_CODE (expr
) == SAVE_EXPR
)
111 pending_sizes
= tree_cons (NULL_TREE
, expr
, pending_sizes
);
114 /* Put a chain of objects into the pending sizes list, which must be
118 put_pending_sizes (tree chain
)
123 pending_sizes
= chain
;
126 /* Given a size SIZE that may not be a constant, return a SAVE_EXPR
127 to serve as the actual size-expression for a type or decl. */
130 variable_size (tree size
)
134 /* If the language-processor is to take responsibility for variable-sized
135 items (e.g., languages which have elaboration procedures like Ada),
136 just return SIZE unchanged. Likewise for self-referential sizes and
138 if (TREE_CONSTANT (size
)
139 || lang_hooks
.decls
.global_bindings_p () < 0
140 || CONTAINS_PLACEHOLDER_P (size
))
143 size
= save_expr (size
);
145 /* If an array with a variable number of elements is declared, and
146 the elements require destruction, we will emit a cleanup for the
147 array. That cleanup is run both on normal exit from the block
148 and in the exception-handler for the block. Normally, when code
149 is used in both ordinary code and in an exception handler it is
150 `unsaved', i.e., all SAVE_EXPRs are recalculated. However, we do
151 not wish to do that here; the array-size is the same in both
153 save
= skip_simple_arithmetic (size
);
154 if (TREE_CODE (save
) == SAVE_EXPR
)
155 SAVE_EXPR_PERSISTENT_P (save
) = 1;
157 if (!immediate_size_expand
&& cfun
&& cfun
->x_dont_save_pending_sizes_p
)
158 /* The front-end doesn't want us to keep a list of the expressions
159 that determine sizes for variable size objects. Trust it. */
162 if (lang_hooks
.decls
.global_bindings_p ())
164 if (TREE_CONSTANT (size
))
165 error ("type size can't be explicitly evaluated");
167 error ("variable-size type declared outside of any function");
169 return size_one_node
;
172 if (immediate_size_expand
)
173 expand_expr (save
, const0_rtx
, VOIDmode
, 0);
175 put_pending_size (save
);
180 /* Given a type T, force elaboration of any SAVE_EXPRs used in the definition
184 force_type_save_exprs (tree t
)
188 switch (TREE_CODE (t
))
196 /* It's probably overly-conservative to force elaboration of bounds and
197 also the sizes, but it's better to be safe than sorry. */
198 force_type_save_exprs_1 (TYPE_MIN_VALUE (TYPE_DOMAIN (t
)));
199 force_type_save_exprs_1 (TYPE_MAX_VALUE (TYPE_DOMAIN (t
)));
204 case QUAL_UNION_TYPE
:
205 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
206 if (TREE_CODE (field
) == FIELD_DECL
)
208 force_type_save_exprs (TREE_TYPE (field
));
209 force_type_save_exprs_1 (DECL_FIELD_OFFSET (field
));
217 force_type_save_exprs_1 (TYPE_SIZE (t
));
218 force_type_save_exprs_1 (TYPE_SIZE_UNIT (t
));
221 /* Utility routine of above, to verify that SIZE has been elaborated and
222 do so it it is a SAVE_EXPR and has not been. */
225 force_type_save_exprs_1 (tree size
)
228 && (size
= skip_simple_arithmetic (size
))
229 && TREE_CODE (size
) == SAVE_EXPR
230 && !SAVE_EXPR_RTL (size
))
231 expand_expr (size
, NULL_RTX
, VOIDmode
, 0);
234 #ifndef MAX_FIXED_MODE_SIZE
235 #define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (DImode)
238 /* Return the machine mode to use for a nonscalar of SIZE bits. The
239 mode must be in class CLASS, and have exactly that many value bits;
240 it may have padding as well. If LIMIT is nonzero, modes of wider
241 than MAX_FIXED_MODE_SIZE will not be used. */
244 mode_for_size (unsigned int size
, enum mode_class
class, int limit
)
246 enum machine_mode mode
;
248 if (limit
&& size
> MAX_FIXED_MODE_SIZE
)
251 /* Get the first mode which has this size, in the specified class. */
252 for (mode
= GET_CLASS_NARROWEST_MODE (class); mode
!= VOIDmode
;
253 mode
= GET_MODE_WIDER_MODE (mode
))
254 if (GET_MODE_PRECISION (mode
) == size
)
260 /* Similar, except passed a tree node. */
263 mode_for_size_tree (tree size
, enum mode_class
class, int limit
)
265 if (TREE_CODE (size
) != INTEGER_CST
266 || TREE_OVERFLOW (size
)
267 /* What we really want to say here is that the size can fit in a
268 host integer, but we know there's no way we'd find a mode for
269 this many bits, so there's no point in doing the precise test. */
270 || compare_tree_int (size
, 1000) > 0)
273 return mode_for_size (tree_low_cst (size
, 1), class, limit
);
276 /* Similar, but never return BLKmode; return the narrowest mode that
277 contains at least the requested number of value bits. */
280 smallest_mode_for_size (unsigned int size
, enum mode_class
class)
282 enum machine_mode mode
;
284 /* Get the first mode which has at least this size, in the
286 for (mode
= GET_CLASS_NARROWEST_MODE (class); mode
!= VOIDmode
;
287 mode
= GET_MODE_WIDER_MODE (mode
))
288 if (GET_MODE_PRECISION (mode
) >= size
)
294 /* Find an integer mode of the exact same size, or BLKmode on failure. */
297 int_mode_for_mode (enum machine_mode mode
)
299 switch (GET_MODE_CLASS (mode
))
302 case MODE_PARTIAL_INT
:
305 case MODE_COMPLEX_INT
:
306 case MODE_COMPLEX_FLOAT
:
308 case MODE_VECTOR_INT
:
309 case MODE_VECTOR_FLOAT
:
310 mode
= mode_for_size (GET_MODE_BITSIZE (mode
), MODE_INT
, 0);
317 /* ... fall through ... */
327 /* Return the alignment of MODE. This will be bounded by 1 and
328 BIGGEST_ALIGNMENT. */
331 get_mode_alignment (enum machine_mode mode
)
333 return MIN (BIGGEST_ALIGNMENT
, MAX (1, mode_base_align
[mode
]*BITS_PER_UNIT
));
336 /* Return the value of VALUE, rounded up to a multiple of DIVISOR.
337 This can only be applied to objects of a sizetype. */
340 round_up (tree value
, int divisor
)
342 tree arg
= size_int_type (divisor
, TREE_TYPE (value
));
344 return size_binop (MULT_EXPR
, size_binop (CEIL_DIV_EXPR
, value
, arg
), arg
);
347 /* Likewise, but round down. */
350 round_down (tree value
, int divisor
)
352 tree arg
= size_int_type (divisor
, TREE_TYPE (value
));
354 return size_binop (MULT_EXPR
, size_binop (FLOOR_DIV_EXPR
, value
, arg
), arg
);
357 /* Subroutine of layout_decl: Force alignment required for the data type.
358 But if the decl itself wants greater alignment, don't override that. */
361 do_type_align (tree type
, tree decl
)
363 if (TYPE_ALIGN (type
) > DECL_ALIGN (decl
))
365 DECL_ALIGN (decl
) = TYPE_ALIGN (type
);
366 if (TREE_CODE (decl
) == FIELD_DECL
)
367 DECL_USER_ALIGN (decl
) = TYPE_USER_ALIGN (type
);
371 /* Set the size, mode and alignment of a ..._DECL node.
372 TYPE_DECL does need this for C++.
373 Note that LABEL_DECL and CONST_DECL nodes do not need this,
374 and FUNCTION_DECL nodes have them set up in a special (and simple) way.
375 Don't call layout_decl for them.
377 KNOWN_ALIGN is the amount of alignment we can assume this
378 decl has with no special effort. It is relevant only for FIELD_DECLs
379 and depends on the previous fields.
380 All that matters about KNOWN_ALIGN is which powers of 2 divide it.
381 If KNOWN_ALIGN is 0, it means, "as much alignment as you like":
382 the record will be aligned to suit. */
385 layout_decl (tree decl
, unsigned int known_align
)
387 tree type
= TREE_TYPE (decl
);
388 enum tree_code code
= TREE_CODE (decl
);
391 if (code
== CONST_DECL
)
393 else if (code
!= VAR_DECL
&& code
!= PARM_DECL
&& code
!= RESULT_DECL
394 && code
!= TYPE_DECL
&& code
!= FIELD_DECL
)
397 rtl
= DECL_RTL_IF_SET (decl
);
399 if (type
== error_mark_node
)
400 type
= void_type_node
;
402 /* Usually the size and mode come from the data type without change,
403 however, the front-end may set the explicit width of the field, so its
404 size may not be the same as the size of its type. This happens with
405 bitfields, of course (an `int' bitfield may be only 2 bits, say), but it
406 also happens with other fields. For example, the C++ front-end creates
407 zero-sized fields corresponding to empty base classes, and depends on
408 layout_type setting DECL_FIELD_BITPOS correctly for the field. Set the
409 size in bytes from the size in bits. If we have already set the mode,
410 don't set it again since we can be called twice for FIELD_DECLs. */
412 DECL_UNSIGNED (decl
) = TYPE_UNSIGNED (type
);
413 if (DECL_MODE (decl
) == VOIDmode
)
414 DECL_MODE (decl
) = TYPE_MODE (type
);
416 if (DECL_SIZE (decl
) == 0)
418 DECL_SIZE (decl
) = TYPE_SIZE (type
);
419 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (type
);
421 else if (DECL_SIZE_UNIT (decl
) == 0)
422 DECL_SIZE_UNIT (decl
)
423 = convert (sizetype
, size_binop (CEIL_DIV_EXPR
, DECL_SIZE (decl
),
426 if (code
!= FIELD_DECL
)
427 /* For non-fields, update the alignment from the type. */
428 do_type_align (type
, decl
);
430 /* For fields, it's a bit more complicated... */
432 bool old_user_align
= DECL_USER_ALIGN (decl
);
434 if (DECL_BIT_FIELD (decl
))
436 DECL_BIT_FIELD_TYPE (decl
) = type
;
438 /* A zero-length bit-field affects the alignment of the next
440 if (integer_zerop (DECL_SIZE (decl
))
441 && ! DECL_PACKED (decl
)
442 && ! targetm
.ms_bitfield_layout_p (DECL_FIELD_CONTEXT (decl
)))
444 #ifdef PCC_BITFIELD_TYPE_MATTERS
445 if (PCC_BITFIELD_TYPE_MATTERS
)
446 do_type_align (type
, decl
);
450 #ifdef EMPTY_FIELD_BOUNDARY
451 if (EMPTY_FIELD_BOUNDARY
> DECL_ALIGN (decl
))
453 DECL_ALIGN (decl
) = EMPTY_FIELD_BOUNDARY
;
454 DECL_USER_ALIGN (decl
) = 0;
460 /* See if we can use an ordinary integer mode for a bit-field.
461 Conditions are: a fixed size that is correct for another mode
462 and occupying a complete byte or bytes on proper boundary. */
463 if (TYPE_SIZE (type
) != 0
464 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
465 && GET_MODE_CLASS (TYPE_MODE (type
)) == MODE_INT
)
467 enum machine_mode xmode
468 = mode_for_size_tree (DECL_SIZE (decl
), MODE_INT
, 1);
472 || known_align
>= GET_MODE_ALIGNMENT (xmode
)))
474 DECL_ALIGN (decl
) = MAX (GET_MODE_ALIGNMENT (xmode
),
476 DECL_MODE (decl
) = xmode
;
477 DECL_BIT_FIELD (decl
) = 0;
481 /* Turn off DECL_BIT_FIELD if we won't need it set. */
482 if (TYPE_MODE (type
) == BLKmode
&& DECL_MODE (decl
) == BLKmode
483 && known_align
>= TYPE_ALIGN (type
)
484 && DECL_ALIGN (decl
) >= TYPE_ALIGN (type
))
485 DECL_BIT_FIELD (decl
) = 0;
487 else if (DECL_PACKED (decl
) && DECL_USER_ALIGN (decl
))
488 /* Don't touch DECL_ALIGN. For other packed fields, go ahead and
489 round up; we'll reduce it again below. We want packing to
490 supersede USER_ALIGN inherited from the type, but defer to
491 alignment explicitly specified on the field decl. */;
493 do_type_align (type
, decl
);
495 /* If the field is of variable size, we can't misalign it since we
496 have no way to make a temporary to align the result. But this
497 isn't an issue if the decl is not addressable. Likewise if it
500 Note that do_type_align may set DECL_USER_ALIGN, so we need to
501 check old_user_align instead. */
502 if (DECL_PACKED (decl
)
504 && (DECL_NONADDRESSABLE_P (decl
)
505 || DECL_SIZE_UNIT (decl
) == 0
506 || TREE_CODE (DECL_SIZE_UNIT (decl
)) == INTEGER_CST
))
507 DECL_ALIGN (decl
) = MIN (DECL_ALIGN (decl
), BITS_PER_UNIT
);
509 if (! DECL_USER_ALIGN (decl
) && ! DECL_PACKED (decl
))
511 /* Some targets (i.e. i386, VMS) limit struct field alignment
512 to a lower boundary than alignment of variables unless
513 it was overridden by attribute aligned. */
514 #ifdef BIGGEST_FIELD_ALIGNMENT
516 = MIN (DECL_ALIGN (decl
), (unsigned) BIGGEST_FIELD_ALIGNMENT
);
518 #ifdef ADJUST_FIELD_ALIGN
519 DECL_ALIGN (decl
) = ADJUST_FIELD_ALIGN (decl
, DECL_ALIGN (decl
));
523 /* Should this be controlled by DECL_USER_ALIGN, too? */
524 if (maximum_field_alignment
!= 0)
525 DECL_ALIGN (decl
) = MIN (DECL_ALIGN (decl
), maximum_field_alignment
);
528 /* Evaluate nonconstant size only once, either now or as soon as safe. */
529 if (DECL_SIZE (decl
) != 0 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
530 DECL_SIZE (decl
) = variable_size (DECL_SIZE (decl
));
531 if (DECL_SIZE_UNIT (decl
) != 0
532 && TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
)
533 DECL_SIZE_UNIT (decl
) = variable_size (DECL_SIZE_UNIT (decl
));
535 /* If requested, warn about definitions of large data objects. */
537 && (code
== VAR_DECL
|| code
== PARM_DECL
)
538 && ! DECL_EXTERNAL (decl
))
540 tree size
= DECL_SIZE_UNIT (decl
);
542 if (size
!= 0 && TREE_CODE (size
) == INTEGER_CST
543 && compare_tree_int (size
, larger_than_size
) > 0)
545 int size_as_int
= TREE_INT_CST_LOW (size
);
547 if (compare_tree_int (size
, size_as_int
) == 0)
548 warning ("%Jsize of '%D' is %d bytes", decl
, decl
, size_as_int
);
550 warning ("%Jsize of '%D' is larger than %d bytes",
551 decl
, decl
, larger_than_size
);
555 /* If the RTL was already set, update its mode and mem attributes. */
558 PUT_MODE (rtl
, DECL_MODE (decl
));
559 SET_DECL_RTL (decl
, 0);
560 set_mem_attributes (rtl
, decl
, 1);
561 SET_DECL_RTL (decl
, rtl
);
565 /* Hook for a front-end function that can modify the record layout as needed
566 immediately before it is finalized. */
568 void (*lang_adjust_rli
) (record_layout_info
) = 0;
571 set_lang_adjust_rli (void (*f
) (record_layout_info
))
576 /* Begin laying out type T, which may be a RECORD_TYPE, UNION_TYPE, or
577 QUAL_UNION_TYPE. Return a pointer to a struct record_layout_info which
578 is to be passed to all other layout functions for this record. It is the
579 responsibility of the caller to call `free' for the storage returned.
580 Note that garbage collection is not permitted until we finish laying
584 start_record_layout (tree t
)
586 record_layout_info rli
= xmalloc (sizeof (struct record_layout_info_s
));
590 /* If the type has a minimum specified alignment (via an attribute
591 declaration, for example) use it -- otherwise, start with a
592 one-byte alignment. */
593 rli
->record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (t
));
594 rli
->unpacked_align
= rli
->record_align
;
595 rli
->offset_align
= MAX (rli
->record_align
, BIGGEST_ALIGNMENT
);
597 #ifdef STRUCTURE_SIZE_BOUNDARY
598 /* Packed structures don't need to have minimum size. */
599 if (! TYPE_PACKED (t
))
600 rli
->record_align
= MAX (rli
->record_align
, (unsigned) STRUCTURE_SIZE_BOUNDARY
);
603 rli
->offset
= size_zero_node
;
604 rli
->bitpos
= bitsize_zero_node
;
606 rli
->pending_statics
= 0;
607 rli
->packed_maybe_necessary
= 0;
612 /* These four routines perform computations that convert between
613 the offset/bitpos forms and byte and bit offsets. */
616 bit_from_pos (tree offset
, tree bitpos
)
618 return size_binop (PLUS_EXPR
, bitpos
,
619 size_binop (MULT_EXPR
, convert (bitsizetype
, offset
),
624 byte_from_pos (tree offset
, tree bitpos
)
626 return size_binop (PLUS_EXPR
, offset
,
628 size_binop (TRUNC_DIV_EXPR
, bitpos
,
629 bitsize_unit_node
)));
633 pos_from_bit (tree
*poffset
, tree
*pbitpos
, unsigned int off_align
,
636 *poffset
= size_binop (MULT_EXPR
,
638 size_binop (FLOOR_DIV_EXPR
, pos
,
639 bitsize_int (off_align
))),
640 size_int (off_align
/ BITS_PER_UNIT
));
641 *pbitpos
= size_binop (FLOOR_MOD_EXPR
, pos
, bitsize_int (off_align
));
644 /* Given a pointer to bit and byte offsets and an offset alignment,
645 normalize the offsets so they are within the alignment. */
648 normalize_offset (tree
*poffset
, tree
*pbitpos
, unsigned int off_align
)
650 /* If the bit position is now larger than it should be, adjust it
652 if (compare_tree_int (*pbitpos
, off_align
) >= 0)
654 tree extra_aligns
= size_binop (FLOOR_DIV_EXPR
, *pbitpos
,
655 bitsize_int (off_align
));
658 = size_binop (PLUS_EXPR
, *poffset
,
659 size_binop (MULT_EXPR
, convert (sizetype
, extra_aligns
),
660 size_int (off_align
/ BITS_PER_UNIT
)));
663 = size_binop (FLOOR_MOD_EXPR
, *pbitpos
, bitsize_int (off_align
));
667 /* Print debugging information about the information in RLI. */
670 debug_rli (record_layout_info rli
)
672 print_node_brief (stderr
, "type", rli
->t
, 0);
673 print_node_brief (stderr
, "\noffset", rli
->offset
, 0);
674 print_node_brief (stderr
, " bitpos", rli
->bitpos
, 0);
676 fprintf (stderr
, "\naligns: rec = %u, unpack = %u, off = %u\n",
677 rli
->record_align
, rli
->unpacked_align
,
679 if (rli
->packed_maybe_necessary
)
680 fprintf (stderr
, "packed may be necessary\n");
682 if (rli
->pending_statics
)
684 fprintf (stderr
, "pending statics:\n");
685 debug_tree (rli
->pending_statics
);
689 /* Given an RLI with a possibly-incremented BITPOS, adjust OFFSET and
690 BITPOS if necessary to keep BITPOS below OFFSET_ALIGN. */
693 normalize_rli (record_layout_info rli
)
695 normalize_offset (&rli
->offset
, &rli
->bitpos
, rli
->offset_align
);
698 /* Returns the size in bytes allocated so far. */
701 rli_size_unit_so_far (record_layout_info rli
)
703 return byte_from_pos (rli
->offset
, rli
->bitpos
);
706 /* Returns the size in bits allocated so far. */
709 rli_size_so_far (record_layout_info rli
)
711 return bit_from_pos (rli
->offset
, rli
->bitpos
);
714 /* FIELD is about to be added to RLI->T. The alignment (in bits) of
715 the next available location is given by KNOWN_ALIGN. Update the
716 variable alignment fields in RLI, and return the alignment to give
720 update_alignment_for_field (record_layout_info rli
, tree field
,
721 unsigned int known_align
)
723 /* The alignment required for FIELD. */
724 unsigned int desired_align
;
725 /* The type of this field. */
726 tree type
= TREE_TYPE (field
);
727 /* True if the field was explicitly aligned by the user. */
731 /* Lay out the field so we know what alignment it needs. */
732 layout_decl (field
, known_align
);
733 desired_align
= DECL_ALIGN (field
);
734 user_align
= DECL_USER_ALIGN (field
);
736 is_bitfield
= (type
!= error_mark_node
737 && DECL_BIT_FIELD_TYPE (field
)
738 && ! integer_zerop (TYPE_SIZE (type
)));
740 /* Record must have at least as much alignment as any field.
741 Otherwise, the alignment of the field within the record is
743 if (is_bitfield
&& targetm
.ms_bitfield_layout_p (rli
->t
))
745 /* Here, the alignment of the underlying type of a bitfield can
746 affect the alignment of a record; even a zero-sized field
747 can do this. The alignment should be to the alignment of
748 the type, except that for zero-size bitfields this only
749 applies if there was an immediately prior, nonzero-size
750 bitfield. (That's the way it is, experimentally.) */
751 if (! integer_zerop (DECL_SIZE (field
))
752 ? ! DECL_PACKED (field
)
754 && DECL_BIT_FIELD_TYPE (rli
->prev_field
)
755 && ! integer_zerop (DECL_SIZE (rli
->prev_field
))))
757 unsigned int type_align
= TYPE_ALIGN (type
);
758 type_align
= MAX (type_align
, desired_align
);
759 if (maximum_field_alignment
!= 0)
760 type_align
= MIN (type_align
, maximum_field_alignment
);
761 rli
->record_align
= MAX (rli
->record_align
, type_align
);
762 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
765 #ifdef PCC_BITFIELD_TYPE_MATTERS
766 else if (is_bitfield
&& PCC_BITFIELD_TYPE_MATTERS
)
768 /* Named bit-fields cause the entire structure to have the
769 alignment implied by their type. Some targets also apply the same
770 rules to unnamed bitfields. */
771 if (DECL_NAME (field
) != 0
772 || targetm
.align_anon_bitfield ())
774 unsigned int type_align
= TYPE_ALIGN (type
);
776 #ifdef ADJUST_FIELD_ALIGN
777 if (! TYPE_USER_ALIGN (type
))
778 type_align
= ADJUST_FIELD_ALIGN (field
, type_align
);
781 if (maximum_field_alignment
!= 0)
782 type_align
= MIN (type_align
, maximum_field_alignment
);
783 else if (DECL_PACKED (field
))
784 type_align
= MIN (type_align
, BITS_PER_UNIT
);
786 /* The alignment of the record is increased to the maximum
787 of the current alignment, the alignment indicated on the
788 field (i.e., the alignment specified by an __aligned__
789 attribute), and the alignment indicated by the type of
791 rli
->record_align
= MAX (rli
->record_align
, desired_align
);
792 rli
->record_align
= MAX (rli
->record_align
, type_align
);
795 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
796 user_align
|= TYPE_USER_ALIGN (type
);
802 rli
->record_align
= MAX (rli
->record_align
, desired_align
);
803 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
806 TYPE_USER_ALIGN (rli
->t
) |= user_align
;
808 return desired_align
;
811 /* Called from place_field to handle unions. */
814 place_union_field (record_layout_info rli
, tree field
)
816 update_alignment_for_field (rli
, field
, /*known_align=*/0);
818 DECL_FIELD_OFFSET (field
) = size_zero_node
;
819 DECL_FIELD_BIT_OFFSET (field
) = bitsize_zero_node
;
820 SET_DECL_OFFSET_ALIGN (field
, BIGGEST_ALIGNMENT
);
822 /* We assume the union's size will be a multiple of a byte so we don't
823 bother with BITPOS. */
824 if (TREE_CODE (rli
->t
) == UNION_TYPE
)
825 rli
->offset
= size_binop (MAX_EXPR
, rli
->offset
, DECL_SIZE_UNIT (field
));
826 else if (TREE_CODE (rli
->t
) == QUAL_UNION_TYPE
)
827 rli
->offset
= fold (build (COND_EXPR
, sizetype
,
828 DECL_QUALIFIER (field
),
829 DECL_SIZE_UNIT (field
), rli
->offset
));
832 #if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED)
833 /* A bitfield of SIZE with a required access alignment of ALIGN is allocated
834 at BYTE_OFFSET / BIT_OFFSET. Return nonzero if the field would span more
835 units of alignment than the underlying TYPE. */
837 excess_unit_span (HOST_WIDE_INT byte_offset
, HOST_WIDE_INT bit_offset
,
838 HOST_WIDE_INT size
, HOST_WIDE_INT align
, tree type
)
840 /* Note that the calculation of OFFSET might overflow; we calculate it so
841 that we still get the right result as long as ALIGN is a power of two. */
842 unsigned HOST_WIDE_INT offset
= byte_offset
* BITS_PER_UNIT
+ bit_offset
;
844 offset
= offset
% align
;
845 return ((offset
+ size
+ align
- 1) / align
846 > ((unsigned HOST_WIDE_INT
) tree_low_cst (TYPE_SIZE (type
), 1)
851 /* RLI contains information about the layout of a RECORD_TYPE. FIELD
852 is a FIELD_DECL to be added after those fields already present in
853 T. (FIELD is not actually added to the TYPE_FIELDS list here;
854 callers that desire that behavior must manually perform that step.) */
857 place_field (record_layout_info rli
, tree field
)
859 /* The alignment required for FIELD. */
860 unsigned int desired_align
;
861 /* The alignment FIELD would have if we just dropped it into the
862 record as it presently stands. */
863 unsigned int known_align
;
864 unsigned int actual_align
;
865 /* The type of this field. */
866 tree type
= TREE_TYPE (field
);
868 if (TREE_CODE (field
) == ERROR_MARK
|| TREE_CODE (type
) == ERROR_MARK
)
871 /* If FIELD is static, then treat it like a separate variable, not
872 really like a structure field. If it is a FUNCTION_DECL, it's a
873 method. In both cases, all we do is lay out the decl, and we do
874 it *after* the record is laid out. */
875 if (TREE_CODE (field
) == VAR_DECL
)
877 rli
->pending_statics
= tree_cons (NULL_TREE
, field
,
878 rli
->pending_statics
);
882 /* Enumerators and enum types which are local to this class need not
883 be laid out. Likewise for initialized constant fields. */
884 else if (TREE_CODE (field
) != FIELD_DECL
)
887 /* Unions are laid out very differently than records, so split
888 that code off to another function. */
889 else if (TREE_CODE (rli
->t
) != RECORD_TYPE
)
891 place_union_field (rli
, field
);
895 /* Work out the known alignment so far. Note that A & (-A) is the
896 value of the least-significant bit in A that is one. */
897 if (! integer_zerop (rli
->bitpos
))
898 known_align
= (tree_low_cst (rli
->bitpos
, 1)
899 & - tree_low_cst (rli
->bitpos
, 1));
900 else if (integer_zerop (rli
->offset
))
901 known_align
= BIGGEST_ALIGNMENT
;
902 else if (host_integerp (rli
->offset
, 1))
903 known_align
= (BITS_PER_UNIT
904 * (tree_low_cst (rli
->offset
, 1)
905 & - tree_low_cst (rli
->offset
, 1)));
907 known_align
= rli
->offset_align
;
909 desired_align
= update_alignment_for_field (rli
, field
, known_align
);
911 if (warn_packed
&& DECL_PACKED (field
))
913 if (known_align
>= TYPE_ALIGN (type
))
915 if (TYPE_ALIGN (type
) > desired_align
)
917 if (STRICT_ALIGNMENT
)
918 warning ("%Jpacked attribute causes inefficient alignment "
919 "for '%D'", field
, field
);
921 warning ("%Jpacked attribute is unnecessary for '%D'",
926 rli
->packed_maybe_necessary
= 1;
929 /* Does this field automatically have alignment it needs by virtue
930 of the fields that precede it and the record's own alignment? */
931 if (known_align
< desired_align
)
933 /* No, we need to skip space before this field.
934 Bump the cumulative size to multiple of field alignment. */
937 warning ("%Jpadding struct to align '%D'", field
, field
);
939 /* If the alignment is still within offset_align, just align
941 if (desired_align
< rli
->offset_align
)
942 rli
->bitpos
= round_up (rli
->bitpos
, desired_align
);
945 /* First adjust OFFSET by the partial bits, then align. */
947 = size_binop (PLUS_EXPR
, rli
->offset
,
949 size_binop (CEIL_DIV_EXPR
, rli
->bitpos
,
950 bitsize_unit_node
)));
951 rli
->bitpos
= bitsize_zero_node
;
953 rli
->offset
= round_up (rli
->offset
, desired_align
/ BITS_PER_UNIT
);
956 if (! TREE_CONSTANT (rli
->offset
))
957 rli
->offset_align
= desired_align
;
961 /* Handle compatibility with PCC. Note that if the record has any
962 variable-sized fields, we need not worry about compatibility. */
963 #ifdef PCC_BITFIELD_TYPE_MATTERS
964 if (PCC_BITFIELD_TYPE_MATTERS
965 && ! targetm
.ms_bitfield_layout_p (rli
->t
)
966 && TREE_CODE (field
) == FIELD_DECL
967 && type
!= error_mark_node
968 && DECL_BIT_FIELD (field
)
969 && ! DECL_PACKED (field
)
970 && maximum_field_alignment
== 0
971 && ! integer_zerop (DECL_SIZE (field
))
972 && host_integerp (DECL_SIZE (field
), 1)
973 && host_integerp (rli
->offset
, 1)
974 && host_integerp (TYPE_SIZE (type
), 1))
976 unsigned int type_align
= TYPE_ALIGN (type
);
977 tree dsize
= DECL_SIZE (field
);
978 HOST_WIDE_INT field_size
= tree_low_cst (dsize
, 1);
979 HOST_WIDE_INT offset
= tree_low_cst (rli
->offset
, 0);
980 HOST_WIDE_INT bit_offset
= tree_low_cst (rli
->bitpos
, 0);
982 #ifdef ADJUST_FIELD_ALIGN
983 if (! TYPE_USER_ALIGN (type
))
984 type_align
= ADJUST_FIELD_ALIGN (field
, type_align
);
987 /* A bit field may not span more units of alignment of its type
988 than its type itself. Advance to next boundary if necessary. */
989 if (excess_unit_span (offset
, bit_offset
, field_size
, type_align
, type
))
990 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
992 TYPE_USER_ALIGN (rli
->t
) |= TYPE_USER_ALIGN (type
);
996 #ifdef BITFIELD_NBYTES_LIMITED
997 if (BITFIELD_NBYTES_LIMITED
998 && ! targetm
.ms_bitfield_layout_p (rli
->t
)
999 && TREE_CODE (field
) == FIELD_DECL
1000 && type
!= error_mark_node
1001 && DECL_BIT_FIELD_TYPE (field
)
1002 && ! DECL_PACKED (field
)
1003 && ! integer_zerop (DECL_SIZE (field
))
1004 && host_integerp (DECL_SIZE (field
), 1)
1005 && host_integerp (rli
->offset
, 1)
1006 && host_integerp (TYPE_SIZE (type
), 1))
1008 unsigned int type_align
= TYPE_ALIGN (type
);
1009 tree dsize
= DECL_SIZE (field
);
1010 HOST_WIDE_INT field_size
= tree_low_cst (dsize
, 1);
1011 HOST_WIDE_INT offset
= tree_low_cst (rli
->offset
, 0);
1012 HOST_WIDE_INT bit_offset
= tree_low_cst (rli
->bitpos
, 0);
1014 #ifdef ADJUST_FIELD_ALIGN
1015 if (! TYPE_USER_ALIGN (type
))
1016 type_align
= ADJUST_FIELD_ALIGN (field
, type_align
);
1019 if (maximum_field_alignment
!= 0)
1020 type_align
= MIN (type_align
, maximum_field_alignment
);
1021 /* ??? This test is opposite the test in the containing if
1022 statement, so this code is unreachable currently. */
1023 else if (DECL_PACKED (field
))
1024 type_align
= MIN (type_align
, BITS_PER_UNIT
);
1026 /* A bit field may not span the unit of alignment of its type.
1027 Advance to next boundary if necessary. */
1028 if (excess_unit_span (offset
, bit_offset
, field_size
, type_align
, type
))
1029 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1031 TYPE_USER_ALIGN (rli
->t
) |= TYPE_USER_ALIGN (type
);
1035 /* See the docs for TARGET_MS_BITFIELD_LAYOUT_P for details.
1037 When a bit field is inserted into a packed record, the whole
1038 size of the underlying type is used by one or more same-size
1039 adjacent bitfields. (That is, if its long:3, 32 bits is
1040 used in the record, and any additional adjacent long bitfields are
1041 packed into the same chunk of 32 bits. However, if the size
1042 changes, a new field of that size is allocated.) In an unpacked
1043 record, this is the same as using alignment, but not equivalent
1046 Note: for compatibility, we use the type size, not the type alignment
1047 to determine alignment, since that matches the documentation */
1049 if (targetm
.ms_bitfield_layout_p (rli
->t
)
1050 && ((DECL_BIT_FIELD_TYPE (field
) && ! DECL_PACKED (field
))
1051 || (rli
->prev_field
&& ! DECL_PACKED (rli
->prev_field
))))
1053 /* At this point, either the prior or current are bitfields,
1054 (possibly both), and we're dealing with MS packing. */
1055 tree prev_saved
= rli
->prev_field
;
1057 /* Is the prior field a bitfield? If so, handle "runs" of same
1058 type size fields. */
1059 if (rli
->prev_field
/* necessarily a bitfield if it exists. */)
1061 /* If both are bitfields, nonzero, and the same size, this is
1062 the middle of a run. Zero declared size fields are special
1063 and handled as "end of run". (Note: it's nonzero declared
1064 size, but equal type sizes!) (Since we know that both
1065 the current and previous fields are bitfields by the
1066 time we check it, DECL_SIZE must be present for both.) */
1067 if (DECL_BIT_FIELD_TYPE (field
)
1068 && !integer_zerop (DECL_SIZE (field
))
1069 && !integer_zerop (DECL_SIZE (rli
->prev_field
))
1070 && host_integerp (DECL_SIZE (rli
->prev_field
), 0)
1071 && host_integerp (TYPE_SIZE (type
), 0)
1072 && simple_cst_equal (TYPE_SIZE (type
),
1073 TYPE_SIZE (TREE_TYPE (rli
->prev_field
))))
1075 /* We're in the middle of a run of equal type size fields; make
1076 sure we realign if we run out of bits. (Not decl size,
1078 HOST_WIDE_INT bitsize
= tree_low_cst (DECL_SIZE (field
), 0);
1080 if (rli
->remaining_in_alignment
< bitsize
)
1082 /* out of bits; bump up to next 'word'. */
1083 rli
->offset
= DECL_FIELD_OFFSET (rli
->prev_field
);
1085 = size_binop (PLUS_EXPR
, TYPE_SIZE (type
),
1086 DECL_FIELD_BIT_OFFSET (rli
->prev_field
));
1087 rli
->prev_field
= field
;
1088 rli
->remaining_in_alignment
1089 = tree_low_cst (TYPE_SIZE (type
), 0);
1092 rli
->remaining_in_alignment
-= bitsize
;
1096 /* End of a run: if leaving a run of bitfields of the same type
1097 size, we have to "use up" the rest of the bits of the type
1100 Compute the new position as the sum of the size for the prior
1101 type and where we first started working on that type.
1102 Note: since the beginning of the field was aligned then
1103 of course the end will be too. No round needed. */
1105 if (!integer_zerop (DECL_SIZE (rli
->prev_field
)))
1107 tree type_size
= TYPE_SIZE (TREE_TYPE (rli
->prev_field
));
1110 = size_binop (PLUS_EXPR
, type_size
,
1111 DECL_FIELD_BIT_OFFSET (rli
->prev_field
));
1114 /* We "use up" size zero fields; the code below should behave
1115 as if the prior field was not a bitfield. */
1118 /* Cause a new bitfield to be captured, either this time (if
1119 currently a bitfield) or next time we see one. */
1120 if (!DECL_BIT_FIELD_TYPE(field
)
1121 || integer_zerop (DECL_SIZE (field
)))
1122 rli
->prev_field
= NULL
;
1125 normalize_rli (rli
);
1128 /* If we're starting a new run of same size type bitfields
1129 (or a run of non-bitfields), set up the "first of the run"
1132 That is, if the current field is not a bitfield, or if there
1133 was a prior bitfield the type sizes differ, or if there wasn't
1134 a prior bitfield the size of the current field is nonzero.
1136 Note: we must be sure to test ONLY the type size if there was
1137 a prior bitfield and ONLY for the current field being zero if
1140 if (!DECL_BIT_FIELD_TYPE (field
)
1141 || ( prev_saved
!= NULL
1142 ? !simple_cst_equal (TYPE_SIZE (type
),
1143 TYPE_SIZE (TREE_TYPE (prev_saved
)))
1144 : !integer_zerop (DECL_SIZE (field
)) ))
1146 /* Never smaller than a byte for compatibility. */
1147 unsigned int type_align
= BITS_PER_UNIT
;
1149 /* (When not a bitfield), we could be seeing a flex array (with
1150 no DECL_SIZE). Since we won't be using remaining_in_alignment
1151 until we see a bitfield (and come by here again) we just skip
1153 if (DECL_SIZE (field
) != NULL
1154 && host_integerp (TYPE_SIZE (TREE_TYPE (field
)), 0)
1155 && host_integerp (DECL_SIZE (field
), 0))
1156 rli
->remaining_in_alignment
1157 = tree_low_cst (TYPE_SIZE (TREE_TYPE(field
)), 0)
1158 - tree_low_cst (DECL_SIZE (field
), 0);
1160 /* Now align (conventionally) for the new type. */
1161 if (!DECL_PACKED(field
))
1162 type_align
= MAX(TYPE_ALIGN (type
), type_align
);
1165 && DECL_BIT_FIELD_TYPE (prev_saved
)
1166 /* If the previous bit-field is zero-sized, we've already
1167 accounted for its alignment needs (or ignored it, if
1168 appropriate) while placing it. */
1169 && ! integer_zerop (DECL_SIZE (prev_saved
)))
1170 type_align
= MAX (type_align
,
1171 TYPE_ALIGN (TREE_TYPE (prev_saved
)));
1173 if (maximum_field_alignment
!= 0)
1174 type_align
= MIN (type_align
, maximum_field_alignment
);
1176 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1178 /* If we really aligned, don't allow subsequent bitfields
1180 rli
->prev_field
= NULL
;
1184 /* Offset so far becomes the position of this field after normalizing. */
1185 normalize_rli (rli
);
1186 DECL_FIELD_OFFSET (field
) = rli
->offset
;
1187 DECL_FIELD_BIT_OFFSET (field
) = rli
->bitpos
;
1188 SET_DECL_OFFSET_ALIGN (field
, rli
->offset_align
);
1190 /* If this field ended up more aligned than we thought it would be (we
1191 approximate this by seeing if its position changed), lay out the field
1192 again; perhaps we can use an integral mode for it now. */
1193 if (! integer_zerop (DECL_FIELD_BIT_OFFSET (field
)))
1194 actual_align
= (tree_low_cst (DECL_FIELD_BIT_OFFSET (field
), 1)
1195 & - tree_low_cst (DECL_FIELD_BIT_OFFSET (field
), 1));
1196 else if (integer_zerop (DECL_FIELD_OFFSET (field
)))
1197 actual_align
= BIGGEST_ALIGNMENT
;
1198 else if (host_integerp (DECL_FIELD_OFFSET (field
), 1))
1199 actual_align
= (BITS_PER_UNIT
1200 * (tree_low_cst (DECL_FIELD_OFFSET (field
), 1)
1201 & - tree_low_cst (DECL_FIELD_OFFSET (field
), 1)));
1203 actual_align
= DECL_OFFSET_ALIGN (field
);
1205 if (known_align
!= actual_align
)
1206 layout_decl (field
, actual_align
);
1208 /* Only the MS bitfields use this. */
1209 if (rli
->prev_field
== NULL
&& DECL_BIT_FIELD_TYPE(field
))
1210 rli
->prev_field
= field
;
1212 /* Now add size of this field to the size of the record. If the size is
1213 not constant, treat the field as being a multiple of bytes and just
1214 adjust the offset, resetting the bit position. Otherwise, apportion the
1215 size amongst the bit position and offset. First handle the case of an
1216 unspecified size, which can happen when we have an invalid nested struct
1217 definition, such as struct j { struct j { int i; } }. The error message
1218 is printed in finish_struct. */
1219 if (DECL_SIZE (field
) == 0)
1221 else if (TREE_CODE (DECL_SIZE_UNIT (field
)) != INTEGER_CST
1222 || TREE_CONSTANT_OVERFLOW (DECL_SIZE_UNIT (field
)))
1225 = size_binop (PLUS_EXPR
, rli
->offset
,
1227 size_binop (CEIL_DIV_EXPR
, rli
->bitpos
,
1228 bitsize_unit_node
)));
1230 = size_binop (PLUS_EXPR
, rli
->offset
, DECL_SIZE_UNIT (field
));
1231 rli
->bitpos
= bitsize_zero_node
;
1232 rli
->offset_align
= MIN (rli
->offset_align
, desired_align
);
1236 rli
->bitpos
= size_binop (PLUS_EXPR
, rli
->bitpos
, DECL_SIZE (field
));
1237 normalize_rli (rli
);
1241 /* Assuming that all the fields have been laid out, this function uses
1242 RLI to compute the final TYPE_SIZE, TYPE_ALIGN, etc. for the type
1243 indicated by RLI. */
1246 finalize_record_size (record_layout_info rli
)
1248 tree unpadded_size
, unpadded_size_unit
;
1250 /* Now we want just byte and bit offsets, so set the offset alignment
1251 to be a byte and then normalize. */
1252 rli
->offset_align
= BITS_PER_UNIT
;
1253 normalize_rli (rli
);
1255 /* Determine the desired alignment. */
1256 #ifdef ROUND_TYPE_ALIGN
1257 TYPE_ALIGN (rli
->t
) = ROUND_TYPE_ALIGN (rli
->t
, TYPE_ALIGN (rli
->t
),
1260 TYPE_ALIGN (rli
->t
) = MAX (TYPE_ALIGN (rli
->t
), rli
->record_align
);
1263 /* Compute the size so far. Be sure to allow for extra bits in the
1264 size in bytes. We have guaranteed above that it will be no more
1265 than a single byte. */
1266 unpadded_size
= rli_size_so_far (rli
);
1267 unpadded_size_unit
= rli_size_unit_so_far (rli
);
1268 if (! integer_zerop (rli
->bitpos
))
1270 = size_binop (PLUS_EXPR
, unpadded_size_unit
, size_one_node
);
1272 /* Round the size up to be a multiple of the required alignment. */
1273 TYPE_SIZE (rli
->t
) = round_up (unpadded_size
, TYPE_ALIGN (rli
->t
));
1274 TYPE_SIZE_UNIT (rli
->t
) = round_up (unpadded_size_unit
,
1275 TYPE_ALIGN (rli
->t
) / BITS_PER_UNIT
);
1277 if (warn_padded
&& TREE_CONSTANT (unpadded_size
)
1278 && simple_cst_equal (unpadded_size
, TYPE_SIZE (rli
->t
)) == 0)
1279 warning ("padding struct size to alignment boundary");
1281 if (warn_packed
&& TREE_CODE (rli
->t
) == RECORD_TYPE
1282 && TYPE_PACKED (rli
->t
) && ! rli
->packed_maybe_necessary
1283 && TREE_CONSTANT (unpadded_size
))
1287 #ifdef ROUND_TYPE_ALIGN
1289 = ROUND_TYPE_ALIGN (rli
->t
, TYPE_ALIGN (rli
->t
), rli
->unpacked_align
);
1291 rli
->unpacked_align
= MAX (TYPE_ALIGN (rli
->t
), rli
->unpacked_align
);
1294 unpacked_size
= round_up (TYPE_SIZE (rli
->t
), rli
->unpacked_align
);
1295 if (simple_cst_equal (unpacked_size
, TYPE_SIZE (rli
->t
)))
1297 TYPE_PACKED (rli
->t
) = 0;
1299 if (TYPE_NAME (rli
->t
))
1303 if (TREE_CODE (TYPE_NAME (rli
->t
)) == IDENTIFIER_NODE
)
1304 name
= IDENTIFIER_POINTER (TYPE_NAME (rli
->t
));
1306 name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (rli
->t
)));
1308 if (STRICT_ALIGNMENT
)
1309 warning ("packed attribute causes inefficient alignment for `%s'", name
);
1311 warning ("packed attribute is unnecessary for `%s'", name
);
1315 if (STRICT_ALIGNMENT
)
1316 warning ("packed attribute causes inefficient alignment");
1318 warning ("packed attribute is unnecessary");
1324 /* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE). */
1327 compute_record_mode (tree type
)
1330 enum machine_mode mode
= VOIDmode
;
1332 /* Most RECORD_TYPEs have BLKmode, so we start off assuming that.
1333 However, if possible, we use a mode that fits in a register
1334 instead, in order to allow for better optimization down the
1336 TYPE_MODE (type
) = BLKmode
;
1338 if (! host_integerp (TYPE_SIZE (type
), 1))
1341 /* A record which has any BLKmode members must itself be
1342 BLKmode; it can't go in a register. Unless the member is
1343 BLKmode only because it isn't aligned. */
1344 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1346 if (TREE_CODE (field
) != FIELD_DECL
)
1349 if (TREE_CODE (TREE_TYPE (field
)) == ERROR_MARK
1350 || (TYPE_MODE (TREE_TYPE (field
)) == BLKmode
1351 && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field
))
1352 && !(TYPE_SIZE (TREE_TYPE (field
)) != 0
1353 && integer_zerop (TYPE_SIZE (TREE_TYPE (field
)))))
1354 || ! host_integerp (bit_position (field
), 1)
1355 || DECL_SIZE (field
) == 0
1356 || ! host_integerp (DECL_SIZE (field
), 1))
1359 /* If this field is the whole struct, remember its mode so
1360 that, say, we can put a double in a class into a DF
1361 register instead of forcing it to live in the stack. */
1362 if (simple_cst_equal (TYPE_SIZE (type
), DECL_SIZE (field
)))
1363 mode
= DECL_MODE (field
);
1365 #ifdef MEMBER_TYPE_FORCES_BLK
1366 /* With some targets, eg. c4x, it is sub-optimal
1367 to access an aligned BLKmode structure as a scalar. */
1369 if (MEMBER_TYPE_FORCES_BLK (field
, mode
))
1371 #endif /* MEMBER_TYPE_FORCES_BLK */
1374 /* If we only have one real field; use its mode. This only applies to
1375 RECORD_TYPE. This does not apply to unions. */
1376 if (TREE_CODE (type
) == RECORD_TYPE
&& mode
!= VOIDmode
)
1377 TYPE_MODE (type
) = mode
;
1379 TYPE_MODE (type
) = mode_for_size_tree (TYPE_SIZE (type
), MODE_INT
, 1);
1381 /* If structure's known alignment is less than what the scalar
1382 mode would need, and it matters, then stick with BLKmode. */
1383 if (TYPE_MODE (type
) != BLKmode
1385 && ! (TYPE_ALIGN (type
) >= BIGGEST_ALIGNMENT
1386 || TYPE_ALIGN (type
) >= GET_MODE_ALIGNMENT (TYPE_MODE (type
))))
1388 /* If this is the only reason this type is BLKmode, then
1389 don't force containing types to be BLKmode. */
1390 TYPE_NO_FORCE_BLK (type
) = 1;
1391 TYPE_MODE (type
) = BLKmode
;
1395 /* Compute TYPE_SIZE and TYPE_ALIGN for TYPE, once it has been laid
1399 finalize_type_size (tree type
)
1401 /* Normally, use the alignment corresponding to the mode chosen.
1402 However, where strict alignment is not required, avoid
1403 over-aligning structures, since most compilers do not do this
1406 if (TYPE_MODE (type
) != BLKmode
&& TYPE_MODE (type
) != VOIDmode
1407 && (STRICT_ALIGNMENT
1408 || (TREE_CODE (type
) != RECORD_TYPE
&& TREE_CODE (type
) != UNION_TYPE
1409 && TREE_CODE (type
) != QUAL_UNION_TYPE
1410 && TREE_CODE (type
) != ARRAY_TYPE
)))
1412 TYPE_ALIGN (type
) = GET_MODE_ALIGNMENT (TYPE_MODE (type
));
1413 TYPE_USER_ALIGN (type
) = 0;
1416 /* Do machine-dependent extra alignment. */
1417 #ifdef ROUND_TYPE_ALIGN
1419 = ROUND_TYPE_ALIGN (type
, TYPE_ALIGN (type
), BITS_PER_UNIT
);
1422 /* If we failed to find a simple way to calculate the unit size
1423 of the type, find it by division. */
1424 if (TYPE_SIZE_UNIT (type
) == 0 && TYPE_SIZE (type
) != 0)
1425 /* TYPE_SIZE (type) is computed in bitsizetype. After the division, the
1426 result will fit in sizetype. We will get more efficient code using
1427 sizetype, so we force a conversion. */
1428 TYPE_SIZE_UNIT (type
)
1429 = convert (sizetype
,
1430 size_binop (FLOOR_DIV_EXPR
, TYPE_SIZE (type
),
1431 bitsize_unit_node
));
1433 if (TYPE_SIZE (type
) != 0)
1435 TYPE_SIZE (type
) = round_up (TYPE_SIZE (type
), TYPE_ALIGN (type
));
1436 TYPE_SIZE_UNIT (type
)
1437 = round_up (TYPE_SIZE_UNIT (type
), TYPE_ALIGN (type
) / BITS_PER_UNIT
);
1440 /* Evaluate nonconstant sizes only once, either now or as soon as safe. */
1441 if (TYPE_SIZE (type
) != 0 && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1442 TYPE_SIZE (type
) = variable_size (TYPE_SIZE (type
));
1443 if (TYPE_SIZE_UNIT (type
) != 0
1444 && TREE_CODE (TYPE_SIZE_UNIT (type
)) != INTEGER_CST
)
1445 TYPE_SIZE_UNIT (type
) = variable_size (TYPE_SIZE_UNIT (type
));
1447 /* Also layout any other variants of the type. */
1448 if (TYPE_NEXT_VARIANT (type
)
1449 || type
!= TYPE_MAIN_VARIANT (type
))
1452 /* Record layout info of this variant. */
1453 tree size
= TYPE_SIZE (type
);
1454 tree size_unit
= TYPE_SIZE_UNIT (type
);
1455 unsigned int align
= TYPE_ALIGN (type
);
1456 unsigned int user_align
= TYPE_USER_ALIGN (type
);
1457 enum machine_mode mode
= TYPE_MODE (type
);
1459 /* Copy it into all variants. */
1460 for (variant
= TYPE_MAIN_VARIANT (type
);
1462 variant
= TYPE_NEXT_VARIANT (variant
))
1464 TYPE_SIZE (variant
) = size
;
1465 TYPE_SIZE_UNIT (variant
) = size_unit
;
1466 TYPE_ALIGN (variant
) = align
;
1467 TYPE_USER_ALIGN (variant
) = user_align
;
1468 TYPE_MODE (variant
) = mode
;
1473 /* Do all of the work required to layout the type indicated by RLI,
1474 once the fields have been laid out. This function will call `free'
1475 for RLI, unless FREE_P is false. Passing a value other than false
1476 for FREE_P is bad practice; this option only exists to support the
1480 finish_record_layout (record_layout_info rli
, int free_p
)
1482 /* Compute the final size. */
1483 finalize_record_size (rli
);
1485 /* Compute the TYPE_MODE for the record. */
1486 compute_record_mode (rli
->t
);
1488 /* Perform any last tweaks to the TYPE_SIZE, etc. */
1489 finalize_type_size (rli
->t
);
1491 /* Lay out any static members. This is done now because their type
1492 may use the record's type. */
1493 while (rli
->pending_statics
)
1495 layout_decl (TREE_VALUE (rli
->pending_statics
), 0);
1496 rli
->pending_statics
= TREE_CHAIN (rli
->pending_statics
);
1505 /* Finish processing a builtin RECORD_TYPE type TYPE. It's name is
1506 NAME, its fields are chained in reverse on FIELDS.
1508 If ALIGN_TYPE is non-null, it is given the same alignment as
1512 finish_builtin_struct (tree type
, const char *name
, tree fields
,
1517 for (tail
= NULL_TREE
; fields
; tail
= fields
, fields
= next
)
1519 DECL_FIELD_CONTEXT (fields
) = type
;
1520 next
= TREE_CHAIN (fields
);
1521 TREE_CHAIN (fields
) = tail
;
1523 TYPE_FIELDS (type
) = tail
;
1527 TYPE_ALIGN (type
) = TYPE_ALIGN (align_type
);
1528 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (align_type
);
1532 #if 0 /* not yet, should get fixed properly later */
1533 TYPE_NAME (type
) = make_type_decl (get_identifier (name
), type
);
1535 TYPE_NAME (type
) = build_decl (TYPE_DECL
, get_identifier (name
), type
);
1537 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
1538 layout_decl (TYPE_NAME (type
), 0);
1541 /* Calculate the mode, size, and alignment for TYPE.
1542 For an array type, calculate the element separation as well.
1543 Record TYPE on the chain of permanent or temporary types
1544 so that dbxout will find out about it.
1546 TYPE_SIZE of a type is nonzero if the type has been laid out already.
1547 layout_type does nothing on such a type.
1549 If the type is incomplete, its TYPE_SIZE remains zero. */
1552 layout_type (tree type
)
1557 if (type
== error_mark_node
)
1560 /* Do nothing if type has been laid out before. */
1561 if (TYPE_SIZE (type
))
1564 switch (TREE_CODE (type
))
1567 /* This kind of type is the responsibility
1568 of the language-specific code. */
1571 case BOOLEAN_TYPE
: /* Used for Java, Pascal, and Chill. */
1572 if (TYPE_PRECISION (type
) == 0)
1573 TYPE_PRECISION (type
) = 1; /* default to one byte/boolean. */
1575 /* ... fall through ... */
1580 if (TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
1581 && tree_int_cst_sgn (TYPE_MIN_VALUE (type
)) >= 0)
1582 TYPE_UNSIGNED (type
) = 1;
1584 TYPE_MODE (type
) = smallest_mode_for_size (TYPE_PRECISION (type
),
1586 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
1587 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
1591 TYPE_MODE (type
) = mode_for_size (TYPE_PRECISION (type
), MODE_FLOAT
, 0);
1592 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
1593 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
1597 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TREE_TYPE (type
));
1599 = mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type
)),
1600 (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
1601 ? MODE_COMPLEX_FLOAT
: MODE_COMPLEX_INT
),
1603 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
1604 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
1608 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TREE_TYPE (type
));
1609 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
1610 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
1614 /* This is an incomplete type and so doesn't have a size. */
1615 TYPE_ALIGN (type
) = 1;
1616 TYPE_USER_ALIGN (type
) = 0;
1617 TYPE_MODE (type
) = VOIDmode
;
1621 TYPE_SIZE (type
) = bitsize_int (POINTER_SIZE
);
1622 TYPE_SIZE_UNIT (type
) = size_int (POINTER_SIZE
/ BITS_PER_UNIT
);
1623 /* A pointer might be MODE_PARTIAL_INT,
1624 but ptrdiff_t must be integral. */
1625 TYPE_MODE (type
) = mode_for_size (POINTER_SIZE
, MODE_INT
, 0);
1630 /* It's hard to see what the mode and size of a function ought to
1631 be, but we do know the alignment is FUNCTION_BOUNDARY, so
1632 make it consistent with that. */
1633 TYPE_MODE (type
) = mode_for_size (FUNCTION_BOUNDARY
, MODE_INT
, 0);
1634 TYPE_SIZE (type
) = bitsize_int (FUNCTION_BOUNDARY
);
1635 TYPE_SIZE_UNIT (type
) = size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
1639 case REFERENCE_TYPE
:
1642 enum machine_mode mode
= ((TREE_CODE (type
) == REFERENCE_TYPE
1643 && reference_types_internal
)
1644 ? Pmode
: TYPE_MODE (type
));
1646 int nbits
= GET_MODE_BITSIZE (mode
);
1648 TYPE_SIZE (type
) = bitsize_int (nbits
);
1649 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (mode
));
1650 TYPE_UNSIGNED (type
) = 1;
1651 TYPE_PRECISION (type
) = nbits
;
1657 tree index
= TYPE_DOMAIN (type
);
1658 tree element
= TREE_TYPE (type
);
1660 build_pointer_type (element
);
1662 /* We need to know both bounds in order to compute the size. */
1663 if (index
&& TYPE_MAX_VALUE (index
) && TYPE_MIN_VALUE (index
)
1664 && TYPE_SIZE (element
))
1666 tree ub
= TYPE_MAX_VALUE (index
);
1667 tree lb
= TYPE_MIN_VALUE (index
);
1671 /* The initial subtraction should happen in the original type so
1672 that (possible) negative values are handled appropriately. */
1673 length
= size_binop (PLUS_EXPR
, size_one_node
,
1675 fold (build (MINUS_EXPR
,
1679 /* Special handling for arrays of bits (for Chill). */
1680 element_size
= TYPE_SIZE (element
);
1681 if (TYPE_PACKED (type
) && INTEGRAL_TYPE_P (element
)
1682 && (integer_zerop (TYPE_MAX_VALUE (element
))
1683 || integer_onep (TYPE_MAX_VALUE (element
)))
1684 && host_integerp (TYPE_MIN_VALUE (element
), 1))
1686 HOST_WIDE_INT maxvalue
1687 = tree_low_cst (TYPE_MAX_VALUE (element
), 1);
1688 HOST_WIDE_INT minvalue
1689 = tree_low_cst (TYPE_MIN_VALUE (element
), 1);
1691 if (maxvalue
- minvalue
== 1
1692 && (maxvalue
== 1 || maxvalue
== 0))
1693 element_size
= integer_one_node
;
1696 /* If neither bound is a constant and sizetype is signed, make
1697 sure the size is never negative. We should really do this
1698 if *either* bound is non-constant, but this is the best
1699 compromise between C and Ada. */
1700 if (!TYPE_UNSIGNED (sizetype
)
1701 && TREE_CODE (TYPE_MIN_VALUE (index
)) != INTEGER_CST
1702 && TREE_CODE (TYPE_MAX_VALUE (index
)) != INTEGER_CST
)
1703 length
= size_binop (MAX_EXPR
, length
, size_zero_node
);
1705 TYPE_SIZE (type
) = size_binop (MULT_EXPR
, element_size
,
1706 convert (bitsizetype
, length
));
1708 /* If we know the size of the element, calculate the total
1709 size directly, rather than do some division thing below.
1710 This optimization helps Fortran assumed-size arrays
1711 (where the size of the array is determined at runtime)
1713 Note that we can't do this in the case where the size of
1714 the elements is one bit since TYPE_SIZE_UNIT cannot be
1715 set correctly in that case. */
1716 if (TYPE_SIZE_UNIT (element
) != 0 && ! integer_onep (element_size
))
1717 TYPE_SIZE_UNIT (type
)
1718 = size_binop (MULT_EXPR
, TYPE_SIZE_UNIT (element
), length
);
1721 /* Now round the alignment and size,
1722 using machine-dependent criteria if any. */
1724 #ifdef ROUND_TYPE_ALIGN
1726 = ROUND_TYPE_ALIGN (type
, TYPE_ALIGN (element
), BITS_PER_UNIT
);
1728 TYPE_ALIGN (type
) = MAX (TYPE_ALIGN (element
), BITS_PER_UNIT
);
1730 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (element
);
1731 TYPE_MODE (type
) = BLKmode
;
1732 if (TYPE_SIZE (type
) != 0
1733 #ifdef MEMBER_TYPE_FORCES_BLK
1734 && ! MEMBER_TYPE_FORCES_BLK (type
, VOIDmode
)
1736 /* BLKmode elements force BLKmode aggregate;
1737 else extract/store fields may lose. */
1738 && (TYPE_MODE (TREE_TYPE (type
)) != BLKmode
1739 || TYPE_NO_FORCE_BLK (TREE_TYPE (type
))))
1741 /* One-element arrays get the component type's mode. */
1742 if (simple_cst_equal (TYPE_SIZE (type
),
1743 TYPE_SIZE (TREE_TYPE (type
))))
1744 TYPE_MODE (type
) = TYPE_MODE (TREE_TYPE (type
));
1747 = mode_for_size_tree (TYPE_SIZE (type
), MODE_INT
, 1);
1749 if (TYPE_MODE (type
) != BLKmode
1750 && STRICT_ALIGNMENT
&& TYPE_ALIGN (type
) < BIGGEST_ALIGNMENT
1751 && TYPE_ALIGN (type
) < GET_MODE_ALIGNMENT (TYPE_MODE (type
))
1752 && TYPE_MODE (type
) != BLKmode
)
1754 TYPE_NO_FORCE_BLK (type
) = 1;
1755 TYPE_MODE (type
) = BLKmode
;
1763 case QUAL_UNION_TYPE
:
1766 record_layout_info rli
;
1768 /* Initialize the layout information. */
1769 rli
= start_record_layout (type
);
1771 /* If this is a QUAL_UNION_TYPE, we want to process the fields
1772 in the reverse order in building the COND_EXPR that denotes
1773 its size. We reverse them again later. */
1774 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
1775 TYPE_FIELDS (type
) = nreverse (TYPE_FIELDS (type
));
1777 /* Place all the fields. */
1778 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
1779 place_field (rli
, field
);
1781 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
1782 TYPE_FIELDS (type
) = nreverse (TYPE_FIELDS (type
));
1784 if (lang_adjust_rli
)
1785 (*lang_adjust_rli
) (rli
);
1787 /* Finish laying out the record. */
1788 finish_record_layout (rli
, /*free_p=*/true);
1792 case SET_TYPE
: /* Used by Chill and Pascal. */
1793 if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))) != INTEGER_CST
1794 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (type
))) != INTEGER_CST
)
1798 #ifndef SET_WORD_SIZE
1799 #define SET_WORD_SIZE BITS_PER_WORD
1801 unsigned int alignment
1802 = set_alignment
? set_alignment
: SET_WORD_SIZE
;
1803 HOST_WIDE_INT size_in_bits
1804 = (tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)), 0)
1805 - tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)), 0) + 1);
1806 HOST_WIDE_INT rounded_size
1807 = ((size_in_bits
+ alignment
- 1) / alignment
) * alignment
;
1809 if (rounded_size
> (int) alignment
)
1810 TYPE_MODE (type
) = BLKmode
;
1812 TYPE_MODE (type
) = mode_for_size (alignment
, MODE_INT
, 1);
1814 TYPE_SIZE (type
) = bitsize_int (rounded_size
);
1815 TYPE_SIZE_UNIT (type
) = size_int (rounded_size
/ BITS_PER_UNIT
);
1816 TYPE_ALIGN (type
) = alignment
;
1817 TYPE_USER_ALIGN (type
) = 0;
1818 TYPE_PRECISION (type
) = size_in_bits
;
1823 /* The size may vary in different languages, so the language front end
1824 should fill in the size. */
1825 TYPE_ALIGN (type
) = BIGGEST_ALIGNMENT
;
1826 TYPE_USER_ALIGN (type
) = 0;
1827 TYPE_MODE (type
) = BLKmode
;
1834 /* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE. For
1835 records and unions, finish_record_layout already called this
1837 if (TREE_CODE (type
) != RECORD_TYPE
1838 && TREE_CODE (type
) != UNION_TYPE
1839 && TREE_CODE (type
) != QUAL_UNION_TYPE
)
1840 finalize_type_size (type
);
1842 /* If this type is created before sizetype has been permanently set,
1843 record it so set_sizetype can fix it up. */
1845 early_type_list
= tree_cons (NULL_TREE
, type
, early_type_list
);
1847 /* If an alias set has been set for this aggregate when it was incomplete,
1848 force it into alias set 0.
1849 This is too conservative, but we cannot call record_component_aliases
1850 here because some frontends still change the aggregates after
1852 if (AGGREGATE_TYPE_P (type
) && TYPE_ALIAS_SET_KNOWN_P (type
))
1853 TYPE_ALIAS_SET (type
) = 0;
1856 /* Create and return a type for signed integers of PRECISION bits. */
1859 make_signed_type (int precision
)
1861 tree type
= make_node (INTEGER_TYPE
);
1863 TYPE_PRECISION (type
) = precision
;
1865 fixup_signed_type (type
);
1869 /* Create and return a type for unsigned integers of PRECISION bits. */
1872 make_unsigned_type (int precision
)
1874 tree type
= make_node (INTEGER_TYPE
);
1876 TYPE_PRECISION (type
) = precision
;
1878 fixup_unsigned_type (type
);
1882 /* Initialize sizetype and bitsizetype to a reasonable and temporary
1883 value to enable integer types to be created. */
1886 initialize_sizetypes (void)
1888 tree t
= make_node (INTEGER_TYPE
);
1890 /* Set this so we do something reasonable for the build_int_2 calls
1892 integer_type_node
= t
;
1894 TYPE_MODE (t
) = SImode
;
1895 TYPE_ALIGN (t
) = GET_MODE_ALIGNMENT (SImode
);
1896 TYPE_USER_ALIGN (t
) = 0;
1897 TYPE_SIZE (t
) = build_int_2 (GET_MODE_BITSIZE (SImode
), 0);
1898 TYPE_SIZE_UNIT (t
) = build_int_2 (GET_MODE_SIZE (SImode
), 0);
1899 TYPE_UNSIGNED (t
) = 1;
1900 TYPE_PRECISION (t
) = GET_MODE_BITSIZE (SImode
);
1901 TYPE_MIN_VALUE (t
) = build_int_2 (0, 0);
1902 TYPE_IS_SIZETYPE (t
) = 1;
1904 /* 1000 avoids problems with possible overflow and is certainly
1905 larger than any size value we'd want to be storing. */
1906 TYPE_MAX_VALUE (t
) = build_int_2 (1000, 0);
1908 /* These two must be different nodes because of the caching done in
1911 bitsizetype
= copy_node (t
);
1912 integer_type_node
= 0;
1915 /* Set sizetype to TYPE, and initialize *sizetype accordingly.
1916 Also update the type of any standard type's sizes made so far. */
1919 set_sizetype (tree type
)
1921 int oprecision
= TYPE_PRECISION (type
);
1922 /* The *bitsizetype types use a precision that avoids overflows when
1923 calculating signed sizes / offsets in bits. However, when
1924 cross-compiling from a 32 bit to a 64 bit host, we are limited to 64 bit
1926 int precision
= MIN (oprecision
+ BITS_PER_UNIT_LOG
+ 1,
1927 2 * HOST_BITS_PER_WIDE_INT
);
1934 /* Make copies of nodes since we'll be setting TYPE_IS_SIZETYPE. */
1935 sizetype
= copy_node (type
);
1936 TYPE_ORIG_SIZE_TYPE (sizetype
) = type
;
1937 TYPE_IS_SIZETYPE (sizetype
) = 1;
1938 bitsizetype
= make_node (INTEGER_TYPE
);
1939 TYPE_NAME (bitsizetype
) = TYPE_NAME (type
);
1940 TYPE_PRECISION (bitsizetype
) = precision
;
1941 TYPE_IS_SIZETYPE (bitsizetype
) = 1;
1943 if (TYPE_UNSIGNED (type
))
1944 fixup_unsigned_type (bitsizetype
);
1946 fixup_signed_type (bitsizetype
);
1948 layout_type (bitsizetype
);
1950 if (TYPE_UNSIGNED (type
))
1952 usizetype
= sizetype
;
1953 ubitsizetype
= bitsizetype
;
1954 ssizetype
= copy_node (make_signed_type (oprecision
));
1955 sbitsizetype
= copy_node (make_signed_type (precision
));
1959 ssizetype
= sizetype
;
1960 sbitsizetype
= bitsizetype
;
1961 usizetype
= copy_node (make_unsigned_type (oprecision
));
1962 ubitsizetype
= copy_node (make_unsigned_type (precision
));
1965 TYPE_NAME (bitsizetype
) = get_identifier ("bit_size_type");
1967 /* Show is a sizetype, is a main type, and has no pointers to it. */
1968 for (i
= 0; i
< ARRAY_SIZE (sizetype_tab
); i
++)
1970 TYPE_IS_SIZETYPE (sizetype_tab
[i
]) = 1;
1971 TYPE_MAIN_VARIANT (sizetype_tab
[i
]) = sizetype_tab
[i
];
1972 TYPE_NEXT_VARIANT (sizetype_tab
[i
]) = 0;
1973 TYPE_POINTER_TO (sizetype_tab
[i
]) = 0;
1974 TYPE_REFERENCE_TO (sizetype_tab
[i
]) = 0;
1977 /* Go down each of the types we already made and set the proper type
1978 for the sizes in them. */
1979 for (t
= early_type_list
; t
!= 0; t
= TREE_CHAIN (t
))
1981 if (TREE_CODE (TREE_VALUE (t
)) != INTEGER_TYPE
1982 && TREE_CODE (TREE_VALUE (t
)) != BOOLEAN_TYPE
)
1985 TREE_TYPE (TYPE_SIZE (TREE_VALUE (t
))) = bitsizetype
;
1986 TREE_TYPE (TYPE_SIZE_UNIT (TREE_VALUE (t
))) = sizetype
;
1989 early_type_list
= 0;
1993 /* TYPE is an integral type, i.e., an INTEGRAL_TYPE, ENUMERAL_TYPE,
1994 BOOLEAN_TYPE, or CHAR_TYPE. Set TYPE_MIN_VALUE and TYPE_MAX_VALUE
1995 for TYPE, based on the PRECISION and whether or not the TYPE
1996 IS_UNSIGNED. PRECISION need not correspond to a width supported
1997 natively by the hardware; for example, on a machine with 8-bit,
1998 16-bit, and 32-bit register modes, PRECISION might be 7, 23, or
2002 set_min_and_max_values_for_integral_type (tree type
,
2011 min_value
= build_int_2 (0, 0);
2013 = build_int_2 (precision
- HOST_BITS_PER_WIDE_INT
>= 0
2014 ? -1 : ((HOST_WIDE_INT
) 1 << precision
) - 1,
2015 precision
- HOST_BITS_PER_WIDE_INT
> 0
2016 ? ((unsigned HOST_WIDE_INT
) ~0
2017 >> (HOST_BITS_PER_WIDE_INT
2018 - (precision
- HOST_BITS_PER_WIDE_INT
)))
2024 = build_int_2 ((precision
- HOST_BITS_PER_WIDE_INT
> 0
2025 ? 0 : (HOST_WIDE_INT
) (-1) << (precision
- 1)),
2026 (((HOST_WIDE_INT
) (-1)
2027 << (precision
- HOST_BITS_PER_WIDE_INT
- 1 > 0
2028 ? precision
- HOST_BITS_PER_WIDE_INT
- 1
2031 = build_int_2 ((precision
- HOST_BITS_PER_WIDE_INT
> 0
2032 ? -1 : ((HOST_WIDE_INT
) 1 << (precision
- 1)) - 1),
2033 (precision
- HOST_BITS_PER_WIDE_INT
- 1 > 0
2034 ? (((HOST_WIDE_INT
) 1
2035 << (precision
- HOST_BITS_PER_WIDE_INT
- 1))) - 1
2039 TREE_TYPE (min_value
) = type
;
2040 TREE_TYPE (max_value
) = type
;
2041 TYPE_MIN_VALUE (type
) = min_value
;
2042 TYPE_MAX_VALUE (type
) = max_value
;
2045 /* Set the extreme values of TYPE based on its precision in bits,
2046 then lay it out. Used when make_signed_type won't do
2047 because the tree code is not INTEGER_TYPE.
2048 E.g. for Pascal, when the -fsigned-char option is given. */
2051 fixup_signed_type (tree type
)
2053 int precision
= TYPE_PRECISION (type
);
2055 /* We can not represent properly constants greater then
2056 2 * HOST_BITS_PER_WIDE_INT, still we need the types
2057 as they are used by i386 vector extensions and friends. */
2058 if (precision
> HOST_BITS_PER_WIDE_INT
* 2)
2059 precision
= HOST_BITS_PER_WIDE_INT
* 2;
2061 set_min_and_max_values_for_integral_type (type
, precision
,
2062 /*is_unsigned=*/false);
2064 /* Lay out the type: set its alignment, size, etc. */
2068 /* Set the extreme values of TYPE based on its precision in bits,
2069 then lay it out. This is used both in `make_unsigned_type'
2070 and for enumeral types. */
2073 fixup_unsigned_type (tree type
)
2075 int precision
= TYPE_PRECISION (type
);
2077 /* We can not represent properly constants greater then
2078 2 * HOST_BITS_PER_WIDE_INT, still we need the types
2079 as they are used by i386 vector extensions and friends. */
2080 if (precision
> HOST_BITS_PER_WIDE_INT
* 2)
2081 precision
= HOST_BITS_PER_WIDE_INT
* 2;
2083 set_min_and_max_values_for_integral_type (type
, precision
,
2084 /*is_unsigned=*/true);
2086 /* Lay out the type: set its alignment, size, etc. */
2090 /* Find the best machine mode to use when referencing a bit field of length
2091 BITSIZE bits starting at BITPOS.
2093 The underlying object is known to be aligned to a boundary of ALIGN bits.
2094 If LARGEST_MODE is not VOIDmode, it means that we should not use a mode
2095 larger than LARGEST_MODE (usually SImode).
2097 If no mode meets all these conditions, we return VOIDmode. Otherwise, if
2098 VOLATILEP is true or SLOW_BYTE_ACCESS is false, we return the smallest
2099 mode meeting these conditions.
2101 Otherwise (VOLATILEP is false and SLOW_BYTE_ACCESS is true), we return
2102 the largest mode (but a mode no wider than UNITS_PER_WORD) that meets
2103 all the conditions. */
2106 get_best_mode (int bitsize
, int bitpos
, unsigned int align
,
2107 enum machine_mode largest_mode
, int volatilep
)
2109 enum machine_mode mode
;
2110 unsigned int unit
= 0;
2112 /* Find the narrowest integer mode that contains the bit field. */
2113 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_INT
); mode
!= VOIDmode
;
2114 mode
= GET_MODE_WIDER_MODE (mode
))
2116 unit
= GET_MODE_BITSIZE (mode
);
2117 if ((bitpos
% unit
) + bitsize
<= unit
)
2121 if (mode
== VOIDmode
2122 /* It is tempting to omit the following line
2123 if STRICT_ALIGNMENT is true.
2124 But that is incorrect, since if the bitfield uses part of 3 bytes
2125 and we use a 4-byte mode, we could get a spurious segv
2126 if the extra 4th byte is past the end of memory.
2127 (Though at least one Unix compiler ignores this problem:
2128 that on the Sequent 386 machine. */
2129 || MIN (unit
, BIGGEST_ALIGNMENT
) > align
2130 || (largest_mode
!= VOIDmode
&& unit
> GET_MODE_BITSIZE (largest_mode
)))
2133 if (SLOW_BYTE_ACCESS
&& ! volatilep
)
2135 enum machine_mode wide_mode
= VOIDmode
, tmode
;
2137 for (tmode
= GET_CLASS_NARROWEST_MODE (MODE_INT
); tmode
!= VOIDmode
;
2138 tmode
= GET_MODE_WIDER_MODE (tmode
))
2140 unit
= GET_MODE_BITSIZE (tmode
);
2141 if (bitpos
/ unit
== (bitpos
+ bitsize
- 1) / unit
2142 && unit
<= BITS_PER_WORD
2143 && unit
<= MIN (align
, BIGGEST_ALIGNMENT
)
2144 && (largest_mode
== VOIDmode
2145 || unit
<= GET_MODE_BITSIZE (largest_mode
)))
2149 if (wide_mode
!= VOIDmode
)
2156 /* Gets minimal and maximal values for MODE (signed or unsigned depending on
2157 SIGN). The returned constants are made to be usable in TARGET_MODE. */
2160 get_mode_bounds (enum machine_mode mode
, int sign
,
2161 enum machine_mode target_mode
,
2162 rtx
*mmin
, rtx
*mmax
)
2164 unsigned size
= GET_MODE_BITSIZE (mode
);
2165 unsigned HOST_WIDE_INT min_val
, max_val
;
2167 if (size
> HOST_BITS_PER_WIDE_INT
)
2172 min_val
= -((unsigned HOST_WIDE_INT
) 1 << (size
- 1));
2173 max_val
= ((unsigned HOST_WIDE_INT
) 1 << (size
- 1)) - 1;
2178 max_val
= ((unsigned HOST_WIDE_INT
) 1 << (size
- 1) << 1) - 1;
2181 *mmin
= GEN_INT (trunc_int_for_mode (min_val
, target_mode
));
2182 *mmax
= GEN_INT (trunc_int_for_mode (max_val
, target_mode
));
2185 #include "gt-stor-layout.h"