1 /* C-compiler utilities for types and variables storage layout
2 Copyright (C) 1987-2015 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
29 #include "stringpool.h"
31 #include "insn-config.h"
35 #include "diagnostic-core.h"
37 #include "fold-const.h"
38 #include "stor-layout.h"
40 #include "print-tree.h"
47 #include "langhooks.h"
49 #include "tree-inline.h"
50 #include "tree-dump.h"
53 /* Data type for the expressions representing sizes of data types.
54 It is the first integer type laid out. */
55 tree sizetype_tab
[(int) stk_type_kind_last
];
57 /* If nonzero, this is an upper limit on alignment of structure fields.
58 The value is measured in bits. */
59 unsigned int maximum_field_alignment
= TARGET_DEFAULT_PACK_STRUCT
* BITS_PER_UNIT
;
61 /* Nonzero if all REFERENCE_TYPEs are internal and hence should be allocated
62 in the address spaces' address_mode, not pointer_mode. Set only by
63 internal_reference_types called only by a front end. */
64 static int reference_types_internal
= 0;
66 static tree
self_referential_size (tree
);
67 static void finalize_record_size (record_layout_info
);
68 static void finalize_type_size (tree
);
69 static void place_union_field (record_layout_info
, tree
);
70 static int excess_unit_span (HOST_WIDE_INT
, HOST_WIDE_INT
, HOST_WIDE_INT
,
72 extern void debug_rli (record_layout_info
);
74 /* Show that REFERENCE_TYPES are internal and should use address_mode.
75 Called only by front end. */
78 internal_reference_types (void)
80 reference_types_internal
= 1;
83 /* Given a size SIZE that may not be a constant, return a SAVE_EXPR
84 to serve as the actual size-expression for a type or decl. */
87 variable_size (tree size
)
90 if (TREE_CONSTANT (size
))
93 /* If the size is self-referential, we can't make a SAVE_EXPR (see
94 save_expr for the rationale). But we can do something else. */
95 if (CONTAINS_PLACEHOLDER_P (size
))
96 return self_referential_size (size
);
98 /* If we are in the global binding level, we can't make a SAVE_EXPR
99 since it may end up being shared across functions, so it is up
100 to the front-end to deal with this case. */
101 if (lang_hooks
.decls
.global_bindings_p ())
104 return save_expr (size
);
107 /* An array of functions used for self-referential size computation. */
108 static GTY(()) vec
<tree
, va_gc
> *size_functions
;
110 /* Return true if T is a self-referential component reference. */
113 self_referential_component_ref_p (tree t
)
115 if (TREE_CODE (t
) != COMPONENT_REF
)
118 while (REFERENCE_CLASS_P (t
))
119 t
= TREE_OPERAND (t
, 0);
121 return (TREE_CODE (t
) == PLACEHOLDER_EXPR
);
124 /* Similar to copy_tree_r but do not copy component references involving
125 PLACEHOLDER_EXPRs. These nodes are spotted in find_placeholder_in_expr
126 and substituted in substitute_in_expr. */
129 copy_self_referential_tree_r (tree
*tp
, int *walk_subtrees
, void *data
)
131 enum tree_code code
= TREE_CODE (*tp
);
133 /* Stop at types, decls, constants like copy_tree_r. */
134 if (TREE_CODE_CLASS (code
) == tcc_type
135 || TREE_CODE_CLASS (code
) == tcc_declaration
136 || TREE_CODE_CLASS (code
) == tcc_constant
)
142 /* This is the pattern built in ada/make_aligning_type. */
143 else if (code
== ADDR_EXPR
144 && TREE_CODE (TREE_OPERAND (*tp
, 0)) == PLACEHOLDER_EXPR
)
150 /* Default case: the component reference. */
151 else if (self_referential_component_ref_p (*tp
))
157 /* We're not supposed to have them in self-referential size trees
158 because we wouldn't properly control when they are evaluated.
159 However, not creating superfluous SAVE_EXPRs requires accurate
160 tracking of readonly-ness all the way down to here, which we
161 cannot always guarantee in practice. So punt in this case. */
162 else if (code
== SAVE_EXPR
)
163 return error_mark_node
;
165 else if (code
== STATEMENT_LIST
)
168 return copy_tree_r (tp
, walk_subtrees
, data
);
171 /* Given a SIZE expression that is self-referential, return an equivalent
172 expression to serve as the actual size expression for a type. */
175 self_referential_size (tree size
)
177 static unsigned HOST_WIDE_INT fnno
= 0;
178 vec
<tree
> self_refs
= vNULL
;
179 tree param_type_list
= NULL
, param_decl_list
= NULL
;
180 tree t
, ref
, return_type
, fntype
, fnname
, fndecl
;
183 vec
<tree
, va_gc
> *args
= NULL
;
185 /* Do not factor out simple operations. */
186 t
= skip_simple_constant_arithmetic (size
);
187 if (TREE_CODE (t
) == CALL_EXPR
|| self_referential_component_ref_p (t
))
190 /* Collect the list of self-references in the expression. */
191 find_placeholder_in_expr (size
, &self_refs
);
192 gcc_assert (self_refs
.length () > 0);
194 /* Obtain a private copy of the expression. */
196 if (walk_tree (&t
, copy_self_referential_tree_r
, NULL
, NULL
) != NULL_TREE
)
200 /* Build the parameter and argument lists in parallel; also
201 substitute the former for the latter in the expression. */
202 vec_alloc (args
, self_refs
.length ());
203 FOR_EACH_VEC_ELT (self_refs
, i
, ref
)
205 tree subst
, param_name
, param_type
, param_decl
;
209 /* We shouldn't have true variables here. */
210 gcc_assert (TREE_READONLY (ref
));
213 /* This is the pattern built in ada/make_aligning_type. */
214 else if (TREE_CODE (ref
) == ADDR_EXPR
)
216 /* Default case: the component reference. */
218 subst
= TREE_OPERAND (ref
, 1);
220 sprintf (buf
, "p%d", i
);
221 param_name
= get_identifier (buf
);
222 param_type
= TREE_TYPE (ref
);
224 = build_decl (input_location
, PARM_DECL
, param_name
, param_type
);
225 DECL_ARG_TYPE (param_decl
) = param_type
;
226 DECL_ARTIFICIAL (param_decl
) = 1;
227 TREE_READONLY (param_decl
) = 1;
229 size
= substitute_in_expr (size
, subst
, param_decl
);
231 param_type_list
= tree_cons (NULL_TREE
, param_type
, param_type_list
);
232 param_decl_list
= chainon (param_decl
, param_decl_list
);
233 args
->quick_push (ref
);
236 self_refs
.release ();
238 /* Append 'void' to indicate that the number of parameters is fixed. */
239 param_type_list
= tree_cons (NULL_TREE
, void_type_node
, param_type_list
);
241 /* The 3 lists have been created in reverse order. */
242 param_type_list
= nreverse (param_type_list
);
243 param_decl_list
= nreverse (param_decl_list
);
245 /* Build the function type. */
246 return_type
= TREE_TYPE (size
);
247 fntype
= build_function_type (return_type
, param_type_list
);
249 /* Build the function declaration. */
250 sprintf (buf
, "SZ" HOST_WIDE_INT_PRINT_UNSIGNED
, fnno
++);
251 fnname
= get_file_function_name (buf
);
252 fndecl
= build_decl (input_location
, FUNCTION_DECL
, fnname
, fntype
);
253 for (t
= param_decl_list
; t
; t
= DECL_CHAIN (t
))
254 DECL_CONTEXT (t
) = fndecl
;
255 DECL_ARGUMENTS (fndecl
) = param_decl_list
;
257 = build_decl (input_location
, RESULT_DECL
, 0, return_type
);
258 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
260 /* The function has been created by the compiler and we don't
261 want to emit debug info for it. */
262 DECL_ARTIFICIAL (fndecl
) = 1;
263 DECL_IGNORED_P (fndecl
) = 1;
265 /* It is supposed to be "const" and never throw. */
266 TREE_READONLY (fndecl
) = 1;
267 TREE_NOTHROW (fndecl
) = 1;
269 /* We want it to be inlined when this is deemed profitable, as
270 well as discarded if every call has been integrated. */
271 DECL_DECLARED_INLINE_P (fndecl
) = 1;
273 /* It is made up of a unique return statement. */
274 DECL_INITIAL (fndecl
) = make_node (BLOCK
);
275 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
276 t
= build2 (MODIFY_EXPR
, return_type
, DECL_RESULT (fndecl
), size
);
277 DECL_SAVED_TREE (fndecl
) = build1 (RETURN_EXPR
, void_type_node
, t
);
278 TREE_STATIC (fndecl
) = 1;
280 /* Put it onto the list of size functions. */
281 vec_safe_push (size_functions
, fndecl
);
283 /* Replace the original expression with a call to the size function. */
284 return build_call_expr_loc_vec (UNKNOWN_LOCATION
, fndecl
, args
);
287 /* Take, queue and compile all the size functions. It is essential that
288 the size functions be gimplified at the very end of the compilation
289 in order to guarantee transparent handling of self-referential sizes.
290 Otherwise the GENERIC inliner would not be able to inline them back
291 at each of their call sites, thus creating artificial non-constant
292 size expressions which would trigger nasty problems later on. */
295 finalize_size_functions (void)
300 for (i
= 0; size_functions
&& size_functions
->iterate (i
, &fndecl
); i
++)
302 allocate_struct_function (fndecl
, false);
304 dump_function (TDI_original
, fndecl
);
305 gimplify_function_tree (fndecl
);
306 cgraph_node::finalize_function (fndecl
, false);
309 vec_free (size_functions
);
312 /* Return the machine mode to use for a nonscalar of SIZE bits. The
313 mode must be in class MCLASS, and have exactly that many value bits;
314 it may have padding as well. If LIMIT is nonzero, modes of wider
315 than MAX_FIXED_MODE_SIZE will not be used. */
318 mode_for_size (unsigned int size
, enum mode_class mclass
, int limit
)
323 if (limit
&& size
> MAX_FIXED_MODE_SIZE
)
326 /* Get the first mode which has this size, in the specified class. */
327 for (mode
= GET_CLASS_NARROWEST_MODE (mclass
); mode
!= VOIDmode
;
328 mode
= GET_MODE_WIDER_MODE (mode
))
329 if (GET_MODE_PRECISION (mode
) == size
)
332 if (mclass
== MODE_INT
|| mclass
== MODE_PARTIAL_INT
)
333 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
334 if (int_n_data
[i
].bitsize
== size
335 && int_n_enabled_p
[i
])
336 return int_n_data
[i
].m
;
341 /* Similar, except passed a tree node. */
344 mode_for_size_tree (const_tree size
, enum mode_class mclass
, int limit
)
346 unsigned HOST_WIDE_INT uhwi
;
349 if (!tree_fits_uhwi_p (size
))
351 uhwi
= tree_to_uhwi (size
);
355 return mode_for_size (ui
, mclass
, limit
);
358 /* Similar, but never return BLKmode; return the narrowest mode that
359 contains at least the requested number of value bits. */
362 smallest_mode_for_size (unsigned int size
, enum mode_class mclass
)
364 machine_mode mode
= VOIDmode
;
367 /* Get the first mode which has at least this size, in the
369 for (mode
= GET_CLASS_NARROWEST_MODE (mclass
); mode
!= VOIDmode
;
370 mode
= GET_MODE_WIDER_MODE (mode
))
371 if (GET_MODE_PRECISION (mode
) >= size
)
374 if (mclass
== MODE_INT
|| mclass
== MODE_PARTIAL_INT
)
375 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
376 if (int_n_data
[i
].bitsize
>= size
377 && int_n_data
[i
].bitsize
< GET_MODE_PRECISION (mode
)
378 && int_n_enabled_p
[i
])
379 mode
= int_n_data
[i
].m
;
381 if (mode
== VOIDmode
)
387 /* Find an integer mode of the exact same size, or BLKmode on failure. */
390 int_mode_for_mode (machine_mode mode
)
392 switch (GET_MODE_CLASS (mode
))
395 case MODE_PARTIAL_INT
:
398 case MODE_COMPLEX_INT
:
399 case MODE_COMPLEX_FLOAT
:
401 case MODE_DECIMAL_FLOAT
:
402 case MODE_VECTOR_INT
:
403 case MODE_VECTOR_FLOAT
:
408 case MODE_VECTOR_FRACT
:
409 case MODE_VECTOR_ACCUM
:
410 case MODE_VECTOR_UFRACT
:
411 case MODE_VECTOR_UACCUM
:
412 case MODE_POINTER_BOUNDS
:
413 mode
= mode_for_size (GET_MODE_BITSIZE (mode
), MODE_INT
, 0);
420 /* ... fall through ... */
430 /* Find a mode that can be used for efficient bitwise operations on MODE.
431 Return BLKmode if no such mode exists. */
434 bitwise_mode_for_mode (machine_mode mode
)
436 /* Quick exit if we already have a suitable mode. */
437 unsigned int bitsize
= GET_MODE_BITSIZE (mode
);
438 if (SCALAR_INT_MODE_P (mode
) && bitsize
<= MAX_FIXED_MODE_SIZE
)
441 /* Reuse the sanity checks from int_mode_for_mode. */
442 gcc_checking_assert ((int_mode_for_mode (mode
), true));
444 /* Try to replace complex modes with complex modes. In general we
445 expect both components to be processed independently, so we only
446 care whether there is a register for the inner mode. */
447 if (COMPLEX_MODE_P (mode
))
449 machine_mode trial
= mode
;
450 if (GET_MODE_CLASS (mode
) != MODE_COMPLEX_INT
)
451 trial
= mode_for_size (bitsize
, MODE_COMPLEX_INT
, false);
453 && have_regs_of_mode
[GET_MODE_INNER (trial
)])
457 /* Try to replace vector modes with vector modes. Also try using vector
458 modes if an integer mode would be too big. */
459 if (VECTOR_MODE_P (mode
) || bitsize
> MAX_FIXED_MODE_SIZE
)
461 machine_mode trial
= mode
;
462 if (GET_MODE_CLASS (mode
) != MODE_VECTOR_INT
)
463 trial
= mode_for_size (bitsize
, MODE_VECTOR_INT
, 0);
465 && have_regs_of_mode
[trial
]
466 && targetm
.vector_mode_supported_p (trial
))
470 /* Otherwise fall back on integers while honoring MAX_FIXED_MODE_SIZE. */
471 return mode_for_size (bitsize
, MODE_INT
, true);
474 /* Find a type that can be used for efficient bitwise operations on MODE.
475 Return null if no such mode exists. */
478 bitwise_type_for_mode (machine_mode mode
)
480 mode
= bitwise_mode_for_mode (mode
);
484 unsigned int inner_size
= GET_MODE_UNIT_BITSIZE (mode
);
485 tree inner_type
= build_nonstandard_integer_type (inner_size
, true);
487 if (VECTOR_MODE_P (mode
))
488 return build_vector_type_for_mode (inner_type
, mode
);
490 if (COMPLEX_MODE_P (mode
))
491 return build_complex_type (inner_type
);
493 gcc_checking_assert (GET_MODE_INNER (mode
) == mode
);
497 /* Find a mode that is suitable for representing a vector with
498 NUNITS elements of mode INNERMODE. Returns BLKmode if there
499 is no suitable mode. */
502 mode_for_vector (machine_mode innermode
, unsigned nunits
)
506 /* First, look for a supported vector type. */
507 if (SCALAR_FLOAT_MODE_P (innermode
))
508 mode
= MIN_MODE_VECTOR_FLOAT
;
509 else if (SCALAR_FRACT_MODE_P (innermode
))
510 mode
= MIN_MODE_VECTOR_FRACT
;
511 else if (SCALAR_UFRACT_MODE_P (innermode
))
512 mode
= MIN_MODE_VECTOR_UFRACT
;
513 else if (SCALAR_ACCUM_MODE_P (innermode
))
514 mode
= MIN_MODE_VECTOR_ACCUM
;
515 else if (SCALAR_UACCUM_MODE_P (innermode
))
516 mode
= MIN_MODE_VECTOR_UACCUM
;
518 mode
= MIN_MODE_VECTOR_INT
;
520 /* Do not check vector_mode_supported_p here. We'll do that
521 later in vector_type_mode. */
522 for (; mode
!= VOIDmode
; mode
= GET_MODE_WIDER_MODE (mode
))
523 if (GET_MODE_NUNITS (mode
) == nunits
524 && GET_MODE_INNER (mode
) == innermode
)
527 /* For integers, try mapping it to a same-sized scalar mode. */
529 && GET_MODE_CLASS (innermode
) == MODE_INT
)
530 mode
= mode_for_size (nunits
* GET_MODE_BITSIZE (innermode
),
534 || (GET_MODE_CLASS (mode
) == MODE_INT
535 && !have_regs_of_mode
[mode
]))
541 /* Return the alignment of MODE. This will be bounded by 1 and
542 BIGGEST_ALIGNMENT. */
545 get_mode_alignment (machine_mode mode
)
547 return MIN (BIGGEST_ALIGNMENT
, MAX (1, mode_base_align
[mode
]*BITS_PER_UNIT
));
550 /* Return the natural mode of an array, given that it is SIZE bytes in
551 total and has elements of type ELEM_TYPE. */
554 mode_for_array (tree elem_type
, tree size
)
557 unsigned HOST_WIDE_INT int_size
, int_elem_size
;
560 /* One-element arrays get the component type's mode. */
561 elem_size
= TYPE_SIZE (elem_type
);
562 if (simple_cst_equal (size
, elem_size
))
563 return TYPE_MODE (elem_type
);
566 if (tree_fits_uhwi_p (size
) && tree_fits_uhwi_p (elem_size
))
568 int_size
= tree_to_uhwi (size
);
569 int_elem_size
= tree_to_uhwi (elem_size
);
570 if (int_elem_size
> 0
571 && int_size
% int_elem_size
== 0
572 && targetm
.array_mode_supported_p (TYPE_MODE (elem_type
),
573 int_size
/ int_elem_size
))
576 return mode_for_size_tree (size
, MODE_INT
, limit_p
);
579 /* Subroutine of layout_decl: Force alignment required for the data type.
580 But if the decl itself wants greater alignment, don't override that. */
583 do_type_align (tree type
, tree decl
)
585 if (TYPE_ALIGN (type
) > DECL_ALIGN (decl
))
587 DECL_ALIGN (decl
) = TYPE_ALIGN (type
);
588 if (TREE_CODE (decl
) == FIELD_DECL
)
589 DECL_USER_ALIGN (decl
) = TYPE_USER_ALIGN (type
);
593 /* Set the size, mode and alignment of a ..._DECL node.
594 TYPE_DECL does need this for C++.
595 Note that LABEL_DECL and CONST_DECL nodes do not need this,
596 and FUNCTION_DECL nodes have them set up in a special (and simple) way.
597 Don't call layout_decl for them.
599 KNOWN_ALIGN is the amount of alignment we can assume this
600 decl has with no special effort. It is relevant only for FIELD_DECLs
601 and depends on the previous fields.
602 All that matters about KNOWN_ALIGN is which powers of 2 divide it.
603 If KNOWN_ALIGN is 0, it means, "as much alignment as you like":
604 the record will be aligned to suit. */
607 layout_decl (tree decl
, unsigned int known_align
)
609 tree type
= TREE_TYPE (decl
);
610 enum tree_code code
= TREE_CODE (decl
);
612 location_t loc
= DECL_SOURCE_LOCATION (decl
);
614 if (code
== CONST_DECL
)
617 gcc_assert (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
618 || code
== TYPE_DECL
||code
== FIELD_DECL
);
620 rtl
= DECL_RTL_IF_SET (decl
);
622 if (type
== error_mark_node
)
623 type
= void_type_node
;
625 /* Usually the size and mode come from the data type without change,
626 however, the front-end may set the explicit width of the field, so its
627 size may not be the same as the size of its type. This happens with
628 bitfields, of course (an `int' bitfield may be only 2 bits, say), but it
629 also happens with other fields. For example, the C++ front-end creates
630 zero-sized fields corresponding to empty base classes, and depends on
631 layout_type setting DECL_FIELD_BITPOS correctly for the field. Set the
632 size in bytes from the size in bits. If we have already set the mode,
633 don't set it again since we can be called twice for FIELD_DECLs. */
635 DECL_UNSIGNED (decl
) = TYPE_UNSIGNED (type
);
636 if (DECL_MODE (decl
) == VOIDmode
)
637 DECL_MODE (decl
) = TYPE_MODE (type
);
639 if (DECL_SIZE (decl
) == 0)
641 DECL_SIZE (decl
) = TYPE_SIZE (type
);
642 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (type
);
644 else if (DECL_SIZE_UNIT (decl
) == 0)
645 DECL_SIZE_UNIT (decl
)
646 = fold_convert_loc (loc
, sizetype
,
647 size_binop_loc (loc
, CEIL_DIV_EXPR
, DECL_SIZE (decl
),
650 if (code
!= FIELD_DECL
)
651 /* For non-fields, update the alignment from the type. */
652 do_type_align (type
, decl
);
654 /* For fields, it's a bit more complicated... */
656 bool old_user_align
= DECL_USER_ALIGN (decl
);
657 bool zero_bitfield
= false;
658 bool packed_p
= DECL_PACKED (decl
);
661 if (DECL_BIT_FIELD (decl
))
663 DECL_BIT_FIELD_TYPE (decl
) = type
;
665 /* A zero-length bit-field affects the alignment of the next
666 field. In essence such bit-fields are not influenced by
667 any packing due to #pragma pack or attribute packed. */
668 if (integer_zerop (DECL_SIZE (decl
))
669 && ! targetm
.ms_bitfield_layout_p (DECL_FIELD_CONTEXT (decl
)))
671 zero_bitfield
= true;
673 if (PCC_BITFIELD_TYPE_MATTERS
)
674 do_type_align (type
, decl
);
677 #ifdef EMPTY_FIELD_BOUNDARY
678 if (EMPTY_FIELD_BOUNDARY
> DECL_ALIGN (decl
))
680 DECL_ALIGN (decl
) = EMPTY_FIELD_BOUNDARY
;
681 DECL_USER_ALIGN (decl
) = 0;
687 /* See if we can use an ordinary integer mode for a bit-field.
688 Conditions are: a fixed size that is correct for another mode,
689 occupying a complete byte or bytes on proper boundary. */
690 if (TYPE_SIZE (type
) != 0
691 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
692 && GET_MODE_CLASS (TYPE_MODE (type
)) == MODE_INT
)
695 = mode_for_size_tree (DECL_SIZE (decl
), MODE_INT
, 1);
696 unsigned int xalign
= GET_MODE_ALIGNMENT (xmode
);
699 && !(xalign
> BITS_PER_UNIT
&& DECL_PACKED (decl
))
700 && (known_align
== 0 || known_align
>= xalign
))
702 DECL_ALIGN (decl
) = MAX (xalign
, DECL_ALIGN (decl
));
703 DECL_MODE (decl
) = xmode
;
704 DECL_BIT_FIELD (decl
) = 0;
708 /* Turn off DECL_BIT_FIELD if we won't need it set. */
709 if (TYPE_MODE (type
) == BLKmode
&& DECL_MODE (decl
) == BLKmode
710 && known_align
>= TYPE_ALIGN (type
)
711 && DECL_ALIGN (decl
) >= TYPE_ALIGN (type
))
712 DECL_BIT_FIELD (decl
) = 0;
714 else if (packed_p
&& DECL_USER_ALIGN (decl
))
715 /* Don't touch DECL_ALIGN. For other packed fields, go ahead and
716 round up; we'll reduce it again below. We want packing to
717 supersede USER_ALIGN inherited from the type, but defer to
718 alignment explicitly specified on the field decl. */;
720 do_type_align (type
, decl
);
722 /* If the field is packed and not explicitly aligned, give it the
723 minimum alignment. Note that do_type_align may set
724 DECL_USER_ALIGN, so we need to check old_user_align instead. */
727 DECL_ALIGN (decl
) = MIN (DECL_ALIGN (decl
), BITS_PER_UNIT
);
729 if (! packed_p
&& ! DECL_USER_ALIGN (decl
))
731 /* Some targets (i.e. i386, VMS) limit struct field alignment
732 to a lower boundary than alignment of variables unless
733 it was overridden by attribute aligned. */
734 #ifdef BIGGEST_FIELD_ALIGNMENT
736 = MIN (DECL_ALIGN (decl
), (unsigned) BIGGEST_FIELD_ALIGNMENT
);
738 #ifdef ADJUST_FIELD_ALIGN
739 DECL_ALIGN (decl
) = ADJUST_FIELD_ALIGN (decl
, DECL_ALIGN (decl
));
744 mfa
= initial_max_fld_align
* BITS_PER_UNIT
;
746 mfa
= maximum_field_alignment
;
747 /* Should this be controlled by DECL_USER_ALIGN, too? */
749 DECL_ALIGN (decl
) = MIN (DECL_ALIGN (decl
), mfa
);
752 /* Evaluate nonconstant size only once, either now or as soon as safe. */
753 if (DECL_SIZE (decl
) != 0 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
754 DECL_SIZE (decl
) = variable_size (DECL_SIZE (decl
));
755 if (DECL_SIZE_UNIT (decl
) != 0
756 && TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
)
757 DECL_SIZE_UNIT (decl
) = variable_size (DECL_SIZE_UNIT (decl
));
759 /* If requested, warn about definitions of large data objects. */
761 && (code
== VAR_DECL
|| code
== PARM_DECL
)
762 && ! DECL_EXTERNAL (decl
))
764 tree size
= DECL_SIZE_UNIT (decl
);
766 if (size
!= 0 && TREE_CODE (size
) == INTEGER_CST
767 && compare_tree_int (size
, larger_than_size
) > 0)
769 int size_as_int
= TREE_INT_CST_LOW (size
);
771 if (compare_tree_int (size
, size_as_int
) == 0)
772 warning (OPT_Wlarger_than_
, "size of %q+D is %d bytes", decl
, size_as_int
);
774 warning (OPT_Wlarger_than_
, "size of %q+D is larger than %wd bytes",
775 decl
, larger_than_size
);
779 /* If the RTL was already set, update its mode and mem attributes. */
782 PUT_MODE (rtl
, DECL_MODE (decl
));
783 SET_DECL_RTL (decl
, 0);
785 set_mem_attributes (rtl
, decl
, 1);
786 SET_DECL_RTL (decl
, rtl
);
790 /* Given a VAR_DECL, PARM_DECL or RESULT_DECL, clears the results of
791 a previous call to layout_decl and calls it again. */
794 relayout_decl (tree decl
)
796 DECL_SIZE (decl
) = DECL_SIZE_UNIT (decl
) = 0;
797 DECL_MODE (decl
) = VOIDmode
;
798 if (!DECL_USER_ALIGN (decl
))
799 DECL_ALIGN (decl
) = 0;
800 SET_DECL_RTL (decl
, 0);
802 layout_decl (decl
, 0);
805 /* Begin laying out type T, which may be a RECORD_TYPE, UNION_TYPE, or
806 QUAL_UNION_TYPE. Return a pointer to a struct record_layout_info which
807 is to be passed to all other layout functions for this record. It is the
808 responsibility of the caller to call `free' for the storage returned.
809 Note that garbage collection is not permitted until we finish laying
813 start_record_layout (tree t
)
815 record_layout_info rli
= XNEW (struct record_layout_info_s
);
819 /* If the type has a minimum specified alignment (via an attribute
820 declaration, for example) use it -- otherwise, start with a
821 one-byte alignment. */
822 rli
->record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (t
));
823 rli
->unpacked_align
= rli
->record_align
;
824 rli
->offset_align
= MAX (rli
->record_align
, BIGGEST_ALIGNMENT
);
826 #ifdef STRUCTURE_SIZE_BOUNDARY
827 /* Packed structures don't need to have minimum size. */
828 if (! TYPE_PACKED (t
))
832 /* #pragma pack overrides STRUCTURE_SIZE_BOUNDARY. */
833 tmp
= (unsigned) STRUCTURE_SIZE_BOUNDARY
;
834 if (maximum_field_alignment
!= 0)
835 tmp
= MIN (tmp
, maximum_field_alignment
);
836 rli
->record_align
= MAX (rli
->record_align
, tmp
);
840 rli
->offset
= size_zero_node
;
841 rli
->bitpos
= bitsize_zero_node
;
843 rli
->pending_statics
= 0;
844 rli
->packed_maybe_necessary
= 0;
845 rli
->remaining_in_alignment
= 0;
850 /* Return the combined bit position for the byte offset OFFSET and the
853 These functions operate on byte and bit positions present in FIELD_DECLs
854 and assume that these expressions result in no (intermediate) overflow.
855 This assumption is necessary to fold the expressions as much as possible,
856 so as to avoid creating artificially variable-sized types in languages
857 supporting variable-sized types like Ada. */
860 bit_from_pos (tree offset
, tree bitpos
)
862 if (TREE_CODE (offset
) == PLUS_EXPR
)
863 offset
= size_binop (PLUS_EXPR
,
864 fold_convert (bitsizetype
, TREE_OPERAND (offset
, 0)),
865 fold_convert (bitsizetype
, TREE_OPERAND (offset
, 1)));
867 offset
= fold_convert (bitsizetype
, offset
);
868 return size_binop (PLUS_EXPR
, bitpos
,
869 size_binop (MULT_EXPR
, offset
, bitsize_unit_node
));
872 /* Return the combined truncated byte position for the byte offset OFFSET and
873 the bit position BITPOS. */
876 byte_from_pos (tree offset
, tree bitpos
)
879 if (TREE_CODE (bitpos
) == MULT_EXPR
880 && tree_int_cst_equal (TREE_OPERAND (bitpos
, 1), bitsize_unit_node
))
881 bytepos
= TREE_OPERAND (bitpos
, 0);
883 bytepos
= size_binop (TRUNC_DIV_EXPR
, bitpos
, bitsize_unit_node
);
884 return size_binop (PLUS_EXPR
, offset
, fold_convert (sizetype
, bytepos
));
887 /* Split the bit position POS into a byte offset *POFFSET and a bit
888 position *PBITPOS with the byte offset aligned to OFF_ALIGN bits. */
891 pos_from_bit (tree
*poffset
, tree
*pbitpos
, unsigned int off_align
,
894 tree toff_align
= bitsize_int (off_align
);
895 if (TREE_CODE (pos
) == MULT_EXPR
896 && tree_int_cst_equal (TREE_OPERAND (pos
, 1), toff_align
))
898 *poffset
= size_binop (MULT_EXPR
,
899 fold_convert (sizetype
, TREE_OPERAND (pos
, 0)),
900 size_int (off_align
/ BITS_PER_UNIT
));
901 *pbitpos
= bitsize_zero_node
;
905 *poffset
= size_binop (MULT_EXPR
,
906 fold_convert (sizetype
,
907 size_binop (FLOOR_DIV_EXPR
, pos
,
909 size_int (off_align
/ BITS_PER_UNIT
));
910 *pbitpos
= size_binop (FLOOR_MOD_EXPR
, pos
, toff_align
);
914 /* Given a pointer to bit and byte offsets and an offset alignment,
915 normalize the offsets so they are within the alignment. */
918 normalize_offset (tree
*poffset
, tree
*pbitpos
, unsigned int off_align
)
920 /* If the bit position is now larger than it should be, adjust it
922 if (compare_tree_int (*pbitpos
, off_align
) >= 0)
925 pos_from_bit (&offset
, &bitpos
, off_align
, *pbitpos
);
926 *poffset
= size_binop (PLUS_EXPR
, *poffset
, offset
);
931 /* Print debugging information about the information in RLI. */
934 debug_rli (record_layout_info rli
)
936 print_node_brief (stderr
, "type", rli
->t
, 0);
937 print_node_brief (stderr
, "\noffset", rli
->offset
, 0);
938 print_node_brief (stderr
, " bitpos", rli
->bitpos
, 0);
940 fprintf (stderr
, "\naligns: rec = %u, unpack = %u, off = %u\n",
941 rli
->record_align
, rli
->unpacked_align
,
944 /* The ms_struct code is the only that uses this. */
945 if (targetm
.ms_bitfield_layout_p (rli
->t
))
946 fprintf (stderr
, "remaining in alignment = %u\n", rli
->remaining_in_alignment
);
948 if (rli
->packed_maybe_necessary
)
949 fprintf (stderr
, "packed may be necessary\n");
951 if (!vec_safe_is_empty (rli
->pending_statics
))
953 fprintf (stderr
, "pending statics:\n");
954 debug_vec_tree (rli
->pending_statics
);
958 /* Given an RLI with a possibly-incremented BITPOS, adjust OFFSET and
959 BITPOS if necessary to keep BITPOS below OFFSET_ALIGN. */
962 normalize_rli (record_layout_info rli
)
964 normalize_offset (&rli
->offset
, &rli
->bitpos
, rli
->offset_align
);
967 /* Returns the size in bytes allocated so far. */
970 rli_size_unit_so_far (record_layout_info rli
)
972 return byte_from_pos (rli
->offset
, rli
->bitpos
);
975 /* Returns the size in bits allocated so far. */
978 rli_size_so_far (record_layout_info rli
)
980 return bit_from_pos (rli
->offset
, rli
->bitpos
);
983 /* FIELD is about to be added to RLI->T. The alignment (in bits) of
984 the next available location within the record is given by KNOWN_ALIGN.
985 Update the variable alignment fields in RLI, and return the alignment
986 to give the FIELD. */
989 update_alignment_for_field (record_layout_info rli
, tree field
,
990 unsigned int known_align
)
992 /* The alignment required for FIELD. */
993 unsigned int desired_align
;
994 /* The type of this field. */
995 tree type
= TREE_TYPE (field
);
996 /* True if the field was explicitly aligned by the user. */
1000 /* Do not attempt to align an ERROR_MARK node */
1001 if (TREE_CODE (type
) == ERROR_MARK
)
1004 /* Lay out the field so we know what alignment it needs. */
1005 layout_decl (field
, known_align
);
1006 desired_align
= DECL_ALIGN (field
);
1007 user_align
= DECL_USER_ALIGN (field
);
1009 is_bitfield
= (type
!= error_mark_node
1010 && DECL_BIT_FIELD_TYPE (field
)
1011 && ! integer_zerop (TYPE_SIZE (type
)));
1013 /* Record must have at least as much alignment as any field.
1014 Otherwise, the alignment of the field within the record is
1016 if (targetm
.ms_bitfield_layout_p (rli
->t
))
1018 /* Here, the alignment of the underlying type of a bitfield can
1019 affect the alignment of a record; even a zero-sized field
1020 can do this. The alignment should be to the alignment of
1021 the type, except that for zero-size bitfields this only
1022 applies if there was an immediately prior, nonzero-size
1023 bitfield. (That's the way it is, experimentally.) */
1024 if ((!is_bitfield
&& !DECL_PACKED (field
))
1025 || ((DECL_SIZE (field
) == NULL_TREE
1026 || !integer_zerop (DECL_SIZE (field
)))
1027 ? !DECL_PACKED (field
)
1029 && DECL_BIT_FIELD_TYPE (rli
->prev_field
)
1030 && ! integer_zerop (DECL_SIZE (rli
->prev_field
)))))
1032 unsigned int type_align
= TYPE_ALIGN (type
);
1033 type_align
= MAX (type_align
, desired_align
);
1034 if (maximum_field_alignment
!= 0)
1035 type_align
= MIN (type_align
, maximum_field_alignment
);
1036 rli
->record_align
= MAX (rli
->record_align
, type_align
);
1037 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
1040 else if (is_bitfield
&& PCC_BITFIELD_TYPE_MATTERS
)
1042 /* Named bit-fields cause the entire structure to have the
1043 alignment implied by their type. Some targets also apply the same
1044 rules to unnamed bitfields. */
1045 if (DECL_NAME (field
) != 0
1046 || targetm
.align_anon_bitfield ())
1048 unsigned int type_align
= TYPE_ALIGN (type
);
1050 #ifdef ADJUST_FIELD_ALIGN
1051 if (! TYPE_USER_ALIGN (type
))
1052 type_align
= ADJUST_FIELD_ALIGN (field
, type_align
);
1055 /* Targets might chose to handle unnamed and hence possibly
1056 zero-width bitfield. Those are not influenced by #pragmas
1057 or packed attributes. */
1058 if (integer_zerop (DECL_SIZE (field
)))
1060 if (initial_max_fld_align
)
1061 type_align
= MIN (type_align
,
1062 initial_max_fld_align
* BITS_PER_UNIT
);
1064 else if (maximum_field_alignment
!= 0)
1065 type_align
= MIN (type_align
, maximum_field_alignment
);
1066 else if (DECL_PACKED (field
))
1067 type_align
= MIN (type_align
, BITS_PER_UNIT
);
1069 /* The alignment of the record is increased to the maximum
1070 of the current alignment, the alignment indicated on the
1071 field (i.e., the alignment specified by an __aligned__
1072 attribute), and the alignment indicated by the type of
1074 rli
->record_align
= MAX (rli
->record_align
, desired_align
);
1075 rli
->record_align
= MAX (rli
->record_align
, type_align
);
1078 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
1079 user_align
|= TYPE_USER_ALIGN (type
);
1084 rli
->record_align
= MAX (rli
->record_align
, desired_align
);
1085 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
1088 TYPE_USER_ALIGN (rli
->t
) |= user_align
;
1090 return desired_align
;
1093 /* Called from place_field to handle unions. */
1096 place_union_field (record_layout_info rli
, tree field
)
1098 update_alignment_for_field (rli
, field
, /*known_align=*/0);
1100 DECL_FIELD_OFFSET (field
) = size_zero_node
;
1101 DECL_FIELD_BIT_OFFSET (field
) = bitsize_zero_node
;
1102 SET_DECL_OFFSET_ALIGN (field
, BIGGEST_ALIGNMENT
);
1104 /* If this is an ERROR_MARK return *after* having set the
1105 field at the start of the union. This helps when parsing
1107 if (TREE_CODE (TREE_TYPE (field
)) == ERROR_MARK
)
1110 /* We assume the union's size will be a multiple of a byte so we don't
1111 bother with BITPOS. */
1112 if (TREE_CODE (rli
->t
) == UNION_TYPE
)
1113 rli
->offset
= size_binop (MAX_EXPR
, rli
->offset
, DECL_SIZE_UNIT (field
));
1114 else if (TREE_CODE (rli
->t
) == QUAL_UNION_TYPE
)
1115 rli
->offset
= fold_build3 (COND_EXPR
, sizetype
, DECL_QUALIFIER (field
),
1116 DECL_SIZE_UNIT (field
), rli
->offset
);
1119 /* A bitfield of SIZE with a required access alignment of ALIGN is allocated
1120 at BYTE_OFFSET / BIT_OFFSET. Return nonzero if the field would span more
1121 units of alignment than the underlying TYPE. */
1123 excess_unit_span (HOST_WIDE_INT byte_offset
, HOST_WIDE_INT bit_offset
,
1124 HOST_WIDE_INT size
, HOST_WIDE_INT align
, tree type
)
1126 /* Note that the calculation of OFFSET might overflow; we calculate it so
1127 that we still get the right result as long as ALIGN is a power of two. */
1128 unsigned HOST_WIDE_INT offset
= byte_offset
* BITS_PER_UNIT
+ bit_offset
;
1130 offset
= offset
% align
;
1131 return ((offset
+ size
+ align
- 1) / align
1132 > tree_to_uhwi (TYPE_SIZE (type
)) / align
);
1135 /* RLI contains information about the layout of a RECORD_TYPE. FIELD
1136 is a FIELD_DECL to be added after those fields already present in
1137 T. (FIELD is not actually added to the TYPE_FIELDS list here;
1138 callers that desire that behavior must manually perform that step.) */
1141 place_field (record_layout_info rli
, tree field
)
1143 /* The alignment required for FIELD. */
1144 unsigned int desired_align
;
1145 /* The alignment FIELD would have if we just dropped it into the
1146 record as it presently stands. */
1147 unsigned int known_align
;
1148 unsigned int actual_align
;
1149 /* The type of this field. */
1150 tree type
= TREE_TYPE (field
);
1152 gcc_assert (TREE_CODE (field
) != ERROR_MARK
);
1154 /* If FIELD is static, then treat it like a separate variable, not
1155 really like a structure field. If it is a FUNCTION_DECL, it's a
1156 method. In both cases, all we do is lay out the decl, and we do
1157 it *after* the record is laid out. */
1158 if (TREE_CODE (field
) == VAR_DECL
)
1160 vec_safe_push (rli
->pending_statics
, field
);
1164 /* Enumerators and enum types which are local to this class need not
1165 be laid out. Likewise for initialized constant fields. */
1166 else if (TREE_CODE (field
) != FIELD_DECL
)
1169 /* Unions are laid out very differently than records, so split
1170 that code off to another function. */
1171 else if (TREE_CODE (rli
->t
) != RECORD_TYPE
)
1173 place_union_field (rli
, field
);
1177 else if (TREE_CODE (type
) == ERROR_MARK
)
1179 /* Place this field at the current allocation position, so we
1180 maintain monotonicity. */
1181 DECL_FIELD_OFFSET (field
) = rli
->offset
;
1182 DECL_FIELD_BIT_OFFSET (field
) = rli
->bitpos
;
1183 SET_DECL_OFFSET_ALIGN (field
, rli
->offset_align
);
1187 /* Work out the known alignment so far. Note that A & (-A) is the
1188 value of the least-significant bit in A that is one. */
1189 if (! integer_zerop (rli
->bitpos
))
1190 known_align
= (tree_to_uhwi (rli
->bitpos
)
1191 & - tree_to_uhwi (rli
->bitpos
));
1192 else if (integer_zerop (rli
->offset
))
1194 else if (tree_fits_uhwi_p (rli
->offset
))
1195 known_align
= (BITS_PER_UNIT
1196 * (tree_to_uhwi (rli
->offset
)
1197 & - tree_to_uhwi (rli
->offset
)));
1199 known_align
= rli
->offset_align
;
1201 desired_align
= update_alignment_for_field (rli
, field
, known_align
);
1202 if (known_align
== 0)
1203 known_align
= MAX (BIGGEST_ALIGNMENT
, rli
->record_align
);
1205 if (warn_packed
&& DECL_PACKED (field
))
1207 if (known_align
>= TYPE_ALIGN (type
))
1209 if (TYPE_ALIGN (type
) > desired_align
)
1211 if (STRICT_ALIGNMENT
)
1212 warning (OPT_Wattributes
, "packed attribute causes "
1213 "inefficient alignment for %q+D", field
);
1214 /* Don't warn if DECL_PACKED was set by the type. */
1215 else if (!TYPE_PACKED (rli
->t
))
1216 warning (OPT_Wattributes
, "packed attribute is "
1217 "unnecessary for %q+D", field
);
1221 rli
->packed_maybe_necessary
= 1;
1224 /* Does this field automatically have alignment it needs by virtue
1225 of the fields that precede it and the record's own alignment? */
1226 if (known_align
< desired_align
)
1228 /* No, we need to skip space before this field.
1229 Bump the cumulative size to multiple of field alignment. */
1231 if (!targetm
.ms_bitfield_layout_p (rli
->t
)
1232 && DECL_SOURCE_LOCATION (field
) != BUILTINS_LOCATION
)
1233 warning (OPT_Wpadded
, "padding struct to align %q+D", field
);
1235 /* If the alignment is still within offset_align, just align
1236 the bit position. */
1237 if (desired_align
< rli
->offset_align
)
1238 rli
->bitpos
= round_up (rli
->bitpos
, desired_align
);
1241 /* First adjust OFFSET by the partial bits, then align. */
1243 = size_binop (PLUS_EXPR
, rli
->offset
,
1244 fold_convert (sizetype
,
1245 size_binop (CEIL_DIV_EXPR
, rli
->bitpos
,
1246 bitsize_unit_node
)));
1247 rli
->bitpos
= bitsize_zero_node
;
1249 rli
->offset
= round_up (rli
->offset
, desired_align
/ BITS_PER_UNIT
);
1252 if (! TREE_CONSTANT (rli
->offset
))
1253 rli
->offset_align
= desired_align
;
1254 if (targetm
.ms_bitfield_layout_p (rli
->t
))
1255 rli
->prev_field
= NULL
;
1258 /* Handle compatibility with PCC. Note that if the record has any
1259 variable-sized fields, we need not worry about compatibility. */
1260 if (PCC_BITFIELD_TYPE_MATTERS
1261 && ! targetm
.ms_bitfield_layout_p (rli
->t
)
1262 && TREE_CODE (field
) == FIELD_DECL
1263 && type
!= error_mark_node
1264 && DECL_BIT_FIELD (field
)
1265 && (! DECL_PACKED (field
)
1266 /* Enter for these packed fields only to issue a warning. */
1267 || TYPE_ALIGN (type
) <= BITS_PER_UNIT
)
1268 && maximum_field_alignment
== 0
1269 && ! integer_zerop (DECL_SIZE (field
))
1270 && tree_fits_uhwi_p (DECL_SIZE (field
))
1271 && tree_fits_uhwi_p (rli
->offset
)
1272 && tree_fits_uhwi_p (TYPE_SIZE (type
)))
1274 unsigned int type_align
= TYPE_ALIGN (type
);
1275 tree dsize
= DECL_SIZE (field
);
1276 HOST_WIDE_INT field_size
= tree_to_uhwi (dsize
);
1277 HOST_WIDE_INT offset
= tree_to_uhwi (rli
->offset
);
1278 HOST_WIDE_INT bit_offset
= tree_to_shwi (rli
->bitpos
);
1280 #ifdef ADJUST_FIELD_ALIGN
1281 if (! TYPE_USER_ALIGN (type
))
1282 type_align
= ADJUST_FIELD_ALIGN (field
, type_align
);
1285 /* A bit field may not span more units of alignment of its type
1286 than its type itself. Advance to next boundary if necessary. */
1287 if (excess_unit_span (offset
, bit_offset
, field_size
, type_align
, type
))
1289 if (DECL_PACKED (field
))
1291 if (warn_packed_bitfield_compat
== 1)
1294 "offset of packed bit-field %qD has changed in GCC 4.4",
1298 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1301 if (! DECL_PACKED (field
))
1302 TYPE_USER_ALIGN (rli
->t
) |= TYPE_USER_ALIGN (type
);
1305 #ifdef BITFIELD_NBYTES_LIMITED
1306 if (BITFIELD_NBYTES_LIMITED
1307 && ! targetm
.ms_bitfield_layout_p (rli
->t
)
1308 && TREE_CODE (field
) == FIELD_DECL
1309 && type
!= error_mark_node
1310 && DECL_BIT_FIELD_TYPE (field
)
1311 && ! DECL_PACKED (field
)
1312 && ! integer_zerop (DECL_SIZE (field
))
1313 && tree_fits_uhwi_p (DECL_SIZE (field
))
1314 && tree_fits_uhwi_p (rli
->offset
)
1315 && tree_fits_uhwi_p (TYPE_SIZE (type
)))
1317 unsigned int type_align
= TYPE_ALIGN (type
);
1318 tree dsize
= DECL_SIZE (field
);
1319 HOST_WIDE_INT field_size
= tree_to_uhwi (dsize
);
1320 HOST_WIDE_INT offset
= tree_to_uhwi (rli
->offset
);
1321 HOST_WIDE_INT bit_offset
= tree_to_shwi (rli
->bitpos
);
1323 #ifdef ADJUST_FIELD_ALIGN
1324 if (! TYPE_USER_ALIGN (type
))
1325 type_align
= ADJUST_FIELD_ALIGN (field
, type_align
);
1328 if (maximum_field_alignment
!= 0)
1329 type_align
= MIN (type_align
, maximum_field_alignment
);
1330 /* ??? This test is opposite the test in the containing if
1331 statement, so this code is unreachable currently. */
1332 else if (DECL_PACKED (field
))
1333 type_align
= MIN (type_align
, BITS_PER_UNIT
);
1335 /* A bit field may not span the unit of alignment of its type.
1336 Advance to next boundary if necessary. */
1337 if (excess_unit_span (offset
, bit_offset
, field_size
, type_align
, type
))
1338 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1340 TYPE_USER_ALIGN (rli
->t
) |= TYPE_USER_ALIGN (type
);
1344 /* See the docs for TARGET_MS_BITFIELD_LAYOUT_P for details.
1346 When a bit field is inserted into a packed record, the whole
1347 size of the underlying type is used by one or more same-size
1348 adjacent bitfields. (That is, if its long:3, 32 bits is
1349 used in the record, and any additional adjacent long bitfields are
1350 packed into the same chunk of 32 bits. However, if the size
1351 changes, a new field of that size is allocated.) In an unpacked
1352 record, this is the same as using alignment, but not equivalent
1355 Note: for compatibility, we use the type size, not the type alignment
1356 to determine alignment, since that matches the documentation */
1358 if (targetm
.ms_bitfield_layout_p (rli
->t
))
1360 tree prev_saved
= rli
->prev_field
;
1361 tree prev_type
= prev_saved
? DECL_BIT_FIELD_TYPE (prev_saved
) : NULL
;
1363 /* This is a bitfield if it exists. */
1364 if (rli
->prev_field
)
1366 /* If both are bitfields, nonzero, and the same size, this is
1367 the middle of a run. Zero declared size fields are special
1368 and handled as "end of run". (Note: it's nonzero declared
1369 size, but equal type sizes!) (Since we know that both
1370 the current and previous fields are bitfields by the
1371 time we check it, DECL_SIZE must be present for both.) */
1372 if (DECL_BIT_FIELD_TYPE (field
)
1373 && !integer_zerop (DECL_SIZE (field
))
1374 && !integer_zerop (DECL_SIZE (rli
->prev_field
))
1375 && tree_fits_shwi_p (DECL_SIZE (rli
->prev_field
))
1376 && tree_fits_uhwi_p (TYPE_SIZE (type
))
1377 && simple_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (prev_type
)))
1379 /* We're in the middle of a run of equal type size fields; make
1380 sure we realign if we run out of bits. (Not decl size,
1382 HOST_WIDE_INT bitsize
= tree_to_uhwi (DECL_SIZE (field
));
1384 if (rli
->remaining_in_alignment
< bitsize
)
1386 HOST_WIDE_INT typesize
= tree_to_uhwi (TYPE_SIZE (type
));
1388 /* out of bits; bump up to next 'word'. */
1390 = size_binop (PLUS_EXPR
, rli
->bitpos
,
1391 bitsize_int (rli
->remaining_in_alignment
));
1392 rli
->prev_field
= field
;
1393 if (typesize
< bitsize
)
1394 rli
->remaining_in_alignment
= 0;
1396 rli
->remaining_in_alignment
= typesize
- bitsize
;
1399 rli
->remaining_in_alignment
-= bitsize
;
1403 /* End of a run: if leaving a run of bitfields of the same type
1404 size, we have to "use up" the rest of the bits of the type
1407 Compute the new position as the sum of the size for the prior
1408 type and where we first started working on that type.
1409 Note: since the beginning of the field was aligned then
1410 of course the end will be too. No round needed. */
1412 if (!integer_zerop (DECL_SIZE (rli
->prev_field
)))
1415 = size_binop (PLUS_EXPR
, rli
->bitpos
,
1416 bitsize_int (rli
->remaining_in_alignment
));
1419 /* We "use up" size zero fields; the code below should behave
1420 as if the prior field was not a bitfield. */
1423 /* Cause a new bitfield to be captured, either this time (if
1424 currently a bitfield) or next time we see one. */
1425 if (!DECL_BIT_FIELD_TYPE (field
)
1426 || integer_zerop (DECL_SIZE (field
)))
1427 rli
->prev_field
= NULL
;
1430 normalize_rli (rli
);
1433 /* If we're starting a new run of same type size bitfields
1434 (or a run of non-bitfields), set up the "first of the run"
1437 That is, if the current field is not a bitfield, or if there
1438 was a prior bitfield the type sizes differ, or if there wasn't
1439 a prior bitfield the size of the current field is nonzero.
1441 Note: we must be sure to test ONLY the type size if there was
1442 a prior bitfield and ONLY for the current field being zero if
1445 if (!DECL_BIT_FIELD_TYPE (field
)
1446 || (prev_saved
!= NULL
1447 ? !simple_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (prev_type
))
1448 : !integer_zerop (DECL_SIZE (field
)) ))
1450 /* Never smaller than a byte for compatibility. */
1451 unsigned int type_align
= BITS_PER_UNIT
;
1453 /* (When not a bitfield), we could be seeing a flex array (with
1454 no DECL_SIZE). Since we won't be using remaining_in_alignment
1455 until we see a bitfield (and come by here again) we just skip
1457 if (DECL_SIZE (field
) != NULL
1458 && tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (field
)))
1459 && tree_fits_uhwi_p (DECL_SIZE (field
)))
1461 unsigned HOST_WIDE_INT bitsize
1462 = tree_to_uhwi (DECL_SIZE (field
));
1463 unsigned HOST_WIDE_INT typesize
1464 = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (field
)));
1466 if (typesize
< bitsize
)
1467 rli
->remaining_in_alignment
= 0;
1469 rli
->remaining_in_alignment
= typesize
- bitsize
;
1472 /* Now align (conventionally) for the new type. */
1473 type_align
= TYPE_ALIGN (TREE_TYPE (field
));
1475 if (maximum_field_alignment
!= 0)
1476 type_align
= MIN (type_align
, maximum_field_alignment
);
1478 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1480 /* If we really aligned, don't allow subsequent bitfields
1482 rli
->prev_field
= NULL
;
1486 /* Offset so far becomes the position of this field after normalizing. */
1487 normalize_rli (rli
);
1488 DECL_FIELD_OFFSET (field
) = rli
->offset
;
1489 DECL_FIELD_BIT_OFFSET (field
) = rli
->bitpos
;
1490 SET_DECL_OFFSET_ALIGN (field
, rli
->offset_align
);
1492 /* Evaluate nonconstant offsets only once, either now or as soon as safe. */
1493 if (TREE_CODE (DECL_FIELD_OFFSET (field
)) != INTEGER_CST
)
1494 DECL_FIELD_OFFSET (field
) = variable_size (DECL_FIELD_OFFSET (field
));
1496 /* If this field ended up more aligned than we thought it would be (we
1497 approximate this by seeing if its position changed), lay out the field
1498 again; perhaps we can use an integral mode for it now. */
1499 if (! integer_zerop (DECL_FIELD_BIT_OFFSET (field
)))
1500 actual_align
= (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field
))
1501 & - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field
)));
1502 else if (integer_zerop (DECL_FIELD_OFFSET (field
)))
1503 actual_align
= MAX (BIGGEST_ALIGNMENT
, rli
->record_align
);
1504 else if (tree_fits_uhwi_p (DECL_FIELD_OFFSET (field
)))
1505 actual_align
= (BITS_PER_UNIT
1506 * (tree_to_uhwi (DECL_FIELD_OFFSET (field
))
1507 & - tree_to_uhwi (DECL_FIELD_OFFSET (field
))));
1509 actual_align
= DECL_OFFSET_ALIGN (field
);
1510 /* ACTUAL_ALIGN is still the actual alignment *within the record* .
1511 store / extract bit field operations will check the alignment of the
1512 record against the mode of bit fields. */
1514 if (known_align
!= actual_align
)
1515 layout_decl (field
, actual_align
);
1517 if (rli
->prev_field
== NULL
&& DECL_BIT_FIELD_TYPE (field
))
1518 rli
->prev_field
= field
;
1520 /* Now add size of this field to the size of the record. If the size is
1521 not constant, treat the field as being a multiple of bytes and just
1522 adjust the offset, resetting the bit position. Otherwise, apportion the
1523 size amongst the bit position and offset. First handle the case of an
1524 unspecified size, which can happen when we have an invalid nested struct
1525 definition, such as struct j { struct j { int i; } }. The error message
1526 is printed in finish_struct. */
1527 if (DECL_SIZE (field
) == 0)
1529 else if (TREE_CODE (DECL_SIZE (field
)) != INTEGER_CST
1530 || TREE_OVERFLOW (DECL_SIZE (field
)))
1533 = size_binop (PLUS_EXPR
, rli
->offset
,
1534 fold_convert (sizetype
,
1535 size_binop (CEIL_DIV_EXPR
, rli
->bitpos
,
1536 bitsize_unit_node
)));
1538 = size_binop (PLUS_EXPR
, rli
->offset
, DECL_SIZE_UNIT (field
));
1539 rli
->bitpos
= bitsize_zero_node
;
1540 rli
->offset_align
= MIN (rli
->offset_align
, desired_align
);
1542 else if (targetm
.ms_bitfield_layout_p (rli
->t
))
1544 rli
->bitpos
= size_binop (PLUS_EXPR
, rli
->bitpos
, DECL_SIZE (field
));
1546 /* If we ended a bitfield before the full length of the type then
1547 pad the struct out to the full length of the last type. */
1548 if ((DECL_CHAIN (field
) == NULL
1549 || TREE_CODE (DECL_CHAIN (field
)) != FIELD_DECL
)
1550 && DECL_BIT_FIELD_TYPE (field
)
1551 && !integer_zerop (DECL_SIZE (field
)))
1552 rli
->bitpos
= size_binop (PLUS_EXPR
, rli
->bitpos
,
1553 bitsize_int (rli
->remaining_in_alignment
));
1555 normalize_rli (rli
);
1559 rli
->bitpos
= size_binop (PLUS_EXPR
, rli
->bitpos
, DECL_SIZE (field
));
1560 normalize_rli (rli
);
1564 /* Assuming that all the fields have been laid out, this function uses
1565 RLI to compute the final TYPE_SIZE, TYPE_ALIGN, etc. for the type
1566 indicated by RLI. */
1569 finalize_record_size (record_layout_info rli
)
1571 tree unpadded_size
, unpadded_size_unit
;
1573 /* Now we want just byte and bit offsets, so set the offset alignment
1574 to be a byte and then normalize. */
1575 rli
->offset_align
= BITS_PER_UNIT
;
1576 normalize_rli (rli
);
1578 /* Determine the desired alignment. */
1579 #ifdef ROUND_TYPE_ALIGN
1580 TYPE_ALIGN (rli
->t
) = ROUND_TYPE_ALIGN (rli
->t
, TYPE_ALIGN (rli
->t
),
1583 TYPE_ALIGN (rli
->t
) = MAX (TYPE_ALIGN (rli
->t
), rli
->record_align
);
1586 /* Compute the size so far. Be sure to allow for extra bits in the
1587 size in bytes. We have guaranteed above that it will be no more
1588 than a single byte. */
1589 unpadded_size
= rli_size_so_far (rli
);
1590 unpadded_size_unit
= rli_size_unit_so_far (rli
);
1591 if (! integer_zerop (rli
->bitpos
))
1593 = size_binop (PLUS_EXPR
, unpadded_size_unit
, size_one_node
);
1595 /* Round the size up to be a multiple of the required alignment. */
1596 TYPE_SIZE (rli
->t
) = round_up (unpadded_size
, TYPE_ALIGN (rli
->t
));
1597 TYPE_SIZE_UNIT (rli
->t
)
1598 = round_up (unpadded_size_unit
, TYPE_ALIGN_UNIT (rli
->t
));
1600 if (TREE_CONSTANT (unpadded_size
)
1601 && simple_cst_equal (unpadded_size
, TYPE_SIZE (rli
->t
)) == 0
1602 && input_location
!= BUILTINS_LOCATION
)
1603 warning (OPT_Wpadded
, "padding struct size to alignment boundary");
1605 if (warn_packed
&& TREE_CODE (rli
->t
) == RECORD_TYPE
1606 && TYPE_PACKED (rli
->t
) && ! rli
->packed_maybe_necessary
1607 && TREE_CONSTANT (unpadded_size
))
1611 #ifdef ROUND_TYPE_ALIGN
1613 = ROUND_TYPE_ALIGN (rli
->t
, TYPE_ALIGN (rli
->t
), rli
->unpacked_align
);
1615 rli
->unpacked_align
= MAX (TYPE_ALIGN (rli
->t
), rli
->unpacked_align
);
1618 unpacked_size
= round_up (TYPE_SIZE (rli
->t
), rli
->unpacked_align
);
1619 if (simple_cst_equal (unpacked_size
, TYPE_SIZE (rli
->t
)))
1621 if (TYPE_NAME (rli
->t
))
1625 if (TREE_CODE (TYPE_NAME (rli
->t
)) == IDENTIFIER_NODE
)
1626 name
= TYPE_NAME (rli
->t
);
1628 name
= DECL_NAME (TYPE_NAME (rli
->t
));
1630 if (STRICT_ALIGNMENT
)
1631 warning (OPT_Wpacked
, "packed attribute causes inefficient "
1632 "alignment for %qE", name
);
1634 warning (OPT_Wpacked
,
1635 "packed attribute is unnecessary for %qE", name
);
1639 if (STRICT_ALIGNMENT
)
1640 warning (OPT_Wpacked
,
1641 "packed attribute causes inefficient alignment");
1643 warning (OPT_Wpacked
, "packed attribute is unnecessary");
1649 /* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE). */
1652 compute_record_mode (tree type
)
1655 machine_mode mode
= VOIDmode
;
1657 /* Most RECORD_TYPEs have BLKmode, so we start off assuming that.
1658 However, if possible, we use a mode that fits in a register
1659 instead, in order to allow for better optimization down the
1661 SET_TYPE_MODE (type
, BLKmode
);
1663 if (! tree_fits_uhwi_p (TYPE_SIZE (type
)))
1666 /* A record which has any BLKmode members must itself be
1667 BLKmode; it can't go in a register. Unless the member is
1668 BLKmode only because it isn't aligned. */
1669 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1671 if (TREE_CODE (field
) != FIELD_DECL
)
1674 if (TREE_CODE (TREE_TYPE (field
)) == ERROR_MARK
1675 || (TYPE_MODE (TREE_TYPE (field
)) == BLKmode
1676 && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field
))
1677 && !(TYPE_SIZE (TREE_TYPE (field
)) != 0
1678 && integer_zerop (TYPE_SIZE (TREE_TYPE (field
)))))
1679 || ! tree_fits_uhwi_p (bit_position (field
))
1680 || DECL_SIZE (field
) == 0
1681 || ! tree_fits_uhwi_p (DECL_SIZE (field
)))
1684 /* If this field is the whole struct, remember its mode so
1685 that, say, we can put a double in a class into a DF
1686 register instead of forcing it to live in the stack. */
1687 if (simple_cst_equal (TYPE_SIZE (type
), DECL_SIZE (field
)))
1688 mode
= DECL_MODE (field
);
1690 /* With some targets, it is sub-optimal to access an aligned
1691 BLKmode structure as a scalar. */
1692 if (targetm
.member_type_forces_blk (field
, mode
))
1696 /* If we only have one real field; use its mode if that mode's size
1697 matches the type's size. This only applies to RECORD_TYPE. This
1698 does not apply to unions. */
1699 if (TREE_CODE (type
) == RECORD_TYPE
&& mode
!= VOIDmode
1700 && tree_fits_uhwi_p (TYPE_SIZE (type
))
1701 && GET_MODE_BITSIZE (mode
) == tree_to_uhwi (TYPE_SIZE (type
)))
1702 SET_TYPE_MODE (type
, mode
);
1704 SET_TYPE_MODE (type
, mode_for_size_tree (TYPE_SIZE (type
), MODE_INT
, 1));
1706 /* If structure's known alignment is less than what the scalar
1707 mode would need, and it matters, then stick with BLKmode. */
1708 if (TYPE_MODE (type
) != BLKmode
1710 && ! (TYPE_ALIGN (type
) >= BIGGEST_ALIGNMENT
1711 || TYPE_ALIGN (type
) >= GET_MODE_ALIGNMENT (TYPE_MODE (type
))))
1713 /* If this is the only reason this type is BLKmode, then
1714 don't force containing types to be BLKmode. */
1715 TYPE_NO_FORCE_BLK (type
) = 1;
1716 SET_TYPE_MODE (type
, BLKmode
);
1720 /* Compute TYPE_SIZE and TYPE_ALIGN for TYPE, once it has been laid
1724 finalize_type_size (tree type
)
1726 /* Normally, use the alignment corresponding to the mode chosen.
1727 However, where strict alignment is not required, avoid
1728 over-aligning structures, since most compilers do not do this
1730 if (TYPE_MODE (type
) != BLKmode
1731 && TYPE_MODE (type
) != VOIDmode
1732 && (STRICT_ALIGNMENT
|| !AGGREGATE_TYPE_P (type
)))
1734 unsigned mode_align
= GET_MODE_ALIGNMENT (TYPE_MODE (type
));
1736 /* Don't override a larger alignment requirement coming from a user
1737 alignment of one of the fields. */
1738 if (mode_align
>= TYPE_ALIGN (type
))
1740 TYPE_ALIGN (type
) = mode_align
;
1741 TYPE_USER_ALIGN (type
) = 0;
1745 /* Do machine-dependent extra alignment. */
1746 #ifdef ROUND_TYPE_ALIGN
1748 = ROUND_TYPE_ALIGN (type
, TYPE_ALIGN (type
), BITS_PER_UNIT
);
1751 /* If we failed to find a simple way to calculate the unit size
1752 of the type, find it by division. */
1753 if (TYPE_SIZE_UNIT (type
) == 0 && TYPE_SIZE (type
) != 0)
1754 /* TYPE_SIZE (type) is computed in bitsizetype. After the division, the
1755 result will fit in sizetype. We will get more efficient code using
1756 sizetype, so we force a conversion. */
1757 TYPE_SIZE_UNIT (type
)
1758 = fold_convert (sizetype
,
1759 size_binop (FLOOR_DIV_EXPR
, TYPE_SIZE (type
),
1760 bitsize_unit_node
));
1762 if (TYPE_SIZE (type
) != 0)
1764 TYPE_SIZE (type
) = round_up (TYPE_SIZE (type
), TYPE_ALIGN (type
));
1765 TYPE_SIZE_UNIT (type
)
1766 = round_up (TYPE_SIZE_UNIT (type
), TYPE_ALIGN_UNIT (type
));
1769 /* Evaluate nonconstant sizes only once, either now or as soon as safe. */
1770 if (TYPE_SIZE (type
) != 0 && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1771 TYPE_SIZE (type
) = variable_size (TYPE_SIZE (type
));
1772 if (TYPE_SIZE_UNIT (type
) != 0
1773 && TREE_CODE (TYPE_SIZE_UNIT (type
)) != INTEGER_CST
)
1774 TYPE_SIZE_UNIT (type
) = variable_size (TYPE_SIZE_UNIT (type
));
1776 /* Also layout any other variants of the type. */
1777 if (TYPE_NEXT_VARIANT (type
)
1778 || type
!= TYPE_MAIN_VARIANT (type
))
1781 /* Record layout info of this variant. */
1782 tree size
= TYPE_SIZE (type
);
1783 tree size_unit
= TYPE_SIZE_UNIT (type
);
1784 unsigned int align
= TYPE_ALIGN (type
);
1785 unsigned int precision
= TYPE_PRECISION (type
);
1786 unsigned int user_align
= TYPE_USER_ALIGN (type
);
1787 machine_mode mode
= TYPE_MODE (type
);
1789 /* Copy it into all variants. */
1790 for (variant
= TYPE_MAIN_VARIANT (type
);
1792 variant
= TYPE_NEXT_VARIANT (variant
))
1794 TYPE_SIZE (variant
) = size
;
1795 TYPE_SIZE_UNIT (variant
) = size_unit
;
1796 unsigned valign
= align
;
1797 if (TYPE_USER_ALIGN (variant
))
1798 valign
= MAX (valign
, TYPE_ALIGN (variant
));
1800 TYPE_USER_ALIGN (variant
) = user_align
;
1801 TYPE_ALIGN (variant
) = valign
;
1802 TYPE_PRECISION (variant
) = precision
;
1803 SET_TYPE_MODE (variant
, mode
);
1808 /* Return a new underlying object for a bitfield started with FIELD. */
1811 start_bitfield_representative (tree field
)
1813 tree repr
= make_node (FIELD_DECL
);
1814 DECL_FIELD_OFFSET (repr
) = DECL_FIELD_OFFSET (field
);
1815 /* Force the representative to begin at a BITS_PER_UNIT aligned
1816 boundary - C++ may use tail-padding of a base object to
1817 continue packing bits so the bitfield region does not start
1818 at bit zero (see g++.dg/abi/bitfield5.C for example).
1819 Unallocated bits may happen for other reasons as well,
1820 for example Ada which allows explicit bit-granular structure layout. */
1821 DECL_FIELD_BIT_OFFSET (repr
)
1822 = size_binop (BIT_AND_EXPR
,
1823 DECL_FIELD_BIT_OFFSET (field
),
1824 bitsize_int (~(BITS_PER_UNIT
- 1)));
1825 SET_DECL_OFFSET_ALIGN (repr
, DECL_OFFSET_ALIGN (field
));
1826 DECL_SIZE (repr
) = DECL_SIZE (field
);
1827 DECL_SIZE_UNIT (repr
) = DECL_SIZE_UNIT (field
);
1828 DECL_PACKED (repr
) = DECL_PACKED (field
);
1829 DECL_CONTEXT (repr
) = DECL_CONTEXT (field
);
1833 /* Finish up a bitfield group that was started by creating the underlying
1834 object REPR with the last field in the bitfield group FIELD. */
1837 finish_bitfield_representative (tree repr
, tree field
)
1839 unsigned HOST_WIDE_INT bitsize
, maxbitsize
;
1843 size
= size_diffop (DECL_FIELD_OFFSET (field
),
1844 DECL_FIELD_OFFSET (repr
));
1845 while (TREE_CODE (size
) == COMPOUND_EXPR
)
1846 size
= TREE_OPERAND (size
, 1);
1847 gcc_assert (tree_fits_uhwi_p (size
));
1848 bitsize
= (tree_to_uhwi (size
) * BITS_PER_UNIT
1849 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field
))
1850 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr
))
1851 + tree_to_uhwi (DECL_SIZE (field
)));
1853 /* Round up bitsize to multiples of BITS_PER_UNIT. */
1854 bitsize
= (bitsize
+ BITS_PER_UNIT
- 1) & ~(BITS_PER_UNIT
- 1);
1856 /* Now nothing tells us how to pad out bitsize ... */
1857 nextf
= DECL_CHAIN (field
);
1858 while (nextf
&& TREE_CODE (nextf
) != FIELD_DECL
)
1859 nextf
= DECL_CHAIN (nextf
);
1863 /* If there was an error, the field may be not laid out
1864 correctly. Don't bother to do anything. */
1865 if (TREE_TYPE (nextf
) == error_mark_node
)
1867 maxsize
= size_diffop (DECL_FIELD_OFFSET (nextf
),
1868 DECL_FIELD_OFFSET (repr
));
1869 if (tree_fits_uhwi_p (maxsize
))
1871 maxbitsize
= (tree_to_uhwi (maxsize
) * BITS_PER_UNIT
1872 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (nextf
))
1873 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr
)));
1874 /* If the group ends within a bitfield nextf does not need to be
1875 aligned to BITS_PER_UNIT. Thus round up. */
1876 maxbitsize
= (maxbitsize
+ BITS_PER_UNIT
- 1) & ~(BITS_PER_UNIT
- 1);
1879 maxbitsize
= bitsize
;
1883 /* ??? If you consider that tail-padding of this struct might be
1884 re-used when deriving from it we cannot really do the following
1885 and thus need to set maxsize to bitsize? Also we cannot
1886 generally rely on maxsize to fold to an integer constant, so
1887 use bitsize as fallback for this case. */
1888 tree maxsize
= size_diffop (TYPE_SIZE_UNIT (DECL_CONTEXT (field
)),
1889 DECL_FIELD_OFFSET (repr
));
1890 if (tree_fits_uhwi_p (maxsize
))
1891 maxbitsize
= (tree_to_uhwi (maxsize
) * BITS_PER_UNIT
1892 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr
)));
1894 maxbitsize
= bitsize
;
1897 /* Only if we don't artificially break up the representative in
1898 the middle of a large bitfield with different possibly
1899 overlapping representatives. And all representatives start
1901 gcc_assert (maxbitsize
% BITS_PER_UNIT
== 0);
1903 /* Find the smallest nice mode to use. */
1904 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_INT
); mode
!= VOIDmode
;
1905 mode
= GET_MODE_WIDER_MODE (mode
))
1906 if (GET_MODE_BITSIZE (mode
) >= bitsize
)
1908 if (mode
!= VOIDmode
1909 && (GET_MODE_BITSIZE (mode
) > maxbitsize
1910 || GET_MODE_BITSIZE (mode
) > MAX_FIXED_MODE_SIZE
))
1913 if (mode
== VOIDmode
)
1915 /* We really want a BLKmode representative only as a last resort,
1916 considering the member b in
1917 struct { int a : 7; int b : 17; int c; } __attribute__((packed));
1918 Otherwise we simply want to split the representative up
1919 allowing for overlaps within the bitfield region as required for
1920 struct { int a : 7; int b : 7;
1921 int c : 10; int d; } __attribute__((packed));
1922 [0, 15] HImode for a and b, [8, 23] HImode for c. */
1923 DECL_SIZE (repr
) = bitsize_int (bitsize
);
1924 DECL_SIZE_UNIT (repr
) = size_int (bitsize
/ BITS_PER_UNIT
);
1925 DECL_MODE (repr
) = BLKmode
;
1926 TREE_TYPE (repr
) = build_array_type_nelts (unsigned_char_type_node
,
1927 bitsize
/ BITS_PER_UNIT
);
1931 unsigned HOST_WIDE_INT modesize
= GET_MODE_BITSIZE (mode
);
1932 DECL_SIZE (repr
) = bitsize_int (modesize
);
1933 DECL_SIZE_UNIT (repr
) = size_int (modesize
/ BITS_PER_UNIT
);
1934 DECL_MODE (repr
) = mode
;
1935 TREE_TYPE (repr
) = lang_hooks
.types
.type_for_mode (mode
, 1);
1938 /* Remember whether the bitfield group is at the end of the
1939 structure or not. */
1940 DECL_CHAIN (repr
) = nextf
;
1943 /* Compute and set FIELD_DECLs for the underlying objects we should
1944 use for bitfield access for the structure T. */
1947 finish_bitfield_layout (tree t
)
1950 tree repr
= NULL_TREE
;
1952 /* Unions would be special, for the ease of type-punning optimizations
1953 we could use the underlying type as hint for the representative
1954 if the bitfield would fit and the representative would not exceed
1955 the union in size. */
1956 if (TREE_CODE (t
) != RECORD_TYPE
)
1959 for (prev
= NULL_TREE
, field
= TYPE_FIELDS (t
);
1960 field
; field
= DECL_CHAIN (field
))
1962 if (TREE_CODE (field
) != FIELD_DECL
)
1965 /* In the C++ memory model, consecutive bit fields in a structure are
1966 considered one memory location and updating a memory location
1967 may not store into adjacent memory locations. */
1969 && DECL_BIT_FIELD_TYPE (field
))
1971 /* Start new representative. */
1972 repr
= start_bitfield_representative (field
);
1975 && ! DECL_BIT_FIELD_TYPE (field
))
1977 /* Finish off new representative. */
1978 finish_bitfield_representative (repr
, prev
);
1981 else if (DECL_BIT_FIELD_TYPE (field
))
1983 gcc_assert (repr
!= NULL_TREE
);
1985 /* Zero-size bitfields finish off a representative and
1986 do not have a representative themselves. This is
1987 required by the C++ memory model. */
1988 if (integer_zerop (DECL_SIZE (field
)))
1990 finish_bitfield_representative (repr
, prev
);
1994 /* We assume that either DECL_FIELD_OFFSET of the representative
1995 and each bitfield member is a constant or they are equal.
1996 This is because we need to be able to compute the bit-offset
1997 of each field relative to the representative in get_bit_range
1998 during RTL expansion.
1999 If these constraints are not met, simply force a new
2000 representative to be generated. That will at most
2001 generate worse code but still maintain correctness with
2002 respect to the C++ memory model. */
2003 else if (!((tree_fits_uhwi_p (DECL_FIELD_OFFSET (repr
))
2004 && tree_fits_uhwi_p (DECL_FIELD_OFFSET (field
)))
2005 || operand_equal_p (DECL_FIELD_OFFSET (repr
),
2006 DECL_FIELD_OFFSET (field
), 0)))
2008 finish_bitfield_representative (repr
, prev
);
2009 repr
= start_bitfield_representative (field
);
2016 DECL_BIT_FIELD_REPRESENTATIVE (field
) = repr
;
2022 finish_bitfield_representative (repr
, prev
);
2025 /* Do all of the work required to layout the type indicated by RLI,
2026 once the fields have been laid out. This function will call `free'
2027 for RLI, unless FREE_P is false. Passing a value other than false
2028 for FREE_P is bad practice; this option only exists to support the
2032 finish_record_layout (record_layout_info rli
, int free_p
)
2036 /* Compute the final size. */
2037 finalize_record_size (rli
);
2039 /* Compute the TYPE_MODE for the record. */
2040 compute_record_mode (rli
->t
);
2042 /* Perform any last tweaks to the TYPE_SIZE, etc. */
2043 finalize_type_size (rli
->t
);
2045 /* Compute bitfield representatives. */
2046 finish_bitfield_layout (rli
->t
);
2048 /* Propagate TYPE_PACKED to variants. With C++ templates,
2049 handle_packed_attribute is too early to do this. */
2050 for (variant
= TYPE_NEXT_VARIANT (rli
->t
); variant
;
2051 variant
= TYPE_NEXT_VARIANT (variant
))
2052 TYPE_PACKED (variant
) = TYPE_PACKED (rli
->t
);
2054 /* Lay out any static members. This is done now because their type
2055 may use the record's type. */
2056 while (!vec_safe_is_empty (rli
->pending_statics
))
2057 layout_decl (rli
->pending_statics
->pop (), 0);
2062 vec_free (rli
->pending_statics
);
2068 /* Finish processing a builtin RECORD_TYPE type TYPE. It's name is
2069 NAME, its fields are chained in reverse on FIELDS.
2071 If ALIGN_TYPE is non-null, it is given the same alignment as
2075 finish_builtin_struct (tree type
, const char *name
, tree fields
,
2080 for (tail
= NULL_TREE
; fields
; tail
= fields
, fields
= next
)
2082 DECL_FIELD_CONTEXT (fields
) = type
;
2083 next
= DECL_CHAIN (fields
);
2084 DECL_CHAIN (fields
) = tail
;
2086 TYPE_FIELDS (type
) = tail
;
2090 TYPE_ALIGN (type
) = TYPE_ALIGN (align_type
);
2091 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (align_type
);
2095 #if 0 /* not yet, should get fixed properly later */
2096 TYPE_NAME (type
) = make_type_decl (get_identifier (name
), type
);
2098 TYPE_NAME (type
) = build_decl (BUILTINS_LOCATION
,
2099 TYPE_DECL
, get_identifier (name
), type
);
2101 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
2102 layout_decl (TYPE_NAME (type
), 0);
2105 /* Calculate the mode, size, and alignment for TYPE.
2106 For an array type, calculate the element separation as well.
2107 Record TYPE on the chain of permanent or temporary types
2108 so that dbxout will find out about it.
2110 TYPE_SIZE of a type is nonzero if the type has been laid out already.
2111 layout_type does nothing on such a type.
2113 If the type is incomplete, its TYPE_SIZE remains zero. */
2116 layout_type (tree type
)
2120 if (type
== error_mark_node
)
2123 /* We don't want finalize_type_size to copy an alignment attribute to
2124 variants that don't have it. */
2125 type
= TYPE_MAIN_VARIANT (type
);
2127 /* Do nothing if type has been laid out before. */
2128 if (TYPE_SIZE (type
))
2131 switch (TREE_CODE (type
))
2134 /* This kind of type is the responsibility
2135 of the language-specific code. */
2141 SET_TYPE_MODE (type
,
2142 smallest_mode_for_size (TYPE_PRECISION (type
), MODE_INT
));
2143 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2144 /* Don't set TYPE_PRECISION here, as it may be set by a bitfield. */
2145 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2149 SET_TYPE_MODE (type
,
2150 mode_for_size (TYPE_PRECISION (type
), MODE_FLOAT
, 0));
2151 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2152 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2155 case FIXED_POINT_TYPE
:
2156 /* TYPE_MODE (type) has been set already. */
2157 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2158 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2162 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TREE_TYPE (type
));
2163 SET_TYPE_MODE (type
,
2164 mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type
)),
2165 (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
2166 ? MODE_COMPLEX_FLOAT
: MODE_COMPLEX_INT
),
2168 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2169 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2174 int nunits
= TYPE_VECTOR_SUBPARTS (type
);
2175 tree innertype
= TREE_TYPE (type
);
2177 gcc_assert (!(nunits
& (nunits
- 1)));
2179 /* Find an appropriate mode for the vector type. */
2180 if (TYPE_MODE (type
) == VOIDmode
)
2181 SET_TYPE_MODE (type
,
2182 mode_for_vector (TYPE_MODE (innertype
), nunits
));
2184 TYPE_SATURATING (type
) = TYPE_SATURATING (TREE_TYPE (type
));
2185 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TREE_TYPE (type
));
2186 /* Several boolean vector elements may fit in a single unit. */
2187 if (VECTOR_BOOLEAN_TYPE_P (type
))
2188 TYPE_SIZE_UNIT (type
)
2189 = size_int (GET_MODE_SIZE (type
->type_common
.mode
));
2191 TYPE_SIZE_UNIT (type
) = int_const_binop (MULT_EXPR
,
2192 TYPE_SIZE_UNIT (innertype
),
2194 TYPE_SIZE (type
) = int_const_binop (MULT_EXPR
,
2195 TYPE_SIZE (innertype
),
2196 bitsize_int (nunits
));
2198 /* For vector types, we do not default to the mode's alignment.
2199 Instead, query a target hook, defaulting to natural alignment.
2200 This prevents ABI changes depending on whether or not native
2201 vector modes are supported. */
2202 TYPE_ALIGN (type
) = targetm
.vector_alignment (type
);
2204 /* However, if the underlying mode requires a bigger alignment than
2205 what the target hook provides, we cannot use the mode. For now,
2206 simply reject that case. */
2207 gcc_assert (TYPE_ALIGN (type
)
2208 >= GET_MODE_ALIGNMENT (TYPE_MODE (type
)));
2213 /* This is an incomplete type and so doesn't have a size. */
2214 TYPE_ALIGN (type
) = 1;
2215 TYPE_USER_ALIGN (type
) = 0;
2216 SET_TYPE_MODE (type
, VOIDmode
);
2219 case POINTER_BOUNDS_TYPE
:
2220 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2221 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2225 TYPE_SIZE (type
) = bitsize_int (POINTER_SIZE
);
2226 TYPE_SIZE_UNIT (type
) = size_int (POINTER_SIZE_UNITS
);
2227 /* A pointer might be MODE_PARTIAL_INT, but ptrdiff_t must be
2228 integral, which may be an __intN. */
2229 SET_TYPE_MODE (type
, mode_for_size (POINTER_SIZE
, MODE_INT
, 0));
2230 TYPE_PRECISION (type
) = POINTER_SIZE
;
2235 /* It's hard to see what the mode and size of a function ought to
2236 be, but we do know the alignment is FUNCTION_BOUNDARY, so
2237 make it consistent with that. */
2238 SET_TYPE_MODE (type
, mode_for_size (FUNCTION_BOUNDARY
, MODE_INT
, 0));
2239 TYPE_SIZE (type
) = bitsize_int (FUNCTION_BOUNDARY
);
2240 TYPE_SIZE_UNIT (type
) = size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
2244 case REFERENCE_TYPE
:
2246 machine_mode mode
= TYPE_MODE (type
);
2247 if (TREE_CODE (type
) == REFERENCE_TYPE
&& reference_types_internal
)
2249 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (type
));
2250 mode
= targetm
.addr_space
.address_mode (as
);
2253 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (mode
));
2254 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (mode
));
2255 TYPE_UNSIGNED (type
) = 1;
2256 TYPE_PRECISION (type
) = GET_MODE_PRECISION (mode
);
2262 tree index
= TYPE_DOMAIN (type
);
2263 tree element
= TREE_TYPE (type
);
2265 build_pointer_type (element
);
2267 /* We need to know both bounds in order to compute the size. */
2268 if (index
&& TYPE_MAX_VALUE (index
) && TYPE_MIN_VALUE (index
)
2269 && TYPE_SIZE (element
))
2271 tree ub
= TYPE_MAX_VALUE (index
);
2272 tree lb
= TYPE_MIN_VALUE (index
);
2273 tree element_size
= TYPE_SIZE (element
);
2276 /* Make sure that an array of zero-sized element is zero-sized
2277 regardless of its extent. */
2278 if (integer_zerop (element_size
))
2279 length
= size_zero_node
;
2281 /* The computation should happen in the original signedness so
2282 that (possible) negative values are handled appropriately
2283 when determining overflow. */
2286 /* ??? When it is obvious that the range is signed
2287 represent it using ssizetype. */
2288 if (TREE_CODE (lb
) == INTEGER_CST
2289 && TREE_CODE (ub
) == INTEGER_CST
2290 && TYPE_UNSIGNED (TREE_TYPE (lb
))
2291 && tree_int_cst_lt (ub
, lb
))
2293 lb
= wide_int_to_tree (ssizetype
,
2294 offset_int::from (lb
, SIGNED
));
2295 ub
= wide_int_to_tree (ssizetype
,
2296 offset_int::from (ub
, SIGNED
));
2299 = fold_convert (sizetype
,
2300 size_binop (PLUS_EXPR
,
2301 build_int_cst (TREE_TYPE (lb
), 1),
2302 size_binop (MINUS_EXPR
, ub
, lb
)));
2305 /* ??? We have no way to distinguish a null-sized array from an
2306 array spanning the whole sizetype range, so we arbitrarily
2307 decide that [0, -1] is the only valid representation. */
2308 if (integer_zerop (length
)
2309 && TREE_OVERFLOW (length
)
2310 && integer_zerop (lb
))
2311 length
= size_zero_node
;
2313 TYPE_SIZE (type
) = size_binop (MULT_EXPR
, element_size
,
2314 fold_convert (bitsizetype
,
2317 /* If we know the size of the element, calculate the total size
2318 directly, rather than do some division thing below. This
2319 optimization helps Fortran assumed-size arrays (where the
2320 size of the array is determined at runtime) substantially. */
2321 if (TYPE_SIZE_UNIT (element
))
2322 TYPE_SIZE_UNIT (type
)
2323 = size_binop (MULT_EXPR
, TYPE_SIZE_UNIT (element
), length
);
2326 /* Now round the alignment and size,
2327 using machine-dependent criteria if any. */
2329 unsigned align
= TYPE_ALIGN (element
);
2330 if (TYPE_USER_ALIGN (type
))
2331 align
= MAX (align
, TYPE_ALIGN (type
));
2333 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (element
);
2334 #ifdef ROUND_TYPE_ALIGN
2335 align
= ROUND_TYPE_ALIGN (type
, align
, BITS_PER_UNIT
);
2337 align
= MAX (align
, BITS_PER_UNIT
);
2339 TYPE_ALIGN (type
) = align
;
2340 SET_TYPE_MODE (type
, BLKmode
);
2341 if (TYPE_SIZE (type
) != 0
2342 && ! targetm
.member_type_forces_blk (type
, VOIDmode
)
2343 /* BLKmode elements force BLKmode aggregate;
2344 else extract/store fields may lose. */
2345 && (TYPE_MODE (TREE_TYPE (type
)) != BLKmode
2346 || TYPE_NO_FORCE_BLK (TREE_TYPE (type
))))
2348 SET_TYPE_MODE (type
, mode_for_array (TREE_TYPE (type
),
2350 if (TYPE_MODE (type
) != BLKmode
2351 && STRICT_ALIGNMENT
&& TYPE_ALIGN (type
) < BIGGEST_ALIGNMENT
2352 && TYPE_ALIGN (type
) < GET_MODE_ALIGNMENT (TYPE_MODE (type
)))
2354 TYPE_NO_FORCE_BLK (type
) = 1;
2355 SET_TYPE_MODE (type
, BLKmode
);
2358 /* When the element size is constant, check that it is at least as
2359 large as the element alignment. */
2360 if (TYPE_SIZE_UNIT (element
)
2361 && TREE_CODE (TYPE_SIZE_UNIT (element
)) == INTEGER_CST
2362 /* If TYPE_SIZE_UNIT overflowed, then it is certainly larger than
2364 && !TREE_OVERFLOW (TYPE_SIZE_UNIT (element
))
2365 && !integer_zerop (TYPE_SIZE_UNIT (element
))
2366 && compare_tree_int (TYPE_SIZE_UNIT (element
),
2367 TYPE_ALIGN_UNIT (element
)) < 0)
2368 error ("alignment of array elements is greater than element size");
2374 case QUAL_UNION_TYPE
:
2377 record_layout_info rli
;
2379 /* Initialize the layout information. */
2380 rli
= start_record_layout (type
);
2382 /* If this is a QUAL_UNION_TYPE, we want to process the fields
2383 in the reverse order in building the COND_EXPR that denotes
2384 its size. We reverse them again later. */
2385 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
2386 TYPE_FIELDS (type
) = nreverse (TYPE_FIELDS (type
));
2388 /* Place all the fields. */
2389 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
2390 place_field (rli
, field
);
2392 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
2393 TYPE_FIELDS (type
) = nreverse (TYPE_FIELDS (type
));
2395 /* Finish laying out the record. */
2396 finish_record_layout (rli
, /*free_p=*/true);
2404 /* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE. For
2405 records and unions, finish_record_layout already called this
2407 if (!RECORD_OR_UNION_TYPE_P (type
))
2408 finalize_type_size (type
);
2410 /* We should never see alias sets on incomplete aggregates. And we
2411 should not call layout_type on not incomplete aggregates. */
2412 if (AGGREGATE_TYPE_P (type
))
2413 gcc_assert (!TYPE_ALIAS_SET_KNOWN_P (type
));
2416 /* Return the least alignment required for type TYPE. */
2419 min_align_of_type (tree type
)
2421 unsigned int align
= TYPE_ALIGN (type
);
2422 if (!TYPE_USER_ALIGN (type
))
2424 align
= MIN (align
, BIGGEST_ALIGNMENT
);
2425 #ifdef BIGGEST_FIELD_ALIGNMENT
2426 align
= MIN (align
, BIGGEST_FIELD_ALIGNMENT
);
2428 unsigned int field_align
= align
;
2429 #ifdef ADJUST_FIELD_ALIGN
2430 tree field
= build_decl (UNKNOWN_LOCATION
, FIELD_DECL
, NULL_TREE
, type
);
2431 field_align
= ADJUST_FIELD_ALIGN (field
, field_align
);
2434 align
= MIN (align
, field_align
);
2436 return align
/ BITS_PER_UNIT
;
2439 /* Vector types need to re-check the target flags each time we report
2440 the machine mode. We need to do this because attribute target can
2441 change the result of vector_mode_supported_p and have_regs_of_mode
2442 on a per-function basis. Thus the TYPE_MODE of a VECTOR_TYPE can
2443 change on a per-function basis. */
2444 /* ??? Possibly a better solution is to run through all the types
2445 referenced by a function and re-compute the TYPE_MODE once, rather
2446 than make the TYPE_MODE macro call a function. */
2449 vector_type_mode (const_tree t
)
2453 gcc_assert (TREE_CODE (t
) == VECTOR_TYPE
);
2455 mode
= t
->type_common
.mode
;
2456 if (VECTOR_MODE_P (mode
)
2457 && (!targetm
.vector_mode_supported_p (mode
)
2458 || !have_regs_of_mode
[mode
]))
2460 machine_mode innermode
= TREE_TYPE (t
)->type_common
.mode
;
2462 /* For integers, try mapping it to a same-sized scalar mode. */
2463 if (GET_MODE_CLASS (innermode
) == MODE_INT
)
2465 mode
= mode_for_size (TYPE_VECTOR_SUBPARTS (t
)
2466 * GET_MODE_BITSIZE (innermode
), MODE_INT
, 0);
2468 if (mode
!= VOIDmode
&& have_regs_of_mode
[mode
])
2478 /* Create and return a type for signed integers of PRECISION bits. */
2481 make_signed_type (int precision
)
2483 tree type
= make_node (INTEGER_TYPE
);
2485 TYPE_PRECISION (type
) = precision
;
2487 fixup_signed_type (type
);
2491 /* Create and return a type for unsigned integers of PRECISION bits. */
2494 make_unsigned_type (int precision
)
2496 tree type
= make_node (INTEGER_TYPE
);
2498 TYPE_PRECISION (type
) = precision
;
2500 fixup_unsigned_type (type
);
2504 /* Create and return a type for fract of PRECISION bits, UNSIGNEDP,
2508 make_fract_type (int precision
, int unsignedp
, int satp
)
2510 tree type
= make_node (FIXED_POINT_TYPE
);
2512 TYPE_PRECISION (type
) = precision
;
2515 TYPE_SATURATING (type
) = 1;
2517 /* Lay out the type: set its alignment, size, etc. */
2520 TYPE_UNSIGNED (type
) = 1;
2521 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_UFRACT
, 0));
2524 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_FRACT
, 0));
2530 /* Create and return a type for accum of PRECISION bits, UNSIGNEDP,
2534 make_accum_type (int precision
, int unsignedp
, int satp
)
2536 tree type
= make_node (FIXED_POINT_TYPE
);
2538 TYPE_PRECISION (type
) = precision
;
2541 TYPE_SATURATING (type
) = 1;
2543 /* Lay out the type: set its alignment, size, etc. */
2546 TYPE_UNSIGNED (type
) = 1;
2547 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_UACCUM
, 0));
2550 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_ACCUM
, 0));
2556 /* Initialize sizetypes so layout_type can use them. */
2559 initialize_sizetypes (void)
2561 int precision
, bprecision
;
2563 /* Get sizetypes precision from the SIZE_TYPE target macro. */
2564 if (strcmp (SIZETYPE
, "unsigned int") == 0)
2565 precision
= INT_TYPE_SIZE
;
2566 else if (strcmp (SIZETYPE
, "long unsigned int") == 0)
2567 precision
= LONG_TYPE_SIZE
;
2568 else if (strcmp (SIZETYPE
, "long long unsigned int") == 0)
2569 precision
= LONG_LONG_TYPE_SIZE
;
2570 else if (strcmp (SIZETYPE
, "short unsigned int") == 0)
2571 precision
= SHORT_TYPE_SIZE
;
2577 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2578 if (int_n_enabled_p
[i
])
2581 sprintf (name
, "__int%d unsigned", int_n_data
[i
].bitsize
);
2583 if (strcmp (name
, SIZETYPE
) == 0)
2585 precision
= int_n_data
[i
].bitsize
;
2588 if (precision
== -1)
2593 = MIN (precision
+ BITS_PER_UNIT_LOG
+ 1, MAX_FIXED_MODE_SIZE
);
2595 = GET_MODE_PRECISION (smallest_mode_for_size (bprecision
, MODE_INT
));
2596 if (bprecision
> HOST_BITS_PER_DOUBLE_INT
)
2597 bprecision
= HOST_BITS_PER_DOUBLE_INT
;
2599 /* Create stubs for sizetype and bitsizetype so we can create constants. */
2600 sizetype
= make_node (INTEGER_TYPE
);
2601 TYPE_NAME (sizetype
) = get_identifier ("sizetype");
2602 TYPE_PRECISION (sizetype
) = precision
;
2603 TYPE_UNSIGNED (sizetype
) = 1;
2604 bitsizetype
= make_node (INTEGER_TYPE
);
2605 TYPE_NAME (bitsizetype
) = get_identifier ("bitsizetype");
2606 TYPE_PRECISION (bitsizetype
) = bprecision
;
2607 TYPE_UNSIGNED (bitsizetype
) = 1;
2609 /* Now layout both types manually. */
2610 SET_TYPE_MODE (sizetype
, smallest_mode_for_size (precision
, MODE_INT
));
2611 TYPE_ALIGN (sizetype
) = GET_MODE_ALIGNMENT (TYPE_MODE (sizetype
));
2612 TYPE_SIZE (sizetype
) = bitsize_int (precision
);
2613 TYPE_SIZE_UNIT (sizetype
) = size_int (GET_MODE_SIZE (TYPE_MODE (sizetype
)));
2614 set_min_and_max_values_for_integral_type (sizetype
, precision
, UNSIGNED
);
2616 SET_TYPE_MODE (bitsizetype
, smallest_mode_for_size (bprecision
, MODE_INT
));
2617 TYPE_ALIGN (bitsizetype
) = GET_MODE_ALIGNMENT (TYPE_MODE (bitsizetype
));
2618 TYPE_SIZE (bitsizetype
) = bitsize_int (bprecision
);
2619 TYPE_SIZE_UNIT (bitsizetype
)
2620 = size_int (GET_MODE_SIZE (TYPE_MODE (bitsizetype
)));
2621 set_min_and_max_values_for_integral_type (bitsizetype
, bprecision
, UNSIGNED
);
2623 /* Create the signed variants of *sizetype. */
2624 ssizetype
= make_signed_type (TYPE_PRECISION (sizetype
));
2625 TYPE_NAME (ssizetype
) = get_identifier ("ssizetype");
2626 sbitsizetype
= make_signed_type (TYPE_PRECISION (bitsizetype
));
2627 TYPE_NAME (sbitsizetype
) = get_identifier ("sbitsizetype");
2630 /* TYPE is an integral type, i.e., an INTEGRAL_TYPE, ENUMERAL_TYPE
2631 or BOOLEAN_TYPE. Set TYPE_MIN_VALUE and TYPE_MAX_VALUE
2632 for TYPE, based on the PRECISION and whether or not the TYPE
2633 IS_UNSIGNED. PRECISION need not correspond to a width supported
2634 natively by the hardware; for example, on a machine with 8-bit,
2635 16-bit, and 32-bit register modes, PRECISION might be 7, 23, or
2639 set_min_and_max_values_for_integral_type (tree type
,
2643 /* For bitfields with zero width we end up creating integer types
2644 with zero precision. Don't assign any minimum/maximum values
2645 to those types, they don't have any valid value. */
2649 TYPE_MIN_VALUE (type
)
2650 = wide_int_to_tree (type
, wi::min_value (precision
, sgn
));
2651 TYPE_MAX_VALUE (type
)
2652 = wide_int_to_tree (type
, wi::max_value (precision
, sgn
));
2655 /* Set the extreme values of TYPE based on its precision in bits,
2656 then lay it out. Used when make_signed_type won't do
2657 because the tree code is not INTEGER_TYPE.
2658 E.g. for Pascal, when the -fsigned-char option is given. */
2661 fixup_signed_type (tree type
)
2663 int precision
= TYPE_PRECISION (type
);
2665 set_min_and_max_values_for_integral_type (type
, precision
, SIGNED
);
2667 /* Lay out the type: set its alignment, size, etc. */
2671 /* Set the extreme values of TYPE based on its precision in bits,
2672 then lay it out. This is used both in `make_unsigned_type'
2673 and for enumeral types. */
2676 fixup_unsigned_type (tree type
)
2678 int precision
= TYPE_PRECISION (type
);
2680 TYPE_UNSIGNED (type
) = 1;
2682 set_min_and_max_values_for_integral_type (type
, precision
, UNSIGNED
);
2684 /* Lay out the type: set its alignment, size, etc. */
2688 /* Construct an iterator for a bitfield that spans BITSIZE bits,
2691 BITREGION_START is the bit position of the first bit in this
2692 sequence of bit fields. BITREGION_END is the last bit in this
2693 sequence. If these two fields are non-zero, we should restrict the
2694 memory access to that range. Otherwise, we are allowed to touch
2695 any adjacent non bit-fields.
2697 ALIGN is the alignment of the underlying object in bits.
2698 VOLATILEP says whether the bitfield is volatile. */
2700 bit_field_mode_iterator
2701 ::bit_field_mode_iterator (HOST_WIDE_INT bitsize
, HOST_WIDE_INT bitpos
,
2702 HOST_WIDE_INT bitregion_start
,
2703 HOST_WIDE_INT bitregion_end
,
2704 unsigned int align
, bool volatilep
)
2705 : m_mode (GET_CLASS_NARROWEST_MODE (MODE_INT
)), m_bitsize (bitsize
),
2706 m_bitpos (bitpos
), m_bitregion_start (bitregion_start
),
2707 m_bitregion_end (bitregion_end
), m_align (align
),
2708 m_volatilep (volatilep
), m_count (0)
2710 if (!m_bitregion_end
)
2712 /* We can assume that any aligned chunk of ALIGN bits that overlaps
2713 the bitfield is mapped and won't trap, provided that ALIGN isn't
2714 too large. The cap is the biggest required alignment for data,
2715 or at least the word size. And force one such chunk at least. */
2716 unsigned HOST_WIDE_INT units
2717 = MIN (align
, MAX (BIGGEST_ALIGNMENT
, BITS_PER_WORD
));
2720 m_bitregion_end
= bitpos
+ bitsize
+ units
- 1;
2721 m_bitregion_end
-= m_bitregion_end
% units
+ 1;
2725 /* Calls to this function return successively larger modes that can be used
2726 to represent the bitfield. Return true if another bitfield mode is
2727 available, storing it in *OUT_MODE if so. */
2730 bit_field_mode_iterator::next_mode (machine_mode
*out_mode
)
2732 for (; m_mode
!= VOIDmode
; m_mode
= GET_MODE_WIDER_MODE (m_mode
))
2734 unsigned int unit
= GET_MODE_BITSIZE (m_mode
);
2736 /* Skip modes that don't have full precision. */
2737 if (unit
!= GET_MODE_PRECISION (m_mode
))
2740 /* Stop if the mode is too wide to handle efficiently. */
2741 if (unit
> MAX_FIXED_MODE_SIZE
)
2744 /* Don't deliver more than one multiword mode; the smallest one
2746 if (m_count
> 0 && unit
> BITS_PER_WORD
)
2749 /* Skip modes that are too small. */
2750 unsigned HOST_WIDE_INT substart
= (unsigned HOST_WIDE_INT
) m_bitpos
% unit
;
2751 unsigned HOST_WIDE_INT subend
= substart
+ m_bitsize
;
2755 /* Stop if the mode goes outside the bitregion. */
2756 HOST_WIDE_INT start
= m_bitpos
- substart
;
2757 if (m_bitregion_start
&& start
< m_bitregion_start
)
2759 HOST_WIDE_INT end
= start
+ unit
;
2760 if (end
> m_bitregion_end
+ 1)
2763 /* Stop if the mode requires too much alignment. */
2764 if (GET_MODE_ALIGNMENT (m_mode
) > m_align
2765 && SLOW_UNALIGNED_ACCESS (m_mode
, m_align
))
2769 m_mode
= GET_MODE_WIDER_MODE (m_mode
);
2776 /* Return true if smaller modes are generally preferred for this kind
2780 bit_field_mode_iterator::prefer_smaller_modes ()
2783 ? targetm
.narrow_volatile_bitfield ()
2784 : !SLOW_BYTE_ACCESS
);
2787 /* Find the best machine mode to use when referencing a bit field of length
2788 BITSIZE bits starting at BITPOS.
2790 BITREGION_START is the bit position of the first bit in this
2791 sequence of bit fields. BITREGION_END is the last bit in this
2792 sequence. If these two fields are non-zero, we should restrict the
2793 memory access to that range. Otherwise, we are allowed to touch
2794 any adjacent non bit-fields.
2796 The underlying object is known to be aligned to a boundary of ALIGN bits.
2797 If LARGEST_MODE is not VOIDmode, it means that we should not use a mode
2798 larger than LARGEST_MODE (usually SImode).
2800 If no mode meets all these conditions, we return VOIDmode.
2802 If VOLATILEP is false and SLOW_BYTE_ACCESS is false, we return the
2803 smallest mode meeting these conditions.
2805 If VOLATILEP is false and SLOW_BYTE_ACCESS is true, we return the
2806 largest mode (but a mode no wider than UNITS_PER_WORD) that meets
2809 If VOLATILEP is true the narrow_volatile_bitfields target hook is used to
2810 decide which of the above modes should be used. */
2813 get_best_mode (int bitsize
, int bitpos
,
2814 unsigned HOST_WIDE_INT bitregion_start
,
2815 unsigned HOST_WIDE_INT bitregion_end
,
2817 machine_mode largest_mode
, bool volatilep
)
2819 bit_field_mode_iterator
iter (bitsize
, bitpos
, bitregion_start
,
2820 bitregion_end
, align
, volatilep
);
2821 machine_mode widest_mode
= VOIDmode
;
2823 while (iter
.next_mode (&mode
)
2824 /* ??? For historical reasons, reject modes that would normally
2825 receive greater alignment, even if unaligned accesses are
2826 acceptable. This has both advantages and disadvantages.
2827 Removing this check means that something like:
2829 struct s { unsigned int x; unsigned int y; };
2830 int f (struct s *s) { return s->x == 0 && s->y == 0; }
2832 can be implemented using a single load and compare on
2833 64-bit machines that have no alignment restrictions.
2834 For example, on powerpc64-linux-gnu, we would generate:
2856 However, accessing more than one field can make life harder
2857 for the gimple optimizers. For example, gcc.dg/vect/bb-slp-5.c
2858 has a series of unsigned short copies followed by a series of
2859 unsigned short comparisons. With this check, both the copies
2860 and comparisons remain 16-bit accesses and FRE is able
2861 to eliminate the latter. Without the check, the comparisons
2862 can be done using 2 64-bit operations, which FRE isn't able
2863 to handle in the same way.
2865 Either way, it would probably be worth disabling this check
2866 during expand. One particular example where removing the
2867 check would help is the get_best_mode call in store_bit_field.
2868 If we are given a memory bitregion of 128 bits that is aligned
2869 to a 64-bit boundary, and the bitfield we want to modify is
2870 in the second half of the bitregion, this check causes
2871 store_bitfield to turn the memory into a 64-bit reference
2872 to the _first_ half of the region. We later use
2873 adjust_bitfield_address to get a reference to the correct half,
2874 but doing so looks to adjust_bitfield_address as though we are
2875 moving past the end of the original object, so it drops the
2876 associated MEM_EXPR and MEM_OFFSET. Removing the check
2877 causes store_bit_field to keep a 128-bit memory reference,
2878 so that the final bitfield reference still has a MEM_EXPR
2880 && GET_MODE_ALIGNMENT (mode
) <= align
2881 && (largest_mode
== VOIDmode
2882 || GET_MODE_SIZE (mode
) <= GET_MODE_SIZE (largest_mode
)))
2885 if (iter
.prefer_smaller_modes ())
2891 /* Gets minimal and maximal values for MODE (signed or unsigned depending on
2892 SIGN). The returned constants are made to be usable in TARGET_MODE. */
2895 get_mode_bounds (machine_mode mode
, int sign
,
2896 machine_mode target_mode
,
2897 rtx
*mmin
, rtx
*mmax
)
2899 unsigned size
= GET_MODE_PRECISION (mode
);
2900 unsigned HOST_WIDE_INT min_val
, max_val
;
2902 gcc_assert (size
<= HOST_BITS_PER_WIDE_INT
);
2904 /* Special case BImode, which has values 0 and STORE_FLAG_VALUE. */
2907 if (STORE_FLAG_VALUE
< 0)
2909 min_val
= STORE_FLAG_VALUE
;
2915 max_val
= STORE_FLAG_VALUE
;
2920 min_val
= -((unsigned HOST_WIDE_INT
) 1 << (size
- 1));
2921 max_val
= ((unsigned HOST_WIDE_INT
) 1 << (size
- 1)) - 1;
2926 max_val
= ((unsigned HOST_WIDE_INT
) 1 << (size
- 1) << 1) - 1;
2929 *mmin
= gen_int_mode (min_val
, target_mode
);
2930 *mmax
= gen_int_mode (max_val
, target_mode
);
2933 #include "gt-stor-layout.h"