1 /* C-compiler utilities for types and variables storage layout
2 Copyright (C) 1987-2015 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
32 #include "fold-const.h"
33 #include "stor-layout.h"
34 #include "stringpool.h"
36 #include "print-tree.h"
40 #include "hard-reg-set.h"
43 #include "statistics.h"
44 #include "insn-config.h"
52 #include "diagnostic-core.h"
54 #include "langhooks.h"
59 #include "plugin-api.h"
62 #include "tree-inline.h"
63 #include "tree-dump.h"
66 /* Data type for the expressions representing sizes of data types.
67 It is the first integer type laid out. */
68 tree sizetype_tab
[(int) stk_type_kind_last
];
70 /* If nonzero, this is an upper limit on alignment of structure fields.
71 The value is measured in bits. */
72 unsigned int maximum_field_alignment
= TARGET_DEFAULT_PACK_STRUCT
* BITS_PER_UNIT
;
74 /* Nonzero if all REFERENCE_TYPEs are internal and hence should be allocated
75 in the address spaces' address_mode, not pointer_mode. Set only by
76 internal_reference_types called only by a front end. */
77 static int reference_types_internal
= 0;
79 static tree
self_referential_size (tree
);
80 static void finalize_record_size (record_layout_info
);
81 static void finalize_type_size (tree
);
82 static void place_union_field (record_layout_info
, tree
);
83 static int excess_unit_span (HOST_WIDE_INT
, HOST_WIDE_INT
, HOST_WIDE_INT
,
85 extern void debug_rli (record_layout_info
);
87 /* Show that REFERENCE_TYPES are internal and should use address_mode.
88 Called only by front end. */
91 internal_reference_types (void)
93 reference_types_internal
= 1;
96 /* Given a size SIZE that may not be a constant, return a SAVE_EXPR
97 to serve as the actual size-expression for a type or decl. */
100 variable_size (tree size
)
103 if (TREE_CONSTANT (size
))
106 /* If the size is self-referential, we can't make a SAVE_EXPR (see
107 save_expr for the rationale). But we can do something else. */
108 if (CONTAINS_PLACEHOLDER_P (size
))
109 return self_referential_size (size
);
111 /* If we are in the global binding level, we can't make a SAVE_EXPR
112 since it may end up being shared across functions, so it is up
113 to the front-end to deal with this case. */
114 if (lang_hooks
.decls
.global_bindings_p ())
117 return save_expr (size
);
120 /* An array of functions used for self-referential size computation. */
121 static GTY(()) vec
<tree
, va_gc
> *size_functions
;
123 /* Return true if T is a self-referential component reference. */
126 self_referential_component_ref_p (tree t
)
128 if (TREE_CODE (t
) != COMPONENT_REF
)
131 while (REFERENCE_CLASS_P (t
))
132 t
= TREE_OPERAND (t
, 0);
134 return (TREE_CODE (t
) == PLACEHOLDER_EXPR
);
137 /* Similar to copy_tree_r but do not copy component references involving
138 PLACEHOLDER_EXPRs. These nodes are spotted in find_placeholder_in_expr
139 and substituted in substitute_in_expr. */
142 copy_self_referential_tree_r (tree
*tp
, int *walk_subtrees
, void *data
)
144 enum tree_code code
= TREE_CODE (*tp
);
146 /* Stop at types, decls, constants like copy_tree_r. */
147 if (TREE_CODE_CLASS (code
) == tcc_type
148 || TREE_CODE_CLASS (code
) == tcc_declaration
149 || TREE_CODE_CLASS (code
) == tcc_constant
)
155 /* This is the pattern built in ada/make_aligning_type. */
156 else if (code
== ADDR_EXPR
157 && TREE_CODE (TREE_OPERAND (*tp
, 0)) == PLACEHOLDER_EXPR
)
163 /* Default case: the component reference. */
164 else if (self_referential_component_ref_p (*tp
))
170 /* We're not supposed to have them in self-referential size trees
171 because we wouldn't properly control when they are evaluated.
172 However, not creating superfluous SAVE_EXPRs requires accurate
173 tracking of readonly-ness all the way down to here, which we
174 cannot always guarantee in practice. So punt in this case. */
175 else if (code
== SAVE_EXPR
)
176 return error_mark_node
;
178 else if (code
== STATEMENT_LIST
)
181 return copy_tree_r (tp
, walk_subtrees
, data
);
184 /* Given a SIZE expression that is self-referential, return an equivalent
185 expression to serve as the actual size expression for a type. */
188 self_referential_size (tree size
)
190 static unsigned HOST_WIDE_INT fnno
= 0;
191 vec
<tree
> self_refs
= vNULL
;
192 tree param_type_list
= NULL
, param_decl_list
= NULL
;
193 tree t
, ref
, return_type
, fntype
, fnname
, fndecl
;
196 vec
<tree
, va_gc
> *args
= NULL
;
198 /* Do not factor out simple operations. */
199 t
= skip_simple_constant_arithmetic (size
);
200 if (TREE_CODE (t
) == CALL_EXPR
|| self_referential_component_ref_p (t
))
203 /* Collect the list of self-references in the expression. */
204 find_placeholder_in_expr (size
, &self_refs
);
205 gcc_assert (self_refs
.length () > 0);
207 /* Obtain a private copy of the expression. */
209 if (walk_tree (&t
, copy_self_referential_tree_r
, NULL
, NULL
) != NULL_TREE
)
213 /* Build the parameter and argument lists in parallel; also
214 substitute the former for the latter in the expression. */
215 vec_alloc (args
, self_refs
.length ());
216 FOR_EACH_VEC_ELT (self_refs
, i
, ref
)
218 tree subst
, param_name
, param_type
, param_decl
;
222 /* We shouldn't have true variables here. */
223 gcc_assert (TREE_READONLY (ref
));
226 /* This is the pattern built in ada/make_aligning_type. */
227 else if (TREE_CODE (ref
) == ADDR_EXPR
)
229 /* Default case: the component reference. */
231 subst
= TREE_OPERAND (ref
, 1);
233 sprintf (buf
, "p%d", i
);
234 param_name
= get_identifier (buf
);
235 param_type
= TREE_TYPE (ref
);
237 = build_decl (input_location
, PARM_DECL
, param_name
, param_type
);
238 DECL_ARG_TYPE (param_decl
) = param_type
;
239 DECL_ARTIFICIAL (param_decl
) = 1;
240 TREE_READONLY (param_decl
) = 1;
242 size
= substitute_in_expr (size
, subst
, param_decl
);
244 param_type_list
= tree_cons (NULL_TREE
, param_type
, param_type_list
);
245 param_decl_list
= chainon (param_decl
, param_decl_list
);
246 args
->quick_push (ref
);
249 self_refs
.release ();
251 /* Append 'void' to indicate that the number of parameters is fixed. */
252 param_type_list
= tree_cons (NULL_TREE
, void_type_node
, param_type_list
);
254 /* The 3 lists have been created in reverse order. */
255 param_type_list
= nreverse (param_type_list
);
256 param_decl_list
= nreverse (param_decl_list
);
258 /* Build the function type. */
259 return_type
= TREE_TYPE (size
);
260 fntype
= build_function_type (return_type
, param_type_list
);
262 /* Build the function declaration. */
263 sprintf (buf
, "SZ" HOST_WIDE_INT_PRINT_UNSIGNED
, fnno
++);
264 fnname
= get_file_function_name (buf
);
265 fndecl
= build_decl (input_location
, FUNCTION_DECL
, fnname
, fntype
);
266 for (t
= param_decl_list
; t
; t
= DECL_CHAIN (t
))
267 DECL_CONTEXT (t
) = fndecl
;
268 DECL_ARGUMENTS (fndecl
) = param_decl_list
;
270 = build_decl (input_location
, RESULT_DECL
, 0, return_type
);
271 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
273 /* The function has been created by the compiler and we don't
274 want to emit debug info for it. */
275 DECL_ARTIFICIAL (fndecl
) = 1;
276 DECL_IGNORED_P (fndecl
) = 1;
278 /* It is supposed to be "const" and never throw. */
279 TREE_READONLY (fndecl
) = 1;
280 TREE_NOTHROW (fndecl
) = 1;
282 /* We want it to be inlined when this is deemed profitable, as
283 well as discarded if every call has been integrated. */
284 DECL_DECLARED_INLINE_P (fndecl
) = 1;
286 /* It is made up of a unique return statement. */
287 DECL_INITIAL (fndecl
) = make_node (BLOCK
);
288 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
289 t
= build2 (MODIFY_EXPR
, return_type
, DECL_RESULT (fndecl
), size
);
290 DECL_SAVED_TREE (fndecl
) = build1 (RETURN_EXPR
, void_type_node
, t
);
291 TREE_STATIC (fndecl
) = 1;
293 /* Put it onto the list of size functions. */
294 vec_safe_push (size_functions
, fndecl
);
296 /* Replace the original expression with a call to the size function. */
297 return build_call_expr_loc_vec (UNKNOWN_LOCATION
, fndecl
, args
);
300 /* Take, queue and compile all the size functions. It is essential that
301 the size functions be gimplified at the very end of the compilation
302 in order to guarantee transparent handling of self-referential sizes.
303 Otherwise the GENERIC inliner would not be able to inline them back
304 at each of their call sites, thus creating artificial non-constant
305 size expressions which would trigger nasty problems later on. */
308 finalize_size_functions (void)
313 for (i
= 0; size_functions
&& size_functions
->iterate (i
, &fndecl
); i
++)
315 allocate_struct_function (fndecl
, false);
317 dump_function (TDI_original
, fndecl
);
318 gimplify_function_tree (fndecl
);
319 cgraph_node::finalize_function (fndecl
, false);
322 vec_free (size_functions
);
325 /* Return the machine mode to use for a nonscalar of SIZE bits. The
326 mode must be in class MCLASS, and have exactly that many value bits;
327 it may have padding as well. If LIMIT is nonzero, modes of wider
328 than MAX_FIXED_MODE_SIZE will not be used. */
331 mode_for_size (unsigned int size
, enum mode_class mclass
, int limit
)
336 if (limit
&& size
> MAX_FIXED_MODE_SIZE
)
339 /* Get the first mode which has this size, in the specified class. */
340 for (mode
= GET_CLASS_NARROWEST_MODE (mclass
); mode
!= VOIDmode
;
341 mode
= GET_MODE_WIDER_MODE (mode
))
342 if (GET_MODE_PRECISION (mode
) == size
)
345 if (mclass
== MODE_INT
|| mclass
== MODE_PARTIAL_INT
)
346 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
347 if (int_n_data
[i
].bitsize
== size
348 && int_n_enabled_p
[i
])
349 return int_n_data
[i
].m
;
354 /* Similar, except passed a tree node. */
357 mode_for_size_tree (const_tree size
, enum mode_class mclass
, int limit
)
359 unsigned HOST_WIDE_INT uhwi
;
362 if (!tree_fits_uhwi_p (size
))
364 uhwi
= tree_to_uhwi (size
);
368 return mode_for_size (ui
, mclass
, limit
);
371 /* Similar, but never return BLKmode; return the narrowest mode that
372 contains at least the requested number of value bits. */
375 smallest_mode_for_size (unsigned int size
, enum mode_class mclass
)
377 machine_mode mode
= VOIDmode
;
380 /* Get the first mode which has at least this size, in the
382 for (mode
= GET_CLASS_NARROWEST_MODE (mclass
); mode
!= VOIDmode
;
383 mode
= GET_MODE_WIDER_MODE (mode
))
384 if (GET_MODE_PRECISION (mode
) >= size
)
387 if (mclass
== MODE_INT
|| mclass
== MODE_PARTIAL_INT
)
388 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
389 if (int_n_data
[i
].bitsize
>= size
390 && int_n_data
[i
].bitsize
< GET_MODE_PRECISION (mode
)
391 && int_n_enabled_p
[i
])
392 mode
= int_n_data
[i
].m
;
394 if (mode
== VOIDmode
)
400 /* Find an integer mode of the exact same size, or BLKmode on failure. */
403 int_mode_for_mode (machine_mode mode
)
405 switch (GET_MODE_CLASS (mode
))
408 case MODE_PARTIAL_INT
:
411 case MODE_COMPLEX_INT
:
412 case MODE_COMPLEX_FLOAT
:
414 case MODE_DECIMAL_FLOAT
:
415 case MODE_VECTOR_INT
:
416 case MODE_VECTOR_FLOAT
:
421 case MODE_VECTOR_FRACT
:
422 case MODE_VECTOR_ACCUM
:
423 case MODE_VECTOR_UFRACT
:
424 case MODE_VECTOR_UACCUM
:
425 case MODE_POINTER_BOUNDS
:
426 mode
= mode_for_size (GET_MODE_BITSIZE (mode
), MODE_INT
, 0);
433 /* ... fall through ... */
443 /* Find a mode that can be used for efficient bitwise operations on MODE.
444 Return BLKmode if no such mode exists. */
447 bitwise_mode_for_mode (machine_mode mode
)
449 /* Quick exit if we already have a suitable mode. */
450 unsigned int bitsize
= GET_MODE_BITSIZE (mode
);
451 if (SCALAR_INT_MODE_P (mode
) && bitsize
<= MAX_FIXED_MODE_SIZE
)
454 /* Reuse the sanity checks from int_mode_for_mode. */
455 gcc_checking_assert ((int_mode_for_mode (mode
), true));
457 /* Try to replace complex modes with complex modes. In general we
458 expect both components to be processed independently, so we only
459 care whether there is a register for the inner mode. */
460 if (COMPLEX_MODE_P (mode
))
462 machine_mode trial
= mode
;
463 if (GET_MODE_CLASS (mode
) != MODE_COMPLEX_INT
)
464 trial
= mode_for_size (bitsize
, MODE_COMPLEX_INT
, false);
466 && have_regs_of_mode
[GET_MODE_INNER (trial
)])
470 /* Try to replace vector modes with vector modes. Also try using vector
471 modes if an integer mode would be too big. */
472 if (VECTOR_MODE_P (mode
) || bitsize
> MAX_FIXED_MODE_SIZE
)
474 machine_mode trial
= mode
;
475 if (GET_MODE_CLASS (mode
) != MODE_VECTOR_INT
)
476 trial
= mode_for_size (bitsize
, MODE_VECTOR_INT
, 0);
478 && have_regs_of_mode
[trial
]
479 && targetm
.vector_mode_supported_p (trial
))
483 /* Otherwise fall back on integers while honoring MAX_FIXED_MODE_SIZE. */
484 return mode_for_size (bitsize
, MODE_INT
, true);
487 /* Find a type that can be used for efficient bitwise operations on MODE.
488 Return null if no such mode exists. */
491 bitwise_type_for_mode (machine_mode mode
)
493 mode
= bitwise_mode_for_mode (mode
);
497 unsigned int inner_size
= GET_MODE_UNIT_BITSIZE (mode
);
498 tree inner_type
= build_nonstandard_integer_type (inner_size
, true);
500 if (VECTOR_MODE_P (mode
))
501 return build_vector_type_for_mode (inner_type
, mode
);
503 if (COMPLEX_MODE_P (mode
))
504 return build_complex_type (inner_type
);
506 gcc_checking_assert (GET_MODE_INNER (mode
) == VOIDmode
);
510 /* Find a mode that is suitable for representing a vector with
511 NUNITS elements of mode INNERMODE. Returns BLKmode if there
512 is no suitable mode. */
515 mode_for_vector (machine_mode innermode
, unsigned nunits
)
519 /* First, look for a supported vector type. */
520 if (SCALAR_FLOAT_MODE_P (innermode
))
521 mode
= MIN_MODE_VECTOR_FLOAT
;
522 else if (SCALAR_FRACT_MODE_P (innermode
))
523 mode
= MIN_MODE_VECTOR_FRACT
;
524 else if (SCALAR_UFRACT_MODE_P (innermode
))
525 mode
= MIN_MODE_VECTOR_UFRACT
;
526 else if (SCALAR_ACCUM_MODE_P (innermode
))
527 mode
= MIN_MODE_VECTOR_ACCUM
;
528 else if (SCALAR_UACCUM_MODE_P (innermode
))
529 mode
= MIN_MODE_VECTOR_UACCUM
;
531 mode
= MIN_MODE_VECTOR_INT
;
533 /* Do not check vector_mode_supported_p here. We'll do that
534 later in vector_type_mode. */
535 for (; mode
!= VOIDmode
; mode
= GET_MODE_WIDER_MODE (mode
))
536 if (GET_MODE_NUNITS (mode
) == nunits
537 && GET_MODE_INNER (mode
) == innermode
)
540 /* For integers, try mapping it to a same-sized scalar mode. */
542 && GET_MODE_CLASS (innermode
) == MODE_INT
)
543 mode
= mode_for_size (nunits
* GET_MODE_BITSIZE (innermode
),
547 || (GET_MODE_CLASS (mode
) == MODE_INT
548 && !have_regs_of_mode
[mode
]))
554 /* Return the alignment of MODE. This will be bounded by 1 and
555 BIGGEST_ALIGNMENT. */
558 get_mode_alignment (machine_mode mode
)
560 return MIN (BIGGEST_ALIGNMENT
, MAX (1, mode_base_align
[mode
]*BITS_PER_UNIT
));
563 /* Return the precision of the mode, or for a complex or vector mode the
564 precision of the mode of its elements. */
567 element_precision (machine_mode mode
)
569 if (COMPLEX_MODE_P (mode
) || VECTOR_MODE_P (mode
))
570 mode
= GET_MODE_INNER (mode
);
572 return GET_MODE_PRECISION (mode
);
575 /* Return the natural mode of an array, given that it is SIZE bytes in
576 total and has elements of type ELEM_TYPE. */
579 mode_for_array (tree elem_type
, tree size
)
582 unsigned HOST_WIDE_INT int_size
, int_elem_size
;
585 /* One-element arrays get the component type's mode. */
586 elem_size
= TYPE_SIZE (elem_type
);
587 if (simple_cst_equal (size
, elem_size
))
588 return TYPE_MODE (elem_type
);
591 if (tree_fits_uhwi_p (size
) && tree_fits_uhwi_p (elem_size
))
593 int_size
= tree_to_uhwi (size
);
594 int_elem_size
= tree_to_uhwi (elem_size
);
595 if (int_elem_size
> 0
596 && int_size
% int_elem_size
== 0
597 && targetm
.array_mode_supported_p (TYPE_MODE (elem_type
),
598 int_size
/ int_elem_size
))
601 return mode_for_size_tree (size
, MODE_INT
, limit_p
);
604 /* Subroutine of layout_decl: Force alignment required for the data type.
605 But if the decl itself wants greater alignment, don't override that. */
608 do_type_align (tree type
, tree decl
)
610 if (TYPE_ALIGN (type
) > DECL_ALIGN (decl
))
612 DECL_ALIGN (decl
) = TYPE_ALIGN (type
);
613 if (TREE_CODE (decl
) == FIELD_DECL
)
614 DECL_USER_ALIGN (decl
) = TYPE_USER_ALIGN (type
);
618 /* Set the size, mode and alignment of a ..._DECL node.
619 TYPE_DECL does need this for C++.
620 Note that LABEL_DECL and CONST_DECL nodes do not need this,
621 and FUNCTION_DECL nodes have them set up in a special (and simple) way.
622 Don't call layout_decl for them.
624 KNOWN_ALIGN is the amount of alignment we can assume this
625 decl has with no special effort. It is relevant only for FIELD_DECLs
626 and depends on the previous fields.
627 All that matters about KNOWN_ALIGN is which powers of 2 divide it.
628 If KNOWN_ALIGN is 0, it means, "as much alignment as you like":
629 the record will be aligned to suit. */
632 layout_decl (tree decl
, unsigned int known_align
)
634 tree type
= TREE_TYPE (decl
);
635 enum tree_code code
= TREE_CODE (decl
);
637 location_t loc
= DECL_SOURCE_LOCATION (decl
);
639 if (code
== CONST_DECL
)
642 gcc_assert (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
643 || code
== TYPE_DECL
||code
== FIELD_DECL
);
645 rtl
= DECL_RTL_IF_SET (decl
);
647 if (type
== error_mark_node
)
648 type
= void_type_node
;
650 /* Usually the size and mode come from the data type without change,
651 however, the front-end may set the explicit width of the field, so its
652 size may not be the same as the size of its type. This happens with
653 bitfields, of course (an `int' bitfield may be only 2 bits, say), but it
654 also happens with other fields. For example, the C++ front-end creates
655 zero-sized fields corresponding to empty base classes, and depends on
656 layout_type setting DECL_FIELD_BITPOS correctly for the field. Set the
657 size in bytes from the size in bits. If we have already set the mode,
658 don't set it again since we can be called twice for FIELD_DECLs. */
660 DECL_UNSIGNED (decl
) = TYPE_UNSIGNED (type
);
661 if (DECL_MODE (decl
) == VOIDmode
)
662 DECL_MODE (decl
) = TYPE_MODE (type
);
664 if (DECL_SIZE (decl
) == 0)
666 DECL_SIZE (decl
) = TYPE_SIZE (type
);
667 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (type
);
669 else if (DECL_SIZE_UNIT (decl
) == 0)
670 DECL_SIZE_UNIT (decl
)
671 = fold_convert_loc (loc
, sizetype
,
672 size_binop_loc (loc
, CEIL_DIV_EXPR
, DECL_SIZE (decl
),
675 if (code
!= FIELD_DECL
)
676 /* For non-fields, update the alignment from the type. */
677 do_type_align (type
, decl
);
679 /* For fields, it's a bit more complicated... */
681 bool old_user_align
= DECL_USER_ALIGN (decl
);
682 bool zero_bitfield
= false;
683 bool packed_p
= DECL_PACKED (decl
);
686 if (DECL_BIT_FIELD (decl
))
688 DECL_BIT_FIELD_TYPE (decl
) = type
;
690 /* A zero-length bit-field affects the alignment of the next
691 field. In essence such bit-fields are not influenced by
692 any packing due to #pragma pack or attribute packed. */
693 if (integer_zerop (DECL_SIZE (decl
))
694 && ! targetm
.ms_bitfield_layout_p (DECL_FIELD_CONTEXT (decl
)))
696 zero_bitfield
= true;
698 if (PCC_BITFIELD_TYPE_MATTERS
)
699 do_type_align (type
, decl
);
702 #ifdef EMPTY_FIELD_BOUNDARY
703 if (EMPTY_FIELD_BOUNDARY
> DECL_ALIGN (decl
))
705 DECL_ALIGN (decl
) = EMPTY_FIELD_BOUNDARY
;
706 DECL_USER_ALIGN (decl
) = 0;
712 /* See if we can use an ordinary integer mode for a bit-field.
713 Conditions are: a fixed size that is correct for another mode,
714 occupying a complete byte or bytes on proper boundary. */
715 if (TYPE_SIZE (type
) != 0
716 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
717 && GET_MODE_CLASS (TYPE_MODE (type
)) == MODE_INT
)
720 = mode_for_size_tree (DECL_SIZE (decl
), MODE_INT
, 1);
721 unsigned int xalign
= GET_MODE_ALIGNMENT (xmode
);
724 && !(xalign
> BITS_PER_UNIT
&& DECL_PACKED (decl
))
725 && (known_align
== 0 || known_align
>= xalign
))
727 DECL_ALIGN (decl
) = MAX (xalign
, DECL_ALIGN (decl
));
728 DECL_MODE (decl
) = xmode
;
729 DECL_BIT_FIELD (decl
) = 0;
733 /* Turn off DECL_BIT_FIELD if we won't need it set. */
734 if (TYPE_MODE (type
) == BLKmode
&& DECL_MODE (decl
) == BLKmode
735 && known_align
>= TYPE_ALIGN (type
)
736 && DECL_ALIGN (decl
) >= TYPE_ALIGN (type
))
737 DECL_BIT_FIELD (decl
) = 0;
739 else if (packed_p
&& DECL_USER_ALIGN (decl
))
740 /* Don't touch DECL_ALIGN. For other packed fields, go ahead and
741 round up; we'll reduce it again below. We want packing to
742 supersede USER_ALIGN inherited from the type, but defer to
743 alignment explicitly specified on the field decl. */;
745 do_type_align (type
, decl
);
747 /* If the field is packed and not explicitly aligned, give it the
748 minimum alignment. Note that do_type_align may set
749 DECL_USER_ALIGN, so we need to check old_user_align instead. */
752 DECL_ALIGN (decl
) = MIN (DECL_ALIGN (decl
), BITS_PER_UNIT
);
754 if (! packed_p
&& ! DECL_USER_ALIGN (decl
))
756 /* Some targets (i.e. i386, VMS) limit struct field alignment
757 to a lower boundary than alignment of variables unless
758 it was overridden by attribute aligned. */
759 #ifdef BIGGEST_FIELD_ALIGNMENT
761 = MIN (DECL_ALIGN (decl
), (unsigned) BIGGEST_FIELD_ALIGNMENT
);
763 #ifdef ADJUST_FIELD_ALIGN
764 DECL_ALIGN (decl
) = ADJUST_FIELD_ALIGN (decl
, DECL_ALIGN (decl
));
769 mfa
= initial_max_fld_align
* BITS_PER_UNIT
;
771 mfa
= maximum_field_alignment
;
772 /* Should this be controlled by DECL_USER_ALIGN, too? */
774 DECL_ALIGN (decl
) = MIN (DECL_ALIGN (decl
), mfa
);
777 /* Evaluate nonconstant size only once, either now or as soon as safe. */
778 if (DECL_SIZE (decl
) != 0 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
779 DECL_SIZE (decl
) = variable_size (DECL_SIZE (decl
));
780 if (DECL_SIZE_UNIT (decl
) != 0
781 && TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
)
782 DECL_SIZE_UNIT (decl
) = variable_size (DECL_SIZE_UNIT (decl
));
784 /* If requested, warn about definitions of large data objects. */
786 && (code
== VAR_DECL
|| code
== PARM_DECL
)
787 && ! DECL_EXTERNAL (decl
))
789 tree size
= DECL_SIZE_UNIT (decl
);
791 if (size
!= 0 && TREE_CODE (size
) == INTEGER_CST
792 && compare_tree_int (size
, larger_than_size
) > 0)
794 int size_as_int
= TREE_INT_CST_LOW (size
);
796 if (compare_tree_int (size
, size_as_int
) == 0)
797 warning (OPT_Wlarger_than_
, "size of %q+D is %d bytes", decl
, size_as_int
);
799 warning (OPT_Wlarger_than_
, "size of %q+D is larger than %wd bytes",
800 decl
, larger_than_size
);
804 /* If the RTL was already set, update its mode and mem attributes. */
807 PUT_MODE (rtl
, DECL_MODE (decl
));
808 SET_DECL_RTL (decl
, 0);
809 set_mem_attributes (rtl
, decl
, 1);
810 SET_DECL_RTL (decl
, rtl
);
814 /* Given a VAR_DECL, PARM_DECL or RESULT_DECL, clears the results of
815 a previous call to layout_decl and calls it again. */
818 relayout_decl (tree decl
)
820 DECL_SIZE (decl
) = DECL_SIZE_UNIT (decl
) = 0;
821 DECL_MODE (decl
) = VOIDmode
;
822 if (!DECL_USER_ALIGN (decl
))
823 DECL_ALIGN (decl
) = 0;
824 SET_DECL_RTL (decl
, 0);
826 layout_decl (decl
, 0);
829 /* Begin laying out type T, which may be a RECORD_TYPE, UNION_TYPE, or
830 QUAL_UNION_TYPE. Return a pointer to a struct record_layout_info which
831 is to be passed to all other layout functions for this record. It is the
832 responsibility of the caller to call `free' for the storage returned.
833 Note that garbage collection is not permitted until we finish laying
837 start_record_layout (tree t
)
839 record_layout_info rli
= XNEW (struct record_layout_info_s
);
843 /* If the type has a minimum specified alignment (via an attribute
844 declaration, for example) use it -- otherwise, start with a
845 one-byte alignment. */
846 rli
->record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (t
));
847 rli
->unpacked_align
= rli
->record_align
;
848 rli
->offset_align
= MAX (rli
->record_align
, BIGGEST_ALIGNMENT
);
850 #ifdef STRUCTURE_SIZE_BOUNDARY
851 /* Packed structures don't need to have minimum size. */
852 if (! TYPE_PACKED (t
))
856 /* #pragma pack overrides STRUCTURE_SIZE_BOUNDARY. */
857 tmp
= (unsigned) STRUCTURE_SIZE_BOUNDARY
;
858 if (maximum_field_alignment
!= 0)
859 tmp
= MIN (tmp
, maximum_field_alignment
);
860 rli
->record_align
= MAX (rli
->record_align
, tmp
);
864 rli
->offset
= size_zero_node
;
865 rli
->bitpos
= bitsize_zero_node
;
867 rli
->pending_statics
= 0;
868 rli
->packed_maybe_necessary
= 0;
869 rli
->remaining_in_alignment
= 0;
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 if (TREE_CODE (offset
) == PLUS_EXPR
)
887 offset
= size_binop (PLUS_EXPR
,
888 fold_convert (bitsizetype
, TREE_OPERAND (offset
, 0)),
889 fold_convert (bitsizetype
, TREE_OPERAND (offset
, 1)));
891 offset
= fold_convert (bitsizetype
, offset
);
892 return size_binop (PLUS_EXPR
, bitpos
,
893 size_binop (MULT_EXPR
, offset
, bitsize_unit_node
));
896 /* Return the combined truncated byte position for the byte offset OFFSET and
897 the bit position BITPOS. */
900 byte_from_pos (tree offset
, tree bitpos
)
903 if (TREE_CODE (bitpos
) == MULT_EXPR
904 && tree_int_cst_equal (TREE_OPERAND (bitpos
, 1), bitsize_unit_node
))
905 bytepos
= TREE_OPERAND (bitpos
, 0);
907 bytepos
= size_binop (TRUNC_DIV_EXPR
, bitpos
, bitsize_unit_node
);
908 return size_binop (PLUS_EXPR
, offset
, fold_convert (sizetype
, bytepos
));
911 /* Split the bit position POS into a byte offset *POFFSET and a bit
912 position *PBITPOS with the byte offset aligned to OFF_ALIGN bits. */
915 pos_from_bit (tree
*poffset
, tree
*pbitpos
, unsigned int off_align
,
918 tree toff_align
= bitsize_int (off_align
);
919 if (TREE_CODE (pos
) == MULT_EXPR
920 && tree_int_cst_equal (TREE_OPERAND (pos
, 1), toff_align
))
922 *poffset
= size_binop (MULT_EXPR
,
923 fold_convert (sizetype
, TREE_OPERAND (pos
, 0)),
924 size_int (off_align
/ BITS_PER_UNIT
));
925 *pbitpos
= bitsize_zero_node
;
929 *poffset
= size_binop (MULT_EXPR
,
930 fold_convert (sizetype
,
931 size_binop (FLOOR_DIV_EXPR
, pos
,
933 size_int (off_align
/ BITS_PER_UNIT
));
934 *pbitpos
= size_binop (FLOOR_MOD_EXPR
, pos
, toff_align
);
938 /* Given a pointer to bit and byte offsets and an offset alignment,
939 normalize the offsets so they are within the alignment. */
942 normalize_offset (tree
*poffset
, tree
*pbitpos
, unsigned int off_align
)
944 /* If the bit position is now larger than it should be, adjust it
946 if (compare_tree_int (*pbitpos
, off_align
) >= 0)
949 pos_from_bit (&offset
, &bitpos
, off_align
, *pbitpos
);
950 *poffset
= size_binop (PLUS_EXPR
, *poffset
, offset
);
955 /* Print debugging information about the information in RLI. */
958 debug_rli (record_layout_info rli
)
960 print_node_brief (stderr
, "type", rli
->t
, 0);
961 print_node_brief (stderr
, "\noffset", rli
->offset
, 0);
962 print_node_brief (stderr
, " bitpos", rli
->bitpos
, 0);
964 fprintf (stderr
, "\naligns: rec = %u, unpack = %u, off = %u\n",
965 rli
->record_align
, rli
->unpacked_align
,
968 /* The ms_struct code is the only that uses this. */
969 if (targetm
.ms_bitfield_layout_p (rli
->t
))
970 fprintf (stderr
, "remaining in alignment = %u\n", rli
->remaining_in_alignment
);
972 if (rli
->packed_maybe_necessary
)
973 fprintf (stderr
, "packed may be necessary\n");
975 if (!vec_safe_is_empty (rli
->pending_statics
))
977 fprintf (stderr
, "pending statics:\n");
978 debug_vec_tree (rli
->pending_statics
);
982 /* Given an RLI with a possibly-incremented BITPOS, adjust OFFSET and
983 BITPOS if necessary to keep BITPOS below OFFSET_ALIGN. */
986 normalize_rli (record_layout_info rli
)
988 normalize_offset (&rli
->offset
, &rli
->bitpos
, rli
->offset_align
);
991 /* Returns the size in bytes allocated so far. */
994 rli_size_unit_so_far (record_layout_info rli
)
996 return byte_from_pos (rli
->offset
, rli
->bitpos
);
999 /* Returns the size in bits allocated so far. */
1002 rli_size_so_far (record_layout_info rli
)
1004 return bit_from_pos (rli
->offset
, rli
->bitpos
);
1007 /* FIELD is about to be added to RLI->T. The alignment (in bits) of
1008 the next available location within the record is given by KNOWN_ALIGN.
1009 Update the variable alignment fields in RLI, and return the alignment
1010 to give the FIELD. */
1013 update_alignment_for_field (record_layout_info rli
, tree field
,
1014 unsigned int known_align
)
1016 /* The alignment required for FIELD. */
1017 unsigned int desired_align
;
1018 /* The type of this field. */
1019 tree type
= TREE_TYPE (field
);
1020 /* True if the field was explicitly aligned by the user. */
1024 /* Do not attempt to align an ERROR_MARK node */
1025 if (TREE_CODE (type
) == ERROR_MARK
)
1028 /* Lay out the field so we know what alignment it needs. */
1029 layout_decl (field
, known_align
);
1030 desired_align
= DECL_ALIGN (field
);
1031 user_align
= DECL_USER_ALIGN (field
);
1033 is_bitfield
= (type
!= error_mark_node
1034 && DECL_BIT_FIELD_TYPE (field
)
1035 && ! integer_zerop (TYPE_SIZE (type
)));
1037 /* Record must have at least as much alignment as any field.
1038 Otherwise, the alignment of the field within the record is
1040 if (targetm
.ms_bitfield_layout_p (rli
->t
))
1042 /* Here, the alignment of the underlying type of a bitfield can
1043 affect the alignment of a record; even a zero-sized field
1044 can do this. The alignment should be to the alignment of
1045 the type, except that for zero-size bitfields this only
1046 applies if there was an immediately prior, nonzero-size
1047 bitfield. (That's the way it is, experimentally.) */
1048 if ((!is_bitfield
&& !DECL_PACKED (field
))
1049 || ((DECL_SIZE (field
) == NULL_TREE
1050 || !integer_zerop (DECL_SIZE (field
)))
1051 ? !DECL_PACKED (field
)
1053 && DECL_BIT_FIELD_TYPE (rli
->prev_field
)
1054 && ! integer_zerop (DECL_SIZE (rli
->prev_field
)))))
1056 unsigned int type_align
= TYPE_ALIGN (type
);
1057 type_align
= MAX (type_align
, desired_align
);
1058 if (maximum_field_alignment
!= 0)
1059 type_align
= MIN (type_align
, maximum_field_alignment
);
1060 rli
->record_align
= MAX (rli
->record_align
, type_align
);
1061 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
1064 else if (is_bitfield
&& PCC_BITFIELD_TYPE_MATTERS
)
1066 /* Named bit-fields cause the entire structure to have the
1067 alignment implied by their type. Some targets also apply the same
1068 rules to unnamed bitfields. */
1069 if (DECL_NAME (field
) != 0
1070 || targetm
.align_anon_bitfield ())
1072 unsigned int type_align
= TYPE_ALIGN (type
);
1074 #ifdef ADJUST_FIELD_ALIGN
1075 if (! TYPE_USER_ALIGN (type
))
1076 type_align
= ADJUST_FIELD_ALIGN (field
, type_align
);
1079 /* Targets might chose to handle unnamed and hence possibly
1080 zero-width bitfield. Those are not influenced by #pragmas
1081 or packed attributes. */
1082 if (integer_zerop (DECL_SIZE (field
)))
1084 if (initial_max_fld_align
)
1085 type_align
= MIN (type_align
,
1086 initial_max_fld_align
* BITS_PER_UNIT
);
1088 else if (maximum_field_alignment
!= 0)
1089 type_align
= MIN (type_align
, maximum_field_alignment
);
1090 else if (DECL_PACKED (field
))
1091 type_align
= MIN (type_align
, BITS_PER_UNIT
);
1093 /* The alignment of the record is increased to the maximum
1094 of the current alignment, the alignment indicated on the
1095 field (i.e., the alignment specified by an __aligned__
1096 attribute), and the alignment indicated by the type of
1098 rli
->record_align
= MAX (rli
->record_align
, desired_align
);
1099 rli
->record_align
= MAX (rli
->record_align
, type_align
);
1102 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
1103 user_align
|= TYPE_USER_ALIGN (type
);
1108 rli
->record_align
= MAX (rli
->record_align
, desired_align
);
1109 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
1112 TYPE_USER_ALIGN (rli
->t
) |= user_align
;
1114 return desired_align
;
1117 /* Called from place_field to handle unions. */
1120 place_union_field (record_layout_info rli
, tree field
)
1122 update_alignment_for_field (rli
, field
, /*known_align=*/0);
1124 DECL_FIELD_OFFSET (field
) = size_zero_node
;
1125 DECL_FIELD_BIT_OFFSET (field
) = bitsize_zero_node
;
1126 SET_DECL_OFFSET_ALIGN (field
, BIGGEST_ALIGNMENT
);
1128 /* If this is an ERROR_MARK return *after* having set the
1129 field at the start of the union. This helps when parsing
1131 if (TREE_CODE (TREE_TYPE (field
)) == ERROR_MARK
)
1134 /* We assume the union's size will be a multiple of a byte so we don't
1135 bother with BITPOS. */
1136 if (TREE_CODE (rli
->t
) == UNION_TYPE
)
1137 rli
->offset
= size_binop (MAX_EXPR
, rli
->offset
, DECL_SIZE_UNIT (field
));
1138 else if (TREE_CODE (rli
->t
) == QUAL_UNION_TYPE
)
1139 rli
->offset
= fold_build3 (COND_EXPR
, sizetype
, DECL_QUALIFIER (field
),
1140 DECL_SIZE_UNIT (field
), rli
->offset
);
1143 /* A bitfield of SIZE with a required access alignment of ALIGN is allocated
1144 at BYTE_OFFSET / BIT_OFFSET. Return nonzero if the field would span more
1145 units of alignment than the underlying TYPE. */
1147 excess_unit_span (HOST_WIDE_INT byte_offset
, HOST_WIDE_INT bit_offset
,
1148 HOST_WIDE_INT size
, HOST_WIDE_INT align
, tree type
)
1150 /* Note that the calculation of OFFSET might overflow; we calculate it so
1151 that we still get the right result as long as ALIGN is a power of two. */
1152 unsigned HOST_WIDE_INT offset
= byte_offset
* BITS_PER_UNIT
+ bit_offset
;
1154 offset
= offset
% align
;
1155 return ((offset
+ size
+ align
- 1) / align
1156 > tree_to_uhwi (TYPE_SIZE (type
)) / align
);
1159 /* RLI contains information about the layout of a RECORD_TYPE. FIELD
1160 is a FIELD_DECL to be added after those fields already present in
1161 T. (FIELD is not actually added to the TYPE_FIELDS list here;
1162 callers that desire that behavior must manually perform that step.) */
1165 place_field (record_layout_info rli
, tree field
)
1167 /* The alignment required for FIELD. */
1168 unsigned int desired_align
;
1169 /* The alignment FIELD would have if we just dropped it into the
1170 record as it presently stands. */
1171 unsigned int known_align
;
1172 unsigned int actual_align
;
1173 /* The type of this field. */
1174 tree type
= TREE_TYPE (field
);
1176 gcc_assert (TREE_CODE (field
) != ERROR_MARK
);
1178 /* If FIELD is static, then treat it like a separate variable, not
1179 really like a structure field. If it is a FUNCTION_DECL, it's a
1180 method. In both cases, all we do is lay out the decl, and we do
1181 it *after* the record is laid out. */
1182 if (TREE_CODE (field
) == VAR_DECL
)
1184 vec_safe_push (rli
->pending_statics
, field
);
1188 /* Enumerators and enum types which are local to this class need not
1189 be laid out. Likewise for initialized constant fields. */
1190 else if (TREE_CODE (field
) != FIELD_DECL
)
1193 /* Unions are laid out very differently than records, so split
1194 that code off to another function. */
1195 else if (TREE_CODE (rli
->t
) != RECORD_TYPE
)
1197 place_union_field (rli
, field
);
1201 else if (TREE_CODE (type
) == ERROR_MARK
)
1203 /* Place this field at the current allocation position, so we
1204 maintain monotonicity. */
1205 DECL_FIELD_OFFSET (field
) = rli
->offset
;
1206 DECL_FIELD_BIT_OFFSET (field
) = rli
->bitpos
;
1207 SET_DECL_OFFSET_ALIGN (field
, rli
->offset_align
);
1211 /* Work out the known alignment so far. Note that A & (-A) is the
1212 value of the least-significant bit in A that is one. */
1213 if (! integer_zerop (rli
->bitpos
))
1214 known_align
= (tree_to_uhwi (rli
->bitpos
)
1215 & - tree_to_uhwi (rli
->bitpos
));
1216 else if (integer_zerop (rli
->offset
))
1218 else if (tree_fits_uhwi_p (rli
->offset
))
1219 known_align
= (BITS_PER_UNIT
1220 * (tree_to_uhwi (rli
->offset
)
1221 & - tree_to_uhwi (rli
->offset
)));
1223 known_align
= rli
->offset_align
;
1225 desired_align
= update_alignment_for_field (rli
, field
, known_align
);
1226 if (known_align
== 0)
1227 known_align
= MAX (BIGGEST_ALIGNMENT
, rli
->record_align
);
1229 if (warn_packed
&& DECL_PACKED (field
))
1231 if (known_align
>= TYPE_ALIGN (type
))
1233 if (TYPE_ALIGN (type
) > desired_align
)
1235 if (STRICT_ALIGNMENT
)
1236 warning (OPT_Wattributes
, "packed attribute causes "
1237 "inefficient alignment for %q+D", field
);
1238 /* Don't warn if DECL_PACKED was set by the type. */
1239 else if (!TYPE_PACKED (rli
->t
))
1240 warning (OPT_Wattributes
, "packed attribute is "
1241 "unnecessary for %q+D", field
);
1245 rli
->packed_maybe_necessary
= 1;
1248 /* Does this field automatically have alignment it needs by virtue
1249 of the fields that precede it and the record's own alignment? */
1250 if (known_align
< desired_align
)
1252 /* No, we need to skip space before this field.
1253 Bump the cumulative size to multiple of field alignment. */
1255 if (!targetm
.ms_bitfield_layout_p (rli
->t
)
1256 && DECL_SOURCE_LOCATION (field
) != BUILTINS_LOCATION
)
1257 warning (OPT_Wpadded
, "padding struct to align %q+D", field
);
1259 /* If the alignment is still within offset_align, just align
1260 the bit position. */
1261 if (desired_align
< rli
->offset_align
)
1262 rli
->bitpos
= round_up (rli
->bitpos
, desired_align
);
1265 /* First adjust OFFSET by the partial bits, then align. */
1267 = size_binop (PLUS_EXPR
, rli
->offset
,
1268 fold_convert (sizetype
,
1269 size_binop (CEIL_DIV_EXPR
, rli
->bitpos
,
1270 bitsize_unit_node
)));
1271 rli
->bitpos
= bitsize_zero_node
;
1273 rli
->offset
= round_up (rli
->offset
, desired_align
/ BITS_PER_UNIT
);
1276 if (! TREE_CONSTANT (rli
->offset
))
1277 rli
->offset_align
= desired_align
;
1278 if (targetm
.ms_bitfield_layout_p (rli
->t
))
1279 rli
->prev_field
= NULL
;
1282 /* Handle compatibility with PCC. Note that if the record has any
1283 variable-sized fields, we need not worry about compatibility. */
1284 if (PCC_BITFIELD_TYPE_MATTERS
1285 && ! targetm
.ms_bitfield_layout_p (rli
->t
)
1286 && TREE_CODE (field
) == FIELD_DECL
1287 && type
!= error_mark_node
1288 && DECL_BIT_FIELD (field
)
1289 && (! DECL_PACKED (field
)
1290 /* Enter for these packed fields only to issue a warning. */
1291 || TYPE_ALIGN (type
) <= BITS_PER_UNIT
)
1292 && maximum_field_alignment
== 0
1293 && ! integer_zerop (DECL_SIZE (field
))
1294 && tree_fits_uhwi_p (DECL_SIZE (field
))
1295 && tree_fits_uhwi_p (rli
->offset
)
1296 && tree_fits_uhwi_p (TYPE_SIZE (type
)))
1298 unsigned int type_align
= TYPE_ALIGN (type
);
1299 tree dsize
= DECL_SIZE (field
);
1300 HOST_WIDE_INT field_size
= tree_to_uhwi (dsize
);
1301 HOST_WIDE_INT offset
= tree_to_uhwi (rli
->offset
);
1302 HOST_WIDE_INT bit_offset
= tree_to_shwi (rli
->bitpos
);
1304 #ifdef ADJUST_FIELD_ALIGN
1305 if (! TYPE_USER_ALIGN (type
))
1306 type_align
= ADJUST_FIELD_ALIGN (field
, type_align
);
1309 /* A bit field may not span more units of alignment of its type
1310 than its type itself. Advance to next boundary if necessary. */
1311 if (excess_unit_span (offset
, bit_offset
, field_size
, type_align
, type
))
1313 if (DECL_PACKED (field
))
1315 if (warn_packed_bitfield_compat
== 1)
1318 "offset of packed bit-field %qD has changed in GCC 4.4",
1322 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1325 if (! DECL_PACKED (field
))
1326 TYPE_USER_ALIGN (rli
->t
) |= TYPE_USER_ALIGN (type
);
1329 #ifdef BITFIELD_NBYTES_LIMITED
1330 if (BITFIELD_NBYTES_LIMITED
1331 && ! targetm
.ms_bitfield_layout_p (rli
->t
)
1332 && TREE_CODE (field
) == FIELD_DECL
1333 && type
!= error_mark_node
1334 && DECL_BIT_FIELD_TYPE (field
)
1335 && ! DECL_PACKED (field
)
1336 && ! integer_zerop (DECL_SIZE (field
))
1337 && tree_fits_uhwi_p (DECL_SIZE (field
))
1338 && tree_fits_uhwi_p (rli
->offset
)
1339 && tree_fits_uhwi_p (TYPE_SIZE (type
)))
1341 unsigned int type_align
= TYPE_ALIGN (type
);
1342 tree dsize
= DECL_SIZE (field
);
1343 HOST_WIDE_INT field_size
= tree_to_uhwi (dsize
);
1344 HOST_WIDE_INT offset
= tree_to_uhwi (rli
->offset
);
1345 HOST_WIDE_INT bit_offset
= tree_to_shwi (rli
->bitpos
);
1347 #ifdef ADJUST_FIELD_ALIGN
1348 if (! TYPE_USER_ALIGN (type
))
1349 type_align
= ADJUST_FIELD_ALIGN (field
, type_align
);
1352 if (maximum_field_alignment
!= 0)
1353 type_align
= MIN (type_align
, maximum_field_alignment
);
1354 /* ??? This test is opposite the test in the containing if
1355 statement, so this code is unreachable currently. */
1356 else if (DECL_PACKED (field
))
1357 type_align
= MIN (type_align
, BITS_PER_UNIT
);
1359 /* A bit field may not span the unit of alignment of its type.
1360 Advance to next boundary if necessary. */
1361 if (excess_unit_span (offset
, bit_offset
, field_size
, type_align
, type
))
1362 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1364 TYPE_USER_ALIGN (rli
->t
) |= TYPE_USER_ALIGN (type
);
1368 /* See the docs for TARGET_MS_BITFIELD_LAYOUT_P for details.
1370 When a bit field is inserted into a packed record, the whole
1371 size of the underlying type is used by one or more same-size
1372 adjacent bitfields. (That is, if its long:3, 32 bits is
1373 used in the record, and any additional adjacent long bitfields are
1374 packed into the same chunk of 32 bits. However, if the size
1375 changes, a new field of that size is allocated.) In an unpacked
1376 record, this is the same as using alignment, but not equivalent
1379 Note: for compatibility, we use the type size, not the type alignment
1380 to determine alignment, since that matches the documentation */
1382 if (targetm
.ms_bitfield_layout_p (rli
->t
))
1384 tree prev_saved
= rli
->prev_field
;
1385 tree prev_type
= prev_saved
? DECL_BIT_FIELD_TYPE (prev_saved
) : NULL
;
1387 /* This is a bitfield if it exists. */
1388 if (rli
->prev_field
)
1390 /* If both are bitfields, nonzero, and the same size, this is
1391 the middle of a run. Zero declared size fields are special
1392 and handled as "end of run". (Note: it's nonzero declared
1393 size, but equal type sizes!) (Since we know that both
1394 the current and previous fields are bitfields by the
1395 time we check it, DECL_SIZE must be present for both.) */
1396 if (DECL_BIT_FIELD_TYPE (field
)
1397 && !integer_zerop (DECL_SIZE (field
))
1398 && !integer_zerop (DECL_SIZE (rli
->prev_field
))
1399 && tree_fits_shwi_p (DECL_SIZE (rli
->prev_field
))
1400 && tree_fits_uhwi_p (TYPE_SIZE (type
))
1401 && simple_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (prev_type
)))
1403 /* We're in the middle of a run of equal type size fields; make
1404 sure we realign if we run out of bits. (Not decl size,
1406 HOST_WIDE_INT bitsize
= tree_to_uhwi (DECL_SIZE (field
));
1408 if (rli
->remaining_in_alignment
< bitsize
)
1410 HOST_WIDE_INT typesize
= tree_to_uhwi (TYPE_SIZE (type
));
1412 /* out of bits; bump up to next 'word'. */
1414 = size_binop (PLUS_EXPR
, rli
->bitpos
,
1415 bitsize_int (rli
->remaining_in_alignment
));
1416 rli
->prev_field
= field
;
1417 if (typesize
< bitsize
)
1418 rli
->remaining_in_alignment
= 0;
1420 rli
->remaining_in_alignment
= typesize
- bitsize
;
1423 rli
->remaining_in_alignment
-= bitsize
;
1427 /* End of a run: if leaving a run of bitfields of the same type
1428 size, we have to "use up" the rest of the bits of the type
1431 Compute the new position as the sum of the size for the prior
1432 type and where we first started working on that type.
1433 Note: since the beginning of the field was aligned then
1434 of course the end will be too. No round needed. */
1436 if (!integer_zerop (DECL_SIZE (rli
->prev_field
)))
1439 = size_binop (PLUS_EXPR
, rli
->bitpos
,
1440 bitsize_int (rli
->remaining_in_alignment
));
1443 /* We "use up" size zero fields; the code below should behave
1444 as if the prior field was not a bitfield. */
1447 /* Cause a new bitfield to be captured, either this time (if
1448 currently a bitfield) or next time we see one. */
1449 if (!DECL_BIT_FIELD_TYPE (field
)
1450 || integer_zerop (DECL_SIZE (field
)))
1451 rli
->prev_field
= NULL
;
1454 normalize_rli (rli
);
1457 /* If we're starting a new run of same type size bitfields
1458 (or a run of non-bitfields), set up the "first of the run"
1461 That is, if the current field is not a bitfield, or if there
1462 was a prior bitfield the type sizes differ, or if there wasn't
1463 a prior bitfield the size of the current field is nonzero.
1465 Note: we must be sure to test ONLY the type size if there was
1466 a prior bitfield and ONLY for the current field being zero if
1469 if (!DECL_BIT_FIELD_TYPE (field
)
1470 || (prev_saved
!= NULL
1471 ? !simple_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (prev_type
))
1472 : !integer_zerop (DECL_SIZE (field
)) ))
1474 /* Never smaller than a byte for compatibility. */
1475 unsigned int type_align
= BITS_PER_UNIT
;
1477 /* (When not a bitfield), we could be seeing a flex array (with
1478 no DECL_SIZE). Since we won't be using remaining_in_alignment
1479 until we see a bitfield (and come by here again) we just skip
1481 if (DECL_SIZE (field
) != NULL
1482 && tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (field
)))
1483 && tree_fits_uhwi_p (DECL_SIZE (field
)))
1485 unsigned HOST_WIDE_INT bitsize
1486 = tree_to_uhwi (DECL_SIZE (field
));
1487 unsigned HOST_WIDE_INT typesize
1488 = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (field
)));
1490 if (typesize
< bitsize
)
1491 rli
->remaining_in_alignment
= 0;
1493 rli
->remaining_in_alignment
= typesize
- bitsize
;
1496 /* Now align (conventionally) for the new type. */
1497 type_align
= TYPE_ALIGN (TREE_TYPE (field
));
1499 if (maximum_field_alignment
!= 0)
1500 type_align
= MIN (type_align
, maximum_field_alignment
);
1502 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1504 /* If we really aligned, don't allow subsequent bitfields
1506 rli
->prev_field
= NULL
;
1510 /* Offset so far becomes the position of this field after normalizing. */
1511 normalize_rli (rli
);
1512 DECL_FIELD_OFFSET (field
) = rli
->offset
;
1513 DECL_FIELD_BIT_OFFSET (field
) = rli
->bitpos
;
1514 SET_DECL_OFFSET_ALIGN (field
, rli
->offset_align
);
1516 /* Evaluate nonconstant offsets only once, either now or as soon as safe. */
1517 if (TREE_CODE (DECL_FIELD_OFFSET (field
)) != INTEGER_CST
)
1518 DECL_FIELD_OFFSET (field
) = variable_size (DECL_FIELD_OFFSET (field
));
1520 /* If this field ended up more aligned than we thought it would be (we
1521 approximate this by seeing if its position changed), lay out the field
1522 again; perhaps we can use an integral mode for it now. */
1523 if (! integer_zerop (DECL_FIELD_BIT_OFFSET (field
)))
1524 actual_align
= (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field
))
1525 & - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field
)));
1526 else if (integer_zerop (DECL_FIELD_OFFSET (field
)))
1527 actual_align
= MAX (BIGGEST_ALIGNMENT
, rli
->record_align
);
1528 else if (tree_fits_uhwi_p (DECL_FIELD_OFFSET (field
)))
1529 actual_align
= (BITS_PER_UNIT
1530 * (tree_to_uhwi (DECL_FIELD_OFFSET (field
))
1531 & - tree_to_uhwi (DECL_FIELD_OFFSET (field
))));
1533 actual_align
= DECL_OFFSET_ALIGN (field
);
1534 /* ACTUAL_ALIGN is still the actual alignment *within the record* .
1535 store / extract bit field operations will check the alignment of the
1536 record against the mode of bit fields. */
1538 if (known_align
!= actual_align
)
1539 layout_decl (field
, actual_align
);
1541 if (rli
->prev_field
== NULL
&& DECL_BIT_FIELD_TYPE (field
))
1542 rli
->prev_field
= field
;
1544 /* Now add size of this field to the size of the record. If the size is
1545 not constant, treat the field as being a multiple of bytes and just
1546 adjust the offset, resetting the bit position. Otherwise, apportion the
1547 size amongst the bit position and offset. First handle the case of an
1548 unspecified size, which can happen when we have an invalid nested struct
1549 definition, such as struct j { struct j { int i; } }. The error message
1550 is printed in finish_struct. */
1551 if (DECL_SIZE (field
) == 0)
1553 else if (TREE_CODE (DECL_SIZE (field
)) != INTEGER_CST
1554 || TREE_OVERFLOW (DECL_SIZE (field
)))
1557 = size_binop (PLUS_EXPR
, rli
->offset
,
1558 fold_convert (sizetype
,
1559 size_binop (CEIL_DIV_EXPR
, rli
->bitpos
,
1560 bitsize_unit_node
)));
1562 = size_binop (PLUS_EXPR
, rli
->offset
, DECL_SIZE_UNIT (field
));
1563 rli
->bitpos
= bitsize_zero_node
;
1564 rli
->offset_align
= MIN (rli
->offset_align
, desired_align
);
1566 else if (targetm
.ms_bitfield_layout_p (rli
->t
))
1568 rli
->bitpos
= size_binop (PLUS_EXPR
, rli
->bitpos
, DECL_SIZE (field
));
1570 /* If we ended a bitfield before the full length of the type then
1571 pad the struct out to the full length of the last type. */
1572 if ((DECL_CHAIN (field
) == NULL
1573 || TREE_CODE (DECL_CHAIN (field
)) != FIELD_DECL
)
1574 && DECL_BIT_FIELD_TYPE (field
)
1575 && !integer_zerop (DECL_SIZE (field
)))
1576 rli
->bitpos
= size_binop (PLUS_EXPR
, rli
->bitpos
,
1577 bitsize_int (rli
->remaining_in_alignment
));
1579 normalize_rli (rli
);
1583 rli
->bitpos
= size_binop (PLUS_EXPR
, rli
->bitpos
, DECL_SIZE (field
));
1584 normalize_rli (rli
);
1588 /* Assuming that all the fields have been laid out, this function uses
1589 RLI to compute the final TYPE_SIZE, TYPE_ALIGN, etc. for the type
1590 indicated by RLI. */
1593 finalize_record_size (record_layout_info rli
)
1595 tree unpadded_size
, unpadded_size_unit
;
1597 /* Now we want just byte and bit offsets, so set the offset alignment
1598 to be a byte and then normalize. */
1599 rli
->offset_align
= BITS_PER_UNIT
;
1600 normalize_rli (rli
);
1602 /* Determine the desired alignment. */
1603 #ifdef ROUND_TYPE_ALIGN
1604 TYPE_ALIGN (rli
->t
) = ROUND_TYPE_ALIGN (rli
->t
, TYPE_ALIGN (rli
->t
),
1607 TYPE_ALIGN (rli
->t
) = MAX (TYPE_ALIGN (rli
->t
), rli
->record_align
);
1610 /* Compute the size so far. Be sure to allow for extra bits in the
1611 size in bytes. We have guaranteed above that it will be no more
1612 than a single byte. */
1613 unpadded_size
= rli_size_so_far (rli
);
1614 unpadded_size_unit
= rli_size_unit_so_far (rli
);
1615 if (! integer_zerop (rli
->bitpos
))
1617 = size_binop (PLUS_EXPR
, unpadded_size_unit
, size_one_node
);
1619 /* Round the size up to be a multiple of the required alignment. */
1620 TYPE_SIZE (rli
->t
) = round_up (unpadded_size
, TYPE_ALIGN (rli
->t
));
1621 TYPE_SIZE_UNIT (rli
->t
)
1622 = round_up (unpadded_size_unit
, TYPE_ALIGN_UNIT (rli
->t
));
1624 if (TREE_CONSTANT (unpadded_size
)
1625 && simple_cst_equal (unpadded_size
, TYPE_SIZE (rli
->t
)) == 0
1626 && input_location
!= BUILTINS_LOCATION
)
1627 warning (OPT_Wpadded
, "padding struct size to alignment boundary");
1629 if (warn_packed
&& TREE_CODE (rli
->t
) == RECORD_TYPE
1630 && TYPE_PACKED (rli
->t
) && ! rli
->packed_maybe_necessary
1631 && TREE_CONSTANT (unpadded_size
))
1635 #ifdef ROUND_TYPE_ALIGN
1637 = ROUND_TYPE_ALIGN (rli
->t
, TYPE_ALIGN (rli
->t
), rli
->unpacked_align
);
1639 rli
->unpacked_align
= MAX (TYPE_ALIGN (rli
->t
), rli
->unpacked_align
);
1642 unpacked_size
= round_up (TYPE_SIZE (rli
->t
), rli
->unpacked_align
);
1643 if (simple_cst_equal (unpacked_size
, TYPE_SIZE (rli
->t
)))
1645 if (TYPE_NAME (rli
->t
))
1649 if (TREE_CODE (TYPE_NAME (rli
->t
)) == IDENTIFIER_NODE
)
1650 name
= TYPE_NAME (rli
->t
);
1652 name
= DECL_NAME (TYPE_NAME (rli
->t
));
1654 if (STRICT_ALIGNMENT
)
1655 warning (OPT_Wpacked
, "packed attribute causes inefficient "
1656 "alignment for %qE", name
);
1658 warning (OPT_Wpacked
,
1659 "packed attribute is unnecessary for %qE", name
);
1663 if (STRICT_ALIGNMENT
)
1664 warning (OPT_Wpacked
,
1665 "packed attribute causes inefficient alignment");
1667 warning (OPT_Wpacked
, "packed attribute is unnecessary");
1673 /* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE). */
1676 compute_record_mode (tree type
)
1679 machine_mode mode
= VOIDmode
;
1681 /* Most RECORD_TYPEs have BLKmode, so we start off assuming that.
1682 However, if possible, we use a mode that fits in a register
1683 instead, in order to allow for better optimization down the
1685 SET_TYPE_MODE (type
, BLKmode
);
1687 if (! tree_fits_uhwi_p (TYPE_SIZE (type
)))
1690 /* A record which has any BLKmode members must itself be
1691 BLKmode; it can't go in a register. Unless the member is
1692 BLKmode only because it isn't aligned. */
1693 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1695 if (TREE_CODE (field
) != FIELD_DECL
)
1698 if (TREE_CODE (TREE_TYPE (field
)) == ERROR_MARK
1699 || (TYPE_MODE (TREE_TYPE (field
)) == BLKmode
1700 && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field
))
1701 && !(TYPE_SIZE (TREE_TYPE (field
)) != 0
1702 && integer_zerop (TYPE_SIZE (TREE_TYPE (field
)))))
1703 || ! tree_fits_uhwi_p (bit_position (field
))
1704 || DECL_SIZE (field
) == 0
1705 || ! tree_fits_uhwi_p (DECL_SIZE (field
)))
1708 /* If this field is the whole struct, remember its mode so
1709 that, say, we can put a double in a class into a DF
1710 register instead of forcing it to live in the stack. */
1711 if (simple_cst_equal (TYPE_SIZE (type
), DECL_SIZE (field
)))
1712 mode
= DECL_MODE (field
);
1714 /* With some targets, it is sub-optimal to access an aligned
1715 BLKmode structure as a scalar. */
1716 if (targetm
.member_type_forces_blk (field
, mode
))
1720 /* If we only have one real field; use its mode if that mode's size
1721 matches the type's size. This only applies to RECORD_TYPE. This
1722 does not apply to unions. */
1723 if (TREE_CODE (type
) == RECORD_TYPE
&& mode
!= VOIDmode
1724 && tree_fits_uhwi_p (TYPE_SIZE (type
))
1725 && GET_MODE_BITSIZE (mode
) == tree_to_uhwi (TYPE_SIZE (type
)))
1726 SET_TYPE_MODE (type
, mode
);
1728 SET_TYPE_MODE (type
, mode_for_size_tree (TYPE_SIZE (type
), MODE_INT
, 1));
1730 /* If structure's known alignment is less than what the scalar
1731 mode would need, and it matters, then stick with BLKmode. */
1732 if (TYPE_MODE (type
) != BLKmode
1734 && ! (TYPE_ALIGN (type
) >= BIGGEST_ALIGNMENT
1735 || TYPE_ALIGN (type
) >= GET_MODE_ALIGNMENT (TYPE_MODE (type
))))
1737 /* If this is the only reason this type is BLKmode, then
1738 don't force containing types to be BLKmode. */
1739 TYPE_NO_FORCE_BLK (type
) = 1;
1740 SET_TYPE_MODE (type
, BLKmode
);
1744 /* Compute TYPE_SIZE and TYPE_ALIGN for TYPE, once it has been laid
1748 finalize_type_size (tree type
)
1750 /* Normally, use the alignment corresponding to the mode chosen.
1751 However, where strict alignment is not required, avoid
1752 over-aligning structures, since most compilers do not do this
1754 if (TYPE_MODE (type
) != BLKmode
1755 && TYPE_MODE (type
) != VOIDmode
1756 && (STRICT_ALIGNMENT
|| !AGGREGATE_TYPE_P (type
)))
1758 unsigned mode_align
= GET_MODE_ALIGNMENT (TYPE_MODE (type
));
1760 /* Don't override a larger alignment requirement coming from a user
1761 alignment of one of the fields. */
1762 if (mode_align
>= TYPE_ALIGN (type
))
1764 TYPE_ALIGN (type
) = mode_align
;
1765 TYPE_USER_ALIGN (type
) = 0;
1769 /* Do machine-dependent extra alignment. */
1770 #ifdef ROUND_TYPE_ALIGN
1772 = ROUND_TYPE_ALIGN (type
, TYPE_ALIGN (type
), BITS_PER_UNIT
);
1775 /* If we failed to find a simple way to calculate the unit size
1776 of the type, find it by division. */
1777 if (TYPE_SIZE_UNIT (type
) == 0 && TYPE_SIZE (type
) != 0)
1778 /* TYPE_SIZE (type) is computed in bitsizetype. After the division, the
1779 result will fit in sizetype. We will get more efficient code using
1780 sizetype, so we force a conversion. */
1781 TYPE_SIZE_UNIT (type
)
1782 = fold_convert (sizetype
,
1783 size_binop (FLOOR_DIV_EXPR
, TYPE_SIZE (type
),
1784 bitsize_unit_node
));
1786 if (TYPE_SIZE (type
) != 0)
1788 TYPE_SIZE (type
) = round_up (TYPE_SIZE (type
), TYPE_ALIGN (type
));
1789 TYPE_SIZE_UNIT (type
)
1790 = round_up (TYPE_SIZE_UNIT (type
), TYPE_ALIGN_UNIT (type
));
1793 /* Evaluate nonconstant sizes only once, either now or as soon as safe. */
1794 if (TYPE_SIZE (type
) != 0 && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1795 TYPE_SIZE (type
) = variable_size (TYPE_SIZE (type
));
1796 if (TYPE_SIZE_UNIT (type
) != 0
1797 && TREE_CODE (TYPE_SIZE_UNIT (type
)) != INTEGER_CST
)
1798 TYPE_SIZE_UNIT (type
) = variable_size (TYPE_SIZE_UNIT (type
));
1800 /* Also layout any other variants of the type. */
1801 if (TYPE_NEXT_VARIANT (type
)
1802 || type
!= TYPE_MAIN_VARIANT (type
))
1805 /* Record layout info of this variant. */
1806 tree size
= TYPE_SIZE (type
);
1807 tree size_unit
= TYPE_SIZE_UNIT (type
);
1808 unsigned int align
= TYPE_ALIGN (type
);
1809 unsigned int precision
= TYPE_PRECISION (type
);
1810 unsigned int user_align
= TYPE_USER_ALIGN (type
);
1811 machine_mode mode
= TYPE_MODE (type
);
1813 /* Copy it into all variants. */
1814 for (variant
= TYPE_MAIN_VARIANT (type
);
1816 variant
= TYPE_NEXT_VARIANT (variant
))
1818 TYPE_SIZE (variant
) = size
;
1819 TYPE_SIZE_UNIT (variant
) = size_unit
;
1820 unsigned valign
= align
;
1821 if (TYPE_USER_ALIGN (variant
))
1822 valign
= MAX (valign
, TYPE_ALIGN (variant
));
1824 TYPE_USER_ALIGN (variant
) = user_align
;
1825 TYPE_ALIGN (variant
) = valign
;
1826 TYPE_PRECISION (variant
) = precision
;
1827 SET_TYPE_MODE (variant
, mode
);
1832 /* Return a new underlying object for a bitfield started with FIELD. */
1835 start_bitfield_representative (tree field
)
1837 tree repr
= make_node (FIELD_DECL
);
1838 DECL_FIELD_OFFSET (repr
) = DECL_FIELD_OFFSET (field
);
1839 /* Force the representative to begin at a BITS_PER_UNIT aligned
1840 boundary - C++ may use tail-padding of a base object to
1841 continue packing bits so the bitfield region does not start
1842 at bit zero (see g++.dg/abi/bitfield5.C for example).
1843 Unallocated bits may happen for other reasons as well,
1844 for example Ada which allows explicit bit-granular structure layout. */
1845 DECL_FIELD_BIT_OFFSET (repr
)
1846 = size_binop (BIT_AND_EXPR
,
1847 DECL_FIELD_BIT_OFFSET (field
),
1848 bitsize_int (~(BITS_PER_UNIT
- 1)));
1849 SET_DECL_OFFSET_ALIGN (repr
, DECL_OFFSET_ALIGN (field
));
1850 DECL_SIZE (repr
) = DECL_SIZE (field
);
1851 DECL_SIZE_UNIT (repr
) = DECL_SIZE_UNIT (field
);
1852 DECL_PACKED (repr
) = DECL_PACKED (field
);
1853 DECL_CONTEXT (repr
) = DECL_CONTEXT (field
);
1857 /* Finish up a bitfield group that was started by creating the underlying
1858 object REPR with the last field in the bitfield group FIELD. */
1861 finish_bitfield_representative (tree repr
, tree field
)
1863 unsigned HOST_WIDE_INT bitsize
, maxbitsize
;
1867 size
= size_diffop (DECL_FIELD_OFFSET (field
),
1868 DECL_FIELD_OFFSET (repr
));
1869 while (TREE_CODE (size
) == COMPOUND_EXPR
)
1870 size
= TREE_OPERAND (size
, 1);
1871 gcc_assert (tree_fits_uhwi_p (size
));
1872 bitsize
= (tree_to_uhwi (size
) * BITS_PER_UNIT
1873 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field
))
1874 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr
))
1875 + tree_to_uhwi (DECL_SIZE (field
)));
1877 /* Round up bitsize to multiples of BITS_PER_UNIT. */
1878 bitsize
= (bitsize
+ BITS_PER_UNIT
- 1) & ~(BITS_PER_UNIT
- 1);
1880 /* Now nothing tells us how to pad out bitsize ... */
1881 nextf
= DECL_CHAIN (field
);
1882 while (nextf
&& TREE_CODE (nextf
) != FIELD_DECL
)
1883 nextf
= DECL_CHAIN (nextf
);
1887 /* If there was an error, the field may be not laid out
1888 correctly. Don't bother to do anything. */
1889 if (TREE_TYPE (nextf
) == error_mark_node
)
1891 maxsize
= size_diffop (DECL_FIELD_OFFSET (nextf
),
1892 DECL_FIELD_OFFSET (repr
));
1893 if (tree_fits_uhwi_p (maxsize
))
1895 maxbitsize
= (tree_to_uhwi (maxsize
) * BITS_PER_UNIT
1896 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (nextf
))
1897 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr
)));
1898 /* If the group ends within a bitfield nextf does not need to be
1899 aligned to BITS_PER_UNIT. Thus round up. */
1900 maxbitsize
= (maxbitsize
+ BITS_PER_UNIT
- 1) & ~(BITS_PER_UNIT
- 1);
1903 maxbitsize
= bitsize
;
1907 /* ??? If you consider that tail-padding of this struct might be
1908 re-used when deriving from it we cannot really do the following
1909 and thus need to set maxsize to bitsize? Also we cannot
1910 generally rely on maxsize to fold to an integer constant, so
1911 use bitsize as fallback for this case. */
1912 tree maxsize
= size_diffop (TYPE_SIZE_UNIT (DECL_CONTEXT (field
)),
1913 DECL_FIELD_OFFSET (repr
));
1914 if (tree_fits_uhwi_p (maxsize
))
1915 maxbitsize
= (tree_to_uhwi (maxsize
) * BITS_PER_UNIT
1916 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr
)));
1918 maxbitsize
= bitsize
;
1921 /* Only if we don't artificially break up the representative in
1922 the middle of a large bitfield with different possibly
1923 overlapping representatives. And all representatives start
1925 gcc_assert (maxbitsize
% BITS_PER_UNIT
== 0);
1927 /* Find the smallest nice mode to use. */
1928 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_INT
); mode
!= VOIDmode
;
1929 mode
= GET_MODE_WIDER_MODE (mode
))
1930 if (GET_MODE_BITSIZE (mode
) >= bitsize
)
1932 if (mode
!= VOIDmode
1933 && (GET_MODE_BITSIZE (mode
) > maxbitsize
1934 || GET_MODE_BITSIZE (mode
) > MAX_FIXED_MODE_SIZE
))
1937 if (mode
== VOIDmode
)
1939 /* We really want a BLKmode representative only as a last resort,
1940 considering the member b in
1941 struct { int a : 7; int b : 17; int c; } __attribute__((packed));
1942 Otherwise we simply want to split the representative up
1943 allowing for overlaps within the bitfield region as required for
1944 struct { int a : 7; int b : 7;
1945 int c : 10; int d; } __attribute__((packed));
1946 [0, 15] HImode for a and b, [8, 23] HImode for c. */
1947 DECL_SIZE (repr
) = bitsize_int (bitsize
);
1948 DECL_SIZE_UNIT (repr
) = size_int (bitsize
/ BITS_PER_UNIT
);
1949 DECL_MODE (repr
) = BLKmode
;
1950 TREE_TYPE (repr
) = build_array_type_nelts (unsigned_char_type_node
,
1951 bitsize
/ BITS_PER_UNIT
);
1955 unsigned HOST_WIDE_INT modesize
= GET_MODE_BITSIZE (mode
);
1956 DECL_SIZE (repr
) = bitsize_int (modesize
);
1957 DECL_SIZE_UNIT (repr
) = size_int (modesize
/ BITS_PER_UNIT
);
1958 DECL_MODE (repr
) = mode
;
1959 TREE_TYPE (repr
) = lang_hooks
.types
.type_for_mode (mode
, 1);
1962 /* Remember whether the bitfield group is at the end of the
1963 structure or not. */
1964 DECL_CHAIN (repr
) = nextf
;
1967 /* Compute and set FIELD_DECLs for the underlying objects we should
1968 use for bitfield access for the structure T. */
1971 finish_bitfield_layout (tree t
)
1974 tree repr
= NULL_TREE
;
1976 /* Unions would be special, for the ease of type-punning optimizations
1977 we could use the underlying type as hint for the representative
1978 if the bitfield would fit and the representative would not exceed
1979 the union in size. */
1980 if (TREE_CODE (t
) != RECORD_TYPE
)
1983 for (prev
= NULL_TREE
, field
= TYPE_FIELDS (t
);
1984 field
; field
= DECL_CHAIN (field
))
1986 if (TREE_CODE (field
) != FIELD_DECL
)
1989 /* In the C++ memory model, consecutive bit fields in a structure are
1990 considered one memory location and updating a memory location
1991 may not store into adjacent memory locations. */
1993 && DECL_BIT_FIELD_TYPE (field
))
1995 /* Start new representative. */
1996 repr
= start_bitfield_representative (field
);
1999 && ! DECL_BIT_FIELD_TYPE (field
))
2001 /* Finish off new representative. */
2002 finish_bitfield_representative (repr
, prev
);
2005 else if (DECL_BIT_FIELD_TYPE (field
))
2007 gcc_assert (repr
!= NULL_TREE
);
2009 /* Zero-size bitfields finish off a representative and
2010 do not have a representative themselves. This is
2011 required by the C++ memory model. */
2012 if (integer_zerop (DECL_SIZE (field
)))
2014 finish_bitfield_representative (repr
, prev
);
2018 /* We assume that either DECL_FIELD_OFFSET of the representative
2019 and each bitfield member is a constant or they are equal.
2020 This is because we need to be able to compute the bit-offset
2021 of each field relative to the representative in get_bit_range
2022 during RTL expansion.
2023 If these constraints are not met, simply force a new
2024 representative to be generated. That will at most
2025 generate worse code but still maintain correctness with
2026 respect to the C++ memory model. */
2027 else if (!((tree_fits_uhwi_p (DECL_FIELD_OFFSET (repr
))
2028 && tree_fits_uhwi_p (DECL_FIELD_OFFSET (field
)))
2029 || operand_equal_p (DECL_FIELD_OFFSET (repr
),
2030 DECL_FIELD_OFFSET (field
), 0)))
2032 finish_bitfield_representative (repr
, prev
);
2033 repr
= start_bitfield_representative (field
);
2040 DECL_BIT_FIELD_REPRESENTATIVE (field
) = repr
;
2046 finish_bitfield_representative (repr
, prev
);
2049 /* Do all of the work required to layout the type indicated by RLI,
2050 once the fields have been laid out. This function will call `free'
2051 for RLI, unless FREE_P is false. Passing a value other than false
2052 for FREE_P is bad practice; this option only exists to support the
2056 finish_record_layout (record_layout_info rli
, int free_p
)
2060 /* Compute the final size. */
2061 finalize_record_size (rli
);
2063 /* Compute the TYPE_MODE for the record. */
2064 compute_record_mode (rli
->t
);
2066 /* Perform any last tweaks to the TYPE_SIZE, etc. */
2067 finalize_type_size (rli
->t
);
2069 /* Compute bitfield representatives. */
2070 finish_bitfield_layout (rli
->t
);
2072 /* Propagate TYPE_PACKED to variants. With C++ templates,
2073 handle_packed_attribute is too early to do this. */
2074 for (variant
= TYPE_NEXT_VARIANT (rli
->t
); variant
;
2075 variant
= TYPE_NEXT_VARIANT (variant
))
2076 TYPE_PACKED (variant
) = TYPE_PACKED (rli
->t
);
2078 /* Lay out any static members. This is done now because their type
2079 may use the record's type. */
2080 while (!vec_safe_is_empty (rli
->pending_statics
))
2081 layout_decl (rli
->pending_statics
->pop (), 0);
2086 vec_free (rli
->pending_statics
);
2092 /* Finish processing a builtin RECORD_TYPE type TYPE. It's name is
2093 NAME, its fields are chained in reverse on FIELDS.
2095 If ALIGN_TYPE is non-null, it is given the same alignment as
2099 finish_builtin_struct (tree type
, const char *name
, tree fields
,
2104 for (tail
= NULL_TREE
; fields
; tail
= fields
, fields
= next
)
2106 DECL_FIELD_CONTEXT (fields
) = type
;
2107 next
= DECL_CHAIN (fields
);
2108 DECL_CHAIN (fields
) = tail
;
2110 TYPE_FIELDS (type
) = tail
;
2114 TYPE_ALIGN (type
) = TYPE_ALIGN (align_type
);
2115 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (align_type
);
2119 #if 0 /* not yet, should get fixed properly later */
2120 TYPE_NAME (type
) = make_type_decl (get_identifier (name
), type
);
2122 TYPE_NAME (type
) = build_decl (BUILTINS_LOCATION
,
2123 TYPE_DECL
, get_identifier (name
), type
);
2125 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
2126 layout_decl (TYPE_NAME (type
), 0);
2129 /* Calculate the mode, size, and alignment for TYPE.
2130 For an array type, calculate the element separation as well.
2131 Record TYPE on the chain of permanent or temporary types
2132 so that dbxout will find out about it.
2134 TYPE_SIZE of a type is nonzero if the type has been laid out already.
2135 layout_type does nothing on such a type.
2137 If the type is incomplete, its TYPE_SIZE remains zero. */
2140 layout_type (tree type
)
2144 if (type
== error_mark_node
)
2147 /* We don't want finalize_type_size to copy an alignment attribute to
2148 variants that don't have it. */
2149 type
= TYPE_MAIN_VARIANT (type
);
2151 /* Do nothing if type has been laid out before. */
2152 if (TYPE_SIZE (type
))
2155 switch (TREE_CODE (type
))
2158 /* This kind of type is the responsibility
2159 of the language-specific code. */
2165 SET_TYPE_MODE (type
,
2166 smallest_mode_for_size (TYPE_PRECISION (type
), MODE_INT
));
2167 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2168 /* Don't set TYPE_PRECISION here, as it may be set by a bitfield. */
2169 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2173 SET_TYPE_MODE (type
,
2174 mode_for_size (TYPE_PRECISION (type
), MODE_FLOAT
, 0));
2175 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2176 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2179 case FIXED_POINT_TYPE
:
2180 /* TYPE_MODE (type) has been set already. */
2181 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2182 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2186 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TREE_TYPE (type
));
2187 SET_TYPE_MODE (type
,
2188 mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type
)),
2189 (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
2190 ? MODE_COMPLEX_FLOAT
: MODE_COMPLEX_INT
),
2192 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2193 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2198 int nunits
= TYPE_VECTOR_SUBPARTS (type
);
2199 tree innertype
= TREE_TYPE (type
);
2201 gcc_assert (!(nunits
& (nunits
- 1)));
2203 /* Find an appropriate mode for the vector type. */
2204 if (TYPE_MODE (type
) == VOIDmode
)
2205 SET_TYPE_MODE (type
,
2206 mode_for_vector (TYPE_MODE (innertype
), nunits
));
2208 TYPE_SATURATING (type
) = TYPE_SATURATING (TREE_TYPE (type
));
2209 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TREE_TYPE (type
));
2210 TYPE_SIZE_UNIT (type
) = int_const_binop (MULT_EXPR
,
2211 TYPE_SIZE_UNIT (innertype
),
2213 TYPE_SIZE (type
) = int_const_binop (MULT_EXPR
, TYPE_SIZE (innertype
),
2214 bitsize_int (nunits
));
2216 /* For vector types, we do not default to the mode's alignment.
2217 Instead, query a target hook, defaulting to natural alignment.
2218 This prevents ABI changes depending on whether or not native
2219 vector modes are supported. */
2220 TYPE_ALIGN (type
) = targetm
.vector_alignment (type
);
2222 /* However, if the underlying mode requires a bigger alignment than
2223 what the target hook provides, we cannot use the mode. For now,
2224 simply reject that case. */
2225 gcc_assert (TYPE_ALIGN (type
)
2226 >= GET_MODE_ALIGNMENT (TYPE_MODE (type
)));
2231 /* This is an incomplete type and so doesn't have a size. */
2232 TYPE_ALIGN (type
) = 1;
2233 TYPE_USER_ALIGN (type
) = 0;
2234 SET_TYPE_MODE (type
, VOIDmode
);
2237 case POINTER_BOUNDS_TYPE
:
2238 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2239 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2243 TYPE_SIZE (type
) = bitsize_int (POINTER_SIZE
);
2244 TYPE_SIZE_UNIT (type
) = size_int (POINTER_SIZE_UNITS
);
2245 /* A pointer might be MODE_PARTIAL_INT, but ptrdiff_t must be
2246 integral, which may be an __intN. */
2247 SET_TYPE_MODE (type
, mode_for_size (POINTER_SIZE
, MODE_INT
, 0));
2248 TYPE_PRECISION (type
) = POINTER_SIZE
;
2253 /* It's hard to see what the mode and size of a function ought to
2254 be, but we do know the alignment is FUNCTION_BOUNDARY, so
2255 make it consistent with that. */
2256 SET_TYPE_MODE (type
, mode_for_size (FUNCTION_BOUNDARY
, MODE_INT
, 0));
2257 TYPE_SIZE (type
) = bitsize_int (FUNCTION_BOUNDARY
);
2258 TYPE_SIZE_UNIT (type
) = size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
2262 case REFERENCE_TYPE
:
2264 machine_mode mode
= TYPE_MODE (type
);
2265 if (TREE_CODE (type
) == REFERENCE_TYPE
&& reference_types_internal
)
2267 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (type
));
2268 mode
= targetm
.addr_space
.address_mode (as
);
2271 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (mode
));
2272 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (mode
));
2273 TYPE_UNSIGNED (type
) = 1;
2274 TYPE_PRECISION (type
) = GET_MODE_PRECISION (mode
);
2280 tree index
= TYPE_DOMAIN (type
);
2281 tree element
= TREE_TYPE (type
);
2283 build_pointer_type (element
);
2285 /* We need to know both bounds in order to compute the size. */
2286 if (index
&& TYPE_MAX_VALUE (index
) && TYPE_MIN_VALUE (index
)
2287 && TYPE_SIZE (element
))
2289 tree ub
= TYPE_MAX_VALUE (index
);
2290 tree lb
= TYPE_MIN_VALUE (index
);
2291 tree element_size
= TYPE_SIZE (element
);
2294 /* Make sure that an array of zero-sized element is zero-sized
2295 regardless of its extent. */
2296 if (integer_zerop (element_size
))
2297 length
= size_zero_node
;
2299 /* The computation should happen in the original signedness so
2300 that (possible) negative values are handled appropriately
2301 when determining overflow. */
2304 /* ??? When it is obvious that the range is signed
2305 represent it using ssizetype. */
2306 if (TREE_CODE (lb
) == INTEGER_CST
2307 && TREE_CODE (ub
) == INTEGER_CST
2308 && TYPE_UNSIGNED (TREE_TYPE (lb
))
2309 && tree_int_cst_lt (ub
, lb
))
2311 lb
= wide_int_to_tree (ssizetype
,
2312 offset_int::from (lb
, SIGNED
));
2313 ub
= wide_int_to_tree (ssizetype
,
2314 offset_int::from (ub
, SIGNED
));
2317 = fold_convert (sizetype
,
2318 size_binop (PLUS_EXPR
,
2319 build_int_cst (TREE_TYPE (lb
), 1),
2320 size_binop (MINUS_EXPR
, ub
, lb
)));
2323 /* ??? We have no way to distinguish a null-sized array from an
2324 array spanning the whole sizetype range, so we arbitrarily
2325 decide that [0, -1] is the only valid representation. */
2326 if (integer_zerop (length
)
2327 && TREE_OVERFLOW (length
)
2328 && integer_zerop (lb
))
2329 length
= size_zero_node
;
2331 TYPE_SIZE (type
) = size_binop (MULT_EXPR
, element_size
,
2332 fold_convert (bitsizetype
,
2335 /* If we know the size of the element, calculate the total size
2336 directly, rather than do some division thing below. This
2337 optimization helps Fortran assumed-size arrays (where the
2338 size of the array is determined at runtime) substantially. */
2339 if (TYPE_SIZE_UNIT (element
))
2340 TYPE_SIZE_UNIT (type
)
2341 = size_binop (MULT_EXPR
, TYPE_SIZE_UNIT (element
), length
);
2344 /* Now round the alignment and size,
2345 using machine-dependent criteria if any. */
2347 unsigned align
= TYPE_ALIGN (element
);
2348 if (TYPE_USER_ALIGN (type
))
2349 align
= MAX (align
, TYPE_ALIGN (type
));
2351 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (element
);
2352 #ifdef ROUND_TYPE_ALIGN
2353 align
= ROUND_TYPE_ALIGN (type
, align
, BITS_PER_UNIT
);
2355 align
= MAX (align
, BITS_PER_UNIT
);
2357 TYPE_ALIGN (type
) = align
;
2358 SET_TYPE_MODE (type
, BLKmode
);
2359 if (TYPE_SIZE (type
) != 0
2360 && ! targetm
.member_type_forces_blk (type
, VOIDmode
)
2361 /* BLKmode elements force BLKmode aggregate;
2362 else extract/store fields may lose. */
2363 && (TYPE_MODE (TREE_TYPE (type
)) != BLKmode
2364 || TYPE_NO_FORCE_BLK (TREE_TYPE (type
))))
2366 SET_TYPE_MODE (type
, mode_for_array (TREE_TYPE (type
),
2368 if (TYPE_MODE (type
) != BLKmode
2369 && STRICT_ALIGNMENT
&& TYPE_ALIGN (type
) < BIGGEST_ALIGNMENT
2370 && TYPE_ALIGN (type
) < GET_MODE_ALIGNMENT (TYPE_MODE (type
)))
2372 TYPE_NO_FORCE_BLK (type
) = 1;
2373 SET_TYPE_MODE (type
, BLKmode
);
2376 /* When the element size is constant, check that it is at least as
2377 large as the element alignment. */
2378 if (TYPE_SIZE_UNIT (element
)
2379 && TREE_CODE (TYPE_SIZE_UNIT (element
)) == INTEGER_CST
2380 /* If TYPE_SIZE_UNIT overflowed, then it is certainly larger than
2382 && !TREE_OVERFLOW (TYPE_SIZE_UNIT (element
))
2383 && !integer_zerop (TYPE_SIZE_UNIT (element
))
2384 && compare_tree_int (TYPE_SIZE_UNIT (element
),
2385 TYPE_ALIGN_UNIT (element
)) < 0)
2386 error ("alignment of array elements is greater than element size");
2392 case QUAL_UNION_TYPE
:
2395 record_layout_info rli
;
2397 /* Initialize the layout information. */
2398 rli
= start_record_layout (type
);
2400 /* If this is a QUAL_UNION_TYPE, we want to process the fields
2401 in the reverse order in building the COND_EXPR that denotes
2402 its size. We reverse them again later. */
2403 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
2404 TYPE_FIELDS (type
) = nreverse (TYPE_FIELDS (type
));
2406 /* Place all the fields. */
2407 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
2408 place_field (rli
, field
);
2410 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
2411 TYPE_FIELDS (type
) = nreverse (TYPE_FIELDS (type
));
2413 /* Finish laying out the record. */
2414 finish_record_layout (rli
, /*free_p=*/true);
2422 /* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE. For
2423 records and unions, finish_record_layout already called this
2425 if (!RECORD_OR_UNION_TYPE_P (type
))
2426 finalize_type_size (type
);
2428 /* We should never see alias sets on incomplete aggregates. And we
2429 should not call layout_type on not incomplete aggregates. */
2430 if (AGGREGATE_TYPE_P (type
))
2431 gcc_assert (!TYPE_ALIAS_SET_KNOWN_P (type
));
2434 /* Return the least alignment required for type TYPE. */
2437 min_align_of_type (tree type
)
2439 unsigned int align
= TYPE_ALIGN (type
);
2440 if (!TYPE_USER_ALIGN (type
))
2442 align
= MIN (align
, BIGGEST_ALIGNMENT
);
2443 #ifdef BIGGEST_FIELD_ALIGNMENT
2444 align
= MIN (align
, BIGGEST_FIELD_ALIGNMENT
);
2446 unsigned int field_align
= align
;
2447 #ifdef ADJUST_FIELD_ALIGN
2448 tree field
= build_decl (UNKNOWN_LOCATION
, FIELD_DECL
, NULL_TREE
, type
);
2449 field_align
= ADJUST_FIELD_ALIGN (field
, field_align
);
2452 align
= MIN (align
, field_align
);
2454 return align
/ BITS_PER_UNIT
;
2457 /* Vector types need to re-check the target flags each time we report
2458 the machine mode. We need to do this because attribute target can
2459 change the result of vector_mode_supported_p and have_regs_of_mode
2460 on a per-function basis. Thus the TYPE_MODE of a VECTOR_TYPE can
2461 change on a per-function basis. */
2462 /* ??? Possibly a better solution is to run through all the types
2463 referenced by a function and re-compute the TYPE_MODE once, rather
2464 than make the TYPE_MODE macro call a function. */
2467 vector_type_mode (const_tree t
)
2471 gcc_assert (TREE_CODE (t
) == VECTOR_TYPE
);
2473 mode
= t
->type_common
.mode
;
2474 if (VECTOR_MODE_P (mode
)
2475 && (!targetm
.vector_mode_supported_p (mode
)
2476 || !have_regs_of_mode
[mode
]))
2478 machine_mode innermode
= TREE_TYPE (t
)->type_common
.mode
;
2480 /* For integers, try mapping it to a same-sized scalar mode. */
2481 if (GET_MODE_CLASS (innermode
) == MODE_INT
)
2483 mode
= mode_for_size (TYPE_VECTOR_SUBPARTS (t
)
2484 * GET_MODE_BITSIZE (innermode
), MODE_INT
, 0);
2486 if (mode
!= VOIDmode
&& have_regs_of_mode
[mode
])
2496 /* Create and return a type for signed integers of PRECISION bits. */
2499 make_signed_type (int precision
)
2501 tree type
= make_node (INTEGER_TYPE
);
2503 TYPE_PRECISION (type
) = precision
;
2505 fixup_signed_type (type
);
2509 /* Create and return a type for unsigned integers of PRECISION bits. */
2512 make_unsigned_type (int precision
)
2514 tree type
= make_node (INTEGER_TYPE
);
2516 TYPE_PRECISION (type
) = precision
;
2518 fixup_unsigned_type (type
);
2522 /* Create and return a type for fract of PRECISION bits, UNSIGNEDP,
2526 make_fract_type (int precision
, int unsignedp
, int satp
)
2528 tree type
= make_node (FIXED_POINT_TYPE
);
2530 TYPE_PRECISION (type
) = precision
;
2533 TYPE_SATURATING (type
) = 1;
2535 /* Lay out the type: set its alignment, size, etc. */
2538 TYPE_UNSIGNED (type
) = 1;
2539 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_UFRACT
, 0));
2542 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_FRACT
, 0));
2548 /* Create and return a type for accum of PRECISION bits, UNSIGNEDP,
2552 make_accum_type (int precision
, int unsignedp
, int satp
)
2554 tree type
= make_node (FIXED_POINT_TYPE
);
2556 TYPE_PRECISION (type
) = precision
;
2559 TYPE_SATURATING (type
) = 1;
2561 /* Lay out the type: set its alignment, size, etc. */
2564 TYPE_UNSIGNED (type
) = 1;
2565 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_UACCUM
, 0));
2568 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_ACCUM
, 0));
2574 /* Initialize sizetypes so layout_type can use them. */
2577 initialize_sizetypes (void)
2579 int precision
, bprecision
;
2581 /* Get sizetypes precision from the SIZE_TYPE target macro. */
2582 if (strcmp (SIZETYPE
, "unsigned int") == 0)
2583 precision
= INT_TYPE_SIZE
;
2584 else if (strcmp (SIZETYPE
, "long unsigned int") == 0)
2585 precision
= LONG_TYPE_SIZE
;
2586 else if (strcmp (SIZETYPE
, "long long unsigned int") == 0)
2587 precision
= LONG_LONG_TYPE_SIZE
;
2588 else if (strcmp (SIZETYPE
, "short unsigned int") == 0)
2589 precision
= SHORT_TYPE_SIZE
;
2595 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2596 if (int_n_enabled_p
[i
])
2599 sprintf (name
, "__int%d unsigned", int_n_data
[i
].bitsize
);
2601 if (strcmp (name
, SIZETYPE
) == 0)
2603 precision
= int_n_data
[i
].bitsize
;
2606 if (precision
== -1)
2611 = MIN (precision
+ BITS_PER_UNIT_LOG
+ 1, MAX_FIXED_MODE_SIZE
);
2613 = GET_MODE_PRECISION (smallest_mode_for_size (bprecision
, MODE_INT
));
2614 if (bprecision
> HOST_BITS_PER_DOUBLE_INT
)
2615 bprecision
= HOST_BITS_PER_DOUBLE_INT
;
2617 /* Create stubs for sizetype and bitsizetype so we can create constants. */
2618 sizetype
= make_node (INTEGER_TYPE
);
2619 TYPE_NAME (sizetype
) = get_identifier ("sizetype");
2620 TYPE_PRECISION (sizetype
) = precision
;
2621 TYPE_UNSIGNED (sizetype
) = 1;
2622 bitsizetype
= make_node (INTEGER_TYPE
);
2623 TYPE_NAME (bitsizetype
) = get_identifier ("bitsizetype");
2624 TYPE_PRECISION (bitsizetype
) = bprecision
;
2625 TYPE_UNSIGNED (bitsizetype
) = 1;
2627 /* Now layout both types manually. */
2628 SET_TYPE_MODE (sizetype
, smallest_mode_for_size (precision
, MODE_INT
));
2629 TYPE_ALIGN (sizetype
) = GET_MODE_ALIGNMENT (TYPE_MODE (sizetype
));
2630 TYPE_SIZE (sizetype
) = bitsize_int (precision
);
2631 TYPE_SIZE_UNIT (sizetype
) = size_int (GET_MODE_SIZE (TYPE_MODE (sizetype
)));
2632 set_min_and_max_values_for_integral_type (sizetype
, precision
, UNSIGNED
);
2634 SET_TYPE_MODE (bitsizetype
, smallest_mode_for_size (bprecision
, MODE_INT
));
2635 TYPE_ALIGN (bitsizetype
) = GET_MODE_ALIGNMENT (TYPE_MODE (bitsizetype
));
2636 TYPE_SIZE (bitsizetype
) = bitsize_int (bprecision
);
2637 TYPE_SIZE_UNIT (bitsizetype
)
2638 = size_int (GET_MODE_SIZE (TYPE_MODE (bitsizetype
)));
2639 set_min_and_max_values_for_integral_type (bitsizetype
, bprecision
, UNSIGNED
);
2641 /* Create the signed variants of *sizetype. */
2642 ssizetype
= make_signed_type (TYPE_PRECISION (sizetype
));
2643 TYPE_NAME (ssizetype
) = get_identifier ("ssizetype");
2644 sbitsizetype
= make_signed_type (TYPE_PRECISION (bitsizetype
));
2645 TYPE_NAME (sbitsizetype
) = get_identifier ("sbitsizetype");
2648 /* TYPE is an integral type, i.e., an INTEGRAL_TYPE, ENUMERAL_TYPE
2649 or BOOLEAN_TYPE. Set TYPE_MIN_VALUE and TYPE_MAX_VALUE
2650 for TYPE, based on the PRECISION and whether or not the TYPE
2651 IS_UNSIGNED. PRECISION need not correspond to a width supported
2652 natively by the hardware; for example, on a machine with 8-bit,
2653 16-bit, and 32-bit register modes, PRECISION might be 7, 23, or
2657 set_min_and_max_values_for_integral_type (tree type
,
2661 /* For bitfields with zero width we end up creating integer types
2662 with zero precision. Don't assign any minimum/maximum values
2663 to those types, they don't have any valid value. */
2667 TYPE_MIN_VALUE (type
)
2668 = wide_int_to_tree (type
, wi::min_value (precision
, sgn
));
2669 TYPE_MAX_VALUE (type
)
2670 = wide_int_to_tree (type
, wi::max_value (precision
, sgn
));
2673 /* Set the extreme values of TYPE based on its precision in bits,
2674 then lay it out. Used when make_signed_type won't do
2675 because the tree code is not INTEGER_TYPE.
2676 E.g. for Pascal, when the -fsigned-char option is given. */
2679 fixup_signed_type (tree type
)
2681 int precision
= TYPE_PRECISION (type
);
2683 set_min_and_max_values_for_integral_type (type
, precision
, SIGNED
);
2685 /* Lay out the type: set its alignment, size, etc. */
2689 /* Set the extreme values of TYPE based on its precision in bits,
2690 then lay it out. This is used both in `make_unsigned_type'
2691 and for enumeral types. */
2694 fixup_unsigned_type (tree type
)
2696 int precision
= TYPE_PRECISION (type
);
2698 TYPE_UNSIGNED (type
) = 1;
2700 set_min_and_max_values_for_integral_type (type
, precision
, UNSIGNED
);
2702 /* Lay out the type: set its alignment, size, etc. */
2706 /* Construct an iterator for a bitfield that spans BITSIZE bits,
2709 BITREGION_START is the bit position of the first bit in this
2710 sequence of bit fields. BITREGION_END is the last bit in this
2711 sequence. If these two fields are non-zero, we should restrict the
2712 memory access to that range. Otherwise, we are allowed to touch
2713 any adjacent non bit-fields.
2715 ALIGN is the alignment of the underlying object in bits.
2716 VOLATILEP says whether the bitfield is volatile. */
2718 bit_field_mode_iterator
2719 ::bit_field_mode_iterator (HOST_WIDE_INT bitsize
, HOST_WIDE_INT bitpos
,
2720 HOST_WIDE_INT bitregion_start
,
2721 HOST_WIDE_INT bitregion_end
,
2722 unsigned int align
, bool volatilep
)
2723 : m_mode (GET_CLASS_NARROWEST_MODE (MODE_INT
)), m_bitsize (bitsize
),
2724 m_bitpos (bitpos
), m_bitregion_start (bitregion_start
),
2725 m_bitregion_end (bitregion_end
), m_align (align
),
2726 m_volatilep (volatilep
), m_count (0)
2728 if (!m_bitregion_end
)
2730 /* We can assume that any aligned chunk of ALIGN bits that overlaps
2731 the bitfield is mapped and won't trap, provided that ALIGN isn't
2732 too large. The cap is the biggest required alignment for data,
2733 or at least the word size. And force one such chunk at least. */
2734 unsigned HOST_WIDE_INT units
2735 = MIN (align
, MAX (BIGGEST_ALIGNMENT
, BITS_PER_WORD
));
2738 m_bitregion_end
= bitpos
+ bitsize
+ units
- 1;
2739 m_bitregion_end
-= m_bitregion_end
% units
+ 1;
2743 /* Calls to this function return successively larger modes that can be used
2744 to represent the bitfield. Return true if another bitfield mode is
2745 available, storing it in *OUT_MODE if so. */
2748 bit_field_mode_iterator::next_mode (machine_mode
*out_mode
)
2750 for (; m_mode
!= VOIDmode
; m_mode
= GET_MODE_WIDER_MODE (m_mode
))
2752 unsigned int unit
= GET_MODE_BITSIZE (m_mode
);
2754 /* Skip modes that don't have full precision. */
2755 if (unit
!= GET_MODE_PRECISION (m_mode
))
2758 /* Stop if the mode is too wide to handle efficiently. */
2759 if (unit
> MAX_FIXED_MODE_SIZE
)
2762 /* Don't deliver more than one multiword mode; the smallest one
2764 if (m_count
> 0 && unit
> BITS_PER_WORD
)
2767 /* Skip modes that are too small. */
2768 unsigned HOST_WIDE_INT substart
= (unsigned HOST_WIDE_INT
) m_bitpos
% unit
;
2769 unsigned HOST_WIDE_INT subend
= substart
+ m_bitsize
;
2773 /* Stop if the mode goes outside the bitregion. */
2774 HOST_WIDE_INT start
= m_bitpos
- substart
;
2775 if (m_bitregion_start
&& start
< m_bitregion_start
)
2777 HOST_WIDE_INT end
= start
+ unit
;
2778 if (end
> m_bitregion_end
+ 1)
2781 /* Stop if the mode requires too much alignment. */
2782 if (GET_MODE_ALIGNMENT (m_mode
) > m_align
2783 && SLOW_UNALIGNED_ACCESS (m_mode
, m_align
))
2787 m_mode
= GET_MODE_WIDER_MODE (m_mode
);
2794 /* Return true if smaller modes are generally preferred for this kind
2798 bit_field_mode_iterator::prefer_smaller_modes ()
2801 ? targetm
.narrow_volatile_bitfield ()
2802 : !SLOW_BYTE_ACCESS
);
2805 /* Find the best machine mode to use when referencing a bit field of length
2806 BITSIZE bits starting at BITPOS.
2808 BITREGION_START is the bit position of the first bit in this
2809 sequence of bit fields. BITREGION_END is the last bit in this
2810 sequence. If these two fields are non-zero, we should restrict the
2811 memory access to that range. Otherwise, we are allowed to touch
2812 any adjacent non bit-fields.
2814 The underlying object is known to be aligned to a boundary of ALIGN bits.
2815 If LARGEST_MODE is not VOIDmode, it means that we should not use a mode
2816 larger than LARGEST_MODE (usually SImode).
2818 If no mode meets all these conditions, we return VOIDmode.
2820 If VOLATILEP is false and SLOW_BYTE_ACCESS is false, we return the
2821 smallest mode meeting these conditions.
2823 If VOLATILEP is false and SLOW_BYTE_ACCESS is true, we return the
2824 largest mode (but a mode no wider than UNITS_PER_WORD) that meets
2827 If VOLATILEP is true the narrow_volatile_bitfields target hook is used to
2828 decide which of the above modes should be used. */
2831 get_best_mode (int bitsize
, int bitpos
,
2832 unsigned HOST_WIDE_INT bitregion_start
,
2833 unsigned HOST_WIDE_INT bitregion_end
,
2835 machine_mode largest_mode
, bool volatilep
)
2837 bit_field_mode_iterator
iter (bitsize
, bitpos
, bitregion_start
,
2838 bitregion_end
, align
, volatilep
);
2839 machine_mode widest_mode
= VOIDmode
;
2841 while (iter
.next_mode (&mode
)
2842 /* ??? For historical reasons, reject modes that would normally
2843 receive greater alignment, even if unaligned accesses are
2844 acceptable. This has both advantages and disadvantages.
2845 Removing this check means that something like:
2847 struct s { unsigned int x; unsigned int y; };
2848 int f (struct s *s) { return s->x == 0 && s->y == 0; }
2850 can be implemented using a single load and compare on
2851 64-bit machines that have no alignment restrictions.
2852 For example, on powerpc64-linux-gnu, we would generate:
2874 However, accessing more than one field can make life harder
2875 for the gimple optimizers. For example, gcc.dg/vect/bb-slp-5.c
2876 has a series of unsigned short copies followed by a series of
2877 unsigned short comparisons. With this check, both the copies
2878 and comparisons remain 16-bit accesses and FRE is able
2879 to eliminate the latter. Without the check, the comparisons
2880 can be done using 2 64-bit operations, which FRE isn't able
2881 to handle in the same way.
2883 Either way, it would probably be worth disabling this check
2884 during expand. One particular example where removing the
2885 check would help is the get_best_mode call in store_bit_field.
2886 If we are given a memory bitregion of 128 bits that is aligned
2887 to a 64-bit boundary, and the bitfield we want to modify is
2888 in the second half of the bitregion, this check causes
2889 store_bitfield to turn the memory into a 64-bit reference
2890 to the _first_ half of the region. We later use
2891 adjust_bitfield_address to get a reference to the correct half,
2892 but doing so looks to adjust_bitfield_address as though we are
2893 moving past the end of the original object, so it drops the
2894 associated MEM_EXPR and MEM_OFFSET. Removing the check
2895 causes store_bit_field to keep a 128-bit memory reference,
2896 so that the final bitfield reference still has a MEM_EXPR
2898 && GET_MODE_ALIGNMENT (mode
) <= align
2899 && (largest_mode
== VOIDmode
2900 || GET_MODE_SIZE (mode
) <= GET_MODE_SIZE (largest_mode
)))
2903 if (iter
.prefer_smaller_modes ())
2909 /* Gets minimal and maximal values for MODE (signed or unsigned depending on
2910 SIGN). The returned constants are made to be usable in TARGET_MODE. */
2913 get_mode_bounds (machine_mode mode
, int sign
,
2914 machine_mode target_mode
,
2915 rtx
*mmin
, rtx
*mmax
)
2917 unsigned size
= GET_MODE_PRECISION (mode
);
2918 unsigned HOST_WIDE_INT min_val
, max_val
;
2920 gcc_assert (size
<= HOST_BITS_PER_WIDE_INT
);
2922 /* Special case BImode, which has values 0 and STORE_FLAG_VALUE. */
2925 if (STORE_FLAG_VALUE
< 0)
2927 min_val
= STORE_FLAG_VALUE
;
2933 max_val
= STORE_FLAG_VALUE
;
2938 min_val
= -((unsigned HOST_WIDE_INT
) 1 << (size
- 1));
2939 max_val
= ((unsigned HOST_WIDE_INT
) 1 << (size
- 1)) - 1;
2944 max_val
= ((unsigned HOST_WIDE_INT
) 1 << (size
- 1) << 1) - 1;
2947 *mmin
= gen_int_mode (min_val
, target_mode
);
2948 *mmax
= gen_int_mode (max_val
, target_mode
);
2951 #include "gt-stor-layout.h"