1 /* C-compiler utilities for types and variables storage layout
2 Copyright (C) 1987-2013 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"
31 #include "diagnostic-core.h"
34 #include "langhooks.h"
38 #include "tree-inline.h"
39 #include "tree-dump.h"
43 /* Data type for the expressions representing sizes of data types.
44 It is the first integer type laid out. */
45 tree sizetype_tab
[(int) stk_type_kind_last
];
47 /* If nonzero, this is an upper limit on alignment of structure fields.
48 The value is measured in bits. */
49 unsigned int maximum_field_alignment
= TARGET_DEFAULT_PACK_STRUCT
* BITS_PER_UNIT
;
51 /* Nonzero if all REFERENCE_TYPEs are internal and hence should be allocated
52 in the address spaces' address_mode, not pointer_mode. Set only by
53 internal_reference_types called only by a front end. */
54 static int reference_types_internal
= 0;
56 static tree
self_referential_size (tree
);
57 static void finalize_record_size (record_layout_info
);
58 static void finalize_type_size (tree
);
59 static void place_union_field (record_layout_info
, tree
);
60 #if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED)
61 static int excess_unit_span (HOST_WIDE_INT
, HOST_WIDE_INT
, HOST_WIDE_INT
,
64 extern void debug_rli (record_layout_info
);
66 /* Show that REFERENCE_TYPES are internal and should use address_mode.
67 Called only by front end. */
70 internal_reference_types (void)
72 reference_types_internal
= 1;
75 /* Given a size SIZE that may not be a constant, return a SAVE_EXPR
76 to serve as the actual size-expression for a type or decl. */
79 variable_size (tree size
)
82 if (TREE_CONSTANT (size
))
85 /* If the size is self-referential, we can't make a SAVE_EXPR (see
86 save_expr for the rationale). But we can do something else. */
87 if (CONTAINS_PLACEHOLDER_P (size
))
88 return self_referential_size (size
);
90 /* If we are in the global binding level, we can't make a SAVE_EXPR
91 since it may end up being shared across functions, so it is up
92 to the front-end to deal with this case. */
93 if (lang_hooks
.decls
.global_bindings_p ())
96 return save_expr (size
);
99 /* An array of functions used for self-referential size computation. */
100 static GTY(()) vec
<tree
, va_gc
> *size_functions
;
102 /* Similar to copy_tree_r but do not copy component references involving
103 PLACEHOLDER_EXPRs. These nodes are spotted in find_placeholder_in_expr
104 and substituted in substitute_in_expr. */
107 copy_self_referential_tree_r (tree
*tp
, int *walk_subtrees
, void *data
)
109 enum tree_code code
= TREE_CODE (*tp
);
111 /* Stop at types, decls, constants like copy_tree_r. */
112 if (TREE_CODE_CLASS (code
) == tcc_type
113 || TREE_CODE_CLASS (code
) == tcc_declaration
114 || TREE_CODE_CLASS (code
) == tcc_constant
)
120 /* This is the pattern built in ada/make_aligning_type. */
121 else if (code
== ADDR_EXPR
122 && TREE_CODE (TREE_OPERAND (*tp
, 0)) == PLACEHOLDER_EXPR
)
128 /* Default case: the component reference. */
129 else if (code
== COMPONENT_REF
)
132 for (inner
= TREE_OPERAND (*tp
, 0);
133 REFERENCE_CLASS_P (inner
);
134 inner
= TREE_OPERAND (inner
, 0))
137 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
)
144 /* We're not supposed to have them in self-referential size trees
145 because we wouldn't properly control when they are evaluated.
146 However, not creating superfluous SAVE_EXPRs requires accurate
147 tracking of readonly-ness all the way down to here, which we
148 cannot always guarantee in practice. So punt in this case. */
149 else if (code
== SAVE_EXPR
)
150 return error_mark_node
;
152 else if (code
== STATEMENT_LIST
)
155 return copy_tree_r (tp
, walk_subtrees
, data
);
158 /* Given a SIZE expression that is self-referential, return an equivalent
159 expression to serve as the actual size expression for a type. */
162 self_referential_size (tree size
)
164 static unsigned HOST_WIDE_INT fnno
= 0;
165 vec
<tree
> self_refs
= vNULL
;
166 tree param_type_list
= NULL
, param_decl_list
= NULL
;
167 tree t
, ref
, return_type
, fntype
, fnname
, fndecl
;
170 vec
<tree
, va_gc
> *args
= NULL
;
172 /* Do not factor out simple operations. */
173 t
= skip_simple_constant_arithmetic (size
);
174 if (TREE_CODE (t
) == CALL_EXPR
)
177 /* Collect the list of self-references in the expression. */
178 find_placeholder_in_expr (size
, &self_refs
);
179 gcc_assert (self_refs
.length () > 0);
181 /* Obtain a private copy of the expression. */
183 if (walk_tree (&t
, copy_self_referential_tree_r
, NULL
, NULL
) != NULL_TREE
)
187 /* Build the parameter and argument lists in parallel; also
188 substitute the former for the latter in the expression. */
189 vec_alloc (args
, self_refs
.length ());
190 FOR_EACH_VEC_ELT (self_refs
, i
, ref
)
192 tree subst
, param_name
, param_type
, param_decl
;
196 /* We shouldn't have true variables here. */
197 gcc_assert (TREE_READONLY (ref
));
200 /* This is the pattern built in ada/make_aligning_type. */
201 else if (TREE_CODE (ref
) == ADDR_EXPR
)
203 /* Default case: the component reference. */
205 subst
= TREE_OPERAND (ref
, 1);
207 sprintf (buf
, "p%d", i
);
208 param_name
= get_identifier (buf
);
209 param_type
= TREE_TYPE (ref
);
211 = build_decl (input_location
, PARM_DECL
, param_name
, param_type
);
212 if (targetm
.calls
.promote_prototypes (NULL_TREE
)
213 && INTEGRAL_TYPE_P (param_type
)
214 && TYPE_PRECISION (param_type
) < TYPE_PRECISION (integer_type_node
))
215 DECL_ARG_TYPE (param_decl
) = integer_type_node
;
217 DECL_ARG_TYPE (param_decl
) = param_type
;
218 DECL_ARTIFICIAL (param_decl
) = 1;
219 TREE_READONLY (param_decl
) = 1;
221 size
= substitute_in_expr (size
, subst
, param_decl
);
223 param_type_list
= tree_cons (NULL_TREE
, param_type
, param_type_list
);
224 param_decl_list
= chainon (param_decl
, param_decl_list
);
225 args
->quick_push (ref
);
228 self_refs
.release ();
230 /* Append 'void' to indicate that the number of parameters is fixed. */
231 param_type_list
= tree_cons (NULL_TREE
, void_type_node
, param_type_list
);
233 /* The 3 lists have been created in reverse order. */
234 param_type_list
= nreverse (param_type_list
);
235 param_decl_list
= nreverse (param_decl_list
);
237 /* Build the function type. */
238 return_type
= TREE_TYPE (size
);
239 fntype
= build_function_type (return_type
, param_type_list
);
241 /* Build the function declaration. */
242 sprintf (buf
, "SZ"HOST_WIDE_INT_PRINT_UNSIGNED
, fnno
++);
243 fnname
= get_file_function_name (buf
);
244 fndecl
= build_decl (input_location
, FUNCTION_DECL
, fnname
, fntype
);
245 for (t
= param_decl_list
; t
; t
= DECL_CHAIN (t
))
246 DECL_CONTEXT (t
) = fndecl
;
247 DECL_ARGUMENTS (fndecl
) = param_decl_list
;
249 = build_decl (input_location
, RESULT_DECL
, 0, return_type
);
250 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
252 /* The function has been created by the compiler and we don't
253 want to emit debug info for it. */
254 DECL_ARTIFICIAL (fndecl
) = 1;
255 DECL_IGNORED_P (fndecl
) = 1;
257 /* It is supposed to be "const" and never throw. */
258 TREE_READONLY (fndecl
) = 1;
259 TREE_NOTHROW (fndecl
) = 1;
261 /* We want it to be inlined when this is deemed profitable, as
262 well as discarded if every call has been integrated. */
263 DECL_DECLARED_INLINE_P (fndecl
) = 1;
265 /* It is made up of a unique return statement. */
266 DECL_INITIAL (fndecl
) = make_node (BLOCK
);
267 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
268 t
= build2 (MODIFY_EXPR
, return_type
, DECL_RESULT (fndecl
), size
);
269 DECL_SAVED_TREE (fndecl
) = build1 (RETURN_EXPR
, void_type_node
, t
);
270 TREE_STATIC (fndecl
) = 1;
272 /* Put it onto the list of size functions. */
273 vec_safe_push (size_functions
, fndecl
);
275 /* Replace the original expression with a call to the size function. */
276 return build_call_expr_loc_vec (UNKNOWN_LOCATION
, fndecl
, args
);
279 /* Take, queue and compile all the size functions. It is essential that
280 the size functions be gimplified at the very end of the compilation
281 in order to guarantee transparent handling of self-referential sizes.
282 Otherwise the GENERIC inliner would not be able to inline them back
283 at each of their call sites, thus creating artificial non-constant
284 size expressions which would trigger nasty problems later on. */
287 finalize_size_functions (void)
292 for (i
= 0; size_functions
&& size_functions
->iterate (i
, &fndecl
); i
++)
294 allocate_struct_function (fndecl
, false);
296 dump_function (TDI_original
, fndecl
);
297 gimplify_function_tree (fndecl
);
298 dump_function (TDI_generic
, fndecl
);
299 cgraph_finalize_function (fndecl
, false);
302 vec_free (size_functions
);
305 /* Return the machine mode to use for a nonscalar of SIZE bits. The
306 mode must be in class MCLASS, and have exactly that many value bits;
307 it may have padding as well. If LIMIT is nonzero, modes of wider
308 than MAX_FIXED_MODE_SIZE will not be used. */
311 mode_for_size (unsigned int size
, enum mode_class mclass
, int limit
)
313 enum machine_mode mode
;
315 if (limit
&& size
> MAX_FIXED_MODE_SIZE
)
318 /* Get the first mode which has this size, in the specified class. */
319 for (mode
= GET_CLASS_NARROWEST_MODE (mclass
); mode
!= VOIDmode
;
320 mode
= GET_MODE_WIDER_MODE (mode
))
321 if (GET_MODE_PRECISION (mode
) == size
)
327 /* Similar, except passed a tree node. */
330 mode_for_size_tree (const_tree size
, enum mode_class mclass
, int limit
)
332 unsigned HOST_WIDE_INT uhwi
;
335 if (!host_integerp (size
, 1))
337 uhwi
= tree_low_cst (size
, 1);
341 return mode_for_size (ui
, mclass
, limit
);
344 /* Similar, but never return BLKmode; return the narrowest mode that
345 contains at least the requested number of value bits. */
348 smallest_mode_for_size (unsigned int size
, enum mode_class mclass
)
350 enum machine_mode mode
;
352 /* Get the first mode which has at least this size, in the
354 for (mode
= GET_CLASS_NARROWEST_MODE (mclass
); mode
!= VOIDmode
;
355 mode
= GET_MODE_WIDER_MODE (mode
))
356 if (GET_MODE_PRECISION (mode
) >= size
)
362 /* Find an integer mode of the exact same size, or BLKmode on failure. */
365 int_mode_for_mode (enum machine_mode mode
)
367 switch (GET_MODE_CLASS (mode
))
370 case MODE_PARTIAL_INT
:
373 case MODE_COMPLEX_INT
:
374 case MODE_COMPLEX_FLOAT
:
376 case MODE_DECIMAL_FLOAT
:
377 case MODE_VECTOR_INT
:
378 case MODE_VECTOR_FLOAT
:
383 case MODE_VECTOR_FRACT
:
384 case MODE_VECTOR_ACCUM
:
385 case MODE_VECTOR_UFRACT
:
386 case MODE_VECTOR_UACCUM
:
387 case MODE_POINTER_BOUNDS
:
388 mode
= mode_for_size (GET_MODE_BITSIZE (mode
), MODE_INT
, 0);
395 /* ... fall through ... */
405 /* Find a mode that is suitable for representing a vector with
406 NUNITS elements of mode INNERMODE. Returns BLKmode if there
407 is no suitable mode. */
410 mode_for_vector (enum machine_mode innermode
, unsigned nunits
)
412 enum machine_mode mode
;
414 /* First, look for a supported vector type. */
415 if (SCALAR_FLOAT_MODE_P (innermode
))
416 mode
= MIN_MODE_VECTOR_FLOAT
;
417 else if (SCALAR_FRACT_MODE_P (innermode
))
418 mode
= MIN_MODE_VECTOR_FRACT
;
419 else if (SCALAR_UFRACT_MODE_P (innermode
))
420 mode
= MIN_MODE_VECTOR_UFRACT
;
421 else if (SCALAR_ACCUM_MODE_P (innermode
))
422 mode
= MIN_MODE_VECTOR_ACCUM
;
423 else if (SCALAR_UACCUM_MODE_P (innermode
))
424 mode
= MIN_MODE_VECTOR_UACCUM
;
426 mode
= MIN_MODE_VECTOR_INT
;
428 /* Do not check vector_mode_supported_p here. We'll do that
429 later in vector_type_mode. */
430 for (; mode
!= VOIDmode
; mode
= GET_MODE_WIDER_MODE (mode
))
431 if (GET_MODE_NUNITS (mode
) == nunits
432 && GET_MODE_INNER (mode
) == innermode
)
435 /* For integers, try mapping it to a same-sized scalar mode. */
437 && GET_MODE_CLASS (innermode
) == MODE_INT
)
438 mode
= mode_for_size (nunits
* GET_MODE_BITSIZE (innermode
),
442 || (GET_MODE_CLASS (mode
) == MODE_INT
443 && !have_regs_of_mode
[mode
]))
449 /* Return the alignment of MODE. This will be bounded by 1 and
450 BIGGEST_ALIGNMENT. */
453 get_mode_alignment (enum machine_mode mode
)
455 return MIN (BIGGEST_ALIGNMENT
, MAX (1, mode_base_align
[mode
]*BITS_PER_UNIT
));
458 /* Return the precision of the mode, or for a complex or vector mode the
459 precision of the mode of its elements. */
462 element_precision (enum machine_mode mode
)
464 if (COMPLEX_MODE_P (mode
) || VECTOR_MODE_P (mode
))
465 mode
= GET_MODE_INNER (mode
);
467 return GET_MODE_PRECISION (mode
);
470 /* Return the natural mode of an array, given that it is SIZE bytes in
471 total and has elements of type ELEM_TYPE. */
473 static enum machine_mode
474 mode_for_array (tree elem_type
, tree size
)
477 unsigned HOST_WIDE_INT int_size
, int_elem_size
;
480 /* One-element arrays get the component type's mode. */
481 elem_size
= TYPE_SIZE (elem_type
);
482 if (simple_cst_equal (size
, elem_size
))
483 return TYPE_MODE (elem_type
);
486 if (host_integerp (size
, 1) && host_integerp (elem_size
, 1))
488 int_size
= tree_low_cst (size
, 1);
489 int_elem_size
= tree_low_cst (elem_size
, 1);
490 if (int_elem_size
> 0
491 && int_size
% int_elem_size
== 0
492 && targetm
.array_mode_supported_p (TYPE_MODE (elem_type
),
493 int_size
/ int_elem_size
))
496 return mode_for_size_tree (size
, MODE_INT
, limit_p
);
499 /* Subroutine of layout_decl: Force alignment required for the data type.
500 But if the decl itself wants greater alignment, don't override that. */
503 do_type_align (tree type
, tree decl
)
505 if (TYPE_ALIGN (type
) > DECL_ALIGN (decl
))
507 DECL_ALIGN (decl
) = TYPE_ALIGN (type
);
508 if (TREE_CODE (decl
) == FIELD_DECL
)
509 DECL_USER_ALIGN (decl
) = TYPE_USER_ALIGN (type
);
513 /* Set the size, mode and alignment of a ..._DECL node.
514 TYPE_DECL does need this for C++.
515 Note that LABEL_DECL and CONST_DECL nodes do not need this,
516 and FUNCTION_DECL nodes have them set up in a special (and simple) way.
517 Don't call layout_decl for them.
519 KNOWN_ALIGN is the amount of alignment we can assume this
520 decl has with no special effort. It is relevant only for FIELD_DECLs
521 and depends on the previous fields.
522 All that matters about KNOWN_ALIGN is which powers of 2 divide it.
523 If KNOWN_ALIGN is 0, it means, "as much alignment as you like":
524 the record will be aligned to suit. */
527 layout_decl (tree decl
, unsigned int known_align
)
529 tree type
= TREE_TYPE (decl
);
530 enum tree_code code
= TREE_CODE (decl
);
532 location_t loc
= DECL_SOURCE_LOCATION (decl
);
534 if (code
== CONST_DECL
)
537 gcc_assert (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
538 || code
== TYPE_DECL
||code
== FIELD_DECL
);
540 rtl
= DECL_RTL_IF_SET (decl
);
542 if (type
== error_mark_node
)
543 type
= void_type_node
;
545 /* Usually the size and mode come from the data type without change,
546 however, the front-end may set the explicit width of the field, so its
547 size may not be the same as the size of its type. This happens with
548 bitfields, of course (an `int' bitfield may be only 2 bits, say), but it
549 also happens with other fields. For example, the C++ front-end creates
550 zero-sized fields corresponding to empty base classes, and depends on
551 layout_type setting DECL_FIELD_BITPOS correctly for the field. Set the
552 size in bytes from the size in bits. If we have already set the mode,
553 don't set it again since we can be called twice for FIELD_DECLs. */
555 DECL_UNSIGNED (decl
) = TYPE_UNSIGNED (type
);
556 if (DECL_MODE (decl
) == VOIDmode
)
557 DECL_MODE (decl
) = TYPE_MODE (type
);
559 if (DECL_SIZE (decl
) == 0)
561 DECL_SIZE (decl
) = TYPE_SIZE (type
);
562 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (type
);
564 else if (DECL_SIZE_UNIT (decl
) == 0)
565 DECL_SIZE_UNIT (decl
)
566 = fold_convert_loc (loc
, sizetype
,
567 size_binop_loc (loc
, CEIL_DIV_EXPR
, DECL_SIZE (decl
),
570 if (code
!= FIELD_DECL
)
571 /* For non-fields, update the alignment from the type. */
572 do_type_align (type
, decl
);
574 /* For fields, it's a bit more complicated... */
576 bool old_user_align
= DECL_USER_ALIGN (decl
);
577 bool zero_bitfield
= false;
578 bool packed_p
= DECL_PACKED (decl
);
581 if (DECL_BIT_FIELD (decl
))
583 DECL_BIT_FIELD_TYPE (decl
) = type
;
585 /* A zero-length bit-field affects the alignment of the next
586 field. In essence such bit-fields are not influenced by
587 any packing due to #pragma pack or attribute packed. */
588 if (integer_zerop (DECL_SIZE (decl
))
589 && ! targetm
.ms_bitfield_layout_p (DECL_FIELD_CONTEXT (decl
)))
591 zero_bitfield
= true;
593 #ifdef PCC_BITFIELD_TYPE_MATTERS
594 if (PCC_BITFIELD_TYPE_MATTERS
)
595 do_type_align (type
, decl
);
599 #ifdef EMPTY_FIELD_BOUNDARY
600 if (EMPTY_FIELD_BOUNDARY
> DECL_ALIGN (decl
))
602 DECL_ALIGN (decl
) = EMPTY_FIELD_BOUNDARY
;
603 DECL_USER_ALIGN (decl
) = 0;
609 /* See if we can use an ordinary integer mode for a bit-field.
610 Conditions are: a fixed size that is correct for another mode,
611 occupying a complete byte or bytes on proper boundary. */
612 if (TYPE_SIZE (type
) != 0
613 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
614 && GET_MODE_CLASS (TYPE_MODE (type
)) == MODE_INT
)
616 enum machine_mode xmode
617 = mode_for_size_tree (DECL_SIZE (decl
), MODE_INT
, 1);
618 unsigned int xalign
= GET_MODE_ALIGNMENT (xmode
);
621 && !(xalign
> BITS_PER_UNIT
&& DECL_PACKED (decl
))
622 && (known_align
== 0 || known_align
>= xalign
))
624 DECL_ALIGN (decl
) = MAX (xalign
, DECL_ALIGN (decl
));
625 DECL_MODE (decl
) = xmode
;
626 DECL_BIT_FIELD (decl
) = 0;
630 /* Turn off DECL_BIT_FIELD if we won't need it set. */
631 if (TYPE_MODE (type
) == BLKmode
&& DECL_MODE (decl
) == BLKmode
632 && known_align
>= TYPE_ALIGN (type
)
633 && DECL_ALIGN (decl
) >= TYPE_ALIGN (type
))
634 DECL_BIT_FIELD (decl
) = 0;
636 else if (packed_p
&& DECL_USER_ALIGN (decl
))
637 /* Don't touch DECL_ALIGN. For other packed fields, go ahead and
638 round up; we'll reduce it again below. We want packing to
639 supersede USER_ALIGN inherited from the type, but defer to
640 alignment explicitly specified on the field decl. */;
642 do_type_align (type
, decl
);
644 /* If the field is packed and not explicitly aligned, give it the
645 minimum alignment. Note that do_type_align may set
646 DECL_USER_ALIGN, so we need to check old_user_align instead. */
649 DECL_ALIGN (decl
) = MIN (DECL_ALIGN (decl
), BITS_PER_UNIT
);
651 if (! packed_p
&& ! DECL_USER_ALIGN (decl
))
653 /* Some targets (i.e. i386, VMS) limit struct field alignment
654 to a lower boundary than alignment of variables unless
655 it was overridden by attribute aligned. */
656 #ifdef BIGGEST_FIELD_ALIGNMENT
658 = MIN (DECL_ALIGN (decl
), (unsigned) BIGGEST_FIELD_ALIGNMENT
);
660 #ifdef ADJUST_FIELD_ALIGN
661 DECL_ALIGN (decl
) = ADJUST_FIELD_ALIGN (decl
, DECL_ALIGN (decl
));
666 mfa
= initial_max_fld_align
* BITS_PER_UNIT
;
668 mfa
= maximum_field_alignment
;
669 /* Should this be controlled by DECL_USER_ALIGN, too? */
671 DECL_ALIGN (decl
) = MIN (DECL_ALIGN (decl
), mfa
);
674 /* Evaluate nonconstant size only once, either now or as soon as safe. */
675 if (DECL_SIZE (decl
) != 0 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
676 DECL_SIZE (decl
) = variable_size (DECL_SIZE (decl
));
677 if (DECL_SIZE_UNIT (decl
) != 0
678 && TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
)
679 DECL_SIZE_UNIT (decl
) = variable_size (DECL_SIZE_UNIT (decl
));
681 /* If requested, warn about definitions of large data objects. */
683 && (code
== VAR_DECL
|| code
== PARM_DECL
)
684 && ! DECL_EXTERNAL (decl
))
686 tree size
= DECL_SIZE_UNIT (decl
);
688 if (size
!= 0 && TREE_CODE (size
) == INTEGER_CST
689 && compare_tree_int (size
, larger_than_size
) > 0)
691 int size_as_int
= TREE_INT_CST_LOW (size
);
693 if (compare_tree_int (size
, size_as_int
) == 0)
694 warning (OPT_Wlarger_than_
, "size of %q+D is %d bytes", decl
, size_as_int
);
696 warning (OPT_Wlarger_than_
, "size of %q+D is larger than %wd bytes",
697 decl
, larger_than_size
);
701 /* If the RTL was already set, update its mode and mem attributes. */
704 PUT_MODE (rtl
, DECL_MODE (decl
));
705 SET_DECL_RTL (decl
, 0);
706 set_mem_attributes (rtl
, decl
, 1);
707 SET_DECL_RTL (decl
, rtl
);
711 /* Given a VAR_DECL, PARM_DECL or RESULT_DECL, clears the results of
712 a previous call to layout_decl and calls it again. */
715 relayout_decl (tree decl
)
717 DECL_SIZE (decl
) = DECL_SIZE_UNIT (decl
) = 0;
718 DECL_MODE (decl
) = VOIDmode
;
719 if (!DECL_USER_ALIGN (decl
))
720 DECL_ALIGN (decl
) = 0;
721 SET_DECL_RTL (decl
, 0);
723 layout_decl (decl
, 0);
726 /* Begin laying out type T, which may be a RECORD_TYPE, UNION_TYPE, or
727 QUAL_UNION_TYPE. Return a pointer to a struct record_layout_info which
728 is to be passed to all other layout functions for this record. It is the
729 responsibility of the caller to call `free' for the storage returned.
730 Note that garbage collection is not permitted until we finish laying
734 start_record_layout (tree t
)
736 record_layout_info rli
= XNEW (struct record_layout_info_s
);
740 /* If the type has a minimum specified alignment (via an attribute
741 declaration, for example) use it -- otherwise, start with a
742 one-byte alignment. */
743 rli
->record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (t
));
744 rli
->unpacked_align
= rli
->record_align
;
745 rli
->offset_align
= MAX (rli
->record_align
, BIGGEST_ALIGNMENT
);
747 #ifdef STRUCTURE_SIZE_BOUNDARY
748 /* Packed structures don't need to have minimum size. */
749 if (! TYPE_PACKED (t
))
753 /* #pragma pack overrides STRUCTURE_SIZE_BOUNDARY. */
754 tmp
= (unsigned) STRUCTURE_SIZE_BOUNDARY
;
755 if (maximum_field_alignment
!= 0)
756 tmp
= MIN (tmp
, maximum_field_alignment
);
757 rli
->record_align
= MAX (rli
->record_align
, tmp
);
761 rli
->offset
= size_zero_node
;
762 rli
->bitpos
= bitsize_zero_node
;
764 rli
->pending_statics
= 0;
765 rli
->packed_maybe_necessary
= 0;
766 rli
->remaining_in_alignment
= 0;
771 /* Return the combined bit position for the byte offset OFFSET and the
774 These functions operate on byte and bit positions present in FIELD_DECLs
775 and assume that these expressions result in no (intermediate) overflow.
776 This assumption is necessary to fold the expressions as much as possible,
777 so as to avoid creating artificially variable-sized types in languages
778 supporting variable-sized types like Ada. */
781 bit_from_pos (tree offset
, tree bitpos
)
783 if (TREE_CODE (offset
) == PLUS_EXPR
)
784 offset
= size_binop (PLUS_EXPR
,
785 fold_convert (bitsizetype
, TREE_OPERAND (offset
, 0)),
786 fold_convert (bitsizetype
, TREE_OPERAND (offset
, 1)));
788 offset
= fold_convert (bitsizetype
, offset
);
789 return size_binop (PLUS_EXPR
, bitpos
,
790 size_binop (MULT_EXPR
, offset
, bitsize_unit_node
));
793 /* Return the combined truncated byte position for the byte offset OFFSET and
794 the bit position BITPOS. */
797 byte_from_pos (tree offset
, tree bitpos
)
800 if (TREE_CODE (bitpos
) == MULT_EXPR
801 && tree_int_cst_equal (TREE_OPERAND (bitpos
, 1), bitsize_unit_node
))
802 bytepos
= TREE_OPERAND (bitpos
, 0);
804 bytepos
= size_binop (TRUNC_DIV_EXPR
, bitpos
, bitsize_unit_node
);
805 return size_binop (PLUS_EXPR
, offset
, fold_convert (sizetype
, bytepos
));
808 /* Split the bit position POS into a byte offset *POFFSET and a bit
809 position *PBITPOS with the byte offset aligned to OFF_ALIGN bits. */
812 pos_from_bit (tree
*poffset
, tree
*pbitpos
, unsigned int off_align
,
815 tree toff_align
= bitsize_int (off_align
);
816 if (TREE_CODE (pos
) == MULT_EXPR
817 && tree_int_cst_equal (TREE_OPERAND (pos
, 1), toff_align
))
819 *poffset
= size_binop (MULT_EXPR
,
820 fold_convert (sizetype
, TREE_OPERAND (pos
, 0)),
821 size_int (off_align
/ BITS_PER_UNIT
));
822 *pbitpos
= bitsize_zero_node
;
826 *poffset
= size_binop (MULT_EXPR
,
827 fold_convert (sizetype
,
828 size_binop (FLOOR_DIV_EXPR
, pos
,
830 size_int (off_align
/ BITS_PER_UNIT
));
831 *pbitpos
= size_binop (FLOOR_MOD_EXPR
, pos
, toff_align
);
835 /* Given a pointer to bit and byte offsets and an offset alignment,
836 normalize the offsets so they are within the alignment. */
839 normalize_offset (tree
*poffset
, tree
*pbitpos
, unsigned int off_align
)
841 /* If the bit position is now larger than it should be, adjust it
843 if (compare_tree_int (*pbitpos
, off_align
) >= 0)
846 pos_from_bit (&offset
, &bitpos
, off_align
, *pbitpos
);
847 *poffset
= size_binop (PLUS_EXPR
, *poffset
, offset
);
852 /* Print debugging information about the information in RLI. */
855 debug_rli (record_layout_info rli
)
857 print_node_brief (stderr
, "type", rli
->t
, 0);
858 print_node_brief (stderr
, "\noffset", rli
->offset
, 0);
859 print_node_brief (stderr
, " bitpos", rli
->bitpos
, 0);
861 fprintf (stderr
, "\naligns: rec = %u, unpack = %u, off = %u\n",
862 rli
->record_align
, rli
->unpacked_align
,
865 /* The ms_struct code is the only that uses this. */
866 if (targetm
.ms_bitfield_layout_p (rli
->t
))
867 fprintf (stderr
, "remaining in alignment = %u\n", rli
->remaining_in_alignment
);
869 if (rli
->packed_maybe_necessary
)
870 fprintf (stderr
, "packed may be necessary\n");
872 if (!vec_safe_is_empty (rli
->pending_statics
))
874 fprintf (stderr
, "pending statics:\n");
875 debug_vec_tree (rli
->pending_statics
);
879 /* Given an RLI with a possibly-incremented BITPOS, adjust OFFSET and
880 BITPOS if necessary to keep BITPOS below OFFSET_ALIGN. */
883 normalize_rli (record_layout_info rli
)
885 normalize_offset (&rli
->offset
, &rli
->bitpos
, rli
->offset_align
);
888 /* Returns the size in bytes allocated so far. */
891 rli_size_unit_so_far (record_layout_info rli
)
893 return byte_from_pos (rli
->offset
, rli
->bitpos
);
896 /* Returns the size in bits allocated so far. */
899 rli_size_so_far (record_layout_info rli
)
901 return bit_from_pos (rli
->offset
, rli
->bitpos
);
904 /* FIELD is about to be added to RLI->T. The alignment (in bits) of
905 the next available location within the record is given by KNOWN_ALIGN.
906 Update the variable alignment fields in RLI, and return the alignment
907 to give the FIELD. */
910 update_alignment_for_field (record_layout_info rli
, tree field
,
911 unsigned int known_align
)
913 /* The alignment required for FIELD. */
914 unsigned int desired_align
;
915 /* The type of this field. */
916 tree type
= TREE_TYPE (field
);
917 /* True if the field was explicitly aligned by the user. */
921 /* Do not attempt to align an ERROR_MARK node */
922 if (TREE_CODE (type
) == ERROR_MARK
)
925 /* Lay out the field so we know what alignment it needs. */
926 layout_decl (field
, known_align
);
927 desired_align
= DECL_ALIGN (field
);
928 user_align
= DECL_USER_ALIGN (field
);
930 is_bitfield
= (type
!= error_mark_node
931 && DECL_BIT_FIELD_TYPE (field
)
932 && ! integer_zerop (TYPE_SIZE (type
)));
934 /* Record must have at least as much alignment as any field.
935 Otherwise, the alignment of the field within the record is
937 if (targetm
.ms_bitfield_layout_p (rli
->t
))
939 /* Here, the alignment of the underlying type of a bitfield can
940 affect the alignment of a record; even a zero-sized field
941 can do this. The alignment should be to the alignment of
942 the type, except that for zero-size bitfields this only
943 applies if there was an immediately prior, nonzero-size
944 bitfield. (That's the way it is, experimentally.) */
945 if ((!is_bitfield
&& !DECL_PACKED (field
))
946 || ((DECL_SIZE (field
) == NULL_TREE
947 || !integer_zerop (DECL_SIZE (field
)))
948 ? !DECL_PACKED (field
)
950 && DECL_BIT_FIELD_TYPE (rli
->prev_field
)
951 && ! integer_zerop (DECL_SIZE (rli
->prev_field
)))))
953 unsigned int type_align
= TYPE_ALIGN (type
);
954 type_align
= MAX (type_align
, desired_align
);
955 if (maximum_field_alignment
!= 0)
956 type_align
= MIN (type_align
, maximum_field_alignment
);
957 rli
->record_align
= MAX (rli
->record_align
, type_align
);
958 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
961 #ifdef PCC_BITFIELD_TYPE_MATTERS
962 else if (is_bitfield
&& PCC_BITFIELD_TYPE_MATTERS
)
964 /* Named bit-fields cause the entire structure to have the
965 alignment implied by their type. Some targets also apply the same
966 rules to unnamed bitfields. */
967 if (DECL_NAME (field
) != 0
968 || targetm
.align_anon_bitfield ())
970 unsigned int type_align
= TYPE_ALIGN (type
);
972 #ifdef ADJUST_FIELD_ALIGN
973 if (! TYPE_USER_ALIGN (type
))
974 type_align
= ADJUST_FIELD_ALIGN (field
, type_align
);
977 /* Targets might chose to handle unnamed and hence possibly
978 zero-width bitfield. Those are not influenced by #pragmas
979 or packed attributes. */
980 if (integer_zerop (DECL_SIZE (field
)))
982 if (initial_max_fld_align
)
983 type_align
= MIN (type_align
,
984 initial_max_fld_align
* BITS_PER_UNIT
);
986 else if (maximum_field_alignment
!= 0)
987 type_align
= MIN (type_align
, maximum_field_alignment
);
988 else if (DECL_PACKED (field
))
989 type_align
= MIN (type_align
, BITS_PER_UNIT
);
991 /* The alignment of the record is increased to the maximum
992 of the current alignment, the alignment indicated on the
993 field (i.e., the alignment specified by an __aligned__
994 attribute), and the alignment indicated by the type of
996 rli
->record_align
= MAX (rli
->record_align
, desired_align
);
997 rli
->record_align
= MAX (rli
->record_align
, type_align
);
1000 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
1001 user_align
|= TYPE_USER_ALIGN (type
);
1007 rli
->record_align
= MAX (rli
->record_align
, desired_align
);
1008 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
1011 TYPE_USER_ALIGN (rli
->t
) |= user_align
;
1013 return desired_align
;
1016 /* Called from place_field to handle unions. */
1019 place_union_field (record_layout_info rli
, tree field
)
1021 update_alignment_for_field (rli
, field
, /*known_align=*/0);
1023 DECL_FIELD_OFFSET (field
) = size_zero_node
;
1024 DECL_FIELD_BIT_OFFSET (field
) = bitsize_zero_node
;
1025 SET_DECL_OFFSET_ALIGN (field
, BIGGEST_ALIGNMENT
);
1027 /* If this is an ERROR_MARK return *after* having set the
1028 field at the start of the union. This helps when parsing
1030 if (TREE_CODE (TREE_TYPE (field
)) == ERROR_MARK
)
1033 /* We assume the union's size will be a multiple of a byte so we don't
1034 bother with BITPOS. */
1035 if (TREE_CODE (rli
->t
) == UNION_TYPE
)
1036 rli
->offset
= size_binop (MAX_EXPR
, rli
->offset
, DECL_SIZE_UNIT (field
));
1037 else if (TREE_CODE (rli
->t
) == QUAL_UNION_TYPE
)
1038 rli
->offset
= fold_build3 (COND_EXPR
, sizetype
, DECL_QUALIFIER (field
),
1039 DECL_SIZE_UNIT (field
), rli
->offset
);
1042 #if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED)
1043 /* A bitfield of SIZE with a required access alignment of ALIGN is allocated
1044 at BYTE_OFFSET / BIT_OFFSET. Return nonzero if the field would span more
1045 units of alignment than the underlying TYPE. */
1047 excess_unit_span (HOST_WIDE_INT byte_offset
, HOST_WIDE_INT bit_offset
,
1048 HOST_WIDE_INT size
, HOST_WIDE_INT align
, tree type
)
1050 /* Note that the calculation of OFFSET might overflow; we calculate it so
1051 that we still get the right result as long as ALIGN is a power of two. */
1052 unsigned HOST_WIDE_INT offset
= byte_offset
* BITS_PER_UNIT
+ bit_offset
;
1054 offset
= offset
% align
;
1055 return ((offset
+ size
+ align
- 1) / align
1056 > ((unsigned HOST_WIDE_INT
) tree_low_cst (TYPE_SIZE (type
), 1)
1061 /* RLI contains information about the layout of a RECORD_TYPE. FIELD
1062 is a FIELD_DECL to be added after those fields already present in
1063 T. (FIELD is not actually added to the TYPE_FIELDS list here;
1064 callers that desire that behavior must manually perform that step.) */
1067 place_field (record_layout_info rli
, tree field
)
1069 /* The alignment required for FIELD. */
1070 unsigned int desired_align
;
1071 /* The alignment FIELD would have if we just dropped it into the
1072 record as it presently stands. */
1073 unsigned int known_align
;
1074 unsigned int actual_align
;
1075 /* The type of this field. */
1076 tree type
= TREE_TYPE (field
);
1078 gcc_assert (TREE_CODE (field
) != ERROR_MARK
);
1080 /* If FIELD is static, then treat it like a separate variable, not
1081 really like a structure field. If it is a FUNCTION_DECL, it's a
1082 method. In both cases, all we do is lay out the decl, and we do
1083 it *after* the record is laid out. */
1084 if (TREE_CODE (field
) == VAR_DECL
)
1086 vec_safe_push (rli
->pending_statics
, field
);
1090 /* Enumerators and enum types which are local to this class need not
1091 be laid out. Likewise for initialized constant fields. */
1092 else if (TREE_CODE (field
) != FIELD_DECL
)
1095 /* Unions are laid out very differently than records, so split
1096 that code off to another function. */
1097 else if (TREE_CODE (rli
->t
) != RECORD_TYPE
)
1099 place_union_field (rli
, field
);
1103 else if (TREE_CODE (type
) == ERROR_MARK
)
1105 /* Place this field at the current allocation position, so we
1106 maintain monotonicity. */
1107 DECL_FIELD_OFFSET (field
) = rli
->offset
;
1108 DECL_FIELD_BIT_OFFSET (field
) = rli
->bitpos
;
1109 SET_DECL_OFFSET_ALIGN (field
, rli
->offset_align
);
1113 /* Work out the known alignment so far. Note that A & (-A) is the
1114 value of the least-significant bit in A that is one. */
1115 if (! integer_zerop (rli
->bitpos
))
1116 known_align
= (tree_low_cst (rli
->bitpos
, 1)
1117 & - tree_low_cst (rli
->bitpos
, 1));
1118 else if (integer_zerop (rli
->offset
))
1120 else if (host_integerp (rli
->offset
, 1))
1121 known_align
= (BITS_PER_UNIT
1122 * (tree_low_cst (rli
->offset
, 1)
1123 & - tree_low_cst (rli
->offset
, 1)));
1125 known_align
= rli
->offset_align
;
1127 desired_align
= update_alignment_for_field (rli
, field
, known_align
);
1128 if (known_align
== 0)
1129 known_align
= MAX (BIGGEST_ALIGNMENT
, rli
->record_align
);
1131 if (warn_packed
&& DECL_PACKED (field
))
1133 if (known_align
>= TYPE_ALIGN (type
))
1135 if (TYPE_ALIGN (type
) > desired_align
)
1137 if (STRICT_ALIGNMENT
)
1138 warning (OPT_Wattributes
, "packed attribute causes "
1139 "inefficient alignment for %q+D", field
);
1140 /* Don't warn if DECL_PACKED was set by the type. */
1141 else if (!TYPE_PACKED (rli
->t
))
1142 warning (OPT_Wattributes
, "packed attribute is "
1143 "unnecessary for %q+D", field
);
1147 rli
->packed_maybe_necessary
= 1;
1150 /* Does this field automatically have alignment it needs by virtue
1151 of the fields that precede it and the record's own alignment? */
1152 if (known_align
< desired_align
)
1154 /* No, we need to skip space before this field.
1155 Bump the cumulative size to multiple of field alignment. */
1157 if (!targetm
.ms_bitfield_layout_p (rli
->t
)
1158 && DECL_SOURCE_LOCATION (field
) != BUILTINS_LOCATION
)
1159 warning (OPT_Wpadded
, "padding struct to align %q+D", field
);
1161 /* If the alignment is still within offset_align, just align
1162 the bit position. */
1163 if (desired_align
< rli
->offset_align
)
1164 rli
->bitpos
= round_up (rli
->bitpos
, desired_align
);
1167 /* First adjust OFFSET by the partial bits, then align. */
1169 = size_binop (PLUS_EXPR
, rli
->offset
,
1170 fold_convert (sizetype
,
1171 size_binop (CEIL_DIV_EXPR
, rli
->bitpos
,
1172 bitsize_unit_node
)));
1173 rli
->bitpos
= bitsize_zero_node
;
1175 rli
->offset
= round_up (rli
->offset
, desired_align
/ BITS_PER_UNIT
);
1178 if (! TREE_CONSTANT (rli
->offset
))
1179 rli
->offset_align
= desired_align
;
1180 if (targetm
.ms_bitfield_layout_p (rli
->t
))
1181 rli
->prev_field
= NULL
;
1184 /* Handle compatibility with PCC. Note that if the record has any
1185 variable-sized fields, we need not worry about compatibility. */
1186 #ifdef PCC_BITFIELD_TYPE_MATTERS
1187 if (PCC_BITFIELD_TYPE_MATTERS
1188 && ! targetm
.ms_bitfield_layout_p (rli
->t
)
1189 && TREE_CODE (field
) == FIELD_DECL
1190 && type
!= error_mark_node
1191 && DECL_BIT_FIELD (field
)
1192 && (! DECL_PACKED (field
)
1193 /* Enter for these packed fields only to issue a warning. */
1194 || TYPE_ALIGN (type
) <= BITS_PER_UNIT
)
1195 && maximum_field_alignment
== 0
1196 && ! integer_zerop (DECL_SIZE (field
))
1197 && host_integerp (DECL_SIZE (field
), 1)
1198 && host_integerp (rli
->offset
, 1)
1199 && host_integerp (TYPE_SIZE (type
), 1))
1201 unsigned int type_align
= TYPE_ALIGN (type
);
1202 tree dsize
= DECL_SIZE (field
);
1203 HOST_WIDE_INT field_size
= tree_low_cst (dsize
, 1);
1204 HOST_WIDE_INT offset
= tree_low_cst (rli
->offset
, 0);
1205 HOST_WIDE_INT bit_offset
= tree_low_cst (rli
->bitpos
, 0);
1207 #ifdef ADJUST_FIELD_ALIGN
1208 if (! TYPE_USER_ALIGN (type
))
1209 type_align
= ADJUST_FIELD_ALIGN (field
, type_align
);
1212 /* A bit field may not span more units of alignment of its type
1213 than its type itself. Advance to next boundary if necessary. */
1214 if (excess_unit_span (offset
, bit_offset
, field_size
, type_align
, type
))
1216 if (DECL_PACKED (field
))
1218 if (warn_packed_bitfield_compat
== 1)
1221 "offset of packed bit-field %qD has changed in GCC 4.4",
1225 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1228 if (! DECL_PACKED (field
))
1229 TYPE_USER_ALIGN (rli
->t
) |= TYPE_USER_ALIGN (type
);
1233 #ifdef BITFIELD_NBYTES_LIMITED
1234 if (BITFIELD_NBYTES_LIMITED
1235 && ! targetm
.ms_bitfield_layout_p (rli
->t
)
1236 && TREE_CODE (field
) == FIELD_DECL
1237 && type
!= error_mark_node
1238 && DECL_BIT_FIELD_TYPE (field
)
1239 && ! DECL_PACKED (field
)
1240 && ! integer_zerop (DECL_SIZE (field
))
1241 && host_integerp (DECL_SIZE (field
), 1)
1242 && host_integerp (rli
->offset
, 1)
1243 && host_integerp (TYPE_SIZE (type
), 1))
1245 unsigned int type_align
= TYPE_ALIGN (type
);
1246 tree dsize
= DECL_SIZE (field
);
1247 HOST_WIDE_INT field_size
= tree_low_cst (dsize
, 1);
1248 HOST_WIDE_INT offset
= tree_low_cst (rli
->offset
, 0);
1249 HOST_WIDE_INT bit_offset
= tree_low_cst (rli
->bitpos
, 0);
1251 #ifdef ADJUST_FIELD_ALIGN
1252 if (! TYPE_USER_ALIGN (type
))
1253 type_align
= ADJUST_FIELD_ALIGN (field
, type_align
);
1256 if (maximum_field_alignment
!= 0)
1257 type_align
= MIN (type_align
, maximum_field_alignment
);
1258 /* ??? This test is opposite the test in the containing if
1259 statement, so this code is unreachable currently. */
1260 else if (DECL_PACKED (field
))
1261 type_align
= MIN (type_align
, BITS_PER_UNIT
);
1263 /* A bit field may not span the unit of alignment of its type.
1264 Advance to next boundary if necessary. */
1265 if (excess_unit_span (offset
, bit_offset
, field_size
, type_align
, type
))
1266 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1268 TYPE_USER_ALIGN (rli
->t
) |= TYPE_USER_ALIGN (type
);
1272 /* See the docs for TARGET_MS_BITFIELD_LAYOUT_P for details.
1274 When a bit field is inserted into a packed record, the whole
1275 size of the underlying type is used by one or more same-size
1276 adjacent bitfields. (That is, if its long:3, 32 bits is
1277 used in the record, and any additional adjacent long bitfields are
1278 packed into the same chunk of 32 bits. However, if the size
1279 changes, a new field of that size is allocated.) In an unpacked
1280 record, this is the same as using alignment, but not equivalent
1283 Note: for compatibility, we use the type size, not the type alignment
1284 to determine alignment, since that matches the documentation */
1286 if (targetm
.ms_bitfield_layout_p (rli
->t
))
1288 tree prev_saved
= rli
->prev_field
;
1289 tree prev_type
= prev_saved
? DECL_BIT_FIELD_TYPE (prev_saved
) : NULL
;
1291 /* This is a bitfield if it exists. */
1292 if (rli
->prev_field
)
1294 /* If both are bitfields, nonzero, and the same size, this is
1295 the middle of a run. Zero declared size fields are special
1296 and handled as "end of run". (Note: it's nonzero declared
1297 size, but equal type sizes!) (Since we know that both
1298 the current and previous fields are bitfields by the
1299 time we check it, DECL_SIZE must be present for both.) */
1300 if (DECL_BIT_FIELD_TYPE (field
)
1301 && !integer_zerop (DECL_SIZE (field
))
1302 && !integer_zerop (DECL_SIZE (rli
->prev_field
))
1303 && tree_fits_shwi_p (DECL_SIZE (rli
->prev_field
))
1304 && tree_fits_shwi_p (TYPE_SIZE (type
))
1305 && simple_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (prev_type
)))
1307 /* We're in the middle of a run of equal type size fields; make
1308 sure we realign if we run out of bits. (Not decl size,
1310 HOST_WIDE_INT bitsize
= tree_low_cst (DECL_SIZE (field
), 1);
1312 if (rli
->remaining_in_alignment
< bitsize
)
1314 HOST_WIDE_INT typesize
= tree_low_cst (TYPE_SIZE (type
), 1);
1316 /* out of bits; bump up to next 'word'. */
1318 = size_binop (PLUS_EXPR
, rli
->bitpos
,
1319 bitsize_int (rli
->remaining_in_alignment
));
1320 rli
->prev_field
= field
;
1321 if (typesize
< bitsize
)
1322 rli
->remaining_in_alignment
= 0;
1324 rli
->remaining_in_alignment
= typesize
- bitsize
;
1327 rli
->remaining_in_alignment
-= bitsize
;
1331 /* End of a run: if leaving a run of bitfields of the same type
1332 size, we have to "use up" the rest of the bits of the type
1335 Compute the new position as the sum of the size for the prior
1336 type and where we first started working on that type.
1337 Note: since the beginning of the field was aligned then
1338 of course the end will be too. No round needed. */
1340 if (!integer_zerop (DECL_SIZE (rli
->prev_field
)))
1343 = size_binop (PLUS_EXPR
, rli
->bitpos
,
1344 bitsize_int (rli
->remaining_in_alignment
));
1347 /* We "use up" size zero fields; the code below should behave
1348 as if the prior field was not a bitfield. */
1351 /* Cause a new bitfield to be captured, either this time (if
1352 currently a bitfield) or next time we see one. */
1353 if (!DECL_BIT_FIELD_TYPE (field
)
1354 || integer_zerop (DECL_SIZE (field
)))
1355 rli
->prev_field
= NULL
;
1358 normalize_rli (rli
);
1361 /* If we're starting a new run of same type size bitfields
1362 (or a run of non-bitfields), set up the "first of the run"
1365 That is, if the current field is not a bitfield, or if there
1366 was a prior bitfield the type sizes differ, or if there wasn't
1367 a prior bitfield the size of the current field is nonzero.
1369 Note: we must be sure to test ONLY the type size if there was
1370 a prior bitfield and ONLY for the current field being zero if
1373 if (!DECL_BIT_FIELD_TYPE (field
)
1374 || (prev_saved
!= NULL
1375 ? !simple_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (prev_type
))
1376 : !integer_zerop (DECL_SIZE (field
)) ))
1378 /* Never smaller than a byte for compatibility. */
1379 unsigned int type_align
= BITS_PER_UNIT
;
1381 /* (When not a bitfield), we could be seeing a flex array (with
1382 no DECL_SIZE). Since we won't be using remaining_in_alignment
1383 until we see a bitfield (and come by here again) we just skip
1385 if (DECL_SIZE (field
) != NULL
1386 && host_integerp (TYPE_SIZE (TREE_TYPE (field
)), 1)
1387 && host_integerp (DECL_SIZE (field
), 1))
1389 unsigned HOST_WIDE_INT bitsize
1390 = tree_low_cst (DECL_SIZE (field
), 1);
1391 unsigned HOST_WIDE_INT typesize
1392 = tree_low_cst (TYPE_SIZE (TREE_TYPE (field
)), 1);
1394 if (typesize
< bitsize
)
1395 rli
->remaining_in_alignment
= 0;
1397 rli
->remaining_in_alignment
= typesize
- bitsize
;
1400 /* Now align (conventionally) for the new type. */
1401 type_align
= TYPE_ALIGN (TREE_TYPE (field
));
1403 if (maximum_field_alignment
!= 0)
1404 type_align
= MIN (type_align
, maximum_field_alignment
);
1406 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1408 /* If we really aligned, don't allow subsequent bitfields
1410 rli
->prev_field
= NULL
;
1414 /* Offset so far becomes the position of this field after normalizing. */
1415 normalize_rli (rli
);
1416 DECL_FIELD_OFFSET (field
) = rli
->offset
;
1417 DECL_FIELD_BIT_OFFSET (field
) = rli
->bitpos
;
1418 SET_DECL_OFFSET_ALIGN (field
, rli
->offset_align
);
1420 /* If this field ended up more aligned than we thought it would be (we
1421 approximate this by seeing if its position changed), lay out the field
1422 again; perhaps we can use an integral mode for it now. */
1423 if (! integer_zerop (DECL_FIELD_BIT_OFFSET (field
)))
1424 actual_align
= (tree_low_cst (DECL_FIELD_BIT_OFFSET (field
), 1)
1425 & - tree_low_cst (DECL_FIELD_BIT_OFFSET (field
), 1));
1426 else if (integer_zerop (DECL_FIELD_OFFSET (field
)))
1427 actual_align
= MAX (BIGGEST_ALIGNMENT
, rli
->record_align
);
1428 else if (host_integerp (DECL_FIELD_OFFSET (field
), 1))
1429 actual_align
= (BITS_PER_UNIT
1430 * (tree_low_cst (DECL_FIELD_OFFSET (field
), 1)
1431 & - tree_low_cst (DECL_FIELD_OFFSET (field
), 1)));
1433 actual_align
= DECL_OFFSET_ALIGN (field
);
1434 /* ACTUAL_ALIGN is still the actual alignment *within the record* .
1435 store / extract bit field operations will check the alignment of the
1436 record against the mode of bit fields. */
1438 if (known_align
!= actual_align
)
1439 layout_decl (field
, actual_align
);
1441 if (rli
->prev_field
== NULL
&& DECL_BIT_FIELD_TYPE (field
))
1442 rli
->prev_field
= field
;
1444 /* Now add size of this field to the size of the record. If the size is
1445 not constant, treat the field as being a multiple of bytes and just
1446 adjust the offset, resetting the bit position. Otherwise, apportion the
1447 size amongst the bit position and offset. First handle the case of an
1448 unspecified size, which can happen when we have an invalid nested struct
1449 definition, such as struct j { struct j { int i; } }. The error message
1450 is printed in finish_struct. */
1451 if (DECL_SIZE (field
) == 0)
1453 else if (TREE_CODE (DECL_SIZE (field
)) != INTEGER_CST
1454 || TREE_OVERFLOW (DECL_SIZE (field
)))
1457 = size_binop (PLUS_EXPR
, rli
->offset
,
1458 fold_convert (sizetype
,
1459 size_binop (CEIL_DIV_EXPR
, rli
->bitpos
,
1460 bitsize_unit_node
)));
1462 = size_binop (PLUS_EXPR
, rli
->offset
, DECL_SIZE_UNIT (field
));
1463 rli
->bitpos
= bitsize_zero_node
;
1464 rli
->offset_align
= MIN (rli
->offset_align
, desired_align
);
1466 else if (targetm
.ms_bitfield_layout_p (rli
->t
))
1468 rli
->bitpos
= size_binop (PLUS_EXPR
, rli
->bitpos
, DECL_SIZE (field
));
1470 /* If we ended a bitfield before the full length of the type then
1471 pad the struct out to the full length of the last type. */
1472 if ((DECL_CHAIN (field
) == NULL
1473 || TREE_CODE (DECL_CHAIN (field
)) != FIELD_DECL
)
1474 && DECL_BIT_FIELD_TYPE (field
)
1475 && !integer_zerop (DECL_SIZE (field
)))
1476 rli
->bitpos
= size_binop (PLUS_EXPR
, rli
->bitpos
,
1477 bitsize_int (rli
->remaining_in_alignment
));
1479 normalize_rli (rli
);
1483 rli
->bitpos
= size_binop (PLUS_EXPR
, rli
->bitpos
, DECL_SIZE (field
));
1484 normalize_rli (rli
);
1488 /* Assuming that all the fields have been laid out, this function uses
1489 RLI to compute the final TYPE_SIZE, TYPE_ALIGN, etc. for the type
1490 indicated by RLI. */
1493 finalize_record_size (record_layout_info rli
)
1495 tree unpadded_size
, unpadded_size_unit
;
1497 /* Now we want just byte and bit offsets, so set the offset alignment
1498 to be a byte and then normalize. */
1499 rli
->offset_align
= BITS_PER_UNIT
;
1500 normalize_rli (rli
);
1502 /* Determine the desired alignment. */
1503 #ifdef ROUND_TYPE_ALIGN
1504 TYPE_ALIGN (rli
->t
) = ROUND_TYPE_ALIGN (rli
->t
, TYPE_ALIGN (rli
->t
),
1507 TYPE_ALIGN (rli
->t
) = MAX (TYPE_ALIGN (rli
->t
), rli
->record_align
);
1510 /* Compute the size so far. Be sure to allow for extra bits in the
1511 size in bytes. We have guaranteed above that it will be no more
1512 than a single byte. */
1513 unpadded_size
= rli_size_so_far (rli
);
1514 unpadded_size_unit
= rli_size_unit_so_far (rli
);
1515 if (! integer_zerop (rli
->bitpos
))
1517 = size_binop (PLUS_EXPR
, unpadded_size_unit
, size_one_node
);
1519 /* Round the size up to be a multiple of the required alignment. */
1520 TYPE_SIZE (rli
->t
) = round_up (unpadded_size
, TYPE_ALIGN (rli
->t
));
1521 TYPE_SIZE_UNIT (rli
->t
)
1522 = round_up (unpadded_size_unit
, TYPE_ALIGN_UNIT (rli
->t
));
1524 if (TREE_CONSTANT (unpadded_size
)
1525 && simple_cst_equal (unpadded_size
, TYPE_SIZE (rli
->t
)) == 0
1526 && input_location
!= BUILTINS_LOCATION
)
1527 warning (OPT_Wpadded
, "padding struct size to alignment boundary");
1529 if (warn_packed
&& TREE_CODE (rli
->t
) == RECORD_TYPE
1530 && TYPE_PACKED (rli
->t
) && ! rli
->packed_maybe_necessary
1531 && TREE_CONSTANT (unpadded_size
))
1535 #ifdef ROUND_TYPE_ALIGN
1537 = ROUND_TYPE_ALIGN (rli
->t
, TYPE_ALIGN (rli
->t
), rli
->unpacked_align
);
1539 rli
->unpacked_align
= MAX (TYPE_ALIGN (rli
->t
), rli
->unpacked_align
);
1542 unpacked_size
= round_up (TYPE_SIZE (rli
->t
), rli
->unpacked_align
);
1543 if (simple_cst_equal (unpacked_size
, TYPE_SIZE (rli
->t
)))
1545 if (TYPE_NAME (rli
->t
))
1549 if (TREE_CODE (TYPE_NAME (rli
->t
)) == IDENTIFIER_NODE
)
1550 name
= TYPE_NAME (rli
->t
);
1552 name
= DECL_NAME (TYPE_NAME (rli
->t
));
1554 if (STRICT_ALIGNMENT
)
1555 warning (OPT_Wpacked
, "packed attribute causes inefficient "
1556 "alignment for %qE", name
);
1558 warning (OPT_Wpacked
,
1559 "packed attribute is unnecessary for %qE", name
);
1563 if (STRICT_ALIGNMENT
)
1564 warning (OPT_Wpacked
,
1565 "packed attribute causes inefficient alignment");
1567 warning (OPT_Wpacked
, "packed attribute is unnecessary");
1573 /* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE). */
1576 compute_record_mode (tree type
)
1579 enum machine_mode mode
= VOIDmode
;
1581 /* Most RECORD_TYPEs have BLKmode, so we start off assuming that.
1582 However, if possible, we use a mode that fits in a register
1583 instead, in order to allow for better optimization down the
1585 SET_TYPE_MODE (type
, BLKmode
);
1587 if (! host_integerp (TYPE_SIZE (type
), 1))
1590 /* A record which has any BLKmode members must itself be
1591 BLKmode; it can't go in a register. Unless the member is
1592 BLKmode only because it isn't aligned. */
1593 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1595 if (TREE_CODE (field
) != FIELD_DECL
)
1598 if (TREE_CODE (TREE_TYPE (field
)) == ERROR_MARK
1599 || (TYPE_MODE (TREE_TYPE (field
)) == BLKmode
1600 && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field
))
1601 && !(TYPE_SIZE (TREE_TYPE (field
)) != 0
1602 && integer_zerop (TYPE_SIZE (TREE_TYPE (field
)))))
1603 || ! host_integerp (bit_position (field
), 1)
1604 || DECL_SIZE (field
) == 0
1605 || ! host_integerp (DECL_SIZE (field
), 1))
1608 /* If this field is the whole struct, remember its mode so
1609 that, say, we can put a double in a class into a DF
1610 register instead of forcing it to live in the stack. */
1611 if (simple_cst_equal (TYPE_SIZE (type
), DECL_SIZE (field
)))
1612 mode
= DECL_MODE (field
);
1614 /* With some targets, it is sub-optimal to access an aligned
1615 BLKmode structure as a scalar. */
1616 if (targetm
.member_type_forces_blk (field
, mode
))
1620 /* If we only have one real field; use its mode if that mode's size
1621 matches the type's size. This only applies to RECORD_TYPE. This
1622 does not apply to unions. */
1623 if (TREE_CODE (type
) == RECORD_TYPE
&& mode
!= VOIDmode
1624 && host_integerp (TYPE_SIZE (type
), 1)
1625 && GET_MODE_BITSIZE (mode
) == TREE_INT_CST_LOW (TYPE_SIZE (type
)))
1626 SET_TYPE_MODE (type
, mode
);
1628 SET_TYPE_MODE (type
, mode_for_size_tree (TYPE_SIZE (type
), MODE_INT
, 1));
1630 /* If structure's known alignment is less than what the scalar
1631 mode would need, and it matters, then stick with BLKmode. */
1632 if (TYPE_MODE (type
) != BLKmode
1634 && ! (TYPE_ALIGN (type
) >= BIGGEST_ALIGNMENT
1635 || TYPE_ALIGN (type
) >= GET_MODE_ALIGNMENT (TYPE_MODE (type
))))
1637 /* If this is the only reason this type is BLKmode, then
1638 don't force containing types to be BLKmode. */
1639 TYPE_NO_FORCE_BLK (type
) = 1;
1640 SET_TYPE_MODE (type
, BLKmode
);
1644 /* Compute TYPE_SIZE and TYPE_ALIGN for TYPE, once it has been laid
1648 finalize_type_size (tree type
)
1650 /* Normally, use the alignment corresponding to the mode chosen.
1651 However, where strict alignment is not required, avoid
1652 over-aligning structures, since most compilers do not do this
1655 if (TYPE_MODE (type
) != BLKmode
&& TYPE_MODE (type
) != VOIDmode
1656 && (STRICT_ALIGNMENT
1657 || (TREE_CODE (type
) != RECORD_TYPE
&& TREE_CODE (type
) != UNION_TYPE
1658 && TREE_CODE (type
) != QUAL_UNION_TYPE
1659 && TREE_CODE (type
) != ARRAY_TYPE
)))
1661 unsigned mode_align
= GET_MODE_ALIGNMENT (TYPE_MODE (type
));
1663 /* Don't override a larger alignment requirement coming from a user
1664 alignment of one of the fields. */
1665 if (mode_align
>= TYPE_ALIGN (type
))
1667 TYPE_ALIGN (type
) = mode_align
;
1668 TYPE_USER_ALIGN (type
) = 0;
1672 /* Do machine-dependent extra alignment. */
1673 #ifdef ROUND_TYPE_ALIGN
1675 = ROUND_TYPE_ALIGN (type
, TYPE_ALIGN (type
), BITS_PER_UNIT
);
1678 /* If we failed to find a simple way to calculate the unit size
1679 of the type, find it by division. */
1680 if (TYPE_SIZE_UNIT (type
) == 0 && TYPE_SIZE (type
) != 0)
1681 /* TYPE_SIZE (type) is computed in bitsizetype. After the division, the
1682 result will fit in sizetype. We will get more efficient code using
1683 sizetype, so we force a conversion. */
1684 TYPE_SIZE_UNIT (type
)
1685 = fold_convert (sizetype
,
1686 size_binop (FLOOR_DIV_EXPR
, TYPE_SIZE (type
),
1687 bitsize_unit_node
));
1689 if (TYPE_SIZE (type
) != 0)
1691 TYPE_SIZE (type
) = round_up (TYPE_SIZE (type
), TYPE_ALIGN (type
));
1692 TYPE_SIZE_UNIT (type
)
1693 = round_up (TYPE_SIZE_UNIT (type
), TYPE_ALIGN_UNIT (type
));
1696 /* Evaluate nonconstant sizes only once, either now or as soon as safe. */
1697 if (TYPE_SIZE (type
) != 0 && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1698 TYPE_SIZE (type
) = variable_size (TYPE_SIZE (type
));
1699 if (TYPE_SIZE_UNIT (type
) != 0
1700 && TREE_CODE (TYPE_SIZE_UNIT (type
)) != INTEGER_CST
)
1701 TYPE_SIZE_UNIT (type
) = variable_size (TYPE_SIZE_UNIT (type
));
1703 /* Also layout any other variants of the type. */
1704 if (TYPE_NEXT_VARIANT (type
)
1705 || type
!= TYPE_MAIN_VARIANT (type
))
1708 /* Record layout info of this variant. */
1709 tree size
= TYPE_SIZE (type
);
1710 tree size_unit
= TYPE_SIZE_UNIT (type
);
1711 unsigned int align
= TYPE_ALIGN (type
);
1712 unsigned int user_align
= TYPE_USER_ALIGN (type
);
1713 enum machine_mode mode
= TYPE_MODE (type
);
1715 /* Copy it into all variants. */
1716 for (variant
= TYPE_MAIN_VARIANT (type
);
1718 variant
= TYPE_NEXT_VARIANT (variant
))
1720 TYPE_SIZE (variant
) = size
;
1721 TYPE_SIZE_UNIT (variant
) = size_unit
;
1722 TYPE_ALIGN (variant
) = align
;
1723 TYPE_USER_ALIGN (variant
) = user_align
;
1724 SET_TYPE_MODE (variant
, mode
);
1729 /* Return a new underlying object for a bitfield started with FIELD. */
1732 start_bitfield_representative (tree field
)
1734 tree repr
= make_node (FIELD_DECL
);
1735 DECL_FIELD_OFFSET (repr
) = DECL_FIELD_OFFSET (field
);
1736 /* Force the representative to begin at a BITS_PER_UNIT aligned
1737 boundary - C++ may use tail-padding of a base object to
1738 continue packing bits so the bitfield region does not start
1739 at bit zero (see g++.dg/abi/bitfield5.C for example).
1740 Unallocated bits may happen for other reasons as well,
1741 for example Ada which allows explicit bit-granular structure layout. */
1742 DECL_FIELD_BIT_OFFSET (repr
)
1743 = size_binop (BIT_AND_EXPR
,
1744 DECL_FIELD_BIT_OFFSET (field
),
1745 bitsize_int (~(BITS_PER_UNIT
- 1)));
1746 SET_DECL_OFFSET_ALIGN (repr
, DECL_OFFSET_ALIGN (field
));
1747 DECL_SIZE (repr
) = DECL_SIZE (field
);
1748 DECL_SIZE_UNIT (repr
) = DECL_SIZE_UNIT (field
);
1749 DECL_PACKED (repr
) = DECL_PACKED (field
);
1750 DECL_CONTEXT (repr
) = DECL_CONTEXT (field
);
1754 /* Finish up a bitfield group that was started by creating the underlying
1755 object REPR with the last field in the bitfield group FIELD. */
1758 finish_bitfield_representative (tree repr
, tree field
)
1760 unsigned HOST_WIDE_INT bitsize
, maxbitsize
;
1761 enum machine_mode mode
;
1764 size
= size_diffop (DECL_FIELD_OFFSET (field
),
1765 DECL_FIELD_OFFSET (repr
));
1766 gcc_assert (host_integerp (size
, 1));
1767 bitsize
= (tree_low_cst (size
, 1) * BITS_PER_UNIT
1768 + tree_low_cst (DECL_FIELD_BIT_OFFSET (field
), 1)
1769 - tree_low_cst (DECL_FIELD_BIT_OFFSET (repr
), 1)
1770 + tree_low_cst (DECL_SIZE (field
), 1));
1772 /* Round up bitsize to multiples of BITS_PER_UNIT. */
1773 bitsize
= (bitsize
+ BITS_PER_UNIT
- 1) & ~(BITS_PER_UNIT
- 1);
1775 /* Now nothing tells us how to pad out bitsize ... */
1776 nextf
= DECL_CHAIN (field
);
1777 while (nextf
&& TREE_CODE (nextf
) != FIELD_DECL
)
1778 nextf
= DECL_CHAIN (nextf
);
1782 /* If there was an error, the field may be not laid out
1783 correctly. Don't bother to do anything. */
1784 if (TREE_TYPE (nextf
) == error_mark_node
)
1786 maxsize
= size_diffop (DECL_FIELD_OFFSET (nextf
),
1787 DECL_FIELD_OFFSET (repr
));
1788 if (host_integerp (maxsize
, 1))
1790 maxbitsize
= (tree_low_cst (maxsize
, 1) * BITS_PER_UNIT
1791 + tree_low_cst (DECL_FIELD_BIT_OFFSET (nextf
), 1)
1792 - tree_low_cst (DECL_FIELD_BIT_OFFSET (repr
), 1));
1793 /* If the group ends within a bitfield nextf does not need to be
1794 aligned to BITS_PER_UNIT. Thus round up. */
1795 maxbitsize
= (maxbitsize
+ BITS_PER_UNIT
- 1) & ~(BITS_PER_UNIT
- 1);
1798 maxbitsize
= bitsize
;
1802 /* ??? If you consider that tail-padding of this struct might be
1803 re-used when deriving from it we cannot really do the following
1804 and thus need to set maxsize to bitsize? Also we cannot
1805 generally rely on maxsize to fold to an integer constant, so
1806 use bitsize as fallback for this case. */
1807 tree maxsize
= size_diffop (TYPE_SIZE_UNIT (DECL_CONTEXT (field
)),
1808 DECL_FIELD_OFFSET (repr
));
1809 if (host_integerp (maxsize
, 1))
1810 maxbitsize
= (tree_low_cst (maxsize
, 1) * BITS_PER_UNIT
1811 - tree_low_cst (DECL_FIELD_BIT_OFFSET (repr
), 1));
1813 maxbitsize
= bitsize
;
1816 /* Only if we don't artificially break up the representative in
1817 the middle of a large bitfield with different possibly
1818 overlapping representatives. And all representatives start
1820 gcc_assert (maxbitsize
% BITS_PER_UNIT
== 0);
1822 /* Find the smallest nice mode to use. */
1823 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_INT
); mode
!= VOIDmode
;
1824 mode
= GET_MODE_WIDER_MODE (mode
))
1825 if (GET_MODE_BITSIZE (mode
) >= bitsize
)
1827 if (mode
!= VOIDmode
1828 && (GET_MODE_BITSIZE (mode
) > maxbitsize
1829 || GET_MODE_BITSIZE (mode
) > MAX_FIXED_MODE_SIZE
))
1832 if (mode
== VOIDmode
)
1834 /* We really want a BLKmode representative only as a last resort,
1835 considering the member b in
1836 struct { int a : 7; int b : 17; int c; } __attribute__((packed));
1837 Otherwise we simply want to split the representative up
1838 allowing for overlaps within the bitfield region as required for
1839 struct { int a : 7; int b : 7;
1840 int c : 10; int d; } __attribute__((packed));
1841 [0, 15] HImode for a and b, [8, 23] HImode for c. */
1842 DECL_SIZE (repr
) = bitsize_int (bitsize
);
1843 DECL_SIZE_UNIT (repr
) = size_int (bitsize
/ BITS_PER_UNIT
);
1844 DECL_MODE (repr
) = BLKmode
;
1845 TREE_TYPE (repr
) = build_array_type_nelts (unsigned_char_type_node
,
1846 bitsize
/ BITS_PER_UNIT
);
1850 unsigned HOST_WIDE_INT modesize
= GET_MODE_BITSIZE (mode
);
1851 DECL_SIZE (repr
) = bitsize_int (modesize
);
1852 DECL_SIZE_UNIT (repr
) = size_int (modesize
/ BITS_PER_UNIT
);
1853 DECL_MODE (repr
) = mode
;
1854 TREE_TYPE (repr
) = lang_hooks
.types
.type_for_mode (mode
, 1);
1857 /* Remember whether the bitfield group is at the end of the
1858 structure or not. */
1859 DECL_CHAIN (repr
) = nextf
;
1862 /* Compute and set FIELD_DECLs for the underlying objects we should
1863 use for bitfield access for the structure laid out with RLI. */
1866 finish_bitfield_layout (record_layout_info rli
)
1869 tree repr
= NULL_TREE
;
1871 /* Unions would be special, for the ease of type-punning optimizations
1872 we could use the underlying type as hint for the representative
1873 if the bitfield would fit and the representative would not exceed
1874 the union in size. */
1875 if (TREE_CODE (rli
->t
) != RECORD_TYPE
)
1878 for (prev
= NULL_TREE
, field
= TYPE_FIELDS (rli
->t
);
1879 field
; field
= DECL_CHAIN (field
))
1881 if (TREE_CODE (field
) != FIELD_DECL
)
1884 /* In the C++ memory model, consecutive bit fields in a structure are
1885 considered one memory location and updating a memory location
1886 may not store into adjacent memory locations. */
1888 && DECL_BIT_FIELD_TYPE (field
))
1890 /* Start new representative. */
1891 repr
= start_bitfield_representative (field
);
1894 && ! DECL_BIT_FIELD_TYPE (field
))
1896 /* Finish off new representative. */
1897 finish_bitfield_representative (repr
, prev
);
1900 else if (DECL_BIT_FIELD_TYPE (field
))
1902 gcc_assert (repr
!= NULL_TREE
);
1904 /* Zero-size bitfields finish off a representative and
1905 do not have a representative themselves. This is
1906 required by the C++ memory model. */
1907 if (integer_zerop (DECL_SIZE (field
)))
1909 finish_bitfield_representative (repr
, prev
);
1913 /* We assume that either DECL_FIELD_OFFSET of the representative
1914 and each bitfield member is a constant or they are equal.
1915 This is because we need to be able to compute the bit-offset
1916 of each field relative to the representative in get_bit_range
1917 during RTL expansion.
1918 If these constraints are not met, simply force a new
1919 representative to be generated. That will at most
1920 generate worse code but still maintain correctness with
1921 respect to the C++ memory model. */
1922 else if (!((host_integerp (DECL_FIELD_OFFSET (repr
), 1)
1923 && host_integerp (DECL_FIELD_OFFSET (field
), 1))
1924 || operand_equal_p (DECL_FIELD_OFFSET (repr
),
1925 DECL_FIELD_OFFSET (field
), 0)))
1927 finish_bitfield_representative (repr
, prev
);
1928 repr
= start_bitfield_representative (field
);
1935 DECL_BIT_FIELD_REPRESENTATIVE (field
) = repr
;
1941 finish_bitfield_representative (repr
, prev
);
1944 /* Do all of the work required to layout the type indicated by RLI,
1945 once the fields have been laid out. This function will call `free'
1946 for RLI, unless FREE_P is false. Passing a value other than false
1947 for FREE_P is bad practice; this option only exists to support the
1951 finish_record_layout (record_layout_info rli
, int free_p
)
1955 /* Compute the final size. */
1956 finalize_record_size (rli
);
1958 /* Compute the TYPE_MODE for the record. */
1959 compute_record_mode (rli
->t
);
1961 /* Perform any last tweaks to the TYPE_SIZE, etc. */
1962 finalize_type_size (rli
->t
);
1964 /* Compute bitfield representatives. */
1965 finish_bitfield_layout (rli
);
1967 /* Propagate TYPE_PACKED to variants. With C++ templates,
1968 handle_packed_attribute is too early to do this. */
1969 for (variant
= TYPE_NEXT_VARIANT (rli
->t
); variant
;
1970 variant
= TYPE_NEXT_VARIANT (variant
))
1971 TYPE_PACKED (variant
) = TYPE_PACKED (rli
->t
);
1973 /* Lay out any static members. This is done now because their type
1974 may use the record's type. */
1975 while (!vec_safe_is_empty (rli
->pending_statics
))
1976 layout_decl (rli
->pending_statics
->pop (), 0);
1981 vec_free (rli
->pending_statics
);
1987 /* Finish processing a builtin RECORD_TYPE type TYPE. It's name is
1988 NAME, its fields are chained in reverse on FIELDS.
1990 If ALIGN_TYPE is non-null, it is given the same alignment as
1994 finish_builtin_struct (tree type
, const char *name
, tree fields
,
1999 for (tail
= NULL_TREE
; fields
; tail
= fields
, fields
= next
)
2001 DECL_FIELD_CONTEXT (fields
) = type
;
2002 next
= DECL_CHAIN (fields
);
2003 DECL_CHAIN (fields
) = tail
;
2005 TYPE_FIELDS (type
) = tail
;
2009 TYPE_ALIGN (type
) = TYPE_ALIGN (align_type
);
2010 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (align_type
);
2014 #if 0 /* not yet, should get fixed properly later */
2015 TYPE_NAME (type
) = make_type_decl (get_identifier (name
), type
);
2017 TYPE_NAME (type
) = build_decl (BUILTINS_LOCATION
,
2018 TYPE_DECL
, get_identifier (name
), type
);
2020 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
2021 layout_decl (TYPE_NAME (type
), 0);
2024 /* Calculate the mode, size, and alignment for TYPE.
2025 For an array type, calculate the element separation as well.
2026 Record TYPE on the chain of permanent or temporary types
2027 so that dbxout will find out about it.
2029 TYPE_SIZE of a type is nonzero if the type has been laid out already.
2030 layout_type does nothing on such a type.
2032 If the type is incomplete, its TYPE_SIZE remains zero. */
2035 layout_type (tree type
)
2039 if (type
== error_mark_node
)
2042 /* Do nothing if type has been laid out before. */
2043 if (TYPE_SIZE (type
))
2046 switch (TREE_CODE (type
))
2049 /* This kind of type is the responsibility
2050 of the language-specific code. */
2056 SET_TYPE_MODE (type
,
2057 smallest_mode_for_size (TYPE_PRECISION (type
), MODE_INT
));
2058 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2059 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2063 SET_TYPE_MODE (type
,
2064 mode_for_size (TYPE_PRECISION (type
), MODE_FLOAT
, 0));
2065 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2066 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2069 case FIXED_POINT_TYPE
:
2070 /* TYPE_MODE (type) has been set already. */
2071 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2072 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2076 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TREE_TYPE (type
));
2077 SET_TYPE_MODE (type
,
2078 mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type
)),
2079 (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
2080 ? MODE_COMPLEX_FLOAT
: MODE_COMPLEX_INT
),
2082 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2083 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2088 int nunits
= TYPE_VECTOR_SUBPARTS (type
);
2089 tree innertype
= TREE_TYPE (type
);
2091 gcc_assert (!(nunits
& (nunits
- 1)));
2093 /* Find an appropriate mode for the vector type. */
2094 if (TYPE_MODE (type
) == VOIDmode
)
2095 SET_TYPE_MODE (type
,
2096 mode_for_vector (TYPE_MODE (innertype
), nunits
));
2098 TYPE_SATURATING (type
) = TYPE_SATURATING (TREE_TYPE (type
));
2099 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TREE_TYPE (type
));
2100 TYPE_SIZE_UNIT (type
) = int_const_binop (MULT_EXPR
,
2101 TYPE_SIZE_UNIT (innertype
),
2103 TYPE_SIZE (type
) = int_const_binop (MULT_EXPR
, TYPE_SIZE (innertype
),
2104 bitsize_int (nunits
));
2106 /* For vector types, we do not default to the mode's alignment.
2107 Instead, query a target hook, defaulting to natural alignment.
2108 This prevents ABI changes depending on whether or not native
2109 vector modes are supported. */
2110 TYPE_ALIGN (type
) = targetm
.vector_alignment (type
);
2112 /* However, if the underlying mode requires a bigger alignment than
2113 what the target hook provides, we cannot use the mode. For now,
2114 simply reject that case. */
2115 gcc_assert (TYPE_ALIGN (type
)
2116 >= GET_MODE_ALIGNMENT (TYPE_MODE (type
)));
2121 /* This is an incomplete type and so doesn't have a size. */
2122 TYPE_ALIGN (type
) = 1;
2123 TYPE_USER_ALIGN (type
) = 0;
2124 SET_TYPE_MODE (type
, VOIDmode
);
2127 case POINTER_BOUNDS_TYPE
:
2128 SET_TYPE_MODE (type
,
2129 mode_for_size (TYPE_PRECISION (type
),
2130 MODE_POINTER_BOUNDS
, 0));
2131 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2132 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2136 TYPE_SIZE (type
) = bitsize_int (POINTER_SIZE
);
2137 TYPE_SIZE_UNIT (type
) = size_int (POINTER_SIZE
/ BITS_PER_UNIT
);
2138 /* A pointer might be MODE_PARTIAL_INT,
2139 but ptrdiff_t must be integral. */
2140 SET_TYPE_MODE (type
, mode_for_size (POINTER_SIZE
, MODE_INT
, 0));
2141 TYPE_PRECISION (type
) = POINTER_SIZE
;
2146 /* It's hard to see what the mode and size of a function ought to
2147 be, but we do know the alignment is FUNCTION_BOUNDARY, so
2148 make it consistent with that. */
2149 SET_TYPE_MODE (type
, mode_for_size (FUNCTION_BOUNDARY
, MODE_INT
, 0));
2150 TYPE_SIZE (type
) = bitsize_int (FUNCTION_BOUNDARY
);
2151 TYPE_SIZE_UNIT (type
) = size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
2155 case REFERENCE_TYPE
:
2157 enum machine_mode mode
= TYPE_MODE (type
);
2158 if (TREE_CODE (type
) == REFERENCE_TYPE
&& reference_types_internal
)
2160 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (type
));
2161 mode
= targetm
.addr_space
.address_mode (as
);
2164 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (mode
));
2165 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (mode
));
2166 TYPE_UNSIGNED (type
) = 1;
2167 TYPE_PRECISION (type
) = GET_MODE_BITSIZE (mode
);
2173 tree index
= TYPE_DOMAIN (type
);
2174 tree element
= TREE_TYPE (type
);
2176 build_pointer_type (element
);
2178 /* We need to know both bounds in order to compute the size. */
2179 if (index
&& TYPE_MAX_VALUE (index
) && TYPE_MIN_VALUE (index
)
2180 && TYPE_SIZE (element
))
2182 tree ub
= TYPE_MAX_VALUE (index
);
2183 tree lb
= TYPE_MIN_VALUE (index
);
2184 tree element_size
= TYPE_SIZE (element
);
2187 /* Make sure that an array of zero-sized element is zero-sized
2188 regardless of its extent. */
2189 if (integer_zerop (element_size
))
2190 length
= size_zero_node
;
2192 /* The computation should happen in the original signedness so
2193 that (possible) negative values are handled appropriately
2194 when determining overflow. */
2197 /* ??? When it is obvious that the range is signed
2198 represent it using ssizetype. */
2199 if (TREE_CODE (lb
) == INTEGER_CST
2200 && TREE_CODE (ub
) == INTEGER_CST
2201 && TYPE_UNSIGNED (TREE_TYPE (lb
))
2202 && tree_int_cst_lt (ub
, lb
))
2204 unsigned prec
= TYPE_PRECISION (TREE_TYPE (lb
));
2205 lb
= double_int_to_tree
2207 tree_to_double_int (lb
).sext (prec
));
2208 ub
= double_int_to_tree
2210 tree_to_double_int (ub
).sext (prec
));
2213 = fold_convert (sizetype
,
2214 size_binop (PLUS_EXPR
,
2215 build_int_cst (TREE_TYPE (lb
), 1),
2216 size_binop (MINUS_EXPR
, ub
, lb
)));
2219 /* ??? We have no way to distinguish a null-sized array from an
2220 array spanning the whole sizetype range, so we arbitrarily
2221 decide that [0, -1] is the only valid representation. */
2222 if (integer_zerop (length
)
2223 && TREE_OVERFLOW (length
)
2224 && integer_zerop (lb
))
2225 length
= size_zero_node
;
2227 TYPE_SIZE (type
) = size_binop (MULT_EXPR
, element_size
,
2228 fold_convert (bitsizetype
,
2231 /* If we know the size of the element, calculate the total size
2232 directly, rather than do some division thing below. This
2233 optimization helps Fortran assumed-size arrays (where the
2234 size of the array is determined at runtime) substantially. */
2235 if (TYPE_SIZE_UNIT (element
))
2236 TYPE_SIZE_UNIT (type
)
2237 = size_binop (MULT_EXPR
, TYPE_SIZE_UNIT (element
), length
);
2240 /* Now round the alignment and size,
2241 using machine-dependent criteria if any. */
2243 #ifdef ROUND_TYPE_ALIGN
2245 = ROUND_TYPE_ALIGN (type
, TYPE_ALIGN (element
), BITS_PER_UNIT
);
2247 TYPE_ALIGN (type
) = MAX (TYPE_ALIGN (element
), BITS_PER_UNIT
);
2249 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (element
);
2250 SET_TYPE_MODE (type
, BLKmode
);
2251 if (TYPE_SIZE (type
) != 0
2252 && ! targetm
.member_type_forces_blk (type
, VOIDmode
)
2253 /* BLKmode elements force BLKmode aggregate;
2254 else extract/store fields may lose. */
2255 && (TYPE_MODE (TREE_TYPE (type
)) != BLKmode
2256 || TYPE_NO_FORCE_BLK (TREE_TYPE (type
))))
2258 SET_TYPE_MODE (type
, mode_for_array (TREE_TYPE (type
),
2260 if (TYPE_MODE (type
) != BLKmode
2261 && STRICT_ALIGNMENT
&& TYPE_ALIGN (type
) < BIGGEST_ALIGNMENT
2262 && TYPE_ALIGN (type
) < GET_MODE_ALIGNMENT (TYPE_MODE (type
)))
2264 TYPE_NO_FORCE_BLK (type
) = 1;
2265 SET_TYPE_MODE (type
, BLKmode
);
2268 /* When the element size is constant, check that it is at least as
2269 large as the element alignment. */
2270 if (TYPE_SIZE_UNIT (element
)
2271 && TREE_CODE (TYPE_SIZE_UNIT (element
)) == INTEGER_CST
2272 /* If TYPE_SIZE_UNIT overflowed, then it is certainly larger than
2274 && !TREE_OVERFLOW (TYPE_SIZE_UNIT (element
))
2275 && !integer_zerop (TYPE_SIZE_UNIT (element
))
2276 && compare_tree_int (TYPE_SIZE_UNIT (element
),
2277 TYPE_ALIGN_UNIT (element
)) < 0)
2278 error ("alignment of array elements is greater than element size");
2284 case QUAL_UNION_TYPE
:
2287 record_layout_info rli
;
2289 /* Initialize the layout information. */
2290 rli
= start_record_layout (type
);
2292 /* If this is a QUAL_UNION_TYPE, we want to process the fields
2293 in the reverse order in building the COND_EXPR that denotes
2294 its size. We reverse them again later. */
2295 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
2296 TYPE_FIELDS (type
) = nreverse (TYPE_FIELDS (type
));
2298 /* Place all the fields. */
2299 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
2300 place_field (rli
, field
);
2302 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
2303 TYPE_FIELDS (type
) = nreverse (TYPE_FIELDS (type
));
2305 /* Finish laying out the record. */
2306 finish_record_layout (rli
, /*free_p=*/true);
2314 /* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE. For
2315 records and unions, finish_record_layout already called this
2317 if (TREE_CODE (type
) != RECORD_TYPE
2318 && TREE_CODE (type
) != UNION_TYPE
2319 && TREE_CODE (type
) != QUAL_UNION_TYPE
)
2320 finalize_type_size (type
);
2322 /* We should never see alias sets on incomplete aggregates. And we
2323 should not call layout_type on not incomplete aggregates. */
2324 if (AGGREGATE_TYPE_P (type
))
2325 gcc_assert (!TYPE_ALIAS_SET_KNOWN_P (type
));
2328 /* Vector types need to re-check the target flags each time we report
2329 the machine mode. We need to do this because attribute target can
2330 change the result of vector_mode_supported_p and have_regs_of_mode
2331 on a per-function basis. Thus the TYPE_MODE of a VECTOR_TYPE can
2332 change on a per-function basis. */
2333 /* ??? Possibly a better solution is to run through all the types
2334 referenced by a function and re-compute the TYPE_MODE once, rather
2335 than make the TYPE_MODE macro call a function. */
2338 vector_type_mode (const_tree t
)
2340 enum machine_mode mode
;
2342 gcc_assert (TREE_CODE (t
) == VECTOR_TYPE
);
2344 mode
= t
->type_common
.mode
;
2345 if (VECTOR_MODE_P (mode
)
2346 && (!targetm
.vector_mode_supported_p (mode
)
2347 || !have_regs_of_mode
[mode
]))
2349 enum machine_mode innermode
= TREE_TYPE (t
)->type_common
.mode
;
2351 /* For integers, try mapping it to a same-sized scalar mode. */
2352 if (GET_MODE_CLASS (innermode
) == MODE_INT
)
2354 mode
= mode_for_size (TYPE_VECTOR_SUBPARTS (t
)
2355 * GET_MODE_BITSIZE (innermode
), MODE_INT
, 0);
2357 if (mode
!= VOIDmode
&& have_regs_of_mode
[mode
])
2367 /* Create and return a type for signed integers of PRECISION bits. */
2370 make_signed_type (int precision
)
2372 tree type
= make_node (INTEGER_TYPE
);
2374 TYPE_PRECISION (type
) = precision
;
2376 fixup_signed_type (type
);
2380 /* Create and return a type for unsigned integers of PRECISION bits. */
2383 make_unsigned_type (int precision
)
2385 tree type
= make_node (INTEGER_TYPE
);
2387 TYPE_PRECISION (type
) = precision
;
2389 fixup_unsigned_type (type
);
2393 /* Create and return a type for fract of PRECISION bits, UNSIGNEDP,
2397 make_fract_type (int precision
, int unsignedp
, int satp
)
2399 tree type
= make_node (FIXED_POINT_TYPE
);
2401 TYPE_PRECISION (type
) = precision
;
2404 TYPE_SATURATING (type
) = 1;
2406 /* Lay out the type: set its alignment, size, etc. */
2409 TYPE_UNSIGNED (type
) = 1;
2410 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_UFRACT
, 0));
2413 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_FRACT
, 0));
2419 /* Create and return a type for accum of PRECISION bits, UNSIGNEDP,
2423 make_accum_type (int precision
, int unsignedp
, int satp
)
2425 tree type
= make_node (FIXED_POINT_TYPE
);
2427 TYPE_PRECISION (type
) = precision
;
2430 TYPE_SATURATING (type
) = 1;
2432 /* Lay out the type: set its alignment, size, etc. */
2435 TYPE_UNSIGNED (type
) = 1;
2436 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_UACCUM
, 0));
2439 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_ACCUM
, 0));
2445 /* Initialize sizetypes so layout_type can use them. */
2448 initialize_sizetypes (void)
2450 int precision
, bprecision
;
2452 /* Get sizetypes precision from the SIZE_TYPE target macro. */
2453 if (strcmp (SIZETYPE
, "unsigned int") == 0)
2454 precision
= INT_TYPE_SIZE
;
2455 else if (strcmp (SIZETYPE
, "long unsigned int") == 0)
2456 precision
= LONG_TYPE_SIZE
;
2457 else if (strcmp (SIZETYPE
, "long long unsigned int") == 0)
2458 precision
= LONG_LONG_TYPE_SIZE
;
2459 else if (strcmp (SIZETYPE
, "short unsigned int") == 0)
2460 precision
= SHORT_TYPE_SIZE
;
2465 = MIN (precision
+ BITS_PER_UNIT_LOG
+ 1, MAX_FIXED_MODE_SIZE
);
2467 = GET_MODE_PRECISION (smallest_mode_for_size (bprecision
, MODE_INT
));
2468 if (bprecision
> HOST_BITS_PER_DOUBLE_INT
)
2469 bprecision
= HOST_BITS_PER_DOUBLE_INT
;
2471 /* Create stubs for sizetype and bitsizetype so we can create constants. */
2472 sizetype
= make_node (INTEGER_TYPE
);
2473 TYPE_NAME (sizetype
) = get_identifier ("sizetype");
2474 TYPE_PRECISION (sizetype
) = precision
;
2475 TYPE_UNSIGNED (sizetype
) = 1;
2476 bitsizetype
= make_node (INTEGER_TYPE
);
2477 TYPE_NAME (bitsizetype
) = get_identifier ("bitsizetype");
2478 TYPE_PRECISION (bitsizetype
) = bprecision
;
2479 TYPE_UNSIGNED (bitsizetype
) = 1;
2481 /* Now layout both types manually. */
2482 SET_TYPE_MODE (sizetype
, smallest_mode_for_size (precision
, MODE_INT
));
2483 TYPE_ALIGN (sizetype
) = GET_MODE_ALIGNMENT (TYPE_MODE (sizetype
));
2484 TYPE_SIZE (sizetype
) = bitsize_int (precision
);
2485 TYPE_SIZE_UNIT (sizetype
) = size_int (GET_MODE_SIZE (TYPE_MODE (sizetype
)));
2486 set_min_and_max_values_for_integral_type (sizetype
, precision
,
2487 /*is_unsigned=*/true);
2489 SET_TYPE_MODE (bitsizetype
, smallest_mode_for_size (bprecision
, MODE_INT
));
2490 TYPE_ALIGN (bitsizetype
) = GET_MODE_ALIGNMENT (TYPE_MODE (bitsizetype
));
2491 TYPE_SIZE (bitsizetype
) = bitsize_int (bprecision
);
2492 TYPE_SIZE_UNIT (bitsizetype
)
2493 = size_int (GET_MODE_SIZE (TYPE_MODE (bitsizetype
)));
2494 set_min_and_max_values_for_integral_type (bitsizetype
, bprecision
,
2495 /*is_unsigned=*/true);
2497 /* Create the signed variants of *sizetype. */
2498 ssizetype
= make_signed_type (TYPE_PRECISION (sizetype
));
2499 TYPE_NAME (ssizetype
) = get_identifier ("ssizetype");
2500 sbitsizetype
= make_signed_type (TYPE_PRECISION (bitsizetype
));
2501 TYPE_NAME (sbitsizetype
) = get_identifier ("sbitsizetype");
2504 /* TYPE is an integral type, i.e., an INTEGRAL_TYPE, ENUMERAL_TYPE
2505 or BOOLEAN_TYPE. Set TYPE_MIN_VALUE and TYPE_MAX_VALUE
2506 for TYPE, based on the PRECISION and whether or not the TYPE
2507 IS_UNSIGNED. PRECISION need not correspond to a width supported
2508 natively by the hardware; for example, on a machine with 8-bit,
2509 16-bit, and 32-bit register modes, PRECISION might be 7, 23, or
2513 set_min_and_max_values_for_integral_type (tree type
,
2520 /* For bitfields with zero width we end up creating integer types
2521 with zero precision. Don't assign any minimum/maximum values
2522 to those types, they don't have any valid value. */
2528 min_value
= build_int_cst (type
, 0);
2530 = build_int_cst_wide (type
, precision
- HOST_BITS_PER_WIDE_INT
>= 0
2532 : ((HOST_WIDE_INT
) 1 << precision
) - 1,
2533 precision
- HOST_BITS_PER_WIDE_INT
> 0
2534 ? ((unsigned HOST_WIDE_INT
) ~0
2535 >> (HOST_BITS_PER_WIDE_INT
2536 - (precision
- HOST_BITS_PER_WIDE_INT
)))
2542 = build_int_cst_wide (type
,
2543 (precision
- HOST_BITS_PER_WIDE_INT
> 0
2545 : (HOST_WIDE_INT
) (-1) << (precision
- 1)),
2546 (((HOST_WIDE_INT
) (-1)
2547 << (precision
- HOST_BITS_PER_WIDE_INT
- 1 > 0
2548 ? precision
- HOST_BITS_PER_WIDE_INT
- 1
2551 = build_int_cst_wide (type
,
2552 (precision
- HOST_BITS_PER_WIDE_INT
> 0
2555 (((unsigned HOST_WIDE_INT
) 1
2556 << (precision
- 1)) - 1)),
2557 (precision
- HOST_BITS_PER_WIDE_INT
- 1 > 0
2559 ((((unsigned HOST_WIDE_INT
) 1
2560 << (precision
- HOST_BITS_PER_WIDE_INT
2565 TYPE_MIN_VALUE (type
) = min_value
;
2566 TYPE_MAX_VALUE (type
) = max_value
;
2569 /* Set the extreme values of TYPE based on its precision in bits,
2570 then lay it out. Used when make_signed_type won't do
2571 because the tree code is not INTEGER_TYPE.
2572 E.g. for Pascal, when the -fsigned-char option is given. */
2575 fixup_signed_type (tree type
)
2577 int precision
= TYPE_PRECISION (type
);
2579 /* We can not represent properly constants greater then
2580 HOST_BITS_PER_DOUBLE_INT, still we need the types
2581 as they are used by i386 vector extensions and friends. */
2582 if (precision
> HOST_BITS_PER_DOUBLE_INT
)
2583 precision
= HOST_BITS_PER_DOUBLE_INT
;
2585 set_min_and_max_values_for_integral_type (type
, precision
,
2586 /*is_unsigned=*/false);
2588 /* Lay out the type: set its alignment, size, etc. */
2592 /* Set the extreme values of TYPE based on its precision in bits,
2593 then lay it out. This is used both in `make_unsigned_type'
2594 and for enumeral types. */
2597 fixup_unsigned_type (tree type
)
2599 int precision
= TYPE_PRECISION (type
);
2601 /* We can not represent properly constants greater then
2602 HOST_BITS_PER_DOUBLE_INT, still we need the types
2603 as they are used by i386 vector extensions and friends. */
2604 if (precision
> HOST_BITS_PER_DOUBLE_INT
)
2605 precision
= HOST_BITS_PER_DOUBLE_INT
;
2607 TYPE_UNSIGNED (type
) = 1;
2609 set_min_and_max_values_for_integral_type (type
, precision
,
2610 /*is_unsigned=*/true);
2612 /* Lay out the type: set its alignment, size, etc. */
2616 /* Construct an iterator for a bitfield that spans BITSIZE bits,
2619 BITREGION_START is the bit position of the first bit in this
2620 sequence of bit fields. BITREGION_END is the last bit in this
2621 sequence. If these two fields are non-zero, we should restrict the
2622 memory access to that range. Otherwise, we are allowed to touch
2623 any adjacent non bit-fields.
2625 ALIGN is the alignment of the underlying object in bits.
2626 VOLATILEP says whether the bitfield is volatile. */
2628 bit_field_mode_iterator
2629 ::bit_field_mode_iterator (HOST_WIDE_INT bitsize
, HOST_WIDE_INT bitpos
,
2630 HOST_WIDE_INT bitregion_start
,
2631 HOST_WIDE_INT bitregion_end
,
2632 unsigned int align
, bool volatilep
)
2633 : m_mode (GET_CLASS_NARROWEST_MODE (MODE_INT
)), m_bitsize (bitsize
),
2634 m_bitpos (bitpos
), m_bitregion_start (bitregion_start
),
2635 m_bitregion_end (bitregion_end
), m_align (align
),
2636 m_volatilep (volatilep
), m_count (0)
2638 if (!m_bitregion_end
)
2640 /* We can assume that any aligned chunk of ALIGN bits that overlaps
2641 the bitfield is mapped and won't trap, provided that ALIGN isn't
2642 too large. The cap is the biggest required alignment for data,
2643 or at least the word size. And force one such chunk at least. */
2644 unsigned HOST_WIDE_INT units
2645 = MIN (align
, MAX (BIGGEST_ALIGNMENT
, BITS_PER_WORD
));
2648 m_bitregion_end
= bitpos
+ bitsize
+ units
- 1;
2649 m_bitregion_end
-= m_bitregion_end
% units
+ 1;
2653 /* Calls to this function return successively larger modes that can be used
2654 to represent the bitfield. Return true if another bitfield mode is
2655 available, storing it in *OUT_MODE if so. */
2658 bit_field_mode_iterator::next_mode (enum machine_mode
*out_mode
)
2660 for (; m_mode
!= VOIDmode
; m_mode
= GET_MODE_WIDER_MODE (m_mode
))
2662 unsigned int unit
= GET_MODE_BITSIZE (m_mode
);
2664 /* Skip modes that don't have full precision. */
2665 if (unit
!= GET_MODE_PRECISION (m_mode
))
2668 /* Stop if the mode is too wide to handle efficiently. */
2669 if (unit
> MAX_FIXED_MODE_SIZE
)
2672 /* Don't deliver more than one multiword mode; the smallest one
2674 if (m_count
> 0 && unit
> BITS_PER_WORD
)
2677 /* Skip modes that are too small. */
2678 unsigned HOST_WIDE_INT substart
= (unsigned HOST_WIDE_INT
) m_bitpos
% unit
;
2679 unsigned HOST_WIDE_INT subend
= substart
+ m_bitsize
;
2683 /* Stop if the mode goes outside the bitregion. */
2684 HOST_WIDE_INT start
= m_bitpos
- substart
;
2685 if (m_bitregion_start
&& start
< m_bitregion_start
)
2687 HOST_WIDE_INT end
= start
+ unit
;
2688 if (end
> m_bitregion_end
+ 1)
2691 /* Stop if the mode requires too much alignment. */
2692 if (GET_MODE_ALIGNMENT (m_mode
) > m_align
2693 && SLOW_UNALIGNED_ACCESS (m_mode
, m_align
))
2697 m_mode
= GET_MODE_WIDER_MODE (m_mode
);
2704 /* Return true if smaller modes are generally preferred for this kind
2708 bit_field_mode_iterator::prefer_smaller_modes ()
2711 ? targetm
.narrow_volatile_bitfield ()
2712 : !SLOW_BYTE_ACCESS
);
2715 /* Find the best machine mode to use when referencing a bit field of length
2716 BITSIZE bits starting at BITPOS.
2718 BITREGION_START is the bit position of the first bit in this
2719 sequence of bit fields. BITREGION_END is the last bit in this
2720 sequence. If these two fields are non-zero, we should restrict the
2721 memory access to that range. Otherwise, we are allowed to touch
2722 any adjacent non bit-fields.
2724 The underlying object is known to be aligned to a boundary of ALIGN bits.
2725 If LARGEST_MODE is not VOIDmode, it means that we should not use a mode
2726 larger than LARGEST_MODE (usually SImode).
2728 If no mode meets all these conditions, we return VOIDmode.
2730 If VOLATILEP is false and SLOW_BYTE_ACCESS is false, we return the
2731 smallest mode meeting these conditions.
2733 If VOLATILEP is false and SLOW_BYTE_ACCESS is true, we return the
2734 largest mode (but a mode no wider than UNITS_PER_WORD) that meets
2737 If VOLATILEP is true the narrow_volatile_bitfields target hook is used to
2738 decide which of the above modes should be used. */
2741 get_best_mode (int bitsize
, int bitpos
,
2742 unsigned HOST_WIDE_INT bitregion_start
,
2743 unsigned HOST_WIDE_INT bitregion_end
,
2745 enum machine_mode largest_mode
, bool volatilep
)
2747 bit_field_mode_iterator
iter (bitsize
, bitpos
, bitregion_start
,
2748 bitregion_end
, align
, volatilep
);
2749 enum machine_mode widest_mode
= VOIDmode
;
2750 enum machine_mode mode
;
2751 while (iter
.next_mode (&mode
)
2752 /* ??? For historical reasons, reject modes that would normally
2753 receive greater alignment, even if unaligned accesses are
2754 acceptable. This has both advantages and disadvantages.
2755 Removing this check means that something like:
2757 struct s { unsigned int x; unsigned int y; };
2758 int f (struct s *s) { return s->x == 0 && s->y == 0; }
2760 can be implemented using a single load and compare on
2761 64-bit machines that have no alignment restrictions.
2762 For example, on powerpc64-linux-gnu, we would generate:
2784 However, accessing more than one field can make life harder
2785 for the gimple optimizers. For example, gcc.dg/vect/bb-slp-5.c
2786 has a series of unsigned short copies followed by a series of
2787 unsigned short comparisons. With this check, both the copies
2788 and comparisons remain 16-bit accesses and FRE is able
2789 to eliminate the latter. Without the check, the comparisons
2790 can be done using 2 64-bit operations, which FRE isn't able
2791 to handle in the same way.
2793 Either way, it would probably be worth disabling this check
2794 during expand. One particular example where removing the
2795 check would help is the get_best_mode call in store_bit_field.
2796 If we are given a memory bitregion of 128 bits that is aligned
2797 to a 64-bit boundary, and the bitfield we want to modify is
2798 in the second half of the bitregion, this check causes
2799 store_bitfield to turn the memory into a 64-bit reference
2800 to the _first_ half of the region. We later use
2801 adjust_bitfield_address to get a reference to the correct half,
2802 but doing so looks to adjust_bitfield_address as though we are
2803 moving past the end of the original object, so it drops the
2804 associated MEM_EXPR and MEM_OFFSET. Removing the check
2805 causes store_bit_field to keep a 128-bit memory reference,
2806 so that the final bitfield reference still has a MEM_EXPR
2808 && GET_MODE_ALIGNMENT (mode
) <= align
2809 && (largest_mode
== VOIDmode
2810 || GET_MODE_SIZE (mode
) <= GET_MODE_SIZE (largest_mode
)))
2813 if (iter
.prefer_smaller_modes ())
2819 /* Gets minimal and maximal values for MODE (signed or unsigned depending on
2820 SIGN). The returned constants are made to be usable in TARGET_MODE. */
2823 get_mode_bounds (enum machine_mode mode
, int sign
,
2824 enum machine_mode target_mode
,
2825 rtx
*mmin
, rtx
*mmax
)
2827 unsigned size
= GET_MODE_BITSIZE (mode
);
2828 unsigned HOST_WIDE_INT min_val
, max_val
;
2830 gcc_assert (size
<= HOST_BITS_PER_WIDE_INT
);
2834 min_val
= -((unsigned HOST_WIDE_INT
) 1 << (size
- 1));
2835 max_val
= ((unsigned HOST_WIDE_INT
) 1 << (size
- 1)) - 1;
2840 max_val
= ((unsigned HOST_WIDE_INT
) 1 << (size
- 1) << 1) - 1;
2843 *mmin
= gen_int_mode (min_val
, target_mode
);
2844 *mmax
= gen_int_mode (max_val
, target_mode
);
2847 #include "gt-stor-layout.h"