1 /* C-compiler utilities for types and variables storage layout
2 Copyright (C) 1987-2015 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
32 #include "fold-const.h"
33 #include "stor-layout.h"
34 #include "stringpool.h"
36 #include "print-tree.h"
40 #include "hard-reg-set.h"
43 #include "statistics.h"
44 #include "insn-config.h"
52 #include "diagnostic-core.h"
54 #include "langhooks.h"
59 #include "plugin-api.h"
62 #include "tree-inline.h"
63 #include "tree-dump.h"
66 /* Data type for the expressions representing sizes of data types.
67 It is the first integer type laid out. */
68 tree sizetype_tab
[(int) stk_type_kind_last
];
70 /* If nonzero, this is an upper limit on alignment of structure fields.
71 The value is measured in bits. */
72 unsigned int maximum_field_alignment
= TARGET_DEFAULT_PACK_STRUCT
* BITS_PER_UNIT
;
74 /* Nonzero if all REFERENCE_TYPEs are internal and hence should be allocated
75 in the address spaces' address_mode, not pointer_mode. Set only by
76 internal_reference_types called only by a front end. */
77 static int reference_types_internal
= 0;
79 static tree
self_referential_size (tree
);
80 static void finalize_record_size (record_layout_info
);
81 static void finalize_type_size (tree
);
82 static void place_union_field (record_layout_info
, tree
);
83 static int excess_unit_span (HOST_WIDE_INT
, HOST_WIDE_INT
, HOST_WIDE_INT
,
85 extern void debug_rli (record_layout_info
);
87 /* Show that REFERENCE_TYPES are internal and should use address_mode.
88 Called only by front end. */
91 internal_reference_types (void)
93 reference_types_internal
= 1;
96 /* Given a size SIZE that may not be a constant, return a SAVE_EXPR
97 to serve as the actual size-expression for a type or decl. */
100 variable_size (tree size
)
103 if (TREE_CONSTANT (size
))
106 /* If the size is self-referential, we can't make a SAVE_EXPR (see
107 save_expr for the rationale). But we can do something else. */
108 if (CONTAINS_PLACEHOLDER_P (size
))
109 return self_referential_size (size
);
111 /* If we are in the global binding level, we can't make a SAVE_EXPR
112 since it may end up being shared across functions, so it is up
113 to the front-end to deal with this case. */
114 if (lang_hooks
.decls
.global_bindings_p ())
117 return save_expr (size
);
120 /* An array of functions used for self-referential size computation. */
121 static GTY(()) vec
<tree
, va_gc
> *size_functions
;
123 /* Return true if T is a self-referential component reference. */
126 self_referential_component_ref_p (tree t
)
128 if (TREE_CODE (t
) != COMPONENT_REF
)
131 while (REFERENCE_CLASS_P (t
))
132 t
= TREE_OPERAND (t
, 0);
134 return (TREE_CODE (t
) == PLACEHOLDER_EXPR
);
137 /* Similar to copy_tree_r but do not copy component references involving
138 PLACEHOLDER_EXPRs. These nodes are spotted in find_placeholder_in_expr
139 and substituted in substitute_in_expr. */
142 copy_self_referential_tree_r (tree
*tp
, int *walk_subtrees
, void *data
)
144 enum tree_code code
= TREE_CODE (*tp
);
146 /* Stop at types, decls, constants like copy_tree_r. */
147 if (TREE_CODE_CLASS (code
) == tcc_type
148 || TREE_CODE_CLASS (code
) == tcc_declaration
149 || TREE_CODE_CLASS (code
) == tcc_constant
)
155 /* This is the pattern built in ada/make_aligning_type. */
156 else if (code
== ADDR_EXPR
157 && TREE_CODE (TREE_OPERAND (*tp
, 0)) == PLACEHOLDER_EXPR
)
163 /* Default case: the component reference. */
164 else if (self_referential_component_ref_p (*tp
))
170 /* We're not supposed to have them in self-referential size trees
171 because we wouldn't properly control when they are evaluated.
172 However, not creating superfluous SAVE_EXPRs requires accurate
173 tracking of readonly-ness all the way down to here, which we
174 cannot always guarantee in practice. So punt in this case. */
175 else if (code
== SAVE_EXPR
)
176 return error_mark_node
;
178 else if (code
== STATEMENT_LIST
)
181 return copy_tree_r (tp
, walk_subtrees
, data
);
184 /* Given a SIZE expression that is self-referential, return an equivalent
185 expression to serve as the actual size expression for a type. */
188 self_referential_size (tree size
)
190 static unsigned HOST_WIDE_INT fnno
= 0;
191 vec
<tree
> self_refs
= vNULL
;
192 tree param_type_list
= NULL
, param_decl_list
= NULL
;
193 tree t
, ref
, return_type
, fntype
, fnname
, fndecl
;
196 vec
<tree
, va_gc
> *args
= NULL
;
198 /* Do not factor out simple operations. */
199 t
= skip_simple_constant_arithmetic (size
);
200 if (TREE_CODE (t
) == CALL_EXPR
|| self_referential_component_ref_p (t
))
203 /* Collect the list of self-references in the expression. */
204 find_placeholder_in_expr (size
, &self_refs
);
205 gcc_assert (self_refs
.length () > 0);
207 /* Obtain a private copy of the expression. */
209 if (walk_tree (&t
, copy_self_referential_tree_r
, NULL
, NULL
) != NULL_TREE
)
213 /* Build the parameter and argument lists in parallel; also
214 substitute the former for the latter in the expression. */
215 vec_alloc (args
, self_refs
.length ());
216 FOR_EACH_VEC_ELT (self_refs
, i
, ref
)
218 tree subst
, param_name
, param_type
, param_decl
;
222 /* We shouldn't have true variables here. */
223 gcc_assert (TREE_READONLY (ref
));
226 /* This is the pattern built in ada/make_aligning_type. */
227 else if (TREE_CODE (ref
) == ADDR_EXPR
)
229 /* Default case: the component reference. */
231 subst
= TREE_OPERAND (ref
, 1);
233 sprintf (buf
, "p%d", i
);
234 param_name
= get_identifier (buf
);
235 param_type
= TREE_TYPE (ref
);
237 = build_decl (input_location
, PARM_DECL
, param_name
, param_type
);
238 DECL_ARG_TYPE (param_decl
) = param_type
;
239 DECL_ARTIFICIAL (param_decl
) = 1;
240 TREE_READONLY (param_decl
) = 1;
242 size
= substitute_in_expr (size
, subst
, param_decl
);
244 param_type_list
= tree_cons (NULL_TREE
, param_type
, param_type_list
);
245 param_decl_list
= chainon (param_decl
, param_decl_list
);
246 args
->quick_push (ref
);
249 self_refs
.release ();
251 /* Append 'void' to indicate that the number of parameters is fixed. */
252 param_type_list
= tree_cons (NULL_TREE
, void_type_node
, param_type_list
);
254 /* The 3 lists have been created in reverse order. */
255 param_type_list
= nreverse (param_type_list
);
256 param_decl_list
= nreverse (param_decl_list
);
258 /* Build the function type. */
259 return_type
= TREE_TYPE (size
);
260 fntype
= build_function_type (return_type
, param_type_list
);
262 /* Build the function declaration. */
263 sprintf (buf
, "SZ" HOST_WIDE_INT_PRINT_UNSIGNED
, fnno
++);
264 fnname
= get_file_function_name (buf
);
265 fndecl
= build_decl (input_location
, FUNCTION_DECL
, fnname
, fntype
);
266 for (t
= param_decl_list
; t
; t
= DECL_CHAIN (t
))
267 DECL_CONTEXT (t
) = fndecl
;
268 DECL_ARGUMENTS (fndecl
) = param_decl_list
;
270 = build_decl (input_location
, RESULT_DECL
, 0, return_type
);
271 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
273 /* The function has been created by the compiler and we don't
274 want to emit debug info for it. */
275 DECL_ARTIFICIAL (fndecl
) = 1;
276 DECL_IGNORED_P (fndecl
) = 1;
278 /* It is supposed to be "const" and never throw. */
279 TREE_READONLY (fndecl
) = 1;
280 TREE_NOTHROW (fndecl
) = 1;
282 /* We want it to be inlined when this is deemed profitable, as
283 well as discarded if every call has been integrated. */
284 DECL_DECLARED_INLINE_P (fndecl
) = 1;
286 /* It is made up of a unique return statement. */
287 DECL_INITIAL (fndecl
) = make_node (BLOCK
);
288 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
289 t
= build2 (MODIFY_EXPR
, return_type
, DECL_RESULT (fndecl
), size
);
290 DECL_SAVED_TREE (fndecl
) = build1 (RETURN_EXPR
, void_type_node
, t
);
291 TREE_STATIC (fndecl
) = 1;
293 /* Put it onto the list of size functions. */
294 vec_safe_push (size_functions
, fndecl
);
296 /* Replace the original expression with a call to the size function. */
297 return build_call_expr_loc_vec (UNKNOWN_LOCATION
, fndecl
, args
);
300 /* Take, queue and compile all the size functions. It is essential that
301 the size functions be gimplified at the very end of the compilation
302 in order to guarantee transparent handling of self-referential sizes.
303 Otherwise the GENERIC inliner would not be able to inline them back
304 at each of their call sites, thus creating artificial non-constant
305 size expressions which would trigger nasty problems later on. */
308 finalize_size_functions (void)
313 for (i
= 0; size_functions
&& size_functions
->iterate (i
, &fndecl
); i
++)
315 allocate_struct_function (fndecl
, false);
317 dump_function (TDI_original
, fndecl
);
318 gimplify_function_tree (fndecl
);
319 dump_function (TDI_generic
, fndecl
);
320 cgraph_node::finalize_function (fndecl
, false);
323 vec_free (size_functions
);
326 /* Return the machine mode to use for a nonscalar of SIZE bits. The
327 mode must be in class MCLASS, and have exactly that many value bits;
328 it may have padding as well. If LIMIT is nonzero, modes of wider
329 than MAX_FIXED_MODE_SIZE will not be used. */
332 mode_for_size (unsigned int size
, enum mode_class mclass
, int limit
)
337 if (limit
&& size
> MAX_FIXED_MODE_SIZE
)
340 /* Get the first mode which has this size, in the specified class. */
341 for (mode
= GET_CLASS_NARROWEST_MODE (mclass
); mode
!= VOIDmode
;
342 mode
= GET_MODE_WIDER_MODE (mode
))
343 if (GET_MODE_PRECISION (mode
) == size
)
346 if (mclass
== MODE_INT
|| mclass
== MODE_PARTIAL_INT
)
347 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
348 if (int_n_data
[i
].bitsize
== size
349 && int_n_enabled_p
[i
])
350 return int_n_data
[i
].m
;
355 /* Similar, except passed a tree node. */
358 mode_for_size_tree (const_tree size
, enum mode_class mclass
, int limit
)
360 unsigned HOST_WIDE_INT uhwi
;
363 if (!tree_fits_uhwi_p (size
))
365 uhwi
= tree_to_uhwi (size
);
369 return mode_for_size (ui
, mclass
, limit
);
372 /* Similar, but never return BLKmode; return the narrowest mode that
373 contains at least the requested number of value bits. */
376 smallest_mode_for_size (unsigned int size
, enum mode_class mclass
)
378 machine_mode mode
= VOIDmode
;
381 /* Get the first mode which has at least this size, in the
383 for (mode
= GET_CLASS_NARROWEST_MODE (mclass
); mode
!= VOIDmode
;
384 mode
= GET_MODE_WIDER_MODE (mode
))
385 if (GET_MODE_PRECISION (mode
) >= size
)
388 if (mclass
== MODE_INT
|| mclass
== MODE_PARTIAL_INT
)
389 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
390 if (int_n_data
[i
].bitsize
>= size
391 && int_n_data
[i
].bitsize
< GET_MODE_PRECISION (mode
)
392 && int_n_enabled_p
[i
])
393 mode
= int_n_data
[i
].m
;
395 if (mode
== VOIDmode
)
401 /* Find an integer mode of the exact same size, or BLKmode on failure. */
404 int_mode_for_mode (machine_mode mode
)
406 switch (GET_MODE_CLASS (mode
))
409 case MODE_PARTIAL_INT
:
412 case MODE_COMPLEX_INT
:
413 case MODE_COMPLEX_FLOAT
:
415 case MODE_DECIMAL_FLOAT
:
416 case MODE_VECTOR_INT
:
417 case MODE_VECTOR_FLOAT
:
422 case MODE_VECTOR_FRACT
:
423 case MODE_VECTOR_ACCUM
:
424 case MODE_VECTOR_UFRACT
:
425 case MODE_VECTOR_UACCUM
:
426 case MODE_POINTER_BOUNDS
:
427 mode
= mode_for_size (GET_MODE_BITSIZE (mode
), MODE_INT
, 0);
434 /* ... fall through ... */
444 /* Find a mode that can be used for efficient bitwise operations on MODE.
445 Return BLKmode if no such mode exists. */
448 bitwise_mode_for_mode (machine_mode mode
)
450 /* Quick exit if we already have a suitable mode. */
451 unsigned int bitsize
= GET_MODE_BITSIZE (mode
);
452 if (SCALAR_INT_MODE_P (mode
) && bitsize
<= MAX_FIXED_MODE_SIZE
)
455 /* Reuse the sanity checks from int_mode_for_mode. */
456 gcc_checking_assert ((int_mode_for_mode (mode
), true));
458 /* Try to replace complex modes with complex modes. In general we
459 expect both components to be processed independently, so we only
460 care whether there is a register for the inner mode. */
461 if (COMPLEX_MODE_P (mode
))
463 machine_mode trial
= mode
;
464 if (GET_MODE_CLASS (mode
) != MODE_COMPLEX_INT
)
465 trial
= mode_for_size (bitsize
, MODE_COMPLEX_INT
, false);
467 && have_regs_of_mode
[GET_MODE_INNER (trial
)])
471 /* Try to replace vector modes with vector modes. Also try using vector
472 modes if an integer mode would be too big. */
473 if (VECTOR_MODE_P (mode
) || bitsize
> MAX_FIXED_MODE_SIZE
)
475 machine_mode trial
= mode
;
476 if (GET_MODE_CLASS (mode
) != MODE_VECTOR_INT
)
477 trial
= mode_for_size (bitsize
, MODE_VECTOR_INT
, 0);
479 && have_regs_of_mode
[trial
]
480 && targetm
.vector_mode_supported_p (trial
))
484 /* Otherwise fall back on integers while honoring MAX_FIXED_MODE_SIZE. */
485 return mode_for_size (bitsize
, MODE_INT
, true);
488 /* Find a type that can be used for efficient bitwise operations on MODE.
489 Return null if no such mode exists. */
492 bitwise_type_for_mode (machine_mode mode
)
494 mode
= bitwise_mode_for_mode (mode
);
498 unsigned int inner_size
= GET_MODE_UNIT_BITSIZE (mode
);
499 tree inner_type
= build_nonstandard_integer_type (inner_size
, true);
501 if (VECTOR_MODE_P (mode
))
502 return build_vector_type_for_mode (inner_type
, mode
);
504 if (COMPLEX_MODE_P (mode
))
505 return build_complex_type (inner_type
);
507 gcc_checking_assert (GET_MODE_INNER (mode
) == VOIDmode
);
511 /* Find a mode that is suitable for representing a vector with
512 NUNITS elements of mode INNERMODE. Returns BLKmode if there
513 is no suitable mode. */
516 mode_for_vector (machine_mode innermode
, unsigned nunits
)
520 /* First, look for a supported vector type. */
521 if (SCALAR_FLOAT_MODE_P (innermode
))
522 mode
= MIN_MODE_VECTOR_FLOAT
;
523 else if (SCALAR_FRACT_MODE_P (innermode
))
524 mode
= MIN_MODE_VECTOR_FRACT
;
525 else if (SCALAR_UFRACT_MODE_P (innermode
))
526 mode
= MIN_MODE_VECTOR_UFRACT
;
527 else if (SCALAR_ACCUM_MODE_P (innermode
))
528 mode
= MIN_MODE_VECTOR_ACCUM
;
529 else if (SCALAR_UACCUM_MODE_P (innermode
))
530 mode
= MIN_MODE_VECTOR_UACCUM
;
532 mode
= MIN_MODE_VECTOR_INT
;
534 /* Do not check vector_mode_supported_p here. We'll do that
535 later in vector_type_mode. */
536 for (; mode
!= VOIDmode
; mode
= GET_MODE_WIDER_MODE (mode
))
537 if (GET_MODE_NUNITS (mode
) == nunits
538 && GET_MODE_INNER (mode
) == innermode
)
541 /* For integers, try mapping it to a same-sized scalar mode. */
543 && GET_MODE_CLASS (innermode
) == MODE_INT
)
544 mode
= mode_for_size (nunits
* GET_MODE_BITSIZE (innermode
),
548 || (GET_MODE_CLASS (mode
) == MODE_INT
549 && !have_regs_of_mode
[mode
]))
555 /* Return the alignment of MODE. This will be bounded by 1 and
556 BIGGEST_ALIGNMENT. */
559 get_mode_alignment (machine_mode mode
)
561 return MIN (BIGGEST_ALIGNMENT
, MAX (1, mode_base_align
[mode
]*BITS_PER_UNIT
));
564 /* Return the precision of the mode, or for a complex or vector mode the
565 precision of the mode of its elements. */
568 element_precision (machine_mode mode
)
570 if (COMPLEX_MODE_P (mode
) || VECTOR_MODE_P (mode
))
571 mode
= GET_MODE_INNER (mode
);
573 return GET_MODE_PRECISION (mode
);
576 /* Return the natural mode of an array, given that it is SIZE bytes in
577 total and has elements of type ELEM_TYPE. */
580 mode_for_array (tree elem_type
, tree size
)
583 unsigned HOST_WIDE_INT int_size
, int_elem_size
;
586 /* One-element arrays get the component type's mode. */
587 elem_size
= TYPE_SIZE (elem_type
);
588 if (simple_cst_equal (size
, elem_size
))
589 return TYPE_MODE (elem_type
);
592 if (tree_fits_uhwi_p (size
) && tree_fits_uhwi_p (elem_size
))
594 int_size
= tree_to_uhwi (size
);
595 int_elem_size
= tree_to_uhwi (elem_size
);
596 if (int_elem_size
> 0
597 && int_size
% int_elem_size
== 0
598 && targetm
.array_mode_supported_p (TYPE_MODE (elem_type
),
599 int_size
/ int_elem_size
))
602 return mode_for_size_tree (size
, MODE_INT
, limit_p
);
605 /* Subroutine of layout_decl: Force alignment required for the data type.
606 But if the decl itself wants greater alignment, don't override that. */
609 do_type_align (tree type
, tree decl
)
611 if (TYPE_ALIGN (type
) > DECL_ALIGN (decl
))
613 DECL_ALIGN (decl
) = TYPE_ALIGN (type
);
614 if (TREE_CODE (decl
) == FIELD_DECL
)
615 DECL_USER_ALIGN (decl
) = TYPE_USER_ALIGN (type
);
619 /* Set the size, mode and alignment of a ..._DECL node.
620 TYPE_DECL does need this for C++.
621 Note that LABEL_DECL and CONST_DECL nodes do not need this,
622 and FUNCTION_DECL nodes have them set up in a special (and simple) way.
623 Don't call layout_decl for them.
625 KNOWN_ALIGN is the amount of alignment we can assume this
626 decl has with no special effort. It is relevant only for FIELD_DECLs
627 and depends on the previous fields.
628 All that matters about KNOWN_ALIGN is which powers of 2 divide it.
629 If KNOWN_ALIGN is 0, it means, "as much alignment as you like":
630 the record will be aligned to suit. */
633 layout_decl (tree decl
, unsigned int known_align
)
635 tree type
= TREE_TYPE (decl
);
636 enum tree_code code
= TREE_CODE (decl
);
638 location_t loc
= DECL_SOURCE_LOCATION (decl
);
640 if (code
== CONST_DECL
)
643 gcc_assert (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
644 || code
== TYPE_DECL
||code
== FIELD_DECL
);
646 rtl
= DECL_RTL_IF_SET (decl
);
648 if (type
== error_mark_node
)
649 type
= void_type_node
;
651 /* Usually the size and mode come from the data type without change,
652 however, the front-end may set the explicit width of the field, so its
653 size may not be the same as the size of its type. This happens with
654 bitfields, of course (an `int' bitfield may be only 2 bits, say), but it
655 also happens with other fields. For example, the C++ front-end creates
656 zero-sized fields corresponding to empty base classes, and depends on
657 layout_type setting DECL_FIELD_BITPOS correctly for the field. Set the
658 size in bytes from the size in bits. If we have already set the mode,
659 don't set it again since we can be called twice for FIELD_DECLs. */
661 DECL_UNSIGNED (decl
) = TYPE_UNSIGNED (type
);
662 if (DECL_MODE (decl
) == VOIDmode
)
663 DECL_MODE (decl
) = TYPE_MODE (type
);
665 if (DECL_SIZE (decl
) == 0)
667 DECL_SIZE (decl
) = TYPE_SIZE (type
);
668 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (type
);
670 else if (DECL_SIZE_UNIT (decl
) == 0)
671 DECL_SIZE_UNIT (decl
)
672 = fold_convert_loc (loc
, sizetype
,
673 size_binop_loc (loc
, CEIL_DIV_EXPR
, DECL_SIZE (decl
),
676 if (code
!= FIELD_DECL
)
677 /* For non-fields, update the alignment from the type. */
678 do_type_align (type
, decl
);
680 /* For fields, it's a bit more complicated... */
682 bool old_user_align
= DECL_USER_ALIGN (decl
);
683 bool zero_bitfield
= false;
684 bool packed_p
= DECL_PACKED (decl
);
687 if (DECL_BIT_FIELD (decl
))
689 DECL_BIT_FIELD_TYPE (decl
) = type
;
691 /* A zero-length bit-field affects the alignment of the next
692 field. In essence such bit-fields are not influenced by
693 any packing due to #pragma pack or attribute packed. */
694 if (integer_zerop (DECL_SIZE (decl
))
695 && ! targetm
.ms_bitfield_layout_p (DECL_FIELD_CONTEXT (decl
)))
697 zero_bitfield
= true;
699 if (PCC_BITFIELD_TYPE_MATTERS
)
700 do_type_align (type
, decl
);
703 #ifdef EMPTY_FIELD_BOUNDARY
704 if (EMPTY_FIELD_BOUNDARY
> DECL_ALIGN (decl
))
706 DECL_ALIGN (decl
) = EMPTY_FIELD_BOUNDARY
;
707 DECL_USER_ALIGN (decl
) = 0;
713 /* See if we can use an ordinary integer mode for a bit-field.
714 Conditions are: a fixed size that is correct for another mode,
715 occupying a complete byte or bytes on proper boundary. */
716 if (TYPE_SIZE (type
) != 0
717 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
718 && GET_MODE_CLASS (TYPE_MODE (type
)) == MODE_INT
)
721 = mode_for_size_tree (DECL_SIZE (decl
), MODE_INT
, 1);
722 unsigned int xalign
= GET_MODE_ALIGNMENT (xmode
);
725 && !(xalign
> BITS_PER_UNIT
&& DECL_PACKED (decl
))
726 && (known_align
== 0 || known_align
>= xalign
))
728 DECL_ALIGN (decl
) = MAX (xalign
, DECL_ALIGN (decl
));
729 DECL_MODE (decl
) = xmode
;
730 DECL_BIT_FIELD (decl
) = 0;
734 /* Turn off DECL_BIT_FIELD if we won't need it set. */
735 if (TYPE_MODE (type
) == BLKmode
&& DECL_MODE (decl
) == BLKmode
736 && known_align
>= TYPE_ALIGN (type
)
737 && DECL_ALIGN (decl
) >= TYPE_ALIGN (type
))
738 DECL_BIT_FIELD (decl
) = 0;
740 else if (packed_p
&& DECL_USER_ALIGN (decl
))
741 /* Don't touch DECL_ALIGN. For other packed fields, go ahead and
742 round up; we'll reduce it again below. We want packing to
743 supersede USER_ALIGN inherited from the type, but defer to
744 alignment explicitly specified on the field decl. */;
746 do_type_align (type
, decl
);
748 /* If the field is packed and not explicitly aligned, give it the
749 minimum alignment. Note that do_type_align may set
750 DECL_USER_ALIGN, so we need to check old_user_align instead. */
753 DECL_ALIGN (decl
) = MIN (DECL_ALIGN (decl
), BITS_PER_UNIT
);
755 if (! packed_p
&& ! DECL_USER_ALIGN (decl
))
757 /* Some targets (i.e. i386, VMS) limit struct field alignment
758 to a lower boundary than alignment of variables unless
759 it was overridden by attribute aligned. */
760 #ifdef BIGGEST_FIELD_ALIGNMENT
762 = MIN (DECL_ALIGN (decl
), (unsigned) BIGGEST_FIELD_ALIGNMENT
);
764 #ifdef ADJUST_FIELD_ALIGN
765 DECL_ALIGN (decl
) = ADJUST_FIELD_ALIGN (decl
, DECL_ALIGN (decl
));
770 mfa
= initial_max_fld_align
* BITS_PER_UNIT
;
772 mfa
= maximum_field_alignment
;
773 /* Should this be controlled by DECL_USER_ALIGN, too? */
775 DECL_ALIGN (decl
) = MIN (DECL_ALIGN (decl
), mfa
);
778 /* Evaluate nonconstant size only once, either now or as soon as safe. */
779 if (DECL_SIZE (decl
) != 0 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
780 DECL_SIZE (decl
) = variable_size (DECL_SIZE (decl
));
781 if (DECL_SIZE_UNIT (decl
) != 0
782 && TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
)
783 DECL_SIZE_UNIT (decl
) = variable_size (DECL_SIZE_UNIT (decl
));
785 /* If requested, warn about definitions of large data objects. */
787 && (code
== VAR_DECL
|| code
== PARM_DECL
)
788 && ! DECL_EXTERNAL (decl
))
790 tree size
= DECL_SIZE_UNIT (decl
);
792 if (size
!= 0 && TREE_CODE (size
) == INTEGER_CST
793 && compare_tree_int (size
, larger_than_size
) > 0)
795 int size_as_int
= TREE_INT_CST_LOW (size
);
797 if (compare_tree_int (size
, size_as_int
) == 0)
798 warning (OPT_Wlarger_than_
, "size of %q+D is %d bytes", decl
, size_as_int
);
800 warning (OPT_Wlarger_than_
, "size of %q+D is larger than %wd bytes",
801 decl
, larger_than_size
);
805 /* If the RTL was already set, update its mode and mem attributes. */
808 PUT_MODE (rtl
, DECL_MODE (decl
));
809 SET_DECL_RTL (decl
, 0);
810 set_mem_attributes (rtl
, decl
, 1);
811 SET_DECL_RTL (decl
, rtl
);
815 /* Given a VAR_DECL, PARM_DECL or RESULT_DECL, clears the results of
816 a previous call to layout_decl and calls it again. */
819 relayout_decl (tree decl
)
821 DECL_SIZE (decl
) = DECL_SIZE_UNIT (decl
) = 0;
822 DECL_MODE (decl
) = VOIDmode
;
823 if (!DECL_USER_ALIGN (decl
))
824 DECL_ALIGN (decl
) = 0;
825 SET_DECL_RTL (decl
, 0);
827 layout_decl (decl
, 0);
830 /* Begin laying out type T, which may be a RECORD_TYPE, UNION_TYPE, or
831 QUAL_UNION_TYPE. Return a pointer to a struct record_layout_info which
832 is to be passed to all other layout functions for this record. It is the
833 responsibility of the caller to call `free' for the storage returned.
834 Note that garbage collection is not permitted until we finish laying
838 start_record_layout (tree t
)
840 record_layout_info rli
= XNEW (struct record_layout_info_s
);
844 /* If the type has a minimum specified alignment (via an attribute
845 declaration, for example) use it -- otherwise, start with a
846 one-byte alignment. */
847 rli
->record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (t
));
848 rli
->unpacked_align
= rli
->record_align
;
849 rli
->offset_align
= MAX (rli
->record_align
, BIGGEST_ALIGNMENT
);
851 #ifdef STRUCTURE_SIZE_BOUNDARY
852 /* Packed structures don't need to have minimum size. */
853 if (! TYPE_PACKED (t
))
857 /* #pragma pack overrides STRUCTURE_SIZE_BOUNDARY. */
858 tmp
= (unsigned) STRUCTURE_SIZE_BOUNDARY
;
859 if (maximum_field_alignment
!= 0)
860 tmp
= MIN (tmp
, maximum_field_alignment
);
861 rli
->record_align
= MAX (rli
->record_align
, tmp
);
865 rli
->offset
= size_zero_node
;
866 rli
->bitpos
= bitsize_zero_node
;
868 rli
->pending_statics
= 0;
869 rli
->packed_maybe_necessary
= 0;
870 rli
->remaining_in_alignment
= 0;
875 /* Return the combined bit position for the byte offset OFFSET and the
878 These functions operate on byte and bit positions present in FIELD_DECLs
879 and assume that these expressions result in no (intermediate) overflow.
880 This assumption is necessary to fold the expressions as much as possible,
881 so as to avoid creating artificially variable-sized types in languages
882 supporting variable-sized types like Ada. */
885 bit_from_pos (tree offset
, tree bitpos
)
887 if (TREE_CODE (offset
) == PLUS_EXPR
)
888 offset
= size_binop (PLUS_EXPR
,
889 fold_convert (bitsizetype
, TREE_OPERAND (offset
, 0)),
890 fold_convert (bitsizetype
, TREE_OPERAND (offset
, 1)));
892 offset
= fold_convert (bitsizetype
, offset
);
893 return size_binop (PLUS_EXPR
, bitpos
,
894 size_binop (MULT_EXPR
, offset
, bitsize_unit_node
));
897 /* Return the combined truncated byte position for the byte offset OFFSET and
898 the bit position BITPOS. */
901 byte_from_pos (tree offset
, tree bitpos
)
904 if (TREE_CODE (bitpos
) == MULT_EXPR
905 && tree_int_cst_equal (TREE_OPERAND (bitpos
, 1), bitsize_unit_node
))
906 bytepos
= TREE_OPERAND (bitpos
, 0);
908 bytepos
= size_binop (TRUNC_DIV_EXPR
, bitpos
, bitsize_unit_node
);
909 return size_binop (PLUS_EXPR
, offset
, fold_convert (sizetype
, bytepos
));
912 /* Split the bit position POS into a byte offset *POFFSET and a bit
913 position *PBITPOS with the byte offset aligned to OFF_ALIGN bits. */
916 pos_from_bit (tree
*poffset
, tree
*pbitpos
, unsigned int off_align
,
919 tree toff_align
= bitsize_int (off_align
);
920 if (TREE_CODE (pos
) == MULT_EXPR
921 && tree_int_cst_equal (TREE_OPERAND (pos
, 1), toff_align
))
923 *poffset
= size_binop (MULT_EXPR
,
924 fold_convert (sizetype
, TREE_OPERAND (pos
, 0)),
925 size_int (off_align
/ BITS_PER_UNIT
));
926 *pbitpos
= bitsize_zero_node
;
930 *poffset
= size_binop (MULT_EXPR
,
931 fold_convert (sizetype
,
932 size_binop (FLOOR_DIV_EXPR
, pos
,
934 size_int (off_align
/ BITS_PER_UNIT
));
935 *pbitpos
= size_binop (FLOOR_MOD_EXPR
, pos
, toff_align
);
939 /* Given a pointer to bit and byte offsets and an offset alignment,
940 normalize the offsets so they are within the alignment. */
943 normalize_offset (tree
*poffset
, tree
*pbitpos
, unsigned int off_align
)
945 /* If the bit position is now larger than it should be, adjust it
947 if (compare_tree_int (*pbitpos
, off_align
) >= 0)
950 pos_from_bit (&offset
, &bitpos
, off_align
, *pbitpos
);
951 *poffset
= size_binop (PLUS_EXPR
, *poffset
, offset
);
956 /* Print debugging information about the information in RLI. */
959 debug_rli (record_layout_info rli
)
961 print_node_brief (stderr
, "type", rli
->t
, 0);
962 print_node_brief (stderr
, "\noffset", rli
->offset
, 0);
963 print_node_brief (stderr
, " bitpos", rli
->bitpos
, 0);
965 fprintf (stderr
, "\naligns: rec = %u, unpack = %u, off = %u\n",
966 rli
->record_align
, rli
->unpacked_align
,
969 /* The ms_struct code is the only that uses this. */
970 if (targetm
.ms_bitfield_layout_p (rli
->t
))
971 fprintf (stderr
, "remaining in alignment = %u\n", rli
->remaining_in_alignment
);
973 if (rli
->packed_maybe_necessary
)
974 fprintf (stderr
, "packed may be necessary\n");
976 if (!vec_safe_is_empty (rli
->pending_statics
))
978 fprintf (stderr
, "pending statics:\n");
979 debug_vec_tree (rli
->pending_statics
);
983 /* Given an RLI with a possibly-incremented BITPOS, adjust OFFSET and
984 BITPOS if necessary to keep BITPOS below OFFSET_ALIGN. */
987 normalize_rli (record_layout_info rli
)
989 normalize_offset (&rli
->offset
, &rli
->bitpos
, rli
->offset_align
);
992 /* Returns the size in bytes allocated so far. */
995 rli_size_unit_so_far (record_layout_info rli
)
997 return byte_from_pos (rli
->offset
, rli
->bitpos
);
1000 /* Returns the size in bits allocated so far. */
1003 rli_size_so_far (record_layout_info rli
)
1005 return bit_from_pos (rli
->offset
, rli
->bitpos
);
1008 /* FIELD is about to be added to RLI->T. The alignment (in bits) of
1009 the next available location within the record is given by KNOWN_ALIGN.
1010 Update the variable alignment fields in RLI, and return the alignment
1011 to give the FIELD. */
1014 update_alignment_for_field (record_layout_info rli
, tree field
,
1015 unsigned int known_align
)
1017 /* The alignment required for FIELD. */
1018 unsigned int desired_align
;
1019 /* The type of this field. */
1020 tree type
= TREE_TYPE (field
);
1021 /* True if the field was explicitly aligned by the user. */
1025 /* Do not attempt to align an ERROR_MARK node */
1026 if (TREE_CODE (type
) == ERROR_MARK
)
1029 /* Lay out the field so we know what alignment it needs. */
1030 layout_decl (field
, known_align
);
1031 desired_align
= DECL_ALIGN (field
);
1032 user_align
= DECL_USER_ALIGN (field
);
1034 is_bitfield
= (type
!= error_mark_node
1035 && DECL_BIT_FIELD_TYPE (field
)
1036 && ! integer_zerop (TYPE_SIZE (type
)));
1038 /* Record must have at least as much alignment as any field.
1039 Otherwise, the alignment of the field within the record is
1041 if (targetm
.ms_bitfield_layout_p (rli
->t
))
1043 /* Here, the alignment of the underlying type of a bitfield can
1044 affect the alignment of a record; even a zero-sized field
1045 can do this. The alignment should be to the alignment of
1046 the type, except that for zero-size bitfields this only
1047 applies if there was an immediately prior, nonzero-size
1048 bitfield. (That's the way it is, experimentally.) */
1049 if ((!is_bitfield
&& !DECL_PACKED (field
))
1050 || ((DECL_SIZE (field
) == NULL_TREE
1051 || !integer_zerop (DECL_SIZE (field
)))
1052 ? !DECL_PACKED (field
)
1054 && DECL_BIT_FIELD_TYPE (rli
->prev_field
)
1055 && ! integer_zerop (DECL_SIZE (rli
->prev_field
)))))
1057 unsigned int type_align
= TYPE_ALIGN (type
);
1058 type_align
= MAX (type_align
, desired_align
);
1059 if (maximum_field_alignment
!= 0)
1060 type_align
= MIN (type_align
, maximum_field_alignment
);
1061 rli
->record_align
= MAX (rli
->record_align
, type_align
);
1062 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
1065 else if (is_bitfield
&& PCC_BITFIELD_TYPE_MATTERS
)
1067 /* Named bit-fields cause the entire structure to have the
1068 alignment implied by their type. Some targets also apply the same
1069 rules to unnamed bitfields. */
1070 if (DECL_NAME (field
) != 0
1071 || targetm
.align_anon_bitfield ())
1073 unsigned int type_align
= TYPE_ALIGN (type
);
1075 #ifdef ADJUST_FIELD_ALIGN
1076 if (! TYPE_USER_ALIGN (type
))
1077 type_align
= ADJUST_FIELD_ALIGN (field
, type_align
);
1080 /* Targets might chose to handle unnamed and hence possibly
1081 zero-width bitfield. Those are not influenced by #pragmas
1082 or packed attributes. */
1083 if (integer_zerop (DECL_SIZE (field
)))
1085 if (initial_max_fld_align
)
1086 type_align
= MIN (type_align
,
1087 initial_max_fld_align
* BITS_PER_UNIT
);
1089 else if (maximum_field_alignment
!= 0)
1090 type_align
= MIN (type_align
, maximum_field_alignment
);
1091 else if (DECL_PACKED (field
))
1092 type_align
= MIN (type_align
, BITS_PER_UNIT
);
1094 /* The alignment of the record is increased to the maximum
1095 of the current alignment, the alignment indicated on the
1096 field (i.e., the alignment specified by an __aligned__
1097 attribute), and the alignment indicated by the type of
1099 rli
->record_align
= MAX (rli
->record_align
, desired_align
);
1100 rli
->record_align
= MAX (rli
->record_align
, type_align
);
1103 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
1104 user_align
|= TYPE_USER_ALIGN (type
);
1109 rli
->record_align
= MAX (rli
->record_align
, desired_align
);
1110 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
1113 TYPE_USER_ALIGN (rli
->t
) |= user_align
;
1115 return desired_align
;
1118 /* Called from place_field to handle unions. */
1121 place_union_field (record_layout_info rli
, tree field
)
1123 update_alignment_for_field (rli
, field
, /*known_align=*/0);
1125 DECL_FIELD_OFFSET (field
) = size_zero_node
;
1126 DECL_FIELD_BIT_OFFSET (field
) = bitsize_zero_node
;
1127 SET_DECL_OFFSET_ALIGN (field
, BIGGEST_ALIGNMENT
);
1129 /* If this is an ERROR_MARK return *after* having set the
1130 field at the start of the union. This helps when parsing
1132 if (TREE_CODE (TREE_TYPE (field
)) == ERROR_MARK
)
1135 /* We assume the union's size will be a multiple of a byte so we don't
1136 bother with BITPOS. */
1137 if (TREE_CODE (rli
->t
) == UNION_TYPE
)
1138 rli
->offset
= size_binop (MAX_EXPR
, rli
->offset
, DECL_SIZE_UNIT (field
));
1139 else if (TREE_CODE (rli
->t
) == QUAL_UNION_TYPE
)
1140 rli
->offset
= fold_build3 (COND_EXPR
, sizetype
, DECL_QUALIFIER (field
),
1141 DECL_SIZE_UNIT (field
), rli
->offset
);
1144 /* A bitfield of SIZE with a required access alignment of ALIGN is allocated
1145 at BYTE_OFFSET / BIT_OFFSET. Return nonzero if the field would span more
1146 units of alignment than the underlying TYPE. */
1148 excess_unit_span (HOST_WIDE_INT byte_offset
, HOST_WIDE_INT bit_offset
,
1149 HOST_WIDE_INT size
, HOST_WIDE_INT align
, tree type
)
1151 /* Note that the calculation of OFFSET might overflow; we calculate it so
1152 that we still get the right result as long as ALIGN is a power of two. */
1153 unsigned HOST_WIDE_INT offset
= byte_offset
* BITS_PER_UNIT
+ bit_offset
;
1155 offset
= offset
% align
;
1156 return ((offset
+ size
+ align
- 1) / align
1157 > tree_to_uhwi (TYPE_SIZE (type
)) / align
);
1160 /* RLI contains information about the layout of a RECORD_TYPE. FIELD
1161 is a FIELD_DECL to be added after those fields already present in
1162 T. (FIELD is not actually added to the TYPE_FIELDS list here;
1163 callers that desire that behavior must manually perform that step.) */
1166 place_field (record_layout_info rli
, tree field
)
1168 /* The alignment required for FIELD. */
1169 unsigned int desired_align
;
1170 /* The alignment FIELD would have if we just dropped it into the
1171 record as it presently stands. */
1172 unsigned int known_align
;
1173 unsigned int actual_align
;
1174 /* The type of this field. */
1175 tree type
= TREE_TYPE (field
);
1177 gcc_assert (TREE_CODE (field
) != ERROR_MARK
);
1179 /* If FIELD is static, then treat it like a separate variable, not
1180 really like a structure field. If it is a FUNCTION_DECL, it's a
1181 method. In both cases, all we do is lay out the decl, and we do
1182 it *after* the record is laid out. */
1183 if (TREE_CODE (field
) == VAR_DECL
)
1185 vec_safe_push (rli
->pending_statics
, field
);
1189 /* Enumerators and enum types which are local to this class need not
1190 be laid out. Likewise for initialized constant fields. */
1191 else if (TREE_CODE (field
) != FIELD_DECL
)
1194 /* Unions are laid out very differently than records, so split
1195 that code off to another function. */
1196 else if (TREE_CODE (rli
->t
) != RECORD_TYPE
)
1198 place_union_field (rli
, field
);
1202 else if (TREE_CODE (type
) == ERROR_MARK
)
1204 /* Place this field at the current allocation position, so we
1205 maintain monotonicity. */
1206 DECL_FIELD_OFFSET (field
) = rli
->offset
;
1207 DECL_FIELD_BIT_OFFSET (field
) = rli
->bitpos
;
1208 SET_DECL_OFFSET_ALIGN (field
, rli
->offset_align
);
1212 /* Work out the known alignment so far. Note that A & (-A) is the
1213 value of the least-significant bit in A that is one. */
1214 if (! integer_zerop (rli
->bitpos
))
1215 known_align
= (tree_to_uhwi (rli
->bitpos
)
1216 & - tree_to_uhwi (rli
->bitpos
));
1217 else if (integer_zerop (rli
->offset
))
1219 else if (tree_fits_uhwi_p (rli
->offset
))
1220 known_align
= (BITS_PER_UNIT
1221 * (tree_to_uhwi (rli
->offset
)
1222 & - tree_to_uhwi (rli
->offset
)));
1224 known_align
= rli
->offset_align
;
1226 desired_align
= update_alignment_for_field (rli
, field
, known_align
);
1227 if (known_align
== 0)
1228 known_align
= MAX (BIGGEST_ALIGNMENT
, rli
->record_align
);
1230 if (warn_packed
&& DECL_PACKED (field
))
1232 if (known_align
>= TYPE_ALIGN (type
))
1234 if (TYPE_ALIGN (type
) > desired_align
)
1236 if (STRICT_ALIGNMENT
)
1237 warning (OPT_Wattributes
, "packed attribute causes "
1238 "inefficient alignment for %q+D", field
);
1239 /* Don't warn if DECL_PACKED was set by the type. */
1240 else if (!TYPE_PACKED (rli
->t
))
1241 warning (OPT_Wattributes
, "packed attribute is "
1242 "unnecessary for %q+D", field
);
1246 rli
->packed_maybe_necessary
= 1;
1249 /* Does this field automatically have alignment it needs by virtue
1250 of the fields that precede it and the record's own alignment? */
1251 if (known_align
< desired_align
)
1253 /* No, we need to skip space before this field.
1254 Bump the cumulative size to multiple of field alignment. */
1256 if (!targetm
.ms_bitfield_layout_p (rli
->t
)
1257 && DECL_SOURCE_LOCATION (field
) != BUILTINS_LOCATION
)
1258 warning (OPT_Wpadded
, "padding struct to align %q+D", field
);
1260 /* If the alignment is still within offset_align, just align
1261 the bit position. */
1262 if (desired_align
< rli
->offset_align
)
1263 rli
->bitpos
= round_up (rli
->bitpos
, desired_align
);
1266 /* First adjust OFFSET by the partial bits, then align. */
1268 = size_binop (PLUS_EXPR
, rli
->offset
,
1269 fold_convert (sizetype
,
1270 size_binop (CEIL_DIV_EXPR
, rli
->bitpos
,
1271 bitsize_unit_node
)));
1272 rli
->bitpos
= bitsize_zero_node
;
1274 rli
->offset
= round_up (rli
->offset
, desired_align
/ BITS_PER_UNIT
);
1277 if (! TREE_CONSTANT (rli
->offset
))
1278 rli
->offset_align
= desired_align
;
1279 if (targetm
.ms_bitfield_layout_p (rli
->t
))
1280 rli
->prev_field
= NULL
;
1283 /* Handle compatibility with PCC. Note that if the record has any
1284 variable-sized fields, we need not worry about compatibility. */
1285 if (PCC_BITFIELD_TYPE_MATTERS
1286 && ! targetm
.ms_bitfield_layout_p (rli
->t
)
1287 && TREE_CODE (field
) == FIELD_DECL
1288 && type
!= error_mark_node
1289 && DECL_BIT_FIELD (field
)
1290 && (! DECL_PACKED (field
)
1291 /* Enter for these packed fields only to issue a warning. */
1292 || TYPE_ALIGN (type
) <= BITS_PER_UNIT
)
1293 && maximum_field_alignment
== 0
1294 && ! integer_zerop (DECL_SIZE (field
))
1295 && tree_fits_uhwi_p (DECL_SIZE (field
))
1296 && tree_fits_uhwi_p (rli
->offset
)
1297 && tree_fits_uhwi_p (TYPE_SIZE (type
)))
1299 unsigned int type_align
= TYPE_ALIGN (type
);
1300 tree dsize
= DECL_SIZE (field
);
1301 HOST_WIDE_INT field_size
= tree_to_uhwi (dsize
);
1302 HOST_WIDE_INT offset
= tree_to_uhwi (rli
->offset
);
1303 HOST_WIDE_INT bit_offset
= tree_to_shwi (rli
->bitpos
);
1305 #ifdef ADJUST_FIELD_ALIGN
1306 if (! TYPE_USER_ALIGN (type
))
1307 type_align
= ADJUST_FIELD_ALIGN (field
, type_align
);
1310 /* A bit field may not span more units of alignment of its type
1311 than its type itself. Advance to next boundary if necessary. */
1312 if (excess_unit_span (offset
, bit_offset
, field_size
, type_align
, type
))
1314 if (DECL_PACKED (field
))
1316 if (warn_packed_bitfield_compat
== 1)
1319 "offset of packed bit-field %qD has changed in GCC 4.4",
1323 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1326 if (! DECL_PACKED (field
))
1327 TYPE_USER_ALIGN (rli
->t
) |= TYPE_USER_ALIGN (type
);
1330 #ifdef BITFIELD_NBYTES_LIMITED
1331 if (BITFIELD_NBYTES_LIMITED
1332 && ! targetm
.ms_bitfield_layout_p (rli
->t
)
1333 && TREE_CODE (field
) == FIELD_DECL
1334 && type
!= error_mark_node
1335 && DECL_BIT_FIELD_TYPE (field
)
1336 && ! DECL_PACKED (field
)
1337 && ! integer_zerop (DECL_SIZE (field
))
1338 && tree_fits_uhwi_p (DECL_SIZE (field
))
1339 && tree_fits_uhwi_p (rli
->offset
)
1340 && tree_fits_uhwi_p (TYPE_SIZE (type
)))
1342 unsigned int type_align
= TYPE_ALIGN (type
);
1343 tree dsize
= DECL_SIZE (field
);
1344 HOST_WIDE_INT field_size
= tree_to_uhwi (dsize
);
1345 HOST_WIDE_INT offset
= tree_to_uhwi (rli
->offset
);
1346 HOST_WIDE_INT bit_offset
= tree_to_shwi (rli
->bitpos
);
1348 #ifdef ADJUST_FIELD_ALIGN
1349 if (! TYPE_USER_ALIGN (type
))
1350 type_align
= ADJUST_FIELD_ALIGN (field
, type_align
);
1353 if (maximum_field_alignment
!= 0)
1354 type_align
= MIN (type_align
, maximum_field_alignment
);
1355 /* ??? This test is opposite the test in the containing if
1356 statement, so this code is unreachable currently. */
1357 else if (DECL_PACKED (field
))
1358 type_align
= MIN (type_align
, BITS_PER_UNIT
);
1360 /* A bit field may not span the unit of alignment of its type.
1361 Advance to next boundary if necessary. */
1362 if (excess_unit_span (offset
, bit_offset
, field_size
, type_align
, type
))
1363 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1365 TYPE_USER_ALIGN (rli
->t
) |= TYPE_USER_ALIGN (type
);
1369 /* See the docs for TARGET_MS_BITFIELD_LAYOUT_P for details.
1371 When a bit field is inserted into a packed record, the whole
1372 size of the underlying type is used by one or more same-size
1373 adjacent bitfields. (That is, if its long:3, 32 bits is
1374 used in the record, and any additional adjacent long bitfields are
1375 packed into the same chunk of 32 bits. However, if the size
1376 changes, a new field of that size is allocated.) In an unpacked
1377 record, this is the same as using alignment, but not equivalent
1380 Note: for compatibility, we use the type size, not the type alignment
1381 to determine alignment, since that matches the documentation */
1383 if (targetm
.ms_bitfield_layout_p (rli
->t
))
1385 tree prev_saved
= rli
->prev_field
;
1386 tree prev_type
= prev_saved
? DECL_BIT_FIELD_TYPE (prev_saved
) : NULL
;
1388 /* This is a bitfield if it exists. */
1389 if (rli
->prev_field
)
1391 /* If both are bitfields, nonzero, and the same size, this is
1392 the middle of a run. Zero declared size fields are special
1393 and handled as "end of run". (Note: it's nonzero declared
1394 size, but equal type sizes!) (Since we know that both
1395 the current and previous fields are bitfields by the
1396 time we check it, DECL_SIZE must be present for both.) */
1397 if (DECL_BIT_FIELD_TYPE (field
)
1398 && !integer_zerop (DECL_SIZE (field
))
1399 && !integer_zerop (DECL_SIZE (rli
->prev_field
))
1400 && tree_fits_shwi_p (DECL_SIZE (rli
->prev_field
))
1401 && tree_fits_uhwi_p (TYPE_SIZE (type
))
1402 && simple_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (prev_type
)))
1404 /* We're in the middle of a run of equal type size fields; make
1405 sure we realign if we run out of bits. (Not decl size,
1407 HOST_WIDE_INT bitsize
= tree_to_uhwi (DECL_SIZE (field
));
1409 if (rli
->remaining_in_alignment
< bitsize
)
1411 HOST_WIDE_INT typesize
= tree_to_uhwi (TYPE_SIZE (type
));
1413 /* out of bits; bump up to next 'word'. */
1415 = size_binop (PLUS_EXPR
, rli
->bitpos
,
1416 bitsize_int (rli
->remaining_in_alignment
));
1417 rli
->prev_field
= field
;
1418 if (typesize
< bitsize
)
1419 rli
->remaining_in_alignment
= 0;
1421 rli
->remaining_in_alignment
= typesize
- bitsize
;
1424 rli
->remaining_in_alignment
-= bitsize
;
1428 /* End of a run: if leaving a run of bitfields of the same type
1429 size, we have to "use up" the rest of the bits of the type
1432 Compute the new position as the sum of the size for the prior
1433 type and where we first started working on that type.
1434 Note: since the beginning of the field was aligned then
1435 of course the end will be too. No round needed. */
1437 if (!integer_zerop (DECL_SIZE (rli
->prev_field
)))
1440 = size_binop (PLUS_EXPR
, rli
->bitpos
,
1441 bitsize_int (rli
->remaining_in_alignment
));
1444 /* We "use up" size zero fields; the code below should behave
1445 as if the prior field was not a bitfield. */
1448 /* Cause a new bitfield to be captured, either this time (if
1449 currently a bitfield) or next time we see one. */
1450 if (!DECL_BIT_FIELD_TYPE (field
)
1451 || integer_zerop (DECL_SIZE (field
)))
1452 rli
->prev_field
= NULL
;
1455 normalize_rli (rli
);
1458 /* If we're starting a new run of same type size bitfields
1459 (or a run of non-bitfields), set up the "first of the run"
1462 That is, if the current field is not a bitfield, or if there
1463 was a prior bitfield the type sizes differ, or if there wasn't
1464 a prior bitfield the size of the current field is nonzero.
1466 Note: we must be sure to test ONLY the type size if there was
1467 a prior bitfield and ONLY for the current field being zero if
1470 if (!DECL_BIT_FIELD_TYPE (field
)
1471 || (prev_saved
!= NULL
1472 ? !simple_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (prev_type
))
1473 : !integer_zerop (DECL_SIZE (field
)) ))
1475 /* Never smaller than a byte for compatibility. */
1476 unsigned int type_align
= BITS_PER_UNIT
;
1478 /* (When not a bitfield), we could be seeing a flex array (with
1479 no DECL_SIZE). Since we won't be using remaining_in_alignment
1480 until we see a bitfield (and come by here again) we just skip
1482 if (DECL_SIZE (field
) != NULL
1483 && tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (field
)))
1484 && tree_fits_uhwi_p (DECL_SIZE (field
)))
1486 unsigned HOST_WIDE_INT bitsize
1487 = tree_to_uhwi (DECL_SIZE (field
));
1488 unsigned HOST_WIDE_INT typesize
1489 = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (field
)));
1491 if (typesize
< bitsize
)
1492 rli
->remaining_in_alignment
= 0;
1494 rli
->remaining_in_alignment
= typesize
- bitsize
;
1497 /* Now align (conventionally) for the new type. */
1498 type_align
= TYPE_ALIGN (TREE_TYPE (field
));
1500 if (maximum_field_alignment
!= 0)
1501 type_align
= MIN (type_align
, maximum_field_alignment
);
1503 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1505 /* If we really aligned, don't allow subsequent bitfields
1507 rli
->prev_field
= NULL
;
1511 /* Offset so far becomes the position of this field after normalizing. */
1512 normalize_rli (rli
);
1513 DECL_FIELD_OFFSET (field
) = rli
->offset
;
1514 DECL_FIELD_BIT_OFFSET (field
) = rli
->bitpos
;
1515 SET_DECL_OFFSET_ALIGN (field
, rli
->offset_align
);
1517 /* Evaluate nonconstant offsets only once, either now or as soon as safe. */
1518 if (TREE_CODE (DECL_FIELD_OFFSET (field
)) != INTEGER_CST
)
1519 DECL_FIELD_OFFSET (field
) = variable_size (DECL_FIELD_OFFSET (field
));
1521 /* If this field ended up more aligned than we thought it would be (we
1522 approximate this by seeing if its position changed), lay out the field
1523 again; perhaps we can use an integral mode for it now. */
1524 if (! integer_zerop (DECL_FIELD_BIT_OFFSET (field
)))
1525 actual_align
= (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field
))
1526 & - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field
)));
1527 else if (integer_zerop (DECL_FIELD_OFFSET (field
)))
1528 actual_align
= MAX (BIGGEST_ALIGNMENT
, rli
->record_align
);
1529 else if (tree_fits_uhwi_p (DECL_FIELD_OFFSET (field
)))
1530 actual_align
= (BITS_PER_UNIT
1531 * (tree_to_uhwi (DECL_FIELD_OFFSET (field
))
1532 & - tree_to_uhwi (DECL_FIELD_OFFSET (field
))));
1534 actual_align
= DECL_OFFSET_ALIGN (field
);
1535 /* ACTUAL_ALIGN is still the actual alignment *within the record* .
1536 store / extract bit field operations will check the alignment of the
1537 record against the mode of bit fields. */
1539 if (known_align
!= actual_align
)
1540 layout_decl (field
, actual_align
);
1542 if (rli
->prev_field
== NULL
&& DECL_BIT_FIELD_TYPE (field
))
1543 rli
->prev_field
= field
;
1545 /* Now add size of this field to the size of the record. If the size is
1546 not constant, treat the field as being a multiple of bytes and just
1547 adjust the offset, resetting the bit position. Otherwise, apportion the
1548 size amongst the bit position and offset. First handle the case of an
1549 unspecified size, which can happen when we have an invalid nested struct
1550 definition, such as struct j { struct j { int i; } }. The error message
1551 is printed in finish_struct. */
1552 if (DECL_SIZE (field
) == 0)
1554 else if (TREE_CODE (DECL_SIZE (field
)) != INTEGER_CST
1555 || TREE_OVERFLOW (DECL_SIZE (field
)))
1558 = size_binop (PLUS_EXPR
, rli
->offset
,
1559 fold_convert (sizetype
,
1560 size_binop (CEIL_DIV_EXPR
, rli
->bitpos
,
1561 bitsize_unit_node
)));
1563 = size_binop (PLUS_EXPR
, rli
->offset
, DECL_SIZE_UNIT (field
));
1564 rli
->bitpos
= bitsize_zero_node
;
1565 rli
->offset_align
= MIN (rli
->offset_align
, desired_align
);
1567 else if (targetm
.ms_bitfield_layout_p (rli
->t
))
1569 rli
->bitpos
= size_binop (PLUS_EXPR
, rli
->bitpos
, DECL_SIZE (field
));
1571 /* If we ended a bitfield before the full length of the type then
1572 pad the struct out to the full length of the last type. */
1573 if ((DECL_CHAIN (field
) == NULL
1574 || TREE_CODE (DECL_CHAIN (field
)) != FIELD_DECL
)
1575 && DECL_BIT_FIELD_TYPE (field
)
1576 && !integer_zerop (DECL_SIZE (field
)))
1577 rli
->bitpos
= size_binop (PLUS_EXPR
, rli
->bitpos
,
1578 bitsize_int (rli
->remaining_in_alignment
));
1580 normalize_rli (rli
);
1584 rli
->bitpos
= size_binop (PLUS_EXPR
, rli
->bitpos
, DECL_SIZE (field
));
1585 normalize_rli (rli
);
1589 /* Assuming that all the fields have been laid out, this function uses
1590 RLI to compute the final TYPE_SIZE, TYPE_ALIGN, etc. for the type
1591 indicated by RLI. */
1594 finalize_record_size (record_layout_info rli
)
1596 tree unpadded_size
, unpadded_size_unit
;
1598 /* Now we want just byte and bit offsets, so set the offset alignment
1599 to be a byte and then normalize. */
1600 rli
->offset_align
= BITS_PER_UNIT
;
1601 normalize_rli (rli
);
1603 /* Determine the desired alignment. */
1604 #ifdef ROUND_TYPE_ALIGN
1605 TYPE_ALIGN (rli
->t
) = ROUND_TYPE_ALIGN (rli
->t
, TYPE_ALIGN (rli
->t
),
1608 TYPE_ALIGN (rli
->t
) = MAX (TYPE_ALIGN (rli
->t
), rli
->record_align
);
1611 /* Compute the size so far. Be sure to allow for extra bits in the
1612 size in bytes. We have guaranteed above that it will be no more
1613 than a single byte. */
1614 unpadded_size
= rli_size_so_far (rli
);
1615 unpadded_size_unit
= rli_size_unit_so_far (rli
);
1616 if (! integer_zerop (rli
->bitpos
))
1618 = size_binop (PLUS_EXPR
, unpadded_size_unit
, size_one_node
);
1620 /* Round the size up to be a multiple of the required alignment. */
1621 TYPE_SIZE (rli
->t
) = round_up (unpadded_size
, TYPE_ALIGN (rli
->t
));
1622 TYPE_SIZE_UNIT (rli
->t
)
1623 = round_up (unpadded_size_unit
, TYPE_ALIGN_UNIT (rli
->t
));
1625 if (TREE_CONSTANT (unpadded_size
)
1626 && simple_cst_equal (unpadded_size
, TYPE_SIZE (rli
->t
)) == 0
1627 && input_location
!= BUILTINS_LOCATION
)
1628 warning (OPT_Wpadded
, "padding struct size to alignment boundary");
1630 if (warn_packed
&& TREE_CODE (rli
->t
) == RECORD_TYPE
1631 && TYPE_PACKED (rli
->t
) && ! rli
->packed_maybe_necessary
1632 && TREE_CONSTANT (unpadded_size
))
1636 #ifdef ROUND_TYPE_ALIGN
1638 = ROUND_TYPE_ALIGN (rli
->t
, TYPE_ALIGN (rli
->t
), rli
->unpacked_align
);
1640 rli
->unpacked_align
= MAX (TYPE_ALIGN (rli
->t
), rli
->unpacked_align
);
1643 unpacked_size
= round_up (TYPE_SIZE (rli
->t
), rli
->unpacked_align
);
1644 if (simple_cst_equal (unpacked_size
, TYPE_SIZE (rli
->t
)))
1646 if (TYPE_NAME (rli
->t
))
1650 if (TREE_CODE (TYPE_NAME (rli
->t
)) == IDENTIFIER_NODE
)
1651 name
= TYPE_NAME (rli
->t
);
1653 name
= DECL_NAME (TYPE_NAME (rli
->t
));
1655 if (STRICT_ALIGNMENT
)
1656 warning (OPT_Wpacked
, "packed attribute causes inefficient "
1657 "alignment for %qE", name
);
1659 warning (OPT_Wpacked
,
1660 "packed attribute is unnecessary for %qE", name
);
1664 if (STRICT_ALIGNMENT
)
1665 warning (OPT_Wpacked
,
1666 "packed attribute causes inefficient alignment");
1668 warning (OPT_Wpacked
, "packed attribute is unnecessary");
1674 /* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE). */
1677 compute_record_mode (tree type
)
1680 machine_mode mode
= VOIDmode
;
1682 /* Most RECORD_TYPEs have BLKmode, so we start off assuming that.
1683 However, if possible, we use a mode that fits in a register
1684 instead, in order to allow for better optimization down the
1686 SET_TYPE_MODE (type
, BLKmode
);
1688 if (! tree_fits_uhwi_p (TYPE_SIZE (type
)))
1691 /* A record which has any BLKmode members must itself be
1692 BLKmode; it can't go in a register. Unless the member is
1693 BLKmode only because it isn't aligned. */
1694 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1696 if (TREE_CODE (field
) != FIELD_DECL
)
1699 if (TREE_CODE (TREE_TYPE (field
)) == ERROR_MARK
1700 || (TYPE_MODE (TREE_TYPE (field
)) == BLKmode
1701 && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field
))
1702 && !(TYPE_SIZE (TREE_TYPE (field
)) != 0
1703 && integer_zerop (TYPE_SIZE (TREE_TYPE (field
)))))
1704 || ! tree_fits_uhwi_p (bit_position (field
))
1705 || DECL_SIZE (field
) == 0
1706 || ! tree_fits_uhwi_p (DECL_SIZE (field
)))
1709 /* If this field is the whole struct, remember its mode so
1710 that, say, we can put a double in a class into a DF
1711 register instead of forcing it to live in the stack. */
1712 if (simple_cst_equal (TYPE_SIZE (type
), DECL_SIZE (field
)))
1713 mode
= DECL_MODE (field
);
1715 /* With some targets, it is sub-optimal to access an aligned
1716 BLKmode structure as a scalar. */
1717 if (targetm
.member_type_forces_blk (field
, mode
))
1721 /* If we only have one real field; use its mode if that mode's size
1722 matches the type's size. This only applies to RECORD_TYPE. This
1723 does not apply to unions. */
1724 if (TREE_CODE (type
) == RECORD_TYPE
&& mode
!= VOIDmode
1725 && tree_fits_uhwi_p (TYPE_SIZE (type
))
1726 && GET_MODE_BITSIZE (mode
) == tree_to_uhwi (TYPE_SIZE (type
)))
1727 SET_TYPE_MODE (type
, mode
);
1729 SET_TYPE_MODE (type
, mode_for_size_tree (TYPE_SIZE (type
), MODE_INT
, 1));
1731 /* If structure's known alignment is less than what the scalar
1732 mode would need, and it matters, then stick with BLKmode. */
1733 if (TYPE_MODE (type
) != BLKmode
1735 && ! (TYPE_ALIGN (type
) >= BIGGEST_ALIGNMENT
1736 || TYPE_ALIGN (type
) >= GET_MODE_ALIGNMENT (TYPE_MODE (type
))))
1738 /* If this is the only reason this type is BLKmode, then
1739 don't force containing types to be BLKmode. */
1740 TYPE_NO_FORCE_BLK (type
) = 1;
1741 SET_TYPE_MODE (type
, BLKmode
);
1745 /* Compute TYPE_SIZE and TYPE_ALIGN for TYPE, once it has been laid
1749 finalize_type_size (tree type
)
1751 /* Normally, use the alignment corresponding to the mode chosen.
1752 However, where strict alignment is not required, avoid
1753 over-aligning structures, since most compilers do not do this
1755 if (TYPE_MODE (type
) != BLKmode
1756 && TYPE_MODE (type
) != VOIDmode
1757 && (STRICT_ALIGNMENT
|| !AGGREGATE_TYPE_P (type
)))
1759 unsigned mode_align
= GET_MODE_ALIGNMENT (TYPE_MODE (type
));
1761 /* Don't override a larger alignment requirement coming from a user
1762 alignment of one of the fields. */
1763 if (mode_align
>= TYPE_ALIGN (type
))
1765 TYPE_ALIGN (type
) = mode_align
;
1766 TYPE_USER_ALIGN (type
) = 0;
1770 /* Do machine-dependent extra alignment. */
1771 #ifdef ROUND_TYPE_ALIGN
1773 = ROUND_TYPE_ALIGN (type
, TYPE_ALIGN (type
), BITS_PER_UNIT
);
1776 /* If we failed to find a simple way to calculate the unit size
1777 of the type, find it by division. */
1778 if (TYPE_SIZE_UNIT (type
) == 0 && TYPE_SIZE (type
) != 0)
1779 /* TYPE_SIZE (type) is computed in bitsizetype. After the division, the
1780 result will fit in sizetype. We will get more efficient code using
1781 sizetype, so we force a conversion. */
1782 TYPE_SIZE_UNIT (type
)
1783 = fold_convert (sizetype
,
1784 size_binop (FLOOR_DIV_EXPR
, TYPE_SIZE (type
),
1785 bitsize_unit_node
));
1787 if (TYPE_SIZE (type
) != 0)
1789 TYPE_SIZE (type
) = round_up (TYPE_SIZE (type
), TYPE_ALIGN (type
));
1790 TYPE_SIZE_UNIT (type
)
1791 = round_up (TYPE_SIZE_UNIT (type
), TYPE_ALIGN_UNIT (type
));
1794 /* Evaluate nonconstant sizes only once, either now or as soon as safe. */
1795 if (TYPE_SIZE (type
) != 0 && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1796 TYPE_SIZE (type
) = variable_size (TYPE_SIZE (type
));
1797 if (TYPE_SIZE_UNIT (type
) != 0
1798 && TREE_CODE (TYPE_SIZE_UNIT (type
)) != INTEGER_CST
)
1799 TYPE_SIZE_UNIT (type
) = variable_size (TYPE_SIZE_UNIT (type
));
1801 /* Also layout any other variants of the type. */
1802 if (TYPE_NEXT_VARIANT (type
)
1803 || type
!= TYPE_MAIN_VARIANT (type
))
1806 /* Record layout info of this variant. */
1807 tree size
= TYPE_SIZE (type
);
1808 tree size_unit
= TYPE_SIZE_UNIT (type
);
1809 unsigned int align
= TYPE_ALIGN (type
);
1810 unsigned int precision
= TYPE_PRECISION (type
);
1811 unsigned int user_align
= TYPE_USER_ALIGN (type
);
1812 machine_mode mode
= TYPE_MODE (type
);
1814 /* Copy it into all variants. */
1815 for (variant
= TYPE_MAIN_VARIANT (type
);
1817 variant
= TYPE_NEXT_VARIANT (variant
))
1819 TYPE_SIZE (variant
) = size
;
1820 TYPE_SIZE_UNIT (variant
) = size_unit
;
1821 unsigned valign
= align
;
1822 if (TYPE_USER_ALIGN (variant
))
1823 valign
= MAX (valign
, TYPE_ALIGN (variant
));
1825 TYPE_USER_ALIGN (variant
) = user_align
;
1826 TYPE_ALIGN (variant
) = valign
;
1827 TYPE_PRECISION (variant
) = precision
;
1828 SET_TYPE_MODE (variant
, mode
);
1833 /* Return a new underlying object for a bitfield started with FIELD. */
1836 start_bitfield_representative (tree field
)
1838 tree repr
= make_node (FIELD_DECL
);
1839 DECL_FIELD_OFFSET (repr
) = DECL_FIELD_OFFSET (field
);
1840 /* Force the representative to begin at a BITS_PER_UNIT aligned
1841 boundary - C++ may use tail-padding of a base object to
1842 continue packing bits so the bitfield region does not start
1843 at bit zero (see g++.dg/abi/bitfield5.C for example).
1844 Unallocated bits may happen for other reasons as well,
1845 for example Ada which allows explicit bit-granular structure layout. */
1846 DECL_FIELD_BIT_OFFSET (repr
)
1847 = size_binop (BIT_AND_EXPR
,
1848 DECL_FIELD_BIT_OFFSET (field
),
1849 bitsize_int (~(BITS_PER_UNIT
- 1)));
1850 SET_DECL_OFFSET_ALIGN (repr
, DECL_OFFSET_ALIGN (field
));
1851 DECL_SIZE (repr
) = DECL_SIZE (field
);
1852 DECL_SIZE_UNIT (repr
) = DECL_SIZE_UNIT (field
);
1853 DECL_PACKED (repr
) = DECL_PACKED (field
);
1854 DECL_CONTEXT (repr
) = DECL_CONTEXT (field
);
1858 /* Finish up a bitfield group that was started by creating the underlying
1859 object REPR with the last field in the bitfield group FIELD. */
1862 finish_bitfield_representative (tree repr
, tree field
)
1864 unsigned HOST_WIDE_INT bitsize
, maxbitsize
;
1868 size
= size_diffop (DECL_FIELD_OFFSET (field
),
1869 DECL_FIELD_OFFSET (repr
));
1870 while (TREE_CODE (size
) == COMPOUND_EXPR
)
1871 size
= TREE_OPERAND (size
, 1);
1872 gcc_assert (tree_fits_uhwi_p (size
));
1873 bitsize
= (tree_to_uhwi (size
) * BITS_PER_UNIT
1874 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field
))
1875 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr
))
1876 + tree_to_uhwi (DECL_SIZE (field
)));
1878 /* Round up bitsize to multiples of BITS_PER_UNIT. */
1879 bitsize
= (bitsize
+ BITS_PER_UNIT
- 1) & ~(BITS_PER_UNIT
- 1);
1881 /* Now nothing tells us how to pad out bitsize ... */
1882 nextf
= DECL_CHAIN (field
);
1883 while (nextf
&& TREE_CODE (nextf
) != FIELD_DECL
)
1884 nextf
= DECL_CHAIN (nextf
);
1888 /* If there was an error, the field may be not laid out
1889 correctly. Don't bother to do anything. */
1890 if (TREE_TYPE (nextf
) == error_mark_node
)
1892 maxsize
= size_diffop (DECL_FIELD_OFFSET (nextf
),
1893 DECL_FIELD_OFFSET (repr
));
1894 if (tree_fits_uhwi_p (maxsize
))
1896 maxbitsize
= (tree_to_uhwi (maxsize
) * BITS_PER_UNIT
1897 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (nextf
))
1898 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr
)));
1899 /* If the group ends within a bitfield nextf does not need to be
1900 aligned to BITS_PER_UNIT. Thus round up. */
1901 maxbitsize
= (maxbitsize
+ BITS_PER_UNIT
- 1) & ~(BITS_PER_UNIT
- 1);
1904 maxbitsize
= bitsize
;
1908 /* ??? If you consider that tail-padding of this struct might be
1909 re-used when deriving from it we cannot really do the following
1910 and thus need to set maxsize to bitsize? Also we cannot
1911 generally rely on maxsize to fold to an integer constant, so
1912 use bitsize as fallback for this case. */
1913 tree maxsize
= size_diffop (TYPE_SIZE_UNIT (DECL_CONTEXT (field
)),
1914 DECL_FIELD_OFFSET (repr
));
1915 if (tree_fits_uhwi_p (maxsize
))
1916 maxbitsize
= (tree_to_uhwi (maxsize
) * BITS_PER_UNIT
1917 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr
)));
1919 maxbitsize
= bitsize
;
1922 /* Only if we don't artificially break up the representative in
1923 the middle of a large bitfield with different possibly
1924 overlapping representatives. And all representatives start
1926 gcc_assert (maxbitsize
% BITS_PER_UNIT
== 0);
1928 /* Find the smallest nice mode to use. */
1929 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_INT
); mode
!= VOIDmode
;
1930 mode
= GET_MODE_WIDER_MODE (mode
))
1931 if (GET_MODE_BITSIZE (mode
) >= bitsize
)
1933 if (mode
!= VOIDmode
1934 && (GET_MODE_BITSIZE (mode
) > maxbitsize
1935 || GET_MODE_BITSIZE (mode
) > MAX_FIXED_MODE_SIZE
))
1938 if (mode
== VOIDmode
)
1940 /* We really want a BLKmode representative only as a last resort,
1941 considering the member b in
1942 struct { int a : 7; int b : 17; int c; } __attribute__((packed));
1943 Otherwise we simply want to split the representative up
1944 allowing for overlaps within the bitfield region as required for
1945 struct { int a : 7; int b : 7;
1946 int c : 10; int d; } __attribute__((packed));
1947 [0, 15] HImode for a and b, [8, 23] HImode for c. */
1948 DECL_SIZE (repr
) = bitsize_int (bitsize
);
1949 DECL_SIZE_UNIT (repr
) = size_int (bitsize
/ BITS_PER_UNIT
);
1950 DECL_MODE (repr
) = BLKmode
;
1951 TREE_TYPE (repr
) = build_array_type_nelts (unsigned_char_type_node
,
1952 bitsize
/ BITS_PER_UNIT
);
1956 unsigned HOST_WIDE_INT modesize
= GET_MODE_BITSIZE (mode
);
1957 DECL_SIZE (repr
) = bitsize_int (modesize
);
1958 DECL_SIZE_UNIT (repr
) = size_int (modesize
/ BITS_PER_UNIT
);
1959 DECL_MODE (repr
) = mode
;
1960 TREE_TYPE (repr
) = lang_hooks
.types
.type_for_mode (mode
, 1);
1963 /* Remember whether the bitfield group is at the end of the
1964 structure or not. */
1965 DECL_CHAIN (repr
) = nextf
;
1968 /* Compute and set FIELD_DECLs for the underlying objects we should
1969 use for bitfield access for the structure T. */
1972 finish_bitfield_layout (tree t
)
1975 tree repr
= NULL_TREE
;
1977 /* Unions would be special, for the ease of type-punning optimizations
1978 we could use the underlying type as hint for the representative
1979 if the bitfield would fit and the representative would not exceed
1980 the union in size. */
1981 if (TREE_CODE (t
) != RECORD_TYPE
)
1984 for (prev
= NULL_TREE
, field
= TYPE_FIELDS (t
);
1985 field
; field
= DECL_CHAIN (field
))
1987 if (TREE_CODE (field
) != FIELD_DECL
)
1990 /* In the C++ memory model, consecutive bit fields in a structure are
1991 considered one memory location and updating a memory location
1992 may not store into adjacent memory locations. */
1994 && DECL_BIT_FIELD_TYPE (field
))
1996 /* Start new representative. */
1997 repr
= start_bitfield_representative (field
);
2000 && ! DECL_BIT_FIELD_TYPE (field
))
2002 /* Finish off new representative. */
2003 finish_bitfield_representative (repr
, prev
);
2006 else if (DECL_BIT_FIELD_TYPE (field
))
2008 gcc_assert (repr
!= NULL_TREE
);
2010 /* Zero-size bitfields finish off a representative and
2011 do not have a representative themselves. This is
2012 required by the C++ memory model. */
2013 if (integer_zerop (DECL_SIZE (field
)))
2015 finish_bitfield_representative (repr
, prev
);
2019 /* We assume that either DECL_FIELD_OFFSET of the representative
2020 and each bitfield member is a constant or they are equal.
2021 This is because we need to be able to compute the bit-offset
2022 of each field relative to the representative in get_bit_range
2023 during RTL expansion.
2024 If these constraints are not met, simply force a new
2025 representative to be generated. That will at most
2026 generate worse code but still maintain correctness with
2027 respect to the C++ memory model. */
2028 else if (!((tree_fits_uhwi_p (DECL_FIELD_OFFSET (repr
))
2029 && tree_fits_uhwi_p (DECL_FIELD_OFFSET (field
)))
2030 || operand_equal_p (DECL_FIELD_OFFSET (repr
),
2031 DECL_FIELD_OFFSET (field
), 0)))
2033 finish_bitfield_representative (repr
, prev
);
2034 repr
= start_bitfield_representative (field
);
2041 DECL_BIT_FIELD_REPRESENTATIVE (field
) = repr
;
2047 finish_bitfield_representative (repr
, prev
);
2050 /* Do all of the work required to layout the type indicated by RLI,
2051 once the fields have been laid out. This function will call `free'
2052 for RLI, unless FREE_P is false. Passing a value other than false
2053 for FREE_P is bad practice; this option only exists to support the
2057 finish_record_layout (record_layout_info rli
, int free_p
)
2061 /* Compute the final size. */
2062 finalize_record_size (rli
);
2064 /* Compute the TYPE_MODE for the record. */
2065 compute_record_mode (rli
->t
);
2067 /* Perform any last tweaks to the TYPE_SIZE, etc. */
2068 finalize_type_size (rli
->t
);
2070 /* Compute bitfield representatives. */
2071 finish_bitfield_layout (rli
->t
);
2073 /* Propagate TYPE_PACKED to variants. With C++ templates,
2074 handle_packed_attribute is too early to do this. */
2075 for (variant
= TYPE_NEXT_VARIANT (rli
->t
); variant
;
2076 variant
= TYPE_NEXT_VARIANT (variant
))
2077 TYPE_PACKED (variant
) = TYPE_PACKED (rli
->t
);
2079 /* Lay out any static members. This is done now because their type
2080 may use the record's type. */
2081 while (!vec_safe_is_empty (rli
->pending_statics
))
2082 layout_decl (rli
->pending_statics
->pop (), 0);
2087 vec_free (rli
->pending_statics
);
2093 /* Finish processing a builtin RECORD_TYPE type TYPE. It's name is
2094 NAME, its fields are chained in reverse on FIELDS.
2096 If ALIGN_TYPE is non-null, it is given the same alignment as
2100 finish_builtin_struct (tree type
, const char *name
, tree fields
,
2105 for (tail
= NULL_TREE
; fields
; tail
= fields
, fields
= next
)
2107 DECL_FIELD_CONTEXT (fields
) = type
;
2108 next
= DECL_CHAIN (fields
);
2109 DECL_CHAIN (fields
) = tail
;
2111 TYPE_FIELDS (type
) = tail
;
2115 TYPE_ALIGN (type
) = TYPE_ALIGN (align_type
);
2116 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (align_type
);
2120 #if 0 /* not yet, should get fixed properly later */
2121 TYPE_NAME (type
) = make_type_decl (get_identifier (name
), type
);
2123 TYPE_NAME (type
) = build_decl (BUILTINS_LOCATION
,
2124 TYPE_DECL
, get_identifier (name
), type
);
2126 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
2127 layout_decl (TYPE_NAME (type
), 0);
2130 /* Calculate the mode, size, and alignment for TYPE.
2131 For an array type, calculate the element separation as well.
2132 Record TYPE on the chain of permanent or temporary types
2133 so that dbxout will find out about it.
2135 TYPE_SIZE of a type is nonzero if the type has been laid out already.
2136 layout_type does nothing on such a type.
2138 If the type is incomplete, its TYPE_SIZE remains zero. */
2141 layout_type (tree type
)
2145 if (type
== error_mark_node
)
2148 /* We don't want finalize_type_size to copy an alignment attribute to
2149 variants that don't have it. */
2150 type
= TYPE_MAIN_VARIANT (type
);
2152 /* Do nothing if type has been laid out before. */
2153 if (TYPE_SIZE (type
))
2156 switch (TREE_CODE (type
))
2159 /* This kind of type is the responsibility
2160 of the language-specific code. */
2166 SET_TYPE_MODE (type
,
2167 smallest_mode_for_size (TYPE_PRECISION (type
), MODE_INT
));
2168 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2169 /* Don't set TYPE_PRECISION here, as it may be set by a bitfield. */
2170 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2174 SET_TYPE_MODE (type
,
2175 mode_for_size (TYPE_PRECISION (type
), MODE_FLOAT
, 0));
2176 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2177 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2180 case FIXED_POINT_TYPE
:
2181 /* TYPE_MODE (type) has been set already. */
2182 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2183 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2187 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TREE_TYPE (type
));
2188 SET_TYPE_MODE (type
,
2189 mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type
)),
2190 (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
2191 ? MODE_COMPLEX_FLOAT
: MODE_COMPLEX_INT
),
2193 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2194 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2199 int nunits
= TYPE_VECTOR_SUBPARTS (type
);
2200 tree innertype
= TREE_TYPE (type
);
2202 gcc_assert (!(nunits
& (nunits
- 1)));
2204 /* Find an appropriate mode for the vector type. */
2205 if (TYPE_MODE (type
) == VOIDmode
)
2206 SET_TYPE_MODE (type
,
2207 mode_for_vector (TYPE_MODE (innertype
), nunits
));
2209 TYPE_SATURATING (type
) = TYPE_SATURATING (TREE_TYPE (type
));
2210 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TREE_TYPE (type
));
2211 TYPE_SIZE_UNIT (type
) = int_const_binop (MULT_EXPR
,
2212 TYPE_SIZE_UNIT (innertype
),
2214 TYPE_SIZE (type
) = int_const_binop (MULT_EXPR
, TYPE_SIZE (innertype
),
2215 bitsize_int (nunits
));
2217 /* For vector types, we do not default to the mode's alignment.
2218 Instead, query a target hook, defaulting to natural alignment.
2219 This prevents ABI changes depending on whether or not native
2220 vector modes are supported. */
2221 TYPE_ALIGN (type
) = targetm
.vector_alignment (type
);
2223 /* However, if the underlying mode requires a bigger alignment than
2224 what the target hook provides, we cannot use the mode. For now,
2225 simply reject that case. */
2226 gcc_assert (TYPE_ALIGN (type
)
2227 >= GET_MODE_ALIGNMENT (TYPE_MODE (type
)));
2232 /* This is an incomplete type and so doesn't have a size. */
2233 TYPE_ALIGN (type
) = 1;
2234 TYPE_USER_ALIGN (type
) = 0;
2235 SET_TYPE_MODE (type
, VOIDmode
);
2238 case POINTER_BOUNDS_TYPE
:
2239 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2240 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2244 TYPE_SIZE (type
) = bitsize_int (POINTER_SIZE
);
2245 TYPE_SIZE_UNIT (type
) = size_int (POINTER_SIZE_UNITS
);
2246 /* A pointer might be MODE_PARTIAL_INT, but ptrdiff_t must be
2247 integral, which may be an __intN. */
2248 SET_TYPE_MODE (type
, mode_for_size (POINTER_SIZE
, MODE_INT
, 0));
2249 TYPE_PRECISION (type
) = POINTER_SIZE
;
2254 /* It's hard to see what the mode and size of a function ought to
2255 be, but we do know the alignment is FUNCTION_BOUNDARY, so
2256 make it consistent with that. */
2257 SET_TYPE_MODE (type
, mode_for_size (FUNCTION_BOUNDARY
, MODE_INT
, 0));
2258 TYPE_SIZE (type
) = bitsize_int (FUNCTION_BOUNDARY
);
2259 TYPE_SIZE_UNIT (type
) = size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
2263 case REFERENCE_TYPE
:
2265 machine_mode mode
= TYPE_MODE (type
);
2266 if (TREE_CODE (type
) == REFERENCE_TYPE
&& reference_types_internal
)
2268 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (type
));
2269 mode
= targetm
.addr_space
.address_mode (as
);
2272 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (mode
));
2273 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (mode
));
2274 TYPE_UNSIGNED (type
) = 1;
2275 TYPE_PRECISION (type
) = GET_MODE_PRECISION (mode
);
2281 tree index
= TYPE_DOMAIN (type
);
2282 tree element
= TREE_TYPE (type
);
2284 build_pointer_type (element
);
2286 /* We need to know both bounds in order to compute the size. */
2287 if (index
&& TYPE_MAX_VALUE (index
) && TYPE_MIN_VALUE (index
)
2288 && TYPE_SIZE (element
))
2290 tree ub
= TYPE_MAX_VALUE (index
);
2291 tree lb
= TYPE_MIN_VALUE (index
);
2292 tree element_size
= TYPE_SIZE (element
);
2295 /* Make sure that an array of zero-sized element is zero-sized
2296 regardless of its extent. */
2297 if (integer_zerop (element_size
))
2298 length
= size_zero_node
;
2300 /* The computation should happen in the original signedness so
2301 that (possible) negative values are handled appropriately
2302 when determining overflow. */
2305 /* ??? When it is obvious that the range is signed
2306 represent it using ssizetype. */
2307 if (TREE_CODE (lb
) == INTEGER_CST
2308 && TREE_CODE (ub
) == INTEGER_CST
2309 && TYPE_UNSIGNED (TREE_TYPE (lb
))
2310 && tree_int_cst_lt (ub
, lb
))
2312 lb
= wide_int_to_tree (ssizetype
,
2313 offset_int::from (lb
, SIGNED
));
2314 ub
= wide_int_to_tree (ssizetype
,
2315 offset_int::from (ub
, SIGNED
));
2318 = fold_convert (sizetype
,
2319 size_binop (PLUS_EXPR
,
2320 build_int_cst (TREE_TYPE (lb
), 1),
2321 size_binop (MINUS_EXPR
, ub
, lb
)));
2324 /* ??? We have no way to distinguish a null-sized array from an
2325 array spanning the whole sizetype range, so we arbitrarily
2326 decide that [0, -1] is the only valid representation. */
2327 if (integer_zerop (length
)
2328 && TREE_OVERFLOW (length
)
2329 && integer_zerop (lb
))
2330 length
= size_zero_node
;
2332 TYPE_SIZE (type
) = size_binop (MULT_EXPR
, element_size
,
2333 fold_convert (bitsizetype
,
2336 /* If we know the size of the element, calculate the total size
2337 directly, rather than do some division thing below. This
2338 optimization helps Fortran assumed-size arrays (where the
2339 size of the array is determined at runtime) substantially. */
2340 if (TYPE_SIZE_UNIT (element
))
2341 TYPE_SIZE_UNIT (type
)
2342 = size_binop (MULT_EXPR
, TYPE_SIZE_UNIT (element
), length
);
2345 /* Now round the alignment and size,
2346 using machine-dependent criteria if any. */
2348 unsigned align
= TYPE_ALIGN (element
);
2349 if (TYPE_USER_ALIGN (type
))
2350 align
= MAX (align
, TYPE_ALIGN (type
));
2352 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (element
);
2353 #ifdef ROUND_TYPE_ALIGN
2354 align
= ROUND_TYPE_ALIGN (type
, align
, BITS_PER_UNIT
);
2356 align
= MAX (align
, BITS_PER_UNIT
);
2358 TYPE_ALIGN (type
) = align
;
2359 SET_TYPE_MODE (type
, BLKmode
);
2360 if (TYPE_SIZE (type
) != 0
2361 && ! targetm
.member_type_forces_blk (type
, VOIDmode
)
2362 /* BLKmode elements force BLKmode aggregate;
2363 else extract/store fields may lose. */
2364 && (TYPE_MODE (TREE_TYPE (type
)) != BLKmode
2365 || TYPE_NO_FORCE_BLK (TREE_TYPE (type
))))
2367 SET_TYPE_MODE (type
, mode_for_array (TREE_TYPE (type
),
2369 if (TYPE_MODE (type
) != BLKmode
2370 && STRICT_ALIGNMENT
&& TYPE_ALIGN (type
) < BIGGEST_ALIGNMENT
2371 && TYPE_ALIGN (type
) < GET_MODE_ALIGNMENT (TYPE_MODE (type
)))
2373 TYPE_NO_FORCE_BLK (type
) = 1;
2374 SET_TYPE_MODE (type
, BLKmode
);
2377 /* When the element size is constant, check that it is at least as
2378 large as the element alignment. */
2379 if (TYPE_SIZE_UNIT (element
)
2380 && TREE_CODE (TYPE_SIZE_UNIT (element
)) == INTEGER_CST
2381 /* If TYPE_SIZE_UNIT overflowed, then it is certainly larger than
2383 && !TREE_OVERFLOW (TYPE_SIZE_UNIT (element
))
2384 && !integer_zerop (TYPE_SIZE_UNIT (element
))
2385 && compare_tree_int (TYPE_SIZE_UNIT (element
),
2386 TYPE_ALIGN_UNIT (element
)) < 0)
2387 error ("alignment of array elements is greater than element size");
2393 case QUAL_UNION_TYPE
:
2396 record_layout_info rli
;
2398 /* Initialize the layout information. */
2399 rli
= start_record_layout (type
);
2401 /* If this is a QUAL_UNION_TYPE, we want to process the fields
2402 in the reverse order in building the COND_EXPR that denotes
2403 its size. We reverse them again later. */
2404 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
2405 TYPE_FIELDS (type
) = nreverse (TYPE_FIELDS (type
));
2407 /* Place all the fields. */
2408 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
2409 place_field (rli
, field
);
2411 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
2412 TYPE_FIELDS (type
) = nreverse (TYPE_FIELDS (type
));
2414 /* Finish laying out the record. */
2415 finish_record_layout (rli
, /*free_p=*/true);
2423 /* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE. For
2424 records and unions, finish_record_layout already called this
2426 if (!RECORD_OR_UNION_TYPE_P (type
))
2427 finalize_type_size (type
);
2429 /* We should never see alias sets on incomplete aggregates. And we
2430 should not call layout_type on not incomplete aggregates. */
2431 if (AGGREGATE_TYPE_P (type
))
2432 gcc_assert (!TYPE_ALIAS_SET_KNOWN_P (type
));
2435 /* Return the least alignment required for type TYPE. */
2438 min_align_of_type (tree type
)
2440 unsigned int align
= TYPE_ALIGN (type
);
2441 if (!TYPE_USER_ALIGN (type
))
2443 align
= MIN (align
, BIGGEST_ALIGNMENT
);
2444 #ifdef BIGGEST_FIELD_ALIGNMENT
2445 align
= MIN (align
, BIGGEST_FIELD_ALIGNMENT
);
2447 unsigned int field_align
= align
;
2448 #ifdef ADJUST_FIELD_ALIGN
2449 tree field
= build_decl (UNKNOWN_LOCATION
, FIELD_DECL
, NULL_TREE
, type
);
2450 field_align
= ADJUST_FIELD_ALIGN (field
, field_align
);
2453 align
= MIN (align
, field_align
);
2455 return align
/ BITS_PER_UNIT
;
2458 /* Vector types need to re-check the target flags each time we report
2459 the machine mode. We need to do this because attribute target can
2460 change the result of vector_mode_supported_p and have_regs_of_mode
2461 on a per-function basis. Thus the TYPE_MODE of a VECTOR_TYPE can
2462 change on a per-function basis. */
2463 /* ??? Possibly a better solution is to run through all the types
2464 referenced by a function and re-compute the TYPE_MODE once, rather
2465 than make the TYPE_MODE macro call a function. */
2468 vector_type_mode (const_tree t
)
2472 gcc_assert (TREE_CODE (t
) == VECTOR_TYPE
);
2474 mode
= t
->type_common
.mode
;
2475 if (VECTOR_MODE_P (mode
)
2476 && (!targetm
.vector_mode_supported_p (mode
)
2477 || !have_regs_of_mode
[mode
]))
2479 machine_mode innermode
= TREE_TYPE (t
)->type_common
.mode
;
2481 /* For integers, try mapping it to a same-sized scalar mode. */
2482 if (GET_MODE_CLASS (innermode
) == MODE_INT
)
2484 mode
= mode_for_size (TYPE_VECTOR_SUBPARTS (t
)
2485 * GET_MODE_BITSIZE (innermode
), MODE_INT
, 0);
2487 if (mode
!= VOIDmode
&& have_regs_of_mode
[mode
])
2497 /* Create and return a type for signed integers of PRECISION bits. */
2500 make_signed_type (int precision
)
2502 tree type
= make_node (INTEGER_TYPE
);
2504 TYPE_PRECISION (type
) = precision
;
2506 fixup_signed_type (type
);
2510 /* Create and return a type for unsigned integers of PRECISION bits. */
2513 make_unsigned_type (int precision
)
2515 tree type
= make_node (INTEGER_TYPE
);
2517 TYPE_PRECISION (type
) = precision
;
2519 fixup_unsigned_type (type
);
2523 /* Create and return a type for fract of PRECISION bits, UNSIGNEDP,
2527 make_fract_type (int precision
, int unsignedp
, int satp
)
2529 tree type
= make_node (FIXED_POINT_TYPE
);
2531 TYPE_PRECISION (type
) = precision
;
2534 TYPE_SATURATING (type
) = 1;
2536 /* Lay out the type: set its alignment, size, etc. */
2539 TYPE_UNSIGNED (type
) = 1;
2540 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_UFRACT
, 0));
2543 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_FRACT
, 0));
2549 /* Create and return a type for accum of PRECISION bits, UNSIGNEDP,
2553 make_accum_type (int precision
, int unsignedp
, int satp
)
2555 tree type
= make_node (FIXED_POINT_TYPE
);
2557 TYPE_PRECISION (type
) = precision
;
2560 TYPE_SATURATING (type
) = 1;
2562 /* Lay out the type: set its alignment, size, etc. */
2565 TYPE_UNSIGNED (type
) = 1;
2566 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_UACCUM
, 0));
2569 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_ACCUM
, 0));
2575 /* Initialize sizetypes so layout_type can use them. */
2578 initialize_sizetypes (void)
2580 int precision
, bprecision
;
2582 /* Get sizetypes precision from the SIZE_TYPE target macro. */
2583 if (strcmp (SIZETYPE
, "unsigned int") == 0)
2584 precision
= INT_TYPE_SIZE
;
2585 else if (strcmp (SIZETYPE
, "long unsigned int") == 0)
2586 precision
= LONG_TYPE_SIZE
;
2587 else if (strcmp (SIZETYPE
, "long long unsigned int") == 0)
2588 precision
= LONG_LONG_TYPE_SIZE
;
2589 else if (strcmp (SIZETYPE
, "short unsigned int") == 0)
2590 precision
= SHORT_TYPE_SIZE
;
2596 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2597 if (int_n_enabled_p
[i
])
2600 sprintf (name
, "__int%d unsigned", int_n_data
[i
].bitsize
);
2602 if (strcmp (name
, SIZETYPE
) == 0)
2604 precision
= int_n_data
[i
].bitsize
;
2607 if (precision
== -1)
2612 = MIN (precision
+ BITS_PER_UNIT_LOG
+ 1, MAX_FIXED_MODE_SIZE
);
2614 = GET_MODE_PRECISION (smallest_mode_for_size (bprecision
, MODE_INT
));
2615 if (bprecision
> HOST_BITS_PER_DOUBLE_INT
)
2616 bprecision
= HOST_BITS_PER_DOUBLE_INT
;
2618 /* Create stubs for sizetype and bitsizetype so we can create constants. */
2619 sizetype
= make_node (INTEGER_TYPE
);
2620 TYPE_NAME (sizetype
) = get_identifier ("sizetype");
2621 TYPE_PRECISION (sizetype
) = precision
;
2622 TYPE_UNSIGNED (sizetype
) = 1;
2623 bitsizetype
= make_node (INTEGER_TYPE
);
2624 TYPE_NAME (bitsizetype
) = get_identifier ("bitsizetype");
2625 TYPE_PRECISION (bitsizetype
) = bprecision
;
2626 TYPE_UNSIGNED (bitsizetype
) = 1;
2628 /* Now layout both types manually. */
2629 SET_TYPE_MODE (sizetype
, smallest_mode_for_size (precision
, MODE_INT
));
2630 TYPE_ALIGN (sizetype
) = GET_MODE_ALIGNMENT (TYPE_MODE (sizetype
));
2631 TYPE_SIZE (sizetype
) = bitsize_int (precision
);
2632 TYPE_SIZE_UNIT (sizetype
) = size_int (GET_MODE_SIZE (TYPE_MODE (sizetype
)));
2633 set_min_and_max_values_for_integral_type (sizetype
, precision
, UNSIGNED
);
2635 SET_TYPE_MODE (bitsizetype
, smallest_mode_for_size (bprecision
, MODE_INT
));
2636 TYPE_ALIGN (bitsizetype
) = GET_MODE_ALIGNMENT (TYPE_MODE (bitsizetype
));
2637 TYPE_SIZE (bitsizetype
) = bitsize_int (bprecision
);
2638 TYPE_SIZE_UNIT (bitsizetype
)
2639 = size_int (GET_MODE_SIZE (TYPE_MODE (bitsizetype
)));
2640 set_min_and_max_values_for_integral_type (bitsizetype
, bprecision
, UNSIGNED
);
2642 /* Create the signed variants of *sizetype. */
2643 ssizetype
= make_signed_type (TYPE_PRECISION (sizetype
));
2644 TYPE_NAME (ssizetype
) = get_identifier ("ssizetype");
2645 sbitsizetype
= make_signed_type (TYPE_PRECISION (bitsizetype
));
2646 TYPE_NAME (sbitsizetype
) = get_identifier ("sbitsizetype");
2649 /* TYPE is an integral type, i.e., an INTEGRAL_TYPE, ENUMERAL_TYPE
2650 or BOOLEAN_TYPE. Set TYPE_MIN_VALUE and TYPE_MAX_VALUE
2651 for TYPE, based on the PRECISION and whether or not the TYPE
2652 IS_UNSIGNED. PRECISION need not correspond to a width supported
2653 natively by the hardware; for example, on a machine with 8-bit,
2654 16-bit, and 32-bit register modes, PRECISION might be 7, 23, or
2658 set_min_and_max_values_for_integral_type (tree type
,
2662 /* For bitfields with zero width we end up creating integer types
2663 with zero precision. Don't assign any minimum/maximum values
2664 to those types, they don't have any valid value. */
2668 TYPE_MIN_VALUE (type
)
2669 = wide_int_to_tree (type
, wi::min_value (precision
, sgn
));
2670 TYPE_MAX_VALUE (type
)
2671 = wide_int_to_tree (type
, wi::max_value (precision
, sgn
));
2674 /* Set the extreme values of TYPE based on its precision in bits,
2675 then lay it out. Used when make_signed_type won't do
2676 because the tree code is not INTEGER_TYPE.
2677 E.g. for Pascal, when the -fsigned-char option is given. */
2680 fixup_signed_type (tree type
)
2682 int precision
= TYPE_PRECISION (type
);
2684 set_min_and_max_values_for_integral_type (type
, precision
, SIGNED
);
2686 /* Lay out the type: set its alignment, size, etc. */
2690 /* Set the extreme values of TYPE based on its precision in bits,
2691 then lay it out. This is used both in `make_unsigned_type'
2692 and for enumeral types. */
2695 fixup_unsigned_type (tree type
)
2697 int precision
= TYPE_PRECISION (type
);
2699 TYPE_UNSIGNED (type
) = 1;
2701 set_min_and_max_values_for_integral_type (type
, precision
, UNSIGNED
);
2703 /* Lay out the type: set its alignment, size, etc. */
2707 /* Construct an iterator for a bitfield that spans BITSIZE bits,
2710 BITREGION_START is the bit position of the first bit in this
2711 sequence of bit fields. BITREGION_END is the last bit in this
2712 sequence. If these two fields are non-zero, we should restrict the
2713 memory access to that range. Otherwise, we are allowed to touch
2714 any adjacent non bit-fields.
2716 ALIGN is the alignment of the underlying object in bits.
2717 VOLATILEP says whether the bitfield is volatile. */
2719 bit_field_mode_iterator
2720 ::bit_field_mode_iterator (HOST_WIDE_INT bitsize
, HOST_WIDE_INT bitpos
,
2721 HOST_WIDE_INT bitregion_start
,
2722 HOST_WIDE_INT bitregion_end
,
2723 unsigned int align
, bool volatilep
)
2724 : m_mode (GET_CLASS_NARROWEST_MODE (MODE_INT
)), m_bitsize (bitsize
),
2725 m_bitpos (bitpos
), m_bitregion_start (bitregion_start
),
2726 m_bitregion_end (bitregion_end
), m_align (align
),
2727 m_volatilep (volatilep
), m_count (0)
2729 if (!m_bitregion_end
)
2731 /* We can assume that any aligned chunk of ALIGN bits that overlaps
2732 the bitfield is mapped and won't trap, provided that ALIGN isn't
2733 too large. The cap is the biggest required alignment for data,
2734 or at least the word size. And force one such chunk at least. */
2735 unsigned HOST_WIDE_INT units
2736 = MIN (align
, MAX (BIGGEST_ALIGNMENT
, BITS_PER_WORD
));
2739 m_bitregion_end
= bitpos
+ bitsize
+ units
- 1;
2740 m_bitregion_end
-= m_bitregion_end
% units
+ 1;
2744 /* Calls to this function return successively larger modes that can be used
2745 to represent the bitfield. Return true if another bitfield mode is
2746 available, storing it in *OUT_MODE if so. */
2749 bit_field_mode_iterator::next_mode (machine_mode
*out_mode
)
2751 for (; m_mode
!= VOIDmode
; m_mode
= GET_MODE_WIDER_MODE (m_mode
))
2753 unsigned int unit
= GET_MODE_BITSIZE (m_mode
);
2755 /* Skip modes that don't have full precision. */
2756 if (unit
!= GET_MODE_PRECISION (m_mode
))
2759 /* Stop if the mode is too wide to handle efficiently. */
2760 if (unit
> MAX_FIXED_MODE_SIZE
)
2763 /* Don't deliver more than one multiword mode; the smallest one
2765 if (m_count
> 0 && unit
> BITS_PER_WORD
)
2768 /* Skip modes that are too small. */
2769 unsigned HOST_WIDE_INT substart
= (unsigned HOST_WIDE_INT
) m_bitpos
% unit
;
2770 unsigned HOST_WIDE_INT subend
= substart
+ m_bitsize
;
2774 /* Stop if the mode goes outside the bitregion. */
2775 HOST_WIDE_INT start
= m_bitpos
- substart
;
2776 if (m_bitregion_start
&& start
< m_bitregion_start
)
2778 HOST_WIDE_INT end
= start
+ unit
;
2779 if (end
> m_bitregion_end
+ 1)
2782 /* Stop if the mode requires too much alignment. */
2783 if (GET_MODE_ALIGNMENT (m_mode
) > m_align
2784 && SLOW_UNALIGNED_ACCESS (m_mode
, m_align
))
2788 m_mode
= GET_MODE_WIDER_MODE (m_mode
);
2795 /* Return true if smaller modes are generally preferred for this kind
2799 bit_field_mode_iterator::prefer_smaller_modes ()
2802 ? targetm
.narrow_volatile_bitfield ()
2803 : !SLOW_BYTE_ACCESS
);
2806 /* Find the best machine mode to use when referencing a bit field of length
2807 BITSIZE bits starting at BITPOS.
2809 BITREGION_START is the bit position of the first bit in this
2810 sequence of bit fields. BITREGION_END is the last bit in this
2811 sequence. If these two fields are non-zero, we should restrict the
2812 memory access to that range. Otherwise, we are allowed to touch
2813 any adjacent non bit-fields.
2815 The underlying object is known to be aligned to a boundary of ALIGN bits.
2816 If LARGEST_MODE is not VOIDmode, it means that we should not use a mode
2817 larger than LARGEST_MODE (usually SImode).
2819 If no mode meets all these conditions, we return VOIDmode.
2821 If VOLATILEP is false and SLOW_BYTE_ACCESS is false, we return the
2822 smallest mode meeting these conditions.
2824 If VOLATILEP is false and SLOW_BYTE_ACCESS is true, we return the
2825 largest mode (but a mode no wider than UNITS_PER_WORD) that meets
2828 If VOLATILEP is true the narrow_volatile_bitfields target hook is used to
2829 decide which of the above modes should be used. */
2832 get_best_mode (int bitsize
, int bitpos
,
2833 unsigned HOST_WIDE_INT bitregion_start
,
2834 unsigned HOST_WIDE_INT bitregion_end
,
2836 machine_mode largest_mode
, bool volatilep
)
2838 bit_field_mode_iterator
iter (bitsize
, bitpos
, bitregion_start
,
2839 bitregion_end
, align
, volatilep
);
2840 machine_mode widest_mode
= VOIDmode
;
2842 while (iter
.next_mode (&mode
)
2843 /* ??? For historical reasons, reject modes that would normally
2844 receive greater alignment, even if unaligned accesses are
2845 acceptable. This has both advantages and disadvantages.
2846 Removing this check means that something like:
2848 struct s { unsigned int x; unsigned int y; };
2849 int f (struct s *s) { return s->x == 0 && s->y == 0; }
2851 can be implemented using a single load and compare on
2852 64-bit machines that have no alignment restrictions.
2853 For example, on powerpc64-linux-gnu, we would generate:
2875 However, accessing more than one field can make life harder
2876 for the gimple optimizers. For example, gcc.dg/vect/bb-slp-5.c
2877 has a series of unsigned short copies followed by a series of
2878 unsigned short comparisons. With this check, both the copies
2879 and comparisons remain 16-bit accesses and FRE is able
2880 to eliminate the latter. Without the check, the comparisons
2881 can be done using 2 64-bit operations, which FRE isn't able
2882 to handle in the same way.
2884 Either way, it would probably be worth disabling this check
2885 during expand. One particular example where removing the
2886 check would help is the get_best_mode call in store_bit_field.
2887 If we are given a memory bitregion of 128 bits that is aligned
2888 to a 64-bit boundary, and the bitfield we want to modify is
2889 in the second half of the bitregion, this check causes
2890 store_bitfield to turn the memory into a 64-bit reference
2891 to the _first_ half of the region. We later use
2892 adjust_bitfield_address to get a reference to the correct half,
2893 but doing so looks to adjust_bitfield_address as though we are
2894 moving past the end of the original object, so it drops the
2895 associated MEM_EXPR and MEM_OFFSET. Removing the check
2896 causes store_bit_field to keep a 128-bit memory reference,
2897 so that the final bitfield reference still has a MEM_EXPR
2899 && GET_MODE_ALIGNMENT (mode
) <= align
2900 && (largest_mode
== VOIDmode
2901 || GET_MODE_SIZE (mode
) <= GET_MODE_SIZE (largest_mode
)))
2904 if (iter
.prefer_smaller_modes ())
2910 /* Gets minimal and maximal values for MODE (signed or unsigned depending on
2911 SIGN). The returned constants are made to be usable in TARGET_MODE. */
2914 get_mode_bounds (machine_mode mode
, int sign
,
2915 machine_mode target_mode
,
2916 rtx
*mmin
, rtx
*mmax
)
2918 unsigned size
= GET_MODE_PRECISION (mode
);
2919 unsigned HOST_WIDE_INT min_val
, max_val
;
2921 gcc_assert (size
<= HOST_BITS_PER_WIDE_INT
);
2923 /* Special case BImode, which has values 0 and STORE_FLAG_VALUE. */
2926 if (STORE_FLAG_VALUE
< 0)
2928 min_val
= STORE_FLAG_VALUE
;
2934 max_val
= STORE_FLAG_VALUE
;
2939 min_val
= -((unsigned HOST_WIDE_INT
) 1 << (size
- 1));
2940 max_val
= ((unsigned HOST_WIDE_INT
) 1 << (size
- 1)) - 1;
2945 max_val
= ((unsigned HOST_WIDE_INT
) 1 << (size
- 1) << 1) - 1;
2948 *mmin
= gen_int_mode (min_val
, target_mode
);
2949 *mmax
= gen_int_mode (max_val
, target_mode
);
2952 #include "gt-stor-layout.h"