1 /* C-compiler utilities for types and variables storage layout
2 Copyright (C) 1987-2019 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"
30 #include "stringpool.h"
34 #include "diagnostic-core.h"
35 #include "fold-const.h"
36 #include "stor-layout.h"
38 #include "print-tree.h"
39 #include "langhooks.h"
40 #include "tree-inline.h"
47 /* Data type for the expressions representing sizes of data types.
48 It is the first integer type laid out. */
49 tree sizetype_tab
[(int) stk_type_kind_last
];
51 /* If nonzero, this is an upper limit on alignment of structure fields.
52 The value is measured in bits. */
53 unsigned int maximum_field_alignment
= TARGET_DEFAULT_PACK_STRUCT
* BITS_PER_UNIT
;
55 static tree
self_referential_size (tree
);
56 static void finalize_record_size (record_layout_info
);
57 static void finalize_type_size (tree
);
58 static void place_union_field (record_layout_info
, tree
);
59 static int excess_unit_span (HOST_WIDE_INT
, HOST_WIDE_INT
, HOST_WIDE_INT
,
61 extern void debug_rli (record_layout_info
);
63 /* Given a size SIZE that may not be a constant, return a SAVE_EXPR
64 to serve as the actual size-expression for a type or decl. */
67 variable_size (tree size
)
70 if (TREE_CONSTANT (size
))
73 /* If the size is self-referential, we can't make a SAVE_EXPR (see
74 save_expr for the rationale). But we can do something else. */
75 if (CONTAINS_PLACEHOLDER_P (size
))
76 return self_referential_size (size
);
78 /* If we are in the global binding level, we can't make a SAVE_EXPR
79 since it may end up being shared across functions, so it is up
80 to the front-end to deal with this case. */
81 if (lang_hooks
.decls
.global_bindings_p ())
84 return save_expr (size
);
87 /* An array of functions used for self-referential size computation. */
88 static GTY(()) vec
<tree
, va_gc
> *size_functions
;
90 /* Return true if T is a self-referential component reference. */
93 self_referential_component_ref_p (tree t
)
95 if (TREE_CODE (t
) != COMPONENT_REF
)
98 while (REFERENCE_CLASS_P (t
))
99 t
= TREE_OPERAND (t
, 0);
101 return (TREE_CODE (t
) == PLACEHOLDER_EXPR
);
104 /* Similar to copy_tree_r but do not copy component references involving
105 PLACEHOLDER_EXPRs. These nodes are spotted in find_placeholder_in_expr
106 and substituted in substitute_in_expr. */
109 copy_self_referential_tree_r (tree
*tp
, int *walk_subtrees
, void *data
)
111 enum tree_code code
= TREE_CODE (*tp
);
113 /* Stop at types, decls, constants like copy_tree_r. */
114 if (TREE_CODE_CLASS (code
) == tcc_type
115 || TREE_CODE_CLASS (code
) == tcc_declaration
116 || TREE_CODE_CLASS (code
) == tcc_constant
)
122 /* This is the pattern built in ada/make_aligning_type. */
123 else if (code
== ADDR_EXPR
124 && TREE_CODE (TREE_OPERAND (*tp
, 0)) == PLACEHOLDER_EXPR
)
130 /* Default case: the component reference. */
131 else if (self_referential_component_ref_p (*tp
))
137 /* We're not supposed to have them in self-referential size trees
138 because we wouldn't properly control when they are evaluated.
139 However, not creating superfluous SAVE_EXPRs requires accurate
140 tracking of readonly-ness all the way down to here, which we
141 cannot always guarantee in practice. So punt in this case. */
142 else if (code
== SAVE_EXPR
)
143 return error_mark_node
;
145 else if (code
== STATEMENT_LIST
)
148 return copy_tree_r (tp
, walk_subtrees
, data
);
151 /* Given a SIZE expression that is self-referential, return an equivalent
152 expression to serve as the actual size expression for a type. */
155 self_referential_size (tree size
)
157 static unsigned HOST_WIDE_INT fnno
= 0;
158 vec
<tree
> self_refs
= vNULL
;
159 tree param_type_list
= NULL
, param_decl_list
= NULL
;
160 tree t
, ref
, return_type
, fntype
, fnname
, fndecl
;
163 vec
<tree
, va_gc
> *args
= NULL
;
165 /* Do not factor out simple operations. */
166 t
= skip_simple_constant_arithmetic (size
);
167 if (TREE_CODE (t
) == CALL_EXPR
|| self_referential_component_ref_p (t
))
170 /* Collect the list of self-references in the expression. */
171 find_placeholder_in_expr (size
, &self_refs
);
172 gcc_assert (self_refs
.length () > 0);
174 /* Obtain a private copy of the expression. */
176 if (walk_tree (&t
, copy_self_referential_tree_r
, NULL
, NULL
) != NULL_TREE
)
180 /* Build the parameter and argument lists in parallel; also
181 substitute the former for the latter in the expression. */
182 vec_alloc (args
, self_refs
.length ());
183 FOR_EACH_VEC_ELT (self_refs
, i
, ref
)
185 tree subst
, param_name
, param_type
, param_decl
;
189 /* We shouldn't have true variables here. */
190 gcc_assert (TREE_READONLY (ref
));
193 /* This is the pattern built in ada/make_aligning_type. */
194 else if (TREE_CODE (ref
) == ADDR_EXPR
)
196 /* Default case: the component reference. */
198 subst
= TREE_OPERAND (ref
, 1);
200 sprintf (buf
, "p%d", i
);
201 param_name
= get_identifier (buf
);
202 param_type
= TREE_TYPE (ref
);
204 = build_decl (input_location
, PARM_DECL
, param_name
, param_type
);
205 DECL_ARG_TYPE (param_decl
) = param_type
;
206 DECL_ARTIFICIAL (param_decl
) = 1;
207 TREE_READONLY (param_decl
) = 1;
209 size
= substitute_in_expr (size
, subst
, param_decl
);
211 param_type_list
= tree_cons (NULL_TREE
, param_type
, param_type_list
);
212 param_decl_list
= chainon (param_decl
, param_decl_list
);
213 args
->quick_push (ref
);
216 self_refs
.release ();
218 /* Append 'void' to indicate that the number of parameters is fixed. */
219 param_type_list
= tree_cons (NULL_TREE
, void_type_node
, param_type_list
);
221 /* The 3 lists have been created in reverse order. */
222 param_type_list
= nreverse (param_type_list
);
223 param_decl_list
= nreverse (param_decl_list
);
225 /* Build the function type. */
226 return_type
= TREE_TYPE (size
);
227 fntype
= build_function_type (return_type
, param_type_list
);
229 /* Build the function declaration. */
230 sprintf (buf
, "SZ" HOST_WIDE_INT_PRINT_UNSIGNED
, fnno
++);
231 fnname
= get_file_function_name (buf
);
232 fndecl
= build_decl (input_location
, FUNCTION_DECL
, fnname
, fntype
);
233 for (t
= param_decl_list
; t
; t
= DECL_CHAIN (t
))
234 DECL_CONTEXT (t
) = fndecl
;
235 DECL_ARGUMENTS (fndecl
) = param_decl_list
;
237 = build_decl (input_location
, RESULT_DECL
, 0, return_type
);
238 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
240 /* The function has been created by the compiler and we don't
241 want to emit debug info for it. */
242 DECL_ARTIFICIAL (fndecl
) = 1;
243 DECL_IGNORED_P (fndecl
) = 1;
245 /* It is supposed to be "const" and never throw. */
246 TREE_READONLY (fndecl
) = 1;
247 TREE_NOTHROW (fndecl
) = 1;
249 /* We want it to be inlined when this is deemed profitable, as
250 well as discarded if every call has been integrated. */
251 DECL_DECLARED_INLINE_P (fndecl
) = 1;
253 /* It is made up of a unique return statement. */
254 DECL_INITIAL (fndecl
) = make_node (BLOCK
);
255 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
256 t
= build2 (MODIFY_EXPR
, return_type
, DECL_RESULT (fndecl
), size
);
257 DECL_SAVED_TREE (fndecl
) = build1 (RETURN_EXPR
, void_type_node
, t
);
258 TREE_STATIC (fndecl
) = 1;
260 /* Put it onto the list of size functions. */
261 vec_safe_push (size_functions
, fndecl
);
263 /* Replace the original expression with a call to the size function. */
264 return build_call_expr_loc_vec (UNKNOWN_LOCATION
, fndecl
, args
);
267 /* Take, queue and compile all the size functions. It is essential that
268 the size functions be gimplified at the very end of the compilation
269 in order to guarantee transparent handling of self-referential sizes.
270 Otherwise the GENERIC inliner would not be able to inline them back
271 at each of their call sites, thus creating artificial non-constant
272 size expressions which would trigger nasty problems later on. */
275 finalize_size_functions (void)
280 for (i
= 0; size_functions
&& size_functions
->iterate (i
, &fndecl
); i
++)
282 allocate_struct_function (fndecl
, false);
284 dump_function (TDI_original
, fndecl
);
286 /* As these functions are used to describe the layout of variable-length
287 structures, debug info generation needs their implementation. */
288 debug_hooks
->size_function (fndecl
);
289 gimplify_function_tree (fndecl
);
290 cgraph_node::finalize_function (fndecl
, false);
293 vec_free (size_functions
);
296 /* Return a machine mode of class MCLASS with SIZE bits of precision,
297 if one exists. The mode may have padding bits as well the SIZE
298 value bits. If LIMIT is nonzero, disregard modes wider than
299 MAX_FIXED_MODE_SIZE. */
302 mode_for_size (poly_uint64 size
, enum mode_class mclass
, int limit
)
307 if (limit
&& maybe_gt (size
, (unsigned int) MAX_FIXED_MODE_SIZE
))
308 return opt_machine_mode ();
310 /* Get the first mode which has this size, in the specified class. */
311 FOR_EACH_MODE_IN_CLASS (mode
, mclass
)
312 if (known_eq (GET_MODE_PRECISION (mode
), size
))
315 if (mclass
== MODE_INT
|| mclass
== MODE_PARTIAL_INT
)
316 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
317 if (known_eq (int_n_data
[i
].bitsize
, size
)
318 && int_n_enabled_p
[i
])
319 return int_n_data
[i
].m
;
321 return opt_machine_mode ();
324 /* Similar, except passed a tree node. */
327 mode_for_size_tree (const_tree size
, enum mode_class mclass
, int limit
)
329 unsigned HOST_WIDE_INT uhwi
;
332 if (!tree_fits_uhwi_p (size
))
333 return opt_machine_mode ();
334 uhwi
= tree_to_uhwi (size
);
337 return opt_machine_mode ();
338 return mode_for_size (ui
, mclass
, limit
);
341 /* Return the narrowest mode of class MCLASS that contains at least
342 SIZE bits. Abort if no such mode exists. */
345 smallest_mode_for_size (poly_uint64 size
, enum mode_class mclass
)
347 machine_mode mode
= VOIDmode
;
350 /* Get the first mode which has at least this size, in the
352 FOR_EACH_MODE_IN_CLASS (mode
, mclass
)
353 if (known_ge (GET_MODE_PRECISION (mode
), size
))
356 gcc_assert (mode
!= VOIDmode
);
358 if (mclass
== MODE_INT
|| mclass
== MODE_PARTIAL_INT
)
359 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
360 if (known_ge (int_n_data
[i
].bitsize
, size
)
361 && known_lt (int_n_data
[i
].bitsize
, GET_MODE_PRECISION (mode
))
362 && int_n_enabled_p
[i
])
363 mode
= int_n_data
[i
].m
;
368 /* Return an integer mode of exactly the same size as MODE, if one exists. */
371 int_mode_for_mode (machine_mode mode
)
373 switch (GET_MODE_CLASS (mode
))
376 case MODE_PARTIAL_INT
:
377 return as_a
<scalar_int_mode
> (mode
);
379 case MODE_COMPLEX_INT
:
380 case MODE_COMPLEX_FLOAT
:
382 case MODE_DECIMAL_FLOAT
:
387 case MODE_VECTOR_BOOL
:
388 case MODE_VECTOR_INT
:
389 case MODE_VECTOR_FLOAT
:
390 case MODE_VECTOR_FRACT
:
391 case MODE_VECTOR_ACCUM
:
392 case MODE_VECTOR_UFRACT
:
393 case MODE_VECTOR_UACCUM
:
394 return int_mode_for_size (GET_MODE_BITSIZE (mode
), 0);
398 return opt_scalar_int_mode ();
408 /* Find a mode that can be used for efficient bitwise operations on MODE,
412 bitwise_mode_for_mode (machine_mode mode
)
414 /* Quick exit if we already have a suitable mode. */
415 scalar_int_mode int_mode
;
416 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
417 && GET_MODE_BITSIZE (int_mode
) <= MAX_FIXED_MODE_SIZE
)
420 /* Reuse the sanity checks from int_mode_for_mode. */
421 gcc_checking_assert ((int_mode_for_mode (mode
), true));
423 poly_int64 bitsize
= GET_MODE_BITSIZE (mode
);
425 /* Try to replace complex modes with complex modes. In general we
426 expect both components to be processed independently, so we only
427 care whether there is a register for the inner mode. */
428 if (COMPLEX_MODE_P (mode
))
430 machine_mode trial
= mode
;
431 if ((GET_MODE_CLASS (trial
) == MODE_COMPLEX_INT
432 || mode_for_size (bitsize
, MODE_COMPLEX_INT
, false).exists (&trial
))
433 && have_regs_of_mode
[GET_MODE_INNER (trial
)])
437 /* Try to replace vector modes with vector modes. Also try using vector
438 modes if an integer mode would be too big. */
439 if (VECTOR_MODE_P (mode
)
440 || maybe_gt (bitsize
, MAX_FIXED_MODE_SIZE
))
442 machine_mode trial
= mode
;
443 if ((GET_MODE_CLASS (trial
) == MODE_VECTOR_INT
444 || mode_for_size (bitsize
, MODE_VECTOR_INT
, 0).exists (&trial
))
445 && have_regs_of_mode
[trial
]
446 && targetm
.vector_mode_supported_p (trial
))
450 /* Otherwise fall back on integers while honoring MAX_FIXED_MODE_SIZE. */
451 return mode_for_size (bitsize
, MODE_INT
, true);
454 /* Find a type that can be used for efficient bitwise operations on MODE.
455 Return null if no such mode exists. */
458 bitwise_type_for_mode (machine_mode mode
)
460 if (!bitwise_mode_for_mode (mode
).exists (&mode
))
463 unsigned int inner_size
= GET_MODE_UNIT_BITSIZE (mode
);
464 tree inner_type
= build_nonstandard_integer_type (inner_size
, true);
466 if (VECTOR_MODE_P (mode
))
467 return build_vector_type_for_mode (inner_type
, mode
);
469 if (COMPLEX_MODE_P (mode
))
470 return build_complex_type (inner_type
);
472 gcc_checking_assert (GET_MODE_INNER (mode
) == mode
);
476 /* Find a mode that is suitable for representing a vector with NUNITS
477 elements of mode INNERMODE, if one exists. The returned mode can be
478 either an integer mode or a vector mode. */
481 mode_for_vector (scalar_mode innermode
, poly_uint64 nunits
)
485 /* First, look for a supported vector type. */
486 if (SCALAR_FLOAT_MODE_P (innermode
))
487 mode
= MIN_MODE_VECTOR_FLOAT
;
488 else if (SCALAR_FRACT_MODE_P (innermode
))
489 mode
= MIN_MODE_VECTOR_FRACT
;
490 else if (SCALAR_UFRACT_MODE_P (innermode
))
491 mode
= MIN_MODE_VECTOR_UFRACT
;
492 else if (SCALAR_ACCUM_MODE_P (innermode
))
493 mode
= MIN_MODE_VECTOR_ACCUM
;
494 else if (SCALAR_UACCUM_MODE_P (innermode
))
495 mode
= MIN_MODE_VECTOR_UACCUM
;
497 mode
= MIN_MODE_VECTOR_INT
;
499 /* Do not check vector_mode_supported_p here. We'll do that
500 later in vector_type_mode. */
501 FOR_EACH_MODE_FROM (mode
, mode
)
502 if (known_eq (GET_MODE_NUNITS (mode
), nunits
)
503 && GET_MODE_INNER (mode
) == innermode
)
506 /* For integers, try mapping it to a same-sized scalar mode. */
507 if (GET_MODE_CLASS (innermode
) == MODE_INT
)
509 poly_uint64 nbits
= nunits
* GET_MODE_BITSIZE (innermode
);
510 if (int_mode_for_size (nbits
, 0).exists (&mode
)
511 && have_regs_of_mode
[mode
])
515 return opt_machine_mode ();
518 /* Return the mode for a vector that has NUNITS integer elements of
519 INT_BITS bits each, if such a mode exists. The mode can be either
520 an integer mode or a vector mode. */
523 mode_for_int_vector (unsigned int int_bits
, poly_uint64 nunits
)
525 scalar_int_mode int_mode
;
526 machine_mode vec_mode
;
527 if (int_mode_for_size (int_bits
, 0).exists (&int_mode
)
528 && mode_for_vector (int_mode
, nunits
).exists (&vec_mode
))
530 return opt_machine_mode ();
533 /* Return the alignment of MODE. This will be bounded by 1 and
534 BIGGEST_ALIGNMENT. */
537 get_mode_alignment (machine_mode mode
)
539 return MIN (BIGGEST_ALIGNMENT
, MAX (1, mode_base_align
[mode
]*BITS_PER_UNIT
));
542 /* Return the natural mode of an array, given that it is SIZE bytes in
543 total and has elements of type ELEM_TYPE. */
546 mode_for_array (tree elem_type
, tree size
)
549 poly_uint64 int_size
, int_elem_size
;
550 unsigned HOST_WIDE_INT num_elems
;
553 /* One-element arrays get the component type's mode. */
554 elem_size
= TYPE_SIZE (elem_type
);
555 if (simple_cst_equal (size
, elem_size
))
556 return TYPE_MODE (elem_type
);
559 if (poly_int_tree_p (size
, &int_size
)
560 && poly_int_tree_p (elem_size
, &int_elem_size
)
561 && maybe_ne (int_elem_size
, 0U)
562 && constant_multiple_p (int_size
, int_elem_size
, &num_elems
))
564 machine_mode elem_mode
= TYPE_MODE (elem_type
);
566 if (targetm
.array_mode (elem_mode
, num_elems
).exists (&mode
))
568 if (targetm
.array_mode_supported_p (elem_mode
, num_elems
))
571 return mode_for_size_tree (size
, MODE_INT
, limit_p
).else_blk ();
574 /* Subroutine of layout_decl: Force alignment required for the data type.
575 But if the decl itself wants greater alignment, don't override that. */
578 do_type_align (tree type
, tree decl
)
580 if (TYPE_ALIGN (type
) > DECL_ALIGN (decl
))
582 SET_DECL_ALIGN (decl
, TYPE_ALIGN (type
));
583 if (TREE_CODE (decl
) == FIELD_DECL
)
584 DECL_USER_ALIGN (decl
) = TYPE_USER_ALIGN (type
);
586 if (TYPE_WARN_IF_NOT_ALIGN (type
) > DECL_WARN_IF_NOT_ALIGN (decl
))
587 SET_DECL_WARN_IF_NOT_ALIGN (decl
, TYPE_WARN_IF_NOT_ALIGN (type
));
590 /* Set the size, mode and alignment of a ..._DECL node.
591 TYPE_DECL does need this for C++.
592 Note that LABEL_DECL and CONST_DECL nodes do not need this,
593 and FUNCTION_DECL nodes have them set up in a special (and simple) way.
594 Don't call layout_decl for them.
596 KNOWN_ALIGN is the amount of alignment we can assume this
597 decl has with no special effort. It is relevant only for FIELD_DECLs
598 and depends on the previous fields.
599 All that matters about KNOWN_ALIGN is which powers of 2 divide it.
600 If KNOWN_ALIGN is 0, it means, "as much alignment as you like":
601 the record will be aligned to suit. */
604 layout_decl (tree decl
, unsigned int known_align
)
606 tree type
= TREE_TYPE (decl
);
607 enum tree_code code
= TREE_CODE (decl
);
609 location_t loc
= DECL_SOURCE_LOCATION (decl
);
611 if (code
== CONST_DECL
)
614 gcc_assert (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
615 || code
== TYPE_DECL
|| code
== FIELD_DECL
);
617 rtl
= DECL_RTL_IF_SET (decl
);
619 if (type
== error_mark_node
)
620 type
= void_type_node
;
622 /* Usually the size and mode come from the data type without change,
623 however, the front-end may set the explicit width of the field, so its
624 size may not be the same as the size of its type. This happens with
625 bitfields, of course (an `int' bitfield may be only 2 bits, say), but it
626 also happens with other fields. For example, the C++ front-end creates
627 zero-sized fields corresponding to empty base classes, and depends on
628 layout_type setting DECL_FIELD_BITPOS correctly for the field. Set the
629 size in bytes from the size in bits. If we have already set the mode,
630 don't set it again since we can be called twice for FIELD_DECLs. */
632 DECL_UNSIGNED (decl
) = TYPE_UNSIGNED (type
);
633 if (DECL_MODE (decl
) == VOIDmode
)
634 SET_DECL_MODE (decl
, TYPE_MODE (type
));
636 if (DECL_SIZE (decl
) == 0)
638 DECL_SIZE (decl
) = TYPE_SIZE (type
);
639 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (type
);
641 else if (DECL_SIZE_UNIT (decl
) == 0)
642 DECL_SIZE_UNIT (decl
)
643 = fold_convert_loc (loc
, sizetype
,
644 size_binop_loc (loc
, CEIL_DIV_EXPR
, DECL_SIZE (decl
),
647 if (code
!= FIELD_DECL
)
648 /* For non-fields, update the alignment from the type. */
649 do_type_align (type
, decl
);
651 /* For fields, it's a bit more complicated... */
653 bool old_user_align
= DECL_USER_ALIGN (decl
);
654 bool zero_bitfield
= false;
655 bool packed_p
= DECL_PACKED (decl
);
658 if (DECL_BIT_FIELD (decl
))
660 DECL_BIT_FIELD_TYPE (decl
) = type
;
662 /* A zero-length bit-field affects the alignment of the next
663 field. In essence such bit-fields are not influenced by
664 any packing due to #pragma pack or attribute packed. */
665 if (integer_zerop (DECL_SIZE (decl
))
666 && ! targetm
.ms_bitfield_layout_p (DECL_FIELD_CONTEXT (decl
)))
668 zero_bitfield
= true;
670 if (PCC_BITFIELD_TYPE_MATTERS
)
671 do_type_align (type
, decl
);
674 #ifdef EMPTY_FIELD_BOUNDARY
675 if (EMPTY_FIELD_BOUNDARY
> DECL_ALIGN (decl
))
677 SET_DECL_ALIGN (decl
, EMPTY_FIELD_BOUNDARY
);
678 DECL_USER_ALIGN (decl
) = 0;
684 /* See if we can use an ordinary integer mode for a bit-field.
685 Conditions are: a fixed size that is correct for another mode,
686 occupying a complete byte or bytes on proper boundary. */
687 if (TYPE_SIZE (type
) != 0
688 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
689 && GET_MODE_CLASS (TYPE_MODE (type
)) == MODE_INT
)
692 if (mode_for_size_tree (DECL_SIZE (decl
),
693 MODE_INT
, 1).exists (&xmode
))
695 unsigned int xalign
= GET_MODE_ALIGNMENT (xmode
);
696 if (!(xalign
> BITS_PER_UNIT
&& DECL_PACKED (decl
))
697 && (known_align
== 0 || known_align
>= xalign
))
699 SET_DECL_ALIGN (decl
, MAX (xalign
, DECL_ALIGN (decl
)));
700 SET_DECL_MODE (decl
, xmode
);
701 DECL_BIT_FIELD (decl
) = 0;
706 /* Turn off DECL_BIT_FIELD if we won't need it set. */
707 if (TYPE_MODE (type
) == BLKmode
&& DECL_MODE (decl
) == BLKmode
708 && known_align
>= TYPE_ALIGN (type
)
709 && DECL_ALIGN (decl
) >= TYPE_ALIGN (type
))
710 DECL_BIT_FIELD (decl
) = 0;
712 else if (packed_p
&& DECL_USER_ALIGN (decl
))
713 /* Don't touch DECL_ALIGN. For other packed fields, go ahead and
714 round up; we'll reduce it again below. We want packing to
715 supersede USER_ALIGN inherited from the type, but defer to
716 alignment explicitly specified on the field decl. */;
718 do_type_align (type
, decl
);
720 /* If the field is packed and not explicitly aligned, give it the
721 minimum alignment. Note that do_type_align may set
722 DECL_USER_ALIGN, so we need to check old_user_align instead. */
725 SET_DECL_ALIGN (decl
, MIN (DECL_ALIGN (decl
), BITS_PER_UNIT
));
727 if (! packed_p
&& ! DECL_USER_ALIGN (decl
))
729 /* Some targets (i.e. i386, VMS) limit struct field alignment
730 to a lower boundary than alignment of variables unless
731 it was overridden by attribute aligned. */
732 #ifdef BIGGEST_FIELD_ALIGNMENT
733 SET_DECL_ALIGN (decl
, MIN (DECL_ALIGN (decl
),
734 (unsigned) BIGGEST_FIELD_ALIGNMENT
));
736 #ifdef ADJUST_FIELD_ALIGN
737 SET_DECL_ALIGN (decl
, ADJUST_FIELD_ALIGN (decl
, TREE_TYPE (decl
),
743 mfa
= initial_max_fld_align
* BITS_PER_UNIT
;
745 mfa
= maximum_field_alignment
;
746 /* Should this be controlled by DECL_USER_ALIGN, too? */
748 SET_DECL_ALIGN (decl
, MIN (DECL_ALIGN (decl
), mfa
));
751 /* Evaluate nonconstant size only once, either now or as soon as safe. */
752 if (DECL_SIZE (decl
) != 0 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
753 DECL_SIZE (decl
) = variable_size (DECL_SIZE (decl
));
754 if (DECL_SIZE_UNIT (decl
) != 0
755 && TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
)
756 DECL_SIZE_UNIT (decl
) = variable_size (DECL_SIZE_UNIT (decl
));
758 /* If requested, warn about definitions of large data objects. */
759 if ((code
== PARM_DECL
|| (code
== VAR_DECL
&& !DECL_NONLOCAL_FRAME (decl
)))
760 && !DECL_EXTERNAL (decl
))
762 tree size
= DECL_SIZE_UNIT (decl
);
764 if (size
!= 0 && TREE_CODE (size
) == INTEGER_CST
)
766 /* -Wlarger-than= argument of HOST_WIDE_INT_MAX is treated
767 as if PTRDIFF_MAX had been specified, with the value
768 being that on the target rather than the host. */
769 unsigned HOST_WIDE_INT max_size
= warn_larger_than_size
;
770 if (max_size
== HOST_WIDE_INT_MAX
)
771 max_size
= tree_to_shwi (TYPE_MAX_VALUE (ptrdiff_type_node
));
773 if (compare_tree_int (size
, max_size
) > 0)
774 warning (OPT_Wlarger_than_
, "size of %q+D %E bytes exceeds "
775 "maximum object size %wu",
776 decl
, size
, max_size
);
780 /* If the RTL was already set, update its mode and mem attributes. */
783 PUT_MODE (rtl
, DECL_MODE (decl
));
784 SET_DECL_RTL (decl
, 0);
786 set_mem_attributes (rtl
, decl
, 1);
787 SET_DECL_RTL (decl
, rtl
);
791 /* Given a VAR_DECL, PARM_DECL, RESULT_DECL, or FIELD_DECL, clears the
792 results of a previous call to layout_decl and calls it again. */
795 relayout_decl (tree decl
)
797 DECL_SIZE (decl
) = DECL_SIZE_UNIT (decl
) = 0;
798 SET_DECL_MODE (decl
, VOIDmode
);
799 if (!DECL_USER_ALIGN (decl
))
800 SET_DECL_ALIGN (decl
, 0);
801 if (DECL_RTL_SET_P (decl
))
802 SET_DECL_RTL (decl
, 0);
804 layout_decl (decl
, 0);
807 /* Begin laying out type T, which may be a RECORD_TYPE, UNION_TYPE, or
808 QUAL_UNION_TYPE. Return a pointer to a struct record_layout_info which
809 is to be passed to all other layout functions for this record. It is the
810 responsibility of the caller to call `free' for the storage returned.
811 Note that garbage collection is not permitted until we finish laying
815 start_record_layout (tree t
)
817 record_layout_info rli
= XNEW (struct record_layout_info_s
);
821 /* If the type has a minimum specified alignment (via an attribute
822 declaration, for example) use it -- otherwise, start with a
823 one-byte alignment. */
824 rli
->record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (t
));
825 rli
->unpacked_align
= rli
->record_align
;
826 rli
->offset_align
= MAX (rli
->record_align
, BIGGEST_ALIGNMENT
);
828 #ifdef STRUCTURE_SIZE_BOUNDARY
829 /* Packed structures don't need to have minimum size. */
830 if (! TYPE_PACKED (t
))
834 /* #pragma pack overrides STRUCTURE_SIZE_BOUNDARY. */
835 tmp
= (unsigned) STRUCTURE_SIZE_BOUNDARY
;
836 if (maximum_field_alignment
!= 0)
837 tmp
= MIN (tmp
, maximum_field_alignment
);
838 rli
->record_align
= MAX (rli
->record_align
, tmp
);
842 rli
->offset
= size_zero_node
;
843 rli
->bitpos
= bitsize_zero_node
;
845 rli
->pending_statics
= 0;
846 rli
->packed_maybe_necessary
= 0;
847 rli
->remaining_in_alignment
= 0;
852 /* Fold sizetype value X to bitsizetype, given that X represents a type
856 bits_from_bytes (tree x
)
858 if (POLY_INT_CST_P (x
))
859 /* The runtime calculation isn't allowed to overflow sizetype;
860 increasing the runtime values must always increase the size
861 or offset of the object. This means that the object imposes
862 a maximum value on the runtime parameters, but we don't record
864 return build_poly_int_cst
866 poly_wide_int::from (poly_int_cst_value (x
),
867 TYPE_PRECISION (bitsizetype
),
868 TYPE_SIGN (TREE_TYPE (x
))));
869 x
= fold_convert (bitsizetype
, x
);
870 gcc_checking_assert (x
);
874 /* Return the combined bit position for the byte offset OFFSET and the
877 These functions operate on byte and bit positions present in FIELD_DECLs
878 and assume that these expressions result in no (intermediate) overflow.
879 This assumption is necessary to fold the expressions as much as possible,
880 so as to avoid creating artificially variable-sized types in languages
881 supporting variable-sized types like Ada. */
884 bit_from_pos (tree offset
, tree bitpos
)
886 return size_binop (PLUS_EXPR
, bitpos
,
887 size_binop (MULT_EXPR
, bits_from_bytes (offset
),
891 /* Return the combined truncated byte position for the byte offset OFFSET and
892 the bit position BITPOS. */
895 byte_from_pos (tree offset
, tree bitpos
)
898 if (TREE_CODE (bitpos
) == MULT_EXPR
899 && tree_int_cst_equal (TREE_OPERAND (bitpos
, 1), bitsize_unit_node
))
900 bytepos
= TREE_OPERAND (bitpos
, 0);
902 bytepos
= size_binop (TRUNC_DIV_EXPR
, bitpos
, bitsize_unit_node
);
903 return size_binop (PLUS_EXPR
, offset
, fold_convert (sizetype
, bytepos
));
906 /* Split the bit position POS into a byte offset *POFFSET and a bit
907 position *PBITPOS with the byte offset aligned to OFF_ALIGN bits. */
910 pos_from_bit (tree
*poffset
, tree
*pbitpos
, unsigned int off_align
,
913 tree toff_align
= bitsize_int (off_align
);
914 if (TREE_CODE (pos
) == MULT_EXPR
915 && tree_int_cst_equal (TREE_OPERAND (pos
, 1), toff_align
))
917 *poffset
= size_binop (MULT_EXPR
,
918 fold_convert (sizetype
, TREE_OPERAND (pos
, 0)),
919 size_int (off_align
/ BITS_PER_UNIT
));
920 *pbitpos
= bitsize_zero_node
;
924 *poffset
= size_binop (MULT_EXPR
,
925 fold_convert (sizetype
,
926 size_binop (FLOOR_DIV_EXPR
, pos
,
928 size_int (off_align
/ BITS_PER_UNIT
));
929 *pbitpos
= size_binop (FLOOR_MOD_EXPR
, pos
, toff_align
);
933 /* Given a pointer to bit and byte offsets and an offset alignment,
934 normalize the offsets so they are within the alignment. */
937 normalize_offset (tree
*poffset
, tree
*pbitpos
, unsigned int off_align
)
939 /* If the bit position is now larger than it should be, adjust it
941 if (compare_tree_int (*pbitpos
, off_align
) >= 0)
944 pos_from_bit (&offset
, &bitpos
, off_align
, *pbitpos
);
945 *poffset
= size_binop (PLUS_EXPR
, *poffset
, offset
);
950 /* Print debugging information about the information in RLI. */
953 debug_rli (record_layout_info rli
)
955 print_node_brief (stderr
, "type", rli
->t
, 0);
956 print_node_brief (stderr
, "\noffset", rli
->offset
, 0);
957 print_node_brief (stderr
, " bitpos", rli
->bitpos
, 0);
959 fprintf (stderr
, "\naligns: rec = %u, unpack = %u, off = %u\n",
960 rli
->record_align
, rli
->unpacked_align
,
963 /* The ms_struct code is the only that uses this. */
964 if (targetm
.ms_bitfield_layout_p (rli
->t
))
965 fprintf (stderr
, "remaining in alignment = %u\n", rli
->remaining_in_alignment
);
967 if (rli
->packed_maybe_necessary
)
968 fprintf (stderr
, "packed may be necessary\n");
970 if (!vec_safe_is_empty (rli
->pending_statics
))
972 fprintf (stderr
, "pending statics:\n");
973 debug (rli
->pending_statics
);
977 /* Given an RLI with a possibly-incremented BITPOS, adjust OFFSET and
978 BITPOS if necessary to keep BITPOS below OFFSET_ALIGN. */
981 normalize_rli (record_layout_info rli
)
983 normalize_offset (&rli
->offset
, &rli
->bitpos
, rli
->offset_align
);
986 /* Returns the size in bytes allocated so far. */
989 rli_size_unit_so_far (record_layout_info rli
)
991 return byte_from_pos (rli
->offset
, rli
->bitpos
);
994 /* Returns the size in bits allocated so far. */
997 rli_size_so_far (record_layout_info rli
)
999 return bit_from_pos (rli
->offset
, rli
->bitpos
);
1002 /* FIELD is about to be added to RLI->T. The alignment (in bits) of
1003 the next available location within the record is given by KNOWN_ALIGN.
1004 Update the variable alignment fields in RLI, and return the alignment
1005 to give the FIELD. */
1008 update_alignment_for_field (record_layout_info rli
, tree field
,
1009 unsigned int known_align
)
1011 /* The alignment required for FIELD. */
1012 unsigned int desired_align
;
1013 /* The type of this field. */
1014 tree type
= TREE_TYPE (field
);
1015 /* True if the field was explicitly aligned by the user. */
1019 /* Do not attempt to align an ERROR_MARK node */
1020 if (TREE_CODE (type
) == ERROR_MARK
)
1023 /* Lay out the field so we know what alignment it needs. */
1024 layout_decl (field
, known_align
);
1025 desired_align
= DECL_ALIGN (field
);
1026 user_align
= DECL_USER_ALIGN (field
);
1028 is_bitfield
= (type
!= error_mark_node
1029 && DECL_BIT_FIELD_TYPE (field
)
1030 && ! integer_zerop (TYPE_SIZE (type
)));
1032 /* Record must have at least as much alignment as any field.
1033 Otherwise, the alignment of the field within the record is
1035 if (targetm
.ms_bitfield_layout_p (rli
->t
))
1037 /* Here, the alignment of the underlying type of a bitfield can
1038 affect the alignment of a record; even a zero-sized field
1039 can do this. The alignment should be to the alignment of
1040 the type, except that for zero-size bitfields this only
1041 applies if there was an immediately prior, nonzero-size
1042 bitfield. (That's the way it is, experimentally.) */
1044 || ((DECL_SIZE (field
) == NULL_TREE
1045 || !integer_zerop (DECL_SIZE (field
)))
1046 ? !DECL_PACKED (field
)
1048 && DECL_BIT_FIELD_TYPE (rli
->prev_field
)
1049 && ! integer_zerop (DECL_SIZE (rli
->prev_field
)))))
1051 unsigned int type_align
= TYPE_ALIGN (type
);
1052 if (!is_bitfield
&& DECL_PACKED (field
))
1053 type_align
= desired_align
;
1055 type_align
= MAX (type_align
, desired_align
);
1056 if (maximum_field_alignment
!= 0)
1057 type_align
= MIN (type_align
, maximum_field_alignment
);
1058 rli
->record_align
= MAX (rli
->record_align
, type_align
);
1059 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
1062 else if (is_bitfield
&& PCC_BITFIELD_TYPE_MATTERS
)
1064 /* Named bit-fields cause the entire structure to have the
1065 alignment implied by their type. Some targets also apply the same
1066 rules to unnamed bitfields. */
1067 if (DECL_NAME (field
) != 0
1068 || targetm
.align_anon_bitfield ())
1070 unsigned int type_align
= TYPE_ALIGN (type
);
1072 #ifdef ADJUST_FIELD_ALIGN
1073 if (! TYPE_USER_ALIGN (type
))
1074 type_align
= ADJUST_FIELD_ALIGN (field
, type
, type_align
);
1077 /* Targets might chose to handle unnamed and hence possibly
1078 zero-width bitfield. Those are not influenced by #pragmas
1079 or packed attributes. */
1080 if (integer_zerop (DECL_SIZE (field
)))
1082 if (initial_max_fld_align
)
1083 type_align
= MIN (type_align
,
1084 initial_max_fld_align
* BITS_PER_UNIT
);
1086 else if (maximum_field_alignment
!= 0)
1087 type_align
= MIN (type_align
, maximum_field_alignment
);
1088 else if (DECL_PACKED (field
))
1089 type_align
= MIN (type_align
, BITS_PER_UNIT
);
1091 /* The alignment of the record is increased to the maximum
1092 of the current alignment, the alignment indicated on the
1093 field (i.e., the alignment specified by an __aligned__
1094 attribute), and the alignment indicated by the type of
1096 rli
->record_align
= MAX (rli
->record_align
, desired_align
);
1097 rli
->record_align
= MAX (rli
->record_align
, type_align
);
1100 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
1101 user_align
|= TYPE_USER_ALIGN (type
);
1106 rli
->record_align
= MAX (rli
->record_align
, desired_align
);
1107 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
1110 TYPE_USER_ALIGN (rli
->t
) |= user_align
;
1112 return desired_align
;
1115 /* Issue a warning if the record alignment, RECORD_ALIGN, is less than
1116 the field alignment of FIELD or FIELD isn't aligned. */
1119 handle_warn_if_not_align (tree field
, unsigned int record_align
)
1121 tree type
= TREE_TYPE (field
);
1123 if (type
== error_mark_node
)
1126 unsigned int warn_if_not_align
= 0;
1130 if (warn_if_not_aligned
)
1132 warn_if_not_align
= DECL_WARN_IF_NOT_ALIGN (field
);
1133 if (!warn_if_not_align
)
1134 warn_if_not_align
= TYPE_WARN_IF_NOT_ALIGN (type
);
1135 if (warn_if_not_align
)
1136 opt_w
= OPT_Wif_not_aligned
;
1139 if (!warn_if_not_align
1140 && warn_packed_not_aligned
1141 && lookup_attribute ("aligned", TYPE_ATTRIBUTES (type
)))
1143 warn_if_not_align
= TYPE_ALIGN (type
);
1144 opt_w
= OPT_Wpacked_not_aligned
;
1147 if (!warn_if_not_align
)
1150 tree context
= DECL_CONTEXT (field
);
1152 warn_if_not_align
/= BITS_PER_UNIT
;
1153 record_align
/= BITS_PER_UNIT
;
1154 if ((record_align
% warn_if_not_align
) != 0)
1155 warning (opt_w
, "alignment %u of %qT is less than %u",
1156 record_align
, context
, warn_if_not_align
);
1158 tree off
= byte_position (field
);
1159 if (!multiple_of_p (TREE_TYPE (off
), off
, size_int (warn_if_not_align
)))
1161 if (TREE_CODE (off
) == INTEGER_CST
)
1162 warning (opt_w
, "%q+D offset %E in %qT isn%'t aligned to %u",
1163 field
, off
, context
, warn_if_not_align
);
1165 warning (opt_w
, "%q+D offset %E in %qT may not be aligned to %u",
1166 field
, off
, context
, warn_if_not_align
);
1170 /* Called from place_field to handle unions. */
1173 place_union_field (record_layout_info rli
, tree field
)
1175 update_alignment_for_field (rli
, field
, /*known_align=*/0);
1177 DECL_FIELD_OFFSET (field
) = size_zero_node
;
1178 DECL_FIELD_BIT_OFFSET (field
) = bitsize_zero_node
;
1179 SET_DECL_OFFSET_ALIGN (field
, BIGGEST_ALIGNMENT
);
1180 handle_warn_if_not_align (field
, rli
->record_align
);
1182 /* If this is an ERROR_MARK return *after* having set the
1183 field at the start of the union. This helps when parsing
1185 if (TREE_CODE (TREE_TYPE (field
)) == ERROR_MARK
)
1188 if (AGGREGATE_TYPE_P (TREE_TYPE (field
))
1189 && TYPE_TYPELESS_STORAGE (TREE_TYPE (field
)))
1190 TYPE_TYPELESS_STORAGE (rli
->t
) = 1;
1192 /* We assume the union's size will be a multiple of a byte so we don't
1193 bother with BITPOS. */
1194 if (TREE_CODE (rli
->t
) == UNION_TYPE
)
1195 rli
->offset
= size_binop (MAX_EXPR
, rli
->offset
, DECL_SIZE_UNIT (field
));
1196 else if (TREE_CODE (rli
->t
) == QUAL_UNION_TYPE
)
1197 rli
->offset
= fold_build3 (COND_EXPR
, sizetype
, DECL_QUALIFIER (field
),
1198 DECL_SIZE_UNIT (field
), rli
->offset
);
1201 /* A bitfield of SIZE with a required access alignment of ALIGN is allocated
1202 at BYTE_OFFSET / BIT_OFFSET. Return nonzero if the field would span more
1203 units of alignment than the underlying TYPE. */
1205 excess_unit_span (HOST_WIDE_INT byte_offset
, HOST_WIDE_INT bit_offset
,
1206 HOST_WIDE_INT size
, HOST_WIDE_INT align
, tree type
)
1208 /* Note that the calculation of OFFSET might overflow; we calculate it so
1209 that we still get the right result as long as ALIGN is a power of two. */
1210 unsigned HOST_WIDE_INT offset
= byte_offset
* BITS_PER_UNIT
+ bit_offset
;
1212 offset
= offset
% align
;
1213 return ((offset
+ size
+ align
- 1) / align
1214 > tree_to_uhwi (TYPE_SIZE (type
)) / align
);
1217 /* RLI contains information about the layout of a RECORD_TYPE. FIELD
1218 is a FIELD_DECL to be added after those fields already present in
1219 T. (FIELD is not actually added to the TYPE_FIELDS list here;
1220 callers that desire that behavior must manually perform that step.) */
1223 place_field (record_layout_info rli
, tree field
)
1225 /* The alignment required for FIELD. */
1226 unsigned int desired_align
;
1227 /* The alignment FIELD would have if we just dropped it into the
1228 record as it presently stands. */
1229 unsigned int known_align
;
1230 unsigned int actual_align
;
1231 /* The type of this field. */
1232 tree type
= TREE_TYPE (field
);
1234 gcc_assert (TREE_CODE (field
) != ERROR_MARK
);
1236 /* If FIELD is static, then treat it like a separate variable, not
1237 really like a structure field. If it is a FUNCTION_DECL, it's a
1238 method. In both cases, all we do is lay out the decl, and we do
1239 it *after* the record is laid out. */
1242 vec_safe_push (rli
->pending_statics
, field
);
1246 /* Enumerators and enum types which are local to this class need not
1247 be laid out. Likewise for initialized constant fields. */
1248 else if (TREE_CODE (field
) != FIELD_DECL
)
1251 /* Unions are laid out very differently than records, so split
1252 that code off to another function. */
1253 else if (TREE_CODE (rli
->t
) != RECORD_TYPE
)
1255 place_union_field (rli
, field
);
1259 else if (TREE_CODE (type
) == ERROR_MARK
)
1261 /* Place this field at the current allocation position, so we
1262 maintain monotonicity. */
1263 DECL_FIELD_OFFSET (field
) = rli
->offset
;
1264 DECL_FIELD_BIT_OFFSET (field
) = rli
->bitpos
;
1265 SET_DECL_OFFSET_ALIGN (field
, rli
->offset_align
);
1266 handle_warn_if_not_align (field
, rli
->record_align
);
1270 if (AGGREGATE_TYPE_P (type
)
1271 && TYPE_TYPELESS_STORAGE (type
))
1272 TYPE_TYPELESS_STORAGE (rli
->t
) = 1;
1274 /* Work out the known alignment so far. Note that A & (-A) is the
1275 value of the least-significant bit in A that is one. */
1276 if (! integer_zerop (rli
->bitpos
))
1277 known_align
= least_bit_hwi (tree_to_uhwi (rli
->bitpos
));
1278 else if (integer_zerop (rli
->offset
))
1280 else if (tree_fits_uhwi_p (rli
->offset
))
1281 known_align
= (BITS_PER_UNIT
1282 * least_bit_hwi (tree_to_uhwi (rli
->offset
)));
1284 known_align
= rli
->offset_align
;
1286 desired_align
= update_alignment_for_field (rli
, field
, known_align
);
1287 if (known_align
== 0)
1288 known_align
= MAX (BIGGEST_ALIGNMENT
, rli
->record_align
);
1290 if (warn_packed
&& DECL_PACKED (field
))
1292 if (known_align
>= TYPE_ALIGN (type
))
1294 if (TYPE_ALIGN (type
) > desired_align
)
1296 if (STRICT_ALIGNMENT
)
1297 warning (OPT_Wattributes
, "packed attribute causes "
1298 "inefficient alignment for %q+D", field
);
1299 /* Don't warn if DECL_PACKED was set by the type. */
1300 else if (!TYPE_PACKED (rli
->t
))
1301 warning (OPT_Wattributes
, "packed attribute is "
1302 "unnecessary for %q+D", field
);
1306 rli
->packed_maybe_necessary
= 1;
1309 /* Does this field automatically have alignment it needs by virtue
1310 of the fields that precede it and the record's own alignment? */
1311 if (known_align
< desired_align
1312 && (! targetm
.ms_bitfield_layout_p (rli
->t
)
1313 || rli
->prev_field
== NULL
))
1315 /* No, we need to skip space before this field.
1316 Bump the cumulative size to multiple of field alignment. */
1318 if (!targetm
.ms_bitfield_layout_p (rli
->t
)
1319 && DECL_SOURCE_LOCATION (field
) != BUILTINS_LOCATION
)
1320 warning (OPT_Wpadded
, "padding struct to align %q+D", field
);
1322 /* If the alignment is still within offset_align, just align
1323 the bit position. */
1324 if (desired_align
< rli
->offset_align
)
1325 rli
->bitpos
= round_up (rli
->bitpos
, desired_align
);
1328 /* First adjust OFFSET by the partial bits, then align. */
1330 = size_binop (PLUS_EXPR
, rli
->offset
,
1331 fold_convert (sizetype
,
1332 size_binop (CEIL_DIV_EXPR
, rli
->bitpos
,
1333 bitsize_unit_node
)));
1334 rli
->bitpos
= bitsize_zero_node
;
1336 rli
->offset
= round_up (rli
->offset
, desired_align
/ BITS_PER_UNIT
);
1339 if (! TREE_CONSTANT (rli
->offset
))
1340 rli
->offset_align
= desired_align
;
1343 /* Handle compatibility with PCC. Note that if the record has any
1344 variable-sized fields, we need not worry about compatibility. */
1345 if (PCC_BITFIELD_TYPE_MATTERS
1346 && ! targetm
.ms_bitfield_layout_p (rli
->t
)
1347 && TREE_CODE (field
) == FIELD_DECL
1348 && type
!= error_mark_node
1349 && DECL_BIT_FIELD (field
)
1350 && (! DECL_PACKED (field
)
1351 /* Enter for these packed fields only to issue a warning. */
1352 || TYPE_ALIGN (type
) <= BITS_PER_UNIT
)
1353 && maximum_field_alignment
== 0
1354 && ! integer_zerop (DECL_SIZE (field
))
1355 && tree_fits_uhwi_p (DECL_SIZE (field
))
1356 && tree_fits_uhwi_p (rli
->offset
)
1357 && tree_fits_uhwi_p (TYPE_SIZE (type
)))
1359 unsigned int type_align
= TYPE_ALIGN (type
);
1360 tree dsize
= DECL_SIZE (field
);
1361 HOST_WIDE_INT field_size
= tree_to_uhwi (dsize
);
1362 HOST_WIDE_INT offset
= tree_to_uhwi (rli
->offset
);
1363 HOST_WIDE_INT bit_offset
= tree_to_shwi (rli
->bitpos
);
1365 #ifdef ADJUST_FIELD_ALIGN
1366 if (! TYPE_USER_ALIGN (type
))
1367 type_align
= ADJUST_FIELD_ALIGN (field
, type
, type_align
);
1370 /* A bit field may not span more units of alignment of its type
1371 than its type itself. Advance to next boundary if necessary. */
1372 if (excess_unit_span (offset
, bit_offset
, field_size
, type_align
, type
))
1374 if (DECL_PACKED (field
))
1376 if (warn_packed_bitfield_compat
== 1)
1379 "offset of packed bit-field %qD has changed in GCC 4.4",
1383 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1386 if (! DECL_PACKED (field
))
1387 TYPE_USER_ALIGN (rli
->t
) |= TYPE_USER_ALIGN (type
);
1389 SET_TYPE_WARN_IF_NOT_ALIGN (rli
->t
,
1390 TYPE_WARN_IF_NOT_ALIGN (type
));
1393 #ifdef BITFIELD_NBYTES_LIMITED
1394 if (BITFIELD_NBYTES_LIMITED
1395 && ! targetm
.ms_bitfield_layout_p (rli
->t
)
1396 && TREE_CODE (field
) == FIELD_DECL
1397 && type
!= error_mark_node
1398 && DECL_BIT_FIELD_TYPE (field
)
1399 && ! DECL_PACKED (field
)
1400 && ! integer_zerop (DECL_SIZE (field
))
1401 && tree_fits_uhwi_p (DECL_SIZE (field
))
1402 && tree_fits_uhwi_p (rli
->offset
)
1403 && tree_fits_uhwi_p (TYPE_SIZE (type
)))
1405 unsigned int type_align
= TYPE_ALIGN (type
);
1406 tree dsize
= DECL_SIZE (field
);
1407 HOST_WIDE_INT field_size
= tree_to_uhwi (dsize
);
1408 HOST_WIDE_INT offset
= tree_to_uhwi (rli
->offset
);
1409 HOST_WIDE_INT bit_offset
= tree_to_shwi (rli
->bitpos
);
1411 #ifdef ADJUST_FIELD_ALIGN
1412 if (! TYPE_USER_ALIGN (type
))
1413 type_align
= ADJUST_FIELD_ALIGN (field
, type
, type_align
);
1416 if (maximum_field_alignment
!= 0)
1417 type_align
= MIN (type_align
, maximum_field_alignment
);
1418 /* ??? This test is opposite the test in the containing if
1419 statement, so this code is unreachable currently. */
1420 else if (DECL_PACKED (field
))
1421 type_align
= MIN (type_align
, BITS_PER_UNIT
);
1423 /* A bit field may not span the unit of alignment of its type.
1424 Advance to next boundary if necessary. */
1425 if (excess_unit_span (offset
, bit_offset
, field_size
, type_align
, type
))
1426 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1428 TYPE_USER_ALIGN (rli
->t
) |= TYPE_USER_ALIGN (type
);
1429 SET_TYPE_WARN_IF_NOT_ALIGN (rli
->t
,
1430 TYPE_WARN_IF_NOT_ALIGN (type
));
1434 /* See the docs for TARGET_MS_BITFIELD_LAYOUT_P for details.
1436 When a bit field is inserted into a packed record, the whole
1437 size of the underlying type is used by one or more same-size
1438 adjacent bitfields. (That is, if its long:3, 32 bits is
1439 used in the record, and any additional adjacent long bitfields are
1440 packed into the same chunk of 32 bits. However, if the size
1441 changes, a new field of that size is allocated.) In an unpacked
1442 record, this is the same as using alignment, but not equivalent
1445 Note: for compatibility, we use the type size, not the type alignment
1446 to determine alignment, since that matches the documentation */
1448 if (targetm
.ms_bitfield_layout_p (rli
->t
))
1450 tree prev_saved
= rli
->prev_field
;
1451 tree prev_type
= prev_saved
? DECL_BIT_FIELD_TYPE (prev_saved
) : NULL
;
1453 /* This is a bitfield if it exists. */
1454 if (rli
->prev_field
)
1456 bool realign_p
= known_align
< desired_align
;
1458 /* If both are bitfields, nonzero, and the same size, this is
1459 the middle of a run. Zero declared size fields are special
1460 and handled as "end of run". (Note: it's nonzero declared
1461 size, but equal type sizes!) (Since we know that both
1462 the current and previous fields are bitfields by the
1463 time we check it, DECL_SIZE must be present for both.) */
1464 if (DECL_BIT_FIELD_TYPE (field
)
1465 && !integer_zerop (DECL_SIZE (field
))
1466 && !integer_zerop (DECL_SIZE (rli
->prev_field
))
1467 && tree_fits_shwi_p (DECL_SIZE (rli
->prev_field
))
1468 && tree_fits_uhwi_p (TYPE_SIZE (type
))
1469 && simple_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (prev_type
)))
1471 /* We're in the middle of a run of equal type size fields; make
1472 sure we realign if we run out of bits. (Not decl size,
1474 HOST_WIDE_INT bitsize
= tree_to_uhwi (DECL_SIZE (field
));
1476 if (rli
->remaining_in_alignment
< bitsize
)
1478 HOST_WIDE_INT typesize
= tree_to_uhwi (TYPE_SIZE (type
));
1480 /* out of bits; bump up to next 'word'. */
1482 = size_binop (PLUS_EXPR
, rli
->bitpos
,
1483 bitsize_int (rli
->remaining_in_alignment
));
1484 rli
->prev_field
= field
;
1485 if (typesize
< bitsize
)
1486 rli
->remaining_in_alignment
= 0;
1488 rli
->remaining_in_alignment
= typesize
- bitsize
;
1492 rli
->remaining_in_alignment
-= bitsize
;
1498 /* End of a run: if leaving a run of bitfields of the same type
1499 size, we have to "use up" the rest of the bits of the type
1502 Compute the new position as the sum of the size for the prior
1503 type and where we first started working on that type.
1504 Note: since the beginning of the field was aligned then
1505 of course the end will be too. No round needed. */
1507 if (!integer_zerop (DECL_SIZE (rli
->prev_field
)))
1510 = size_binop (PLUS_EXPR
, rli
->bitpos
,
1511 bitsize_int (rli
->remaining_in_alignment
));
1514 /* We "use up" size zero fields; the code below should behave
1515 as if the prior field was not a bitfield. */
1518 /* Cause a new bitfield to be captured, either this time (if
1519 currently a bitfield) or next time we see one. */
1520 if (!DECL_BIT_FIELD_TYPE (field
)
1521 || integer_zerop (DECL_SIZE (field
)))
1522 rli
->prev_field
= NULL
;
1525 /* Does this field automatically have alignment it needs by virtue
1526 of the fields that precede it and the record's own alignment? */
1529 /* If the alignment is still within offset_align, just align
1530 the bit position. */
1531 if (desired_align
< rli
->offset_align
)
1532 rli
->bitpos
= round_up (rli
->bitpos
, desired_align
);
1535 /* First adjust OFFSET by the partial bits, then align. */
1536 tree d
= size_binop (CEIL_DIV_EXPR
, rli
->bitpos
,
1538 rli
->offset
= size_binop (PLUS_EXPR
, rli
->offset
,
1539 fold_convert (sizetype
, d
));
1540 rli
->bitpos
= bitsize_zero_node
;
1542 rli
->offset
= round_up (rli
->offset
,
1543 desired_align
/ BITS_PER_UNIT
);
1546 if (! TREE_CONSTANT (rli
->offset
))
1547 rli
->offset_align
= desired_align
;
1550 normalize_rli (rli
);
1553 /* If we're starting a new run of same type size bitfields
1554 (or a run of non-bitfields), set up the "first of the run"
1557 That is, if the current field is not a bitfield, or if there
1558 was a prior bitfield the type sizes differ, or if there wasn't
1559 a prior bitfield the size of the current field is nonzero.
1561 Note: we must be sure to test ONLY the type size if there was
1562 a prior bitfield and ONLY for the current field being zero if
1565 if (!DECL_BIT_FIELD_TYPE (field
)
1566 || (prev_saved
!= NULL
1567 ? !simple_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (prev_type
))
1568 : !integer_zerop (DECL_SIZE (field
))))
1570 /* Never smaller than a byte for compatibility. */
1571 unsigned int type_align
= BITS_PER_UNIT
;
1573 /* (When not a bitfield), we could be seeing a flex array (with
1574 no DECL_SIZE). Since we won't be using remaining_in_alignment
1575 until we see a bitfield (and come by here again) we just skip
1577 if (DECL_SIZE (field
) != NULL
1578 && tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (field
)))
1579 && tree_fits_uhwi_p (DECL_SIZE (field
)))
1581 unsigned HOST_WIDE_INT bitsize
1582 = tree_to_uhwi (DECL_SIZE (field
));
1583 unsigned HOST_WIDE_INT typesize
1584 = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (field
)));
1586 if (typesize
< bitsize
)
1587 rli
->remaining_in_alignment
= 0;
1589 rli
->remaining_in_alignment
= typesize
- bitsize
;
1592 /* Now align (conventionally) for the new type. */
1593 if (! DECL_PACKED (field
))
1594 type_align
= TYPE_ALIGN (TREE_TYPE (field
));
1596 if (maximum_field_alignment
!= 0)
1597 type_align
= MIN (type_align
, maximum_field_alignment
);
1599 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1601 /* If we really aligned, don't allow subsequent bitfields
1603 rli
->prev_field
= NULL
;
1607 /* Offset so far becomes the position of this field after normalizing. */
1608 normalize_rli (rli
);
1609 DECL_FIELD_OFFSET (field
) = rli
->offset
;
1610 DECL_FIELD_BIT_OFFSET (field
) = rli
->bitpos
;
1611 SET_DECL_OFFSET_ALIGN (field
, rli
->offset_align
);
1612 handle_warn_if_not_align (field
, rli
->record_align
);
1614 /* Evaluate nonconstant offsets only once, either now or as soon as safe. */
1615 if (TREE_CODE (DECL_FIELD_OFFSET (field
)) != INTEGER_CST
)
1616 DECL_FIELD_OFFSET (field
) = variable_size (DECL_FIELD_OFFSET (field
));
1618 /* If this field ended up more aligned than we thought it would be (we
1619 approximate this by seeing if its position changed), lay out the field
1620 again; perhaps we can use an integral mode for it now. */
1621 if (! integer_zerop (DECL_FIELD_BIT_OFFSET (field
)))
1622 actual_align
= least_bit_hwi (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field
)));
1623 else if (integer_zerop (DECL_FIELD_OFFSET (field
)))
1624 actual_align
= MAX (BIGGEST_ALIGNMENT
, rli
->record_align
);
1625 else if (tree_fits_uhwi_p (DECL_FIELD_OFFSET (field
)))
1626 actual_align
= (BITS_PER_UNIT
1627 * least_bit_hwi (tree_to_uhwi (DECL_FIELD_OFFSET (field
))));
1629 actual_align
= DECL_OFFSET_ALIGN (field
);
1630 /* ACTUAL_ALIGN is still the actual alignment *within the record* .
1631 store / extract bit field operations will check the alignment of the
1632 record against the mode of bit fields. */
1634 if (known_align
!= actual_align
)
1635 layout_decl (field
, actual_align
);
1637 if (rli
->prev_field
== NULL
&& DECL_BIT_FIELD_TYPE (field
))
1638 rli
->prev_field
= field
;
1640 /* Now add size of this field to the size of the record. If the size is
1641 not constant, treat the field as being a multiple of bytes and just
1642 adjust the offset, resetting the bit position. Otherwise, apportion the
1643 size amongst the bit position and offset. First handle the case of an
1644 unspecified size, which can happen when we have an invalid nested struct
1645 definition, such as struct j { struct j { int i; } }. The error message
1646 is printed in finish_struct. */
1647 if (DECL_SIZE (field
) == 0)
1649 else if (TREE_CODE (DECL_SIZE (field
)) != INTEGER_CST
1650 || TREE_OVERFLOW (DECL_SIZE (field
)))
1653 = size_binop (PLUS_EXPR
, rli
->offset
,
1654 fold_convert (sizetype
,
1655 size_binop (CEIL_DIV_EXPR
, rli
->bitpos
,
1656 bitsize_unit_node
)));
1658 = size_binop (PLUS_EXPR
, rli
->offset
, DECL_SIZE_UNIT (field
));
1659 rli
->bitpos
= bitsize_zero_node
;
1660 rli
->offset_align
= MIN (rli
->offset_align
, desired_align
);
1662 if (!multiple_of_p (bitsizetype
, DECL_SIZE (field
),
1663 bitsize_int (rli
->offset_align
)))
1665 tree type
= strip_array_types (TREE_TYPE (field
));
1666 /* The above adjusts offset_align just based on the start of the
1667 field. The field might not have a size that is a multiple of
1668 that offset_align though. If the field is an array of fixed
1669 sized elements, assume there can be any multiple of those
1670 sizes. If it is a variable length aggregate or array of
1671 variable length aggregates, assume worst that the end is
1672 just BITS_PER_UNIT aligned. */
1673 if (TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
1675 if (TREE_INT_CST_LOW (TYPE_SIZE (type
)))
1677 unsigned HOST_WIDE_INT sz
1678 = least_bit_hwi (TREE_INT_CST_LOW (TYPE_SIZE (type
)));
1679 rli
->offset_align
= MIN (rli
->offset_align
, sz
);
1683 rli
->offset_align
= MIN (rli
->offset_align
, BITS_PER_UNIT
);
1686 else if (targetm
.ms_bitfield_layout_p (rli
->t
))
1688 rli
->bitpos
= size_binop (PLUS_EXPR
, rli
->bitpos
, DECL_SIZE (field
));
1690 /* If FIELD is the last field and doesn't end at the full length
1691 of the type then pad the struct out to the full length of the
1693 if (DECL_BIT_FIELD_TYPE (field
)
1694 && !integer_zerop (DECL_SIZE (field
)))
1696 /* We have to scan, because non-field DECLS are also here. */
1698 while ((probe
= DECL_CHAIN (probe
)))
1699 if (TREE_CODE (probe
) == FIELD_DECL
)
1702 rli
->bitpos
= size_binop (PLUS_EXPR
, rli
->bitpos
,
1703 bitsize_int (rli
->remaining_in_alignment
));
1706 normalize_rli (rli
);
1710 rli
->bitpos
= size_binop (PLUS_EXPR
, rli
->bitpos
, DECL_SIZE (field
));
1711 normalize_rli (rli
);
1715 /* Assuming that all the fields have been laid out, this function uses
1716 RLI to compute the final TYPE_SIZE, TYPE_ALIGN, etc. for the type
1717 indicated by RLI. */
1720 finalize_record_size (record_layout_info rli
)
1722 tree unpadded_size
, unpadded_size_unit
;
1724 /* Now we want just byte and bit offsets, so set the offset alignment
1725 to be a byte and then normalize. */
1726 rli
->offset_align
= BITS_PER_UNIT
;
1727 normalize_rli (rli
);
1729 /* Determine the desired alignment. */
1730 #ifdef ROUND_TYPE_ALIGN
1731 SET_TYPE_ALIGN (rli
->t
, ROUND_TYPE_ALIGN (rli
->t
, TYPE_ALIGN (rli
->t
),
1732 rli
->record_align
));
1734 SET_TYPE_ALIGN (rli
->t
, MAX (TYPE_ALIGN (rli
->t
), rli
->record_align
));
1737 /* Compute the size so far. Be sure to allow for extra bits in the
1738 size in bytes. We have guaranteed above that it will be no more
1739 than a single byte. */
1740 unpadded_size
= rli_size_so_far (rli
);
1741 unpadded_size_unit
= rli_size_unit_so_far (rli
);
1742 if (! integer_zerop (rli
->bitpos
))
1744 = size_binop (PLUS_EXPR
, unpadded_size_unit
, size_one_node
);
1746 /* Round the size up to be a multiple of the required alignment. */
1747 TYPE_SIZE (rli
->t
) = round_up (unpadded_size
, TYPE_ALIGN (rli
->t
));
1748 TYPE_SIZE_UNIT (rli
->t
)
1749 = round_up (unpadded_size_unit
, TYPE_ALIGN_UNIT (rli
->t
));
1751 if (TREE_CONSTANT (unpadded_size
)
1752 && simple_cst_equal (unpadded_size
, TYPE_SIZE (rli
->t
)) == 0
1753 && input_location
!= BUILTINS_LOCATION
)
1754 warning (OPT_Wpadded
, "padding struct size to alignment boundary");
1756 if (warn_packed
&& TREE_CODE (rli
->t
) == RECORD_TYPE
1757 && TYPE_PACKED (rli
->t
) && ! rli
->packed_maybe_necessary
1758 && TREE_CONSTANT (unpadded_size
))
1762 #ifdef ROUND_TYPE_ALIGN
1764 = ROUND_TYPE_ALIGN (rli
->t
, TYPE_ALIGN (rli
->t
), rli
->unpacked_align
);
1766 rli
->unpacked_align
= MAX (TYPE_ALIGN (rli
->t
), rli
->unpacked_align
);
1769 unpacked_size
= round_up (TYPE_SIZE (rli
->t
), rli
->unpacked_align
);
1770 if (simple_cst_equal (unpacked_size
, TYPE_SIZE (rli
->t
)))
1772 if (TYPE_NAME (rli
->t
))
1776 if (TREE_CODE (TYPE_NAME (rli
->t
)) == IDENTIFIER_NODE
)
1777 name
= TYPE_NAME (rli
->t
);
1779 name
= DECL_NAME (TYPE_NAME (rli
->t
));
1781 if (STRICT_ALIGNMENT
)
1782 warning (OPT_Wpacked
, "packed attribute causes inefficient "
1783 "alignment for %qE", name
);
1785 warning (OPT_Wpacked
,
1786 "packed attribute is unnecessary for %qE", name
);
1790 if (STRICT_ALIGNMENT
)
1791 warning (OPT_Wpacked
,
1792 "packed attribute causes inefficient alignment");
1794 warning (OPT_Wpacked
, "packed attribute is unnecessary");
1800 /* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE). */
1803 compute_record_mode (tree type
)
1806 machine_mode mode
= VOIDmode
;
1808 /* Most RECORD_TYPEs have BLKmode, so we start off assuming that.
1809 However, if possible, we use a mode that fits in a register
1810 instead, in order to allow for better optimization down the
1812 SET_TYPE_MODE (type
, BLKmode
);
1814 poly_uint64 type_size
;
1815 if (!poly_int_tree_p (TYPE_SIZE (type
), &type_size
))
1818 /* A record which has any BLKmode members must itself be
1819 BLKmode; it can't go in a register. Unless the member is
1820 BLKmode only because it isn't aligned. */
1821 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1823 if (TREE_CODE (field
) != FIELD_DECL
)
1826 poly_uint64 field_size
;
1827 if (TREE_CODE (TREE_TYPE (field
)) == ERROR_MARK
1828 || (TYPE_MODE (TREE_TYPE (field
)) == BLKmode
1829 && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field
))
1830 && !(TYPE_SIZE (TREE_TYPE (field
)) != 0
1831 && integer_zerop (TYPE_SIZE (TREE_TYPE (field
)))))
1832 || !tree_fits_poly_uint64_p (bit_position (field
))
1833 || DECL_SIZE (field
) == 0
1834 || !poly_int_tree_p (DECL_SIZE (field
), &field_size
))
1837 /* If this field is the whole struct, remember its mode so
1838 that, say, we can put a double in a class into a DF
1839 register instead of forcing it to live in the stack. */
1840 if (known_eq (field_size
, type_size
)
1841 /* Partial int types (e.g. __int20) may have TYPE_SIZE equal to
1842 wider types (e.g. int32), despite precision being less. Ensure
1843 that the TYPE_MODE of the struct does not get set to the partial
1844 int mode if there is a wider type also in the struct. */
1845 && known_gt (GET_MODE_PRECISION (DECL_MODE (field
)),
1846 GET_MODE_PRECISION (mode
)))
1847 mode
= DECL_MODE (field
);
1849 /* With some targets, it is sub-optimal to access an aligned
1850 BLKmode structure as a scalar. */
1851 if (targetm
.member_type_forces_blk (field
, mode
))
1855 /* If we only have one real field; use its mode if that mode's size
1856 matches the type's size. This generally only applies to RECORD_TYPE.
1857 For UNION_TYPE, if the widest field is MODE_INT then use that mode.
1858 If the widest field is MODE_PARTIAL_INT, and the union will be passed
1859 by reference, then use that mode. */
1860 if ((TREE_CODE (type
) == RECORD_TYPE
1861 || (TREE_CODE (type
) == UNION_TYPE
1862 && (GET_MODE_CLASS (mode
) == MODE_INT
1863 || (GET_MODE_CLASS (mode
) == MODE_PARTIAL_INT
1864 && (targetm
.calls
.pass_by_reference
1865 (pack_cumulative_args (0),
1866 function_arg_info (type
, mode
, /*named=*/false)))))))
1868 && known_eq (GET_MODE_BITSIZE (mode
), type_size
))
1871 mode
= mode_for_size_tree (TYPE_SIZE (type
), MODE_INT
, 1).else_blk ();
1873 /* If structure's known alignment is less than what the scalar
1874 mode would need, and it matters, then stick with BLKmode. */
1877 && ! (TYPE_ALIGN (type
) >= BIGGEST_ALIGNMENT
1878 || TYPE_ALIGN (type
) >= GET_MODE_ALIGNMENT (mode
)))
1880 /* If this is the only reason this type is BLKmode, then
1881 don't force containing types to be BLKmode. */
1882 TYPE_NO_FORCE_BLK (type
) = 1;
1886 SET_TYPE_MODE (type
, mode
);
1889 /* Compute TYPE_SIZE and TYPE_ALIGN for TYPE, once it has been laid
1893 finalize_type_size (tree type
)
1895 /* Normally, use the alignment corresponding to the mode chosen.
1896 However, where strict alignment is not required, avoid
1897 over-aligning structures, since most compilers do not do this
1899 if (TYPE_MODE (type
) != BLKmode
1900 && TYPE_MODE (type
) != VOIDmode
1901 && (STRICT_ALIGNMENT
|| !AGGREGATE_TYPE_P (type
)))
1903 unsigned mode_align
= GET_MODE_ALIGNMENT (TYPE_MODE (type
));
1905 /* Don't override a larger alignment requirement coming from a user
1906 alignment of one of the fields. */
1907 if (mode_align
>= TYPE_ALIGN (type
))
1909 SET_TYPE_ALIGN (type
, mode_align
);
1910 TYPE_USER_ALIGN (type
) = 0;
1914 /* Do machine-dependent extra alignment. */
1915 #ifdef ROUND_TYPE_ALIGN
1916 SET_TYPE_ALIGN (type
,
1917 ROUND_TYPE_ALIGN (type
, TYPE_ALIGN (type
), BITS_PER_UNIT
));
1920 /* If we failed to find a simple way to calculate the unit size
1921 of the type, find it by division. */
1922 if (TYPE_SIZE_UNIT (type
) == 0 && TYPE_SIZE (type
) != 0)
1923 /* TYPE_SIZE (type) is computed in bitsizetype. After the division, the
1924 result will fit in sizetype. We will get more efficient code using
1925 sizetype, so we force a conversion. */
1926 TYPE_SIZE_UNIT (type
)
1927 = fold_convert (sizetype
,
1928 size_binop (FLOOR_DIV_EXPR
, TYPE_SIZE (type
),
1929 bitsize_unit_node
));
1931 if (TYPE_SIZE (type
) != 0)
1933 TYPE_SIZE (type
) = round_up (TYPE_SIZE (type
), TYPE_ALIGN (type
));
1934 TYPE_SIZE_UNIT (type
)
1935 = round_up (TYPE_SIZE_UNIT (type
), TYPE_ALIGN_UNIT (type
));
1938 /* Evaluate nonconstant sizes only once, either now or as soon as safe. */
1939 if (TYPE_SIZE (type
) != 0 && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1940 TYPE_SIZE (type
) = variable_size (TYPE_SIZE (type
));
1941 if (TYPE_SIZE_UNIT (type
) != 0
1942 && TREE_CODE (TYPE_SIZE_UNIT (type
)) != INTEGER_CST
)
1943 TYPE_SIZE_UNIT (type
) = variable_size (TYPE_SIZE_UNIT (type
));
1945 /* Handle empty records as per the x86-64 psABI. */
1946 TYPE_EMPTY_P (type
) = targetm
.calls
.empty_record_p (type
);
1948 /* Also layout any other variants of the type. */
1949 if (TYPE_NEXT_VARIANT (type
)
1950 || type
!= TYPE_MAIN_VARIANT (type
))
1953 /* Record layout info of this variant. */
1954 tree size
= TYPE_SIZE (type
);
1955 tree size_unit
= TYPE_SIZE_UNIT (type
);
1956 unsigned int align
= TYPE_ALIGN (type
);
1957 unsigned int precision
= TYPE_PRECISION (type
);
1958 unsigned int user_align
= TYPE_USER_ALIGN (type
);
1959 machine_mode mode
= TYPE_MODE (type
);
1960 bool empty_p
= TYPE_EMPTY_P (type
);
1962 /* Copy it into all variants. */
1963 for (variant
= TYPE_MAIN_VARIANT (type
);
1965 variant
= TYPE_NEXT_VARIANT (variant
))
1967 TYPE_SIZE (variant
) = size
;
1968 TYPE_SIZE_UNIT (variant
) = size_unit
;
1969 unsigned valign
= align
;
1970 if (TYPE_USER_ALIGN (variant
))
1971 valign
= MAX (valign
, TYPE_ALIGN (variant
));
1973 TYPE_USER_ALIGN (variant
) = user_align
;
1974 SET_TYPE_ALIGN (variant
, valign
);
1975 TYPE_PRECISION (variant
) = precision
;
1976 SET_TYPE_MODE (variant
, mode
);
1977 TYPE_EMPTY_P (variant
) = empty_p
;
1982 /* Return a new underlying object for a bitfield started with FIELD. */
1985 start_bitfield_representative (tree field
)
1987 tree repr
= make_node (FIELD_DECL
);
1988 DECL_FIELD_OFFSET (repr
) = DECL_FIELD_OFFSET (field
);
1989 /* Force the representative to begin at a BITS_PER_UNIT aligned
1990 boundary - C++ may use tail-padding of a base object to
1991 continue packing bits so the bitfield region does not start
1992 at bit zero (see g++.dg/abi/bitfield5.C for example).
1993 Unallocated bits may happen for other reasons as well,
1994 for example Ada which allows explicit bit-granular structure layout. */
1995 DECL_FIELD_BIT_OFFSET (repr
)
1996 = size_binop (BIT_AND_EXPR
,
1997 DECL_FIELD_BIT_OFFSET (field
),
1998 bitsize_int (~(BITS_PER_UNIT
- 1)));
1999 SET_DECL_OFFSET_ALIGN (repr
, DECL_OFFSET_ALIGN (field
));
2000 DECL_SIZE (repr
) = DECL_SIZE (field
);
2001 DECL_SIZE_UNIT (repr
) = DECL_SIZE_UNIT (field
);
2002 DECL_PACKED (repr
) = DECL_PACKED (field
);
2003 DECL_CONTEXT (repr
) = DECL_CONTEXT (field
);
2004 /* There are no indirect accesses to this field. If we introduce
2005 some then they have to use the record alias set. This makes
2006 sure to properly conflict with [indirect] accesses to addressable
2007 fields of the bitfield group. */
2008 DECL_NONADDRESSABLE_P (repr
) = 1;
2012 /* Finish up a bitfield group that was started by creating the underlying
2013 object REPR with the last field in the bitfield group FIELD. */
2016 finish_bitfield_representative (tree repr
, tree field
)
2018 unsigned HOST_WIDE_INT bitsize
, maxbitsize
;
2021 size
= size_diffop (DECL_FIELD_OFFSET (field
),
2022 DECL_FIELD_OFFSET (repr
));
2023 while (TREE_CODE (size
) == COMPOUND_EXPR
)
2024 size
= TREE_OPERAND (size
, 1);
2025 gcc_assert (tree_fits_uhwi_p (size
));
2026 bitsize
= (tree_to_uhwi (size
) * BITS_PER_UNIT
2027 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field
))
2028 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr
))
2029 + tree_to_uhwi (DECL_SIZE (field
)));
2031 /* Round up bitsize to multiples of BITS_PER_UNIT. */
2032 bitsize
= (bitsize
+ BITS_PER_UNIT
- 1) & ~(BITS_PER_UNIT
- 1);
2034 /* Now nothing tells us how to pad out bitsize ... */
2035 nextf
= DECL_CHAIN (field
);
2036 while (nextf
&& TREE_CODE (nextf
) != FIELD_DECL
)
2037 nextf
= DECL_CHAIN (nextf
);
2041 /* If there was an error, the field may be not laid out
2042 correctly. Don't bother to do anything. */
2043 if (TREE_TYPE (nextf
) == error_mark_node
)
2045 maxsize
= size_diffop (DECL_FIELD_OFFSET (nextf
),
2046 DECL_FIELD_OFFSET (repr
));
2047 if (tree_fits_uhwi_p (maxsize
))
2049 maxbitsize
= (tree_to_uhwi (maxsize
) * BITS_PER_UNIT
2050 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (nextf
))
2051 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr
)));
2052 /* If the group ends within a bitfield nextf does not need to be
2053 aligned to BITS_PER_UNIT. Thus round up. */
2054 maxbitsize
= (maxbitsize
+ BITS_PER_UNIT
- 1) & ~(BITS_PER_UNIT
- 1);
2057 maxbitsize
= bitsize
;
2061 /* Note that if the C++ FE sets up tail-padding to be re-used it
2062 creates a as-base variant of the type with TYPE_SIZE adjusted
2063 accordingly. So it is safe to include tail-padding here. */
2064 tree aggsize
= lang_hooks
.types
.unit_size_without_reusable_padding
2065 (DECL_CONTEXT (field
));
2066 tree maxsize
= size_diffop (aggsize
, DECL_FIELD_OFFSET (repr
));
2067 /* We cannot generally rely on maxsize to fold to an integer constant,
2068 so use bitsize as fallback for this case. */
2069 if (tree_fits_uhwi_p (maxsize
))
2070 maxbitsize
= (tree_to_uhwi (maxsize
) * BITS_PER_UNIT
2071 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr
)));
2073 maxbitsize
= bitsize
;
2076 /* Only if we don't artificially break up the representative in
2077 the middle of a large bitfield with different possibly
2078 overlapping representatives. And all representatives start
2080 gcc_assert (maxbitsize
% BITS_PER_UNIT
== 0);
2082 /* Find the smallest nice mode to use. */
2083 opt_scalar_int_mode mode_iter
;
2084 FOR_EACH_MODE_IN_CLASS (mode_iter
, MODE_INT
)
2085 if (GET_MODE_BITSIZE (mode_iter
.require ()) >= bitsize
)
2088 scalar_int_mode mode
;
2089 if (!mode_iter
.exists (&mode
)
2090 || GET_MODE_BITSIZE (mode
) > maxbitsize
2091 || GET_MODE_BITSIZE (mode
) > MAX_FIXED_MODE_SIZE
)
2093 /* We really want a BLKmode representative only as a last resort,
2094 considering the member b in
2095 struct { int a : 7; int b : 17; int c; } __attribute__((packed));
2096 Otherwise we simply want to split the representative up
2097 allowing for overlaps within the bitfield region as required for
2098 struct { int a : 7; int b : 7;
2099 int c : 10; int d; } __attribute__((packed));
2100 [0, 15] HImode for a and b, [8, 23] HImode for c. */
2101 DECL_SIZE (repr
) = bitsize_int (bitsize
);
2102 DECL_SIZE_UNIT (repr
) = size_int (bitsize
/ BITS_PER_UNIT
);
2103 SET_DECL_MODE (repr
, BLKmode
);
2104 TREE_TYPE (repr
) = build_array_type_nelts (unsigned_char_type_node
,
2105 bitsize
/ BITS_PER_UNIT
);
2109 unsigned HOST_WIDE_INT modesize
= GET_MODE_BITSIZE (mode
);
2110 DECL_SIZE (repr
) = bitsize_int (modesize
);
2111 DECL_SIZE_UNIT (repr
) = size_int (modesize
/ BITS_PER_UNIT
);
2112 SET_DECL_MODE (repr
, mode
);
2113 TREE_TYPE (repr
) = lang_hooks
.types
.type_for_mode (mode
, 1);
2116 /* Remember whether the bitfield group is at the end of the
2117 structure or not. */
2118 DECL_CHAIN (repr
) = nextf
;
2121 /* Compute and set FIELD_DECLs for the underlying objects we should
2122 use for bitfield access for the structure T. */
2125 finish_bitfield_layout (tree t
)
2128 tree repr
= NULL_TREE
;
2130 /* Unions would be special, for the ease of type-punning optimizations
2131 we could use the underlying type as hint for the representative
2132 if the bitfield would fit and the representative would not exceed
2133 the union in size. */
2134 if (TREE_CODE (t
) != RECORD_TYPE
)
2137 for (prev
= NULL_TREE
, field
= TYPE_FIELDS (t
);
2138 field
; field
= DECL_CHAIN (field
))
2140 if (TREE_CODE (field
) != FIELD_DECL
)
2143 /* In the C++ memory model, consecutive bit fields in a structure are
2144 considered one memory location and updating a memory location
2145 may not store into adjacent memory locations. */
2147 && DECL_BIT_FIELD_TYPE (field
))
2149 /* Start new representative. */
2150 repr
= start_bitfield_representative (field
);
2153 && ! DECL_BIT_FIELD_TYPE (field
))
2155 /* Finish off new representative. */
2156 finish_bitfield_representative (repr
, prev
);
2159 else if (DECL_BIT_FIELD_TYPE (field
))
2161 gcc_assert (repr
!= NULL_TREE
);
2163 /* Zero-size bitfields finish off a representative and
2164 do not have a representative themselves. This is
2165 required by the C++ memory model. */
2166 if (integer_zerop (DECL_SIZE (field
)))
2168 finish_bitfield_representative (repr
, prev
);
2172 /* We assume that either DECL_FIELD_OFFSET of the representative
2173 and each bitfield member is a constant or they are equal.
2174 This is because we need to be able to compute the bit-offset
2175 of each field relative to the representative in get_bit_range
2176 during RTL expansion.
2177 If these constraints are not met, simply force a new
2178 representative to be generated. That will at most
2179 generate worse code but still maintain correctness with
2180 respect to the C++ memory model. */
2181 else if (!((tree_fits_uhwi_p (DECL_FIELD_OFFSET (repr
))
2182 && tree_fits_uhwi_p (DECL_FIELD_OFFSET (field
)))
2183 || operand_equal_p (DECL_FIELD_OFFSET (repr
),
2184 DECL_FIELD_OFFSET (field
), 0)))
2186 finish_bitfield_representative (repr
, prev
);
2187 repr
= start_bitfield_representative (field
);
2194 DECL_BIT_FIELD_REPRESENTATIVE (field
) = repr
;
2200 finish_bitfield_representative (repr
, prev
);
2203 /* Do all of the work required to layout the type indicated by RLI,
2204 once the fields have been laid out. This function will call `free'
2205 for RLI, unless FREE_P is false. Passing a value other than false
2206 for FREE_P is bad practice; this option only exists to support the
2210 finish_record_layout (record_layout_info rli
, int free_p
)
2214 /* Compute the final size. */
2215 finalize_record_size (rli
);
2217 /* Compute the TYPE_MODE for the record. */
2218 compute_record_mode (rli
->t
);
2220 /* Perform any last tweaks to the TYPE_SIZE, etc. */
2221 finalize_type_size (rli
->t
);
2223 /* Compute bitfield representatives. */
2224 finish_bitfield_layout (rli
->t
);
2226 /* Propagate TYPE_PACKED and TYPE_REVERSE_STORAGE_ORDER to variants.
2227 With C++ templates, it is too early to do this when the attribute
2229 for (variant
= TYPE_NEXT_VARIANT (rli
->t
); variant
;
2230 variant
= TYPE_NEXT_VARIANT (variant
))
2232 TYPE_PACKED (variant
) = TYPE_PACKED (rli
->t
);
2233 TYPE_REVERSE_STORAGE_ORDER (variant
)
2234 = TYPE_REVERSE_STORAGE_ORDER (rli
->t
);
2237 /* Lay out any static members. This is done now because their type
2238 may use the record's type. */
2239 while (!vec_safe_is_empty (rli
->pending_statics
))
2240 layout_decl (rli
->pending_statics
->pop (), 0);
2245 vec_free (rli
->pending_statics
);
2251 /* Finish processing a builtin RECORD_TYPE type TYPE. It's name is
2252 NAME, its fields are chained in reverse on FIELDS.
2254 If ALIGN_TYPE is non-null, it is given the same alignment as
2258 finish_builtin_struct (tree type
, const char *name
, tree fields
,
2263 for (tail
= NULL_TREE
; fields
; tail
= fields
, fields
= next
)
2265 DECL_FIELD_CONTEXT (fields
) = type
;
2266 next
= DECL_CHAIN (fields
);
2267 DECL_CHAIN (fields
) = tail
;
2269 TYPE_FIELDS (type
) = tail
;
2273 SET_TYPE_ALIGN (type
, TYPE_ALIGN (align_type
));
2274 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (align_type
);
2275 SET_TYPE_WARN_IF_NOT_ALIGN (type
,
2276 TYPE_WARN_IF_NOT_ALIGN (align_type
));
2280 #if 0 /* not yet, should get fixed properly later */
2281 TYPE_NAME (type
) = make_type_decl (get_identifier (name
), type
);
2283 TYPE_NAME (type
) = build_decl (BUILTINS_LOCATION
,
2284 TYPE_DECL
, get_identifier (name
), type
);
2286 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
2287 layout_decl (TYPE_NAME (type
), 0);
2290 /* Calculate the mode, size, and alignment for TYPE.
2291 For an array type, calculate the element separation as well.
2292 Record TYPE on the chain of permanent or temporary types
2293 so that dbxout will find out about it.
2295 TYPE_SIZE of a type is nonzero if the type has been laid out already.
2296 layout_type does nothing on such a type.
2298 If the type is incomplete, its TYPE_SIZE remains zero. */
2301 layout_type (tree type
)
2305 if (type
== error_mark_node
)
2308 /* We don't want finalize_type_size to copy an alignment attribute to
2309 variants that don't have it. */
2310 type
= TYPE_MAIN_VARIANT (type
);
2312 /* Do nothing if type has been laid out before. */
2313 if (TYPE_SIZE (type
))
2316 switch (TREE_CODE (type
))
2319 /* This kind of type is the responsibility
2320 of the language-specific code. */
2327 scalar_int_mode mode
2328 = smallest_int_mode_for_size (TYPE_PRECISION (type
));
2329 SET_TYPE_MODE (type
, mode
);
2330 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (mode
));
2331 /* Don't set TYPE_PRECISION here, as it may be set by a bitfield. */
2332 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (mode
));
2338 /* Allow the caller to choose the type mode, which is how decimal
2339 floats are distinguished from binary ones. */
2340 if (TYPE_MODE (type
) == VOIDmode
)
2342 (type
, float_mode_for_size (TYPE_PRECISION (type
)).require ());
2343 scalar_float_mode mode
= as_a
<scalar_float_mode
> (TYPE_MODE (type
));
2344 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (mode
));
2345 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (mode
));
2349 case FIXED_POINT_TYPE
:
2351 /* TYPE_MODE (type) has been set already. */
2352 scalar_mode mode
= SCALAR_TYPE_MODE (type
);
2353 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (mode
));
2354 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (mode
));
2359 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TREE_TYPE (type
));
2360 SET_TYPE_MODE (type
,
2361 GET_MODE_COMPLEX_MODE (TYPE_MODE (TREE_TYPE (type
))));
2363 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2364 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2369 poly_uint64 nunits
= TYPE_VECTOR_SUBPARTS (type
);
2370 tree innertype
= TREE_TYPE (type
);
2372 /* Find an appropriate mode for the vector type. */
2373 if (TYPE_MODE (type
) == VOIDmode
)
2374 SET_TYPE_MODE (type
,
2375 mode_for_vector (SCALAR_TYPE_MODE (innertype
),
2376 nunits
).else_blk ());
2378 TYPE_SATURATING (type
) = TYPE_SATURATING (TREE_TYPE (type
));
2379 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TREE_TYPE (type
));
2380 /* Several boolean vector elements may fit in a single unit. */
2381 if (VECTOR_BOOLEAN_TYPE_P (type
)
2382 && type
->type_common
.mode
!= BLKmode
)
2383 TYPE_SIZE_UNIT (type
)
2384 = size_int (GET_MODE_SIZE (type
->type_common
.mode
));
2386 TYPE_SIZE_UNIT (type
) = int_const_binop (MULT_EXPR
,
2387 TYPE_SIZE_UNIT (innertype
),
2389 TYPE_SIZE (type
) = int_const_binop
2391 bits_from_bytes (TYPE_SIZE_UNIT (type
)),
2392 bitsize_int (BITS_PER_UNIT
));
2394 /* For vector types, we do not default to the mode's alignment.
2395 Instead, query a target hook, defaulting to natural alignment.
2396 This prevents ABI changes depending on whether or not native
2397 vector modes are supported. */
2398 SET_TYPE_ALIGN (type
, targetm
.vector_alignment (type
));
2400 /* However, if the underlying mode requires a bigger alignment than
2401 what the target hook provides, we cannot use the mode. For now,
2402 simply reject that case. */
2403 gcc_assert (TYPE_ALIGN (type
)
2404 >= GET_MODE_ALIGNMENT (TYPE_MODE (type
)));
2409 /* This is an incomplete type and so doesn't have a size. */
2410 SET_TYPE_ALIGN (type
, 1);
2411 TYPE_USER_ALIGN (type
) = 0;
2412 SET_TYPE_MODE (type
, VOIDmode
);
2416 TYPE_SIZE (type
) = bitsize_int (POINTER_SIZE
);
2417 TYPE_SIZE_UNIT (type
) = size_int (POINTER_SIZE_UNITS
);
2418 /* A pointer might be MODE_PARTIAL_INT, but ptrdiff_t must be
2419 integral, which may be an __intN. */
2420 SET_TYPE_MODE (type
, int_mode_for_size (POINTER_SIZE
, 0).require ());
2421 TYPE_PRECISION (type
) = POINTER_SIZE
;
2426 /* It's hard to see what the mode and size of a function ought to
2427 be, but we do know the alignment is FUNCTION_BOUNDARY, so
2428 make it consistent with that. */
2429 SET_TYPE_MODE (type
,
2430 int_mode_for_size (FUNCTION_BOUNDARY
, 0).else_blk ());
2431 TYPE_SIZE (type
) = bitsize_int (FUNCTION_BOUNDARY
);
2432 TYPE_SIZE_UNIT (type
) = size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
2436 case REFERENCE_TYPE
:
2438 scalar_int_mode mode
= SCALAR_INT_TYPE_MODE (type
);
2439 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (mode
));
2440 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (mode
));
2441 TYPE_UNSIGNED (type
) = 1;
2442 TYPE_PRECISION (type
) = GET_MODE_PRECISION (mode
);
2448 tree index
= TYPE_DOMAIN (type
);
2449 tree element
= TREE_TYPE (type
);
2451 /* We need to know both bounds in order to compute the size. */
2452 if (index
&& TYPE_MAX_VALUE (index
) && TYPE_MIN_VALUE (index
)
2453 && TYPE_SIZE (element
))
2455 tree ub
= TYPE_MAX_VALUE (index
);
2456 tree lb
= TYPE_MIN_VALUE (index
);
2457 tree element_size
= TYPE_SIZE (element
);
2460 /* Make sure that an array of zero-sized element is zero-sized
2461 regardless of its extent. */
2462 if (integer_zerop (element_size
))
2463 length
= size_zero_node
;
2465 /* The computation should happen in the original signedness so
2466 that (possible) negative values are handled appropriately
2467 when determining overflow. */
2470 /* ??? When it is obvious that the range is signed
2471 represent it using ssizetype. */
2472 if (TREE_CODE (lb
) == INTEGER_CST
2473 && TREE_CODE (ub
) == INTEGER_CST
2474 && TYPE_UNSIGNED (TREE_TYPE (lb
))
2475 && tree_int_cst_lt (ub
, lb
))
2477 lb
= wide_int_to_tree (ssizetype
,
2478 offset_int::from (wi::to_wide (lb
),
2480 ub
= wide_int_to_tree (ssizetype
,
2481 offset_int::from (wi::to_wide (ub
),
2485 = fold_convert (sizetype
,
2486 size_binop (PLUS_EXPR
,
2487 build_int_cst (TREE_TYPE (lb
), 1),
2488 size_binop (MINUS_EXPR
, ub
, lb
)));
2491 /* ??? We have no way to distinguish a null-sized array from an
2492 array spanning the whole sizetype range, so we arbitrarily
2493 decide that [0, -1] is the only valid representation. */
2494 if (integer_zerop (length
)
2495 && TREE_OVERFLOW (length
)
2496 && integer_zerop (lb
))
2497 length
= size_zero_node
;
2499 TYPE_SIZE (type
) = size_binop (MULT_EXPR
, element_size
,
2500 bits_from_bytes (length
));
2502 /* If we know the size of the element, calculate the total size
2503 directly, rather than do some division thing below. This
2504 optimization helps Fortran assumed-size arrays (where the
2505 size of the array is determined at runtime) substantially. */
2506 if (TYPE_SIZE_UNIT (element
))
2507 TYPE_SIZE_UNIT (type
)
2508 = size_binop (MULT_EXPR
, TYPE_SIZE_UNIT (element
), length
);
2511 /* Now round the alignment and size,
2512 using machine-dependent criteria if any. */
2514 unsigned align
= TYPE_ALIGN (element
);
2515 if (TYPE_USER_ALIGN (type
))
2516 align
= MAX (align
, TYPE_ALIGN (type
));
2518 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (element
);
2519 if (!TYPE_WARN_IF_NOT_ALIGN (type
))
2520 SET_TYPE_WARN_IF_NOT_ALIGN (type
,
2521 TYPE_WARN_IF_NOT_ALIGN (element
));
2522 #ifdef ROUND_TYPE_ALIGN
2523 align
= ROUND_TYPE_ALIGN (type
, align
, BITS_PER_UNIT
);
2525 align
= MAX (align
, BITS_PER_UNIT
);
2527 SET_TYPE_ALIGN (type
, align
);
2528 SET_TYPE_MODE (type
, BLKmode
);
2529 if (TYPE_SIZE (type
) != 0
2530 && ! targetm
.member_type_forces_blk (type
, VOIDmode
)
2531 /* BLKmode elements force BLKmode aggregate;
2532 else extract/store fields may lose. */
2533 && (TYPE_MODE (TREE_TYPE (type
)) != BLKmode
2534 || TYPE_NO_FORCE_BLK (TREE_TYPE (type
))))
2536 SET_TYPE_MODE (type
, mode_for_array (TREE_TYPE (type
),
2538 if (TYPE_MODE (type
) != BLKmode
2539 && STRICT_ALIGNMENT
&& TYPE_ALIGN (type
) < BIGGEST_ALIGNMENT
2540 && TYPE_ALIGN (type
) < GET_MODE_ALIGNMENT (TYPE_MODE (type
)))
2542 TYPE_NO_FORCE_BLK (type
) = 1;
2543 SET_TYPE_MODE (type
, BLKmode
);
2546 if (AGGREGATE_TYPE_P (element
))
2547 TYPE_TYPELESS_STORAGE (type
) = TYPE_TYPELESS_STORAGE (element
);
2548 /* When the element size is constant, check that it is at least as
2549 large as the element alignment. */
2550 if (TYPE_SIZE_UNIT (element
)
2551 && TREE_CODE (TYPE_SIZE_UNIT (element
)) == INTEGER_CST
2552 /* If TYPE_SIZE_UNIT overflowed, then it is certainly larger than
2554 && !TREE_OVERFLOW (TYPE_SIZE_UNIT (element
))
2555 && !integer_zerop (TYPE_SIZE_UNIT (element
))
2556 && compare_tree_int (TYPE_SIZE_UNIT (element
),
2557 TYPE_ALIGN_UNIT (element
)) < 0)
2558 error ("alignment of array elements is greater than element size");
2564 case QUAL_UNION_TYPE
:
2567 record_layout_info rli
;
2569 /* Initialize the layout information. */
2570 rli
= start_record_layout (type
);
2572 /* If this is a QUAL_UNION_TYPE, we want to process the fields
2573 in the reverse order in building the COND_EXPR that denotes
2574 its size. We reverse them again later. */
2575 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
2576 TYPE_FIELDS (type
) = nreverse (TYPE_FIELDS (type
));
2578 /* Place all the fields. */
2579 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
2580 place_field (rli
, field
);
2582 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
2583 TYPE_FIELDS (type
) = nreverse (TYPE_FIELDS (type
));
2585 /* Finish laying out the record. */
2586 finish_record_layout (rli
, /*free_p=*/true);
2594 /* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE. For
2595 records and unions, finish_record_layout already called this
2597 if (!RECORD_OR_UNION_TYPE_P (type
))
2598 finalize_type_size (type
);
2600 /* We should never see alias sets on incomplete aggregates. And we
2601 should not call layout_type on not incomplete aggregates. */
2602 if (AGGREGATE_TYPE_P (type
))
2603 gcc_assert (!TYPE_ALIAS_SET_KNOWN_P (type
));
2606 /* Return the least alignment required for type TYPE. */
2609 min_align_of_type (tree type
)
2611 unsigned int align
= TYPE_ALIGN (type
);
2612 if (!TYPE_USER_ALIGN (type
))
2614 align
= MIN (align
, BIGGEST_ALIGNMENT
);
2615 #ifdef BIGGEST_FIELD_ALIGNMENT
2616 align
= MIN (align
, BIGGEST_FIELD_ALIGNMENT
);
2618 unsigned int field_align
= align
;
2619 #ifdef ADJUST_FIELD_ALIGN
2620 field_align
= ADJUST_FIELD_ALIGN (NULL_TREE
, type
, field_align
);
2622 align
= MIN (align
, field_align
);
2624 return align
/ BITS_PER_UNIT
;
2627 /* Create and return a type for signed integers of PRECISION bits. */
2630 make_signed_type (int precision
)
2632 tree type
= make_node (INTEGER_TYPE
);
2634 TYPE_PRECISION (type
) = precision
;
2636 fixup_signed_type (type
);
2640 /* Create and return a type for unsigned integers of PRECISION bits. */
2643 make_unsigned_type (int precision
)
2645 tree type
= make_node (INTEGER_TYPE
);
2647 TYPE_PRECISION (type
) = precision
;
2649 fixup_unsigned_type (type
);
2653 /* Create and return a type for fract of PRECISION bits, UNSIGNEDP,
2657 make_fract_type (int precision
, int unsignedp
, int satp
)
2659 tree type
= make_node (FIXED_POINT_TYPE
);
2661 TYPE_PRECISION (type
) = precision
;
2664 TYPE_SATURATING (type
) = 1;
2666 /* Lay out the type: set its alignment, size, etc. */
2667 TYPE_UNSIGNED (type
) = unsignedp
;
2668 enum mode_class mclass
= unsignedp
? MODE_UFRACT
: MODE_FRACT
;
2669 SET_TYPE_MODE (type
, mode_for_size (precision
, mclass
, 0).require ());
2675 /* Create and return a type for accum of PRECISION bits, UNSIGNEDP,
2679 make_accum_type (int precision
, int unsignedp
, int satp
)
2681 tree type
= make_node (FIXED_POINT_TYPE
);
2683 TYPE_PRECISION (type
) = precision
;
2686 TYPE_SATURATING (type
) = 1;
2688 /* Lay out the type: set its alignment, size, etc. */
2689 TYPE_UNSIGNED (type
) = unsignedp
;
2690 enum mode_class mclass
= unsignedp
? MODE_UACCUM
: MODE_ACCUM
;
2691 SET_TYPE_MODE (type
, mode_for_size (precision
, mclass
, 0).require ());
2697 /* Initialize sizetypes so layout_type can use them. */
2700 initialize_sizetypes (void)
2702 int precision
, bprecision
;
2704 /* Get sizetypes precision from the SIZE_TYPE target macro. */
2705 if (strcmp (SIZETYPE
, "unsigned int") == 0)
2706 precision
= INT_TYPE_SIZE
;
2707 else if (strcmp (SIZETYPE
, "long unsigned int") == 0)
2708 precision
= LONG_TYPE_SIZE
;
2709 else if (strcmp (SIZETYPE
, "long long unsigned int") == 0)
2710 precision
= LONG_LONG_TYPE_SIZE
;
2711 else if (strcmp (SIZETYPE
, "short unsigned int") == 0)
2712 precision
= SHORT_TYPE_SIZE
;
2718 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2719 if (int_n_enabled_p
[i
])
2721 char name
[50], altname
[50];
2722 sprintf (name
, "__int%d unsigned", int_n_data
[i
].bitsize
);
2723 sprintf (altname
, "__int%d__ unsigned", int_n_data
[i
].bitsize
);
2725 if (strcmp (name
, SIZETYPE
) == 0
2726 || strcmp (altname
, SIZETYPE
) == 0)
2728 precision
= int_n_data
[i
].bitsize
;
2731 if (precision
== -1)
2736 = MIN (precision
+ LOG2_BITS_PER_UNIT
+ 1, MAX_FIXED_MODE_SIZE
);
2737 bprecision
= GET_MODE_PRECISION (smallest_int_mode_for_size (bprecision
));
2738 if (bprecision
> HOST_BITS_PER_DOUBLE_INT
)
2739 bprecision
= HOST_BITS_PER_DOUBLE_INT
;
2741 /* Create stubs for sizetype and bitsizetype so we can create constants. */
2742 sizetype
= make_node (INTEGER_TYPE
);
2743 TYPE_NAME (sizetype
) = get_identifier ("sizetype");
2744 TYPE_PRECISION (sizetype
) = precision
;
2745 TYPE_UNSIGNED (sizetype
) = 1;
2746 bitsizetype
= make_node (INTEGER_TYPE
);
2747 TYPE_NAME (bitsizetype
) = get_identifier ("bitsizetype");
2748 TYPE_PRECISION (bitsizetype
) = bprecision
;
2749 TYPE_UNSIGNED (bitsizetype
) = 1;
2751 /* Now layout both types manually. */
2752 scalar_int_mode mode
= smallest_int_mode_for_size (precision
);
2753 SET_TYPE_MODE (sizetype
, mode
);
2754 SET_TYPE_ALIGN (sizetype
, GET_MODE_ALIGNMENT (TYPE_MODE (sizetype
)));
2755 TYPE_SIZE (sizetype
) = bitsize_int (precision
);
2756 TYPE_SIZE_UNIT (sizetype
) = size_int (GET_MODE_SIZE (mode
));
2757 set_min_and_max_values_for_integral_type (sizetype
, precision
, UNSIGNED
);
2759 mode
= smallest_int_mode_for_size (bprecision
);
2760 SET_TYPE_MODE (bitsizetype
, mode
);
2761 SET_TYPE_ALIGN (bitsizetype
, GET_MODE_ALIGNMENT (TYPE_MODE (bitsizetype
)));
2762 TYPE_SIZE (bitsizetype
) = bitsize_int (bprecision
);
2763 TYPE_SIZE_UNIT (bitsizetype
) = size_int (GET_MODE_SIZE (mode
));
2764 set_min_and_max_values_for_integral_type (bitsizetype
, bprecision
, UNSIGNED
);
2766 /* Create the signed variants of *sizetype. */
2767 ssizetype
= make_signed_type (TYPE_PRECISION (sizetype
));
2768 TYPE_NAME (ssizetype
) = get_identifier ("ssizetype");
2769 sbitsizetype
= make_signed_type (TYPE_PRECISION (bitsizetype
));
2770 TYPE_NAME (sbitsizetype
) = get_identifier ("sbitsizetype");
2773 /* TYPE is an integral type, i.e., an INTEGRAL_TYPE, ENUMERAL_TYPE
2774 or BOOLEAN_TYPE. Set TYPE_MIN_VALUE and TYPE_MAX_VALUE
2775 for TYPE, based on the PRECISION and whether or not the TYPE
2776 IS_UNSIGNED. PRECISION need not correspond to a width supported
2777 natively by the hardware; for example, on a machine with 8-bit,
2778 16-bit, and 32-bit register modes, PRECISION might be 7, 23, or
2782 set_min_and_max_values_for_integral_type (tree type
,
2786 /* For bitfields with zero width we end up creating integer types
2787 with zero precision. Don't assign any minimum/maximum values
2788 to those types, they don't have any valid value. */
2792 TYPE_MIN_VALUE (type
)
2793 = wide_int_to_tree (type
, wi::min_value (precision
, sgn
));
2794 TYPE_MAX_VALUE (type
)
2795 = wide_int_to_tree (type
, wi::max_value (precision
, sgn
));
2798 /* Set the extreme values of TYPE based on its precision in bits,
2799 then lay it out. Used when make_signed_type won't do
2800 because the tree code is not INTEGER_TYPE. */
2803 fixup_signed_type (tree type
)
2805 int precision
= TYPE_PRECISION (type
);
2807 set_min_and_max_values_for_integral_type (type
, precision
, SIGNED
);
2809 /* Lay out the type: set its alignment, size, etc. */
2813 /* Set the extreme values of TYPE based on its precision in bits,
2814 then lay it out. This is used both in `make_unsigned_type'
2815 and for enumeral types. */
2818 fixup_unsigned_type (tree type
)
2820 int precision
= TYPE_PRECISION (type
);
2822 TYPE_UNSIGNED (type
) = 1;
2824 set_min_and_max_values_for_integral_type (type
, precision
, UNSIGNED
);
2826 /* Lay out the type: set its alignment, size, etc. */
2830 /* Construct an iterator for a bitfield that spans BITSIZE bits,
2833 BITREGION_START is the bit position of the first bit in this
2834 sequence of bit fields. BITREGION_END is the last bit in this
2835 sequence. If these two fields are non-zero, we should restrict the
2836 memory access to that range. Otherwise, we are allowed to touch
2837 any adjacent non bit-fields.
2839 ALIGN is the alignment of the underlying object in bits.
2840 VOLATILEP says whether the bitfield is volatile. */
2842 bit_field_mode_iterator
2843 ::bit_field_mode_iterator (HOST_WIDE_INT bitsize
, HOST_WIDE_INT bitpos
,
2844 poly_int64 bitregion_start
,
2845 poly_int64 bitregion_end
,
2846 unsigned int align
, bool volatilep
)
2847 : m_mode (NARROWEST_INT_MODE
), m_bitsize (bitsize
),
2848 m_bitpos (bitpos
), m_bitregion_start (bitregion_start
),
2849 m_bitregion_end (bitregion_end
), m_align (align
),
2850 m_volatilep (volatilep
), m_count (0)
2852 if (known_eq (m_bitregion_end
, 0))
2854 /* We can assume that any aligned chunk of ALIGN bits that overlaps
2855 the bitfield is mapped and won't trap, provided that ALIGN isn't
2856 too large. The cap is the biggest required alignment for data,
2857 or at least the word size. And force one such chunk at least. */
2858 unsigned HOST_WIDE_INT units
2859 = MIN (align
, MAX (BIGGEST_ALIGNMENT
, BITS_PER_WORD
));
2862 HOST_WIDE_INT end
= bitpos
+ bitsize
+ units
- 1;
2863 m_bitregion_end
= end
- end
% units
- 1;
2867 /* Calls to this function return successively larger modes that can be used
2868 to represent the bitfield. Return true if another bitfield mode is
2869 available, storing it in *OUT_MODE if so. */
2872 bit_field_mode_iterator::next_mode (scalar_int_mode
*out_mode
)
2874 scalar_int_mode mode
;
2875 for (; m_mode
.exists (&mode
); m_mode
= GET_MODE_WIDER_MODE (mode
))
2877 unsigned int unit
= GET_MODE_BITSIZE (mode
);
2879 /* Skip modes that don't have full precision. */
2880 if (unit
!= GET_MODE_PRECISION (mode
))
2883 /* Stop if the mode is too wide to handle efficiently. */
2884 if (unit
> MAX_FIXED_MODE_SIZE
)
2887 /* Don't deliver more than one multiword mode; the smallest one
2889 if (m_count
> 0 && unit
> BITS_PER_WORD
)
2892 /* Skip modes that are too small. */
2893 unsigned HOST_WIDE_INT substart
= (unsigned HOST_WIDE_INT
) m_bitpos
% unit
;
2894 unsigned HOST_WIDE_INT subend
= substart
+ m_bitsize
;
2898 /* Stop if the mode goes outside the bitregion. */
2899 HOST_WIDE_INT start
= m_bitpos
- substart
;
2900 if (maybe_ne (m_bitregion_start
, 0)
2901 && maybe_lt (start
, m_bitregion_start
))
2903 HOST_WIDE_INT end
= start
+ unit
;
2904 if (maybe_gt (end
, m_bitregion_end
+ 1))
2907 /* Stop if the mode requires too much alignment. */
2908 if (GET_MODE_ALIGNMENT (mode
) > m_align
2909 && targetm
.slow_unaligned_access (mode
, m_align
))
2913 m_mode
= GET_MODE_WIDER_MODE (mode
);
2920 /* Return true if smaller modes are generally preferred for this kind
2924 bit_field_mode_iterator::prefer_smaller_modes ()
2927 ? targetm
.narrow_volatile_bitfield ()
2928 : !SLOW_BYTE_ACCESS
);
2931 /* Find the best machine mode to use when referencing a bit field of length
2932 BITSIZE bits starting at BITPOS.
2934 BITREGION_START is the bit position of the first bit in this
2935 sequence of bit fields. BITREGION_END is the last bit in this
2936 sequence. If these two fields are non-zero, we should restrict the
2937 memory access to that range. Otherwise, we are allowed to touch
2938 any adjacent non bit-fields.
2940 The chosen mode must have no more than LARGEST_MODE_BITSIZE bits.
2941 INT_MAX is a suitable value for LARGEST_MODE_BITSIZE if the caller
2942 doesn't want to apply a specific limit.
2944 If no mode meets all these conditions, we return VOIDmode.
2946 The underlying object is known to be aligned to a boundary of ALIGN bits.
2948 If VOLATILEP is false and SLOW_BYTE_ACCESS is false, we return the
2949 smallest mode meeting these conditions.
2951 If VOLATILEP is false and SLOW_BYTE_ACCESS is true, we return the
2952 largest mode (but a mode no wider than UNITS_PER_WORD) that meets
2955 If VOLATILEP is true the narrow_volatile_bitfields target hook is used to
2956 decide which of the above modes should be used. */
2959 get_best_mode (int bitsize
, int bitpos
,
2960 poly_uint64 bitregion_start
, poly_uint64 bitregion_end
,
2962 unsigned HOST_WIDE_INT largest_mode_bitsize
, bool volatilep
,
2963 scalar_int_mode
*best_mode
)
2965 bit_field_mode_iterator
iter (bitsize
, bitpos
, bitregion_start
,
2966 bitregion_end
, align
, volatilep
);
2967 scalar_int_mode mode
;
2969 while (iter
.next_mode (&mode
)
2970 /* ??? For historical reasons, reject modes that would normally
2971 receive greater alignment, even if unaligned accesses are
2972 acceptable. This has both advantages and disadvantages.
2973 Removing this check means that something like:
2975 struct s { unsigned int x; unsigned int y; };
2976 int f (struct s *s) { return s->x == 0 && s->y == 0; }
2978 can be implemented using a single load and compare on
2979 64-bit machines that have no alignment restrictions.
2980 For example, on powerpc64-linux-gnu, we would generate:
3002 However, accessing more than one field can make life harder
3003 for the gimple optimizers. For example, gcc.dg/vect/bb-slp-5.c
3004 has a series of unsigned short copies followed by a series of
3005 unsigned short comparisons. With this check, both the copies
3006 and comparisons remain 16-bit accesses and FRE is able
3007 to eliminate the latter. Without the check, the comparisons
3008 can be done using 2 64-bit operations, which FRE isn't able
3009 to handle in the same way.
3011 Either way, it would probably be worth disabling this check
3012 during expand. One particular example where removing the
3013 check would help is the get_best_mode call in store_bit_field.
3014 If we are given a memory bitregion of 128 bits that is aligned
3015 to a 64-bit boundary, and the bitfield we want to modify is
3016 in the second half of the bitregion, this check causes
3017 store_bitfield to turn the memory into a 64-bit reference
3018 to the _first_ half of the region. We later use
3019 adjust_bitfield_address to get a reference to the correct half,
3020 but doing so looks to adjust_bitfield_address as though we are
3021 moving past the end of the original object, so it drops the
3022 associated MEM_EXPR and MEM_OFFSET. Removing the check
3023 causes store_bit_field to keep a 128-bit memory reference,
3024 so that the final bitfield reference still has a MEM_EXPR
3026 && GET_MODE_ALIGNMENT (mode
) <= align
3027 && GET_MODE_BITSIZE (mode
) <= largest_mode_bitsize
)
3031 if (iter
.prefer_smaller_modes ())
3038 /* Gets minimal and maximal values for MODE (signed or unsigned depending on
3039 SIGN). The returned constants are made to be usable in TARGET_MODE. */
3042 get_mode_bounds (scalar_int_mode mode
, int sign
,
3043 scalar_int_mode target_mode
,
3044 rtx
*mmin
, rtx
*mmax
)
3046 unsigned size
= GET_MODE_PRECISION (mode
);
3047 unsigned HOST_WIDE_INT min_val
, max_val
;
3049 gcc_assert (size
<= HOST_BITS_PER_WIDE_INT
);
3051 /* Special case BImode, which has values 0 and STORE_FLAG_VALUE. */
3054 if (STORE_FLAG_VALUE
< 0)
3056 min_val
= STORE_FLAG_VALUE
;
3062 max_val
= STORE_FLAG_VALUE
;
3067 min_val
= -(HOST_WIDE_INT_1U
<< (size
- 1));
3068 max_val
= (HOST_WIDE_INT_1U
<< (size
- 1)) - 1;
3073 max_val
= (HOST_WIDE_INT_1U
<< (size
- 1) << 1) - 1;
3076 *mmin
= gen_int_mode (min_val
, target_mode
);
3077 *mmax
= gen_int_mode (max_val
, target_mode
);
3080 #include "gt-stor-layout.h"