1 /* C-compiler utilities for types and variables storage layout
2 Copyright (C) 1987-2014 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"
26 #include "stor-layout.h"
27 #include "stringpool.h"
29 #include "print-tree.h"
35 #include "diagnostic-core.h"
37 #include "langhooks.h"
41 #include "tree-inline.h"
42 #include "tree-dump.h"
45 /* Data type for the expressions representing sizes of data types.
46 It is the first integer type laid out. */
47 tree sizetype_tab
[(int) stk_type_kind_last
];
49 /* If nonzero, this is an upper limit on alignment of structure fields.
50 The value is measured in bits. */
51 unsigned int maximum_field_alignment
= TARGET_DEFAULT_PACK_STRUCT
* BITS_PER_UNIT
;
53 /* Nonzero if all REFERENCE_TYPEs are internal and hence should be allocated
54 in the address spaces' address_mode, not pointer_mode. Set only by
55 internal_reference_types called only by a front end. */
56 static int reference_types_internal
= 0;
58 static tree
self_referential_size (tree
);
59 static void finalize_record_size (record_layout_info
);
60 static void finalize_type_size (tree
);
61 static void place_union_field (record_layout_info
, tree
);
62 #if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED)
63 static int excess_unit_span (HOST_WIDE_INT
, HOST_WIDE_INT
, HOST_WIDE_INT
,
66 extern void debug_rli (record_layout_info
);
68 /* Show that REFERENCE_TYPES are internal and should use address_mode.
69 Called only by front end. */
72 internal_reference_types (void)
74 reference_types_internal
= 1;
77 /* Given a size SIZE that may not be a constant, return a SAVE_EXPR
78 to serve as the actual size-expression for a type or decl. */
81 variable_size (tree size
)
84 if (TREE_CONSTANT (size
))
87 /* If the size is self-referential, we can't make a SAVE_EXPR (see
88 save_expr for the rationale). But we can do something else. */
89 if (CONTAINS_PLACEHOLDER_P (size
))
90 return self_referential_size (size
);
92 /* If we are in the global binding level, we can't make a SAVE_EXPR
93 since it may end up being shared across functions, so it is up
94 to the front-end to deal with this case. */
95 if (lang_hooks
.decls
.global_bindings_p ())
98 return save_expr (size
);
101 /* An array of functions used for self-referential size computation. */
102 static GTY(()) vec
<tree
, va_gc
> *size_functions
;
104 /* Similar to copy_tree_r but do not copy component references involving
105 PLACEHOLDER_EXPRs. These nodes are spotted in find_placeholder_in_expr
106 and substituted in substitute_in_expr. */
109 copy_self_referential_tree_r (tree
*tp
, int *walk_subtrees
, void *data
)
111 enum tree_code code
= TREE_CODE (*tp
);
113 /* Stop at types, decls, constants like copy_tree_r. */
114 if (TREE_CODE_CLASS (code
) == tcc_type
115 || TREE_CODE_CLASS (code
) == tcc_declaration
116 || TREE_CODE_CLASS (code
) == tcc_constant
)
122 /* This is the pattern built in ada/make_aligning_type. */
123 else if (code
== ADDR_EXPR
124 && TREE_CODE (TREE_OPERAND (*tp
, 0)) == PLACEHOLDER_EXPR
)
130 /* Default case: the component reference. */
131 else if (code
== COMPONENT_REF
)
134 for (inner
= TREE_OPERAND (*tp
, 0);
135 REFERENCE_CLASS_P (inner
);
136 inner
= TREE_OPERAND (inner
, 0))
139 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
)
146 /* We're not supposed to have them in self-referential size trees
147 because we wouldn't properly control when they are evaluated.
148 However, not creating superfluous SAVE_EXPRs requires accurate
149 tracking of readonly-ness all the way down to here, which we
150 cannot always guarantee in practice. So punt in this case. */
151 else if (code
== SAVE_EXPR
)
152 return error_mark_node
;
154 else if (code
== STATEMENT_LIST
)
157 return copy_tree_r (tp
, walk_subtrees
, data
);
160 /* Given a SIZE expression that is self-referential, return an equivalent
161 expression to serve as the actual size expression for a type. */
164 self_referential_size (tree size
)
166 static unsigned HOST_WIDE_INT fnno
= 0;
167 vec
<tree
> self_refs
= vNULL
;
168 tree param_type_list
= NULL
, param_decl_list
= NULL
;
169 tree t
, ref
, return_type
, fntype
, fnname
, fndecl
;
172 vec
<tree
, va_gc
> *args
= NULL
;
174 /* Do not factor out simple operations. */
175 t
= skip_simple_constant_arithmetic (size
);
176 if (TREE_CODE (t
) == CALL_EXPR
)
179 /* Collect the list of self-references in the expression. */
180 find_placeholder_in_expr (size
, &self_refs
);
181 gcc_assert (self_refs
.length () > 0);
183 /* Obtain a private copy of the expression. */
185 if (walk_tree (&t
, copy_self_referential_tree_r
, NULL
, NULL
) != NULL_TREE
)
189 /* Build the parameter and argument lists in parallel; also
190 substitute the former for the latter in the expression. */
191 vec_alloc (args
, self_refs
.length ());
192 FOR_EACH_VEC_ELT (self_refs
, i
, ref
)
194 tree subst
, param_name
, param_type
, param_decl
;
198 /* We shouldn't have true variables here. */
199 gcc_assert (TREE_READONLY (ref
));
202 /* This is the pattern built in ada/make_aligning_type. */
203 else if (TREE_CODE (ref
) == ADDR_EXPR
)
205 /* Default case: the component reference. */
207 subst
= TREE_OPERAND (ref
, 1);
209 sprintf (buf
, "p%d", i
);
210 param_name
= get_identifier (buf
);
211 param_type
= TREE_TYPE (ref
);
213 = build_decl (input_location
, PARM_DECL
, param_name
, param_type
);
214 if (targetm
.calls
.promote_prototypes (NULL_TREE
)
215 && INTEGRAL_TYPE_P (param_type
)
216 && TYPE_PRECISION (param_type
) < TYPE_PRECISION (integer_type_node
))
217 DECL_ARG_TYPE (param_decl
) = integer_type_node
;
219 DECL_ARG_TYPE (param_decl
) = param_type
;
220 DECL_ARTIFICIAL (param_decl
) = 1;
221 TREE_READONLY (param_decl
) = 1;
223 size
= substitute_in_expr (size
, subst
, param_decl
);
225 param_type_list
= tree_cons (NULL_TREE
, param_type
, param_type_list
);
226 param_decl_list
= chainon (param_decl
, param_decl_list
);
227 args
->quick_push (ref
);
230 self_refs
.release ();
232 /* Append 'void' to indicate that the number of parameters is fixed. */
233 param_type_list
= tree_cons (NULL_TREE
, void_type_node
, param_type_list
);
235 /* The 3 lists have been created in reverse order. */
236 param_type_list
= nreverse (param_type_list
);
237 param_decl_list
= nreverse (param_decl_list
);
239 /* Build the function type. */
240 return_type
= TREE_TYPE (size
);
241 fntype
= build_function_type (return_type
, param_type_list
);
243 /* Build the function declaration. */
244 sprintf (buf
, "SZ"HOST_WIDE_INT_PRINT_UNSIGNED
, fnno
++);
245 fnname
= get_file_function_name (buf
);
246 fndecl
= build_decl (input_location
, FUNCTION_DECL
, fnname
, fntype
);
247 for (t
= param_decl_list
; t
; t
= DECL_CHAIN (t
))
248 DECL_CONTEXT (t
) = fndecl
;
249 DECL_ARGUMENTS (fndecl
) = param_decl_list
;
251 = build_decl (input_location
, RESULT_DECL
, 0, return_type
);
252 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
254 /* The function has been created by the compiler and we don't
255 want to emit debug info for it. */
256 DECL_ARTIFICIAL (fndecl
) = 1;
257 DECL_IGNORED_P (fndecl
) = 1;
259 /* It is supposed to be "const" and never throw. */
260 TREE_READONLY (fndecl
) = 1;
261 TREE_NOTHROW (fndecl
) = 1;
263 /* We want it to be inlined when this is deemed profitable, as
264 well as discarded if every call has been integrated. */
265 DECL_DECLARED_INLINE_P (fndecl
) = 1;
267 /* It is made up of a unique return statement. */
268 DECL_INITIAL (fndecl
) = make_node (BLOCK
);
269 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
270 t
= build2 (MODIFY_EXPR
, return_type
, DECL_RESULT (fndecl
), size
);
271 DECL_SAVED_TREE (fndecl
) = build1 (RETURN_EXPR
, void_type_node
, t
);
272 TREE_STATIC (fndecl
) = 1;
274 /* Put it onto the list of size functions. */
275 vec_safe_push (size_functions
, fndecl
);
277 /* Replace the original expression with a call to the size function. */
278 return build_call_expr_loc_vec (UNKNOWN_LOCATION
, fndecl
, args
);
281 /* Take, queue and compile all the size functions. It is essential that
282 the size functions be gimplified at the very end of the compilation
283 in order to guarantee transparent handling of self-referential sizes.
284 Otherwise the GENERIC inliner would not be able to inline them back
285 at each of their call sites, thus creating artificial non-constant
286 size expressions which would trigger nasty problems later on. */
289 finalize_size_functions (void)
294 for (i
= 0; size_functions
&& size_functions
->iterate (i
, &fndecl
); i
++)
296 allocate_struct_function (fndecl
, false);
298 dump_function (TDI_original
, fndecl
);
299 gimplify_function_tree (fndecl
);
300 dump_function (TDI_generic
, fndecl
);
301 cgraph_node::finalize_function (fndecl
, false);
304 vec_free (size_functions
);
307 /* Return the machine mode to use for a nonscalar of SIZE bits. The
308 mode must be in class MCLASS, and have exactly that many value bits;
309 it may have padding as well. If LIMIT is nonzero, modes of wider
310 than MAX_FIXED_MODE_SIZE will not be used. */
313 mode_for_size (unsigned int size
, enum mode_class mclass
, int limit
)
315 enum machine_mode mode
;
318 if (limit
&& size
> MAX_FIXED_MODE_SIZE
)
321 /* Get the first mode which has this size, in the specified class. */
322 for (mode
= GET_CLASS_NARROWEST_MODE (mclass
); mode
!= VOIDmode
;
323 mode
= GET_MODE_WIDER_MODE (mode
))
324 if (GET_MODE_PRECISION (mode
) == size
)
327 if (mclass
== MODE_INT
|| mclass
== MODE_PARTIAL_INT
)
328 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
329 if (int_n_data
[i
].bitsize
== size
330 && int_n_enabled_p
[i
])
331 return int_n_data
[i
].m
;
336 /* Similar, except passed a tree node. */
339 mode_for_size_tree (const_tree size
, enum mode_class mclass
, int limit
)
341 unsigned HOST_WIDE_INT uhwi
;
344 if (!tree_fits_uhwi_p (size
))
346 uhwi
= tree_to_uhwi (size
);
350 return mode_for_size (ui
, mclass
, limit
);
353 /* Similar, but never return BLKmode; return the narrowest mode that
354 contains at least the requested number of value bits. */
357 smallest_mode_for_size (unsigned int size
, enum mode_class mclass
)
359 enum machine_mode mode
= VOIDmode
;
362 /* Get the first mode which has at least this size, in the
364 for (mode
= GET_CLASS_NARROWEST_MODE (mclass
); mode
!= VOIDmode
;
365 mode
= GET_MODE_WIDER_MODE (mode
))
366 if (GET_MODE_PRECISION (mode
) >= size
)
369 if (mclass
== MODE_INT
|| mclass
== MODE_PARTIAL_INT
)
370 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
371 if (int_n_data
[i
].bitsize
>= size
372 && int_n_data
[i
].bitsize
< GET_MODE_PRECISION (mode
)
373 && int_n_enabled_p
[i
])
374 mode
= int_n_data
[i
].m
;
376 if (mode
== VOIDmode
)
382 /* Find an integer mode of the exact same size, or BLKmode on failure. */
385 int_mode_for_mode (enum machine_mode mode
)
387 switch (GET_MODE_CLASS (mode
))
390 case MODE_PARTIAL_INT
:
393 case MODE_COMPLEX_INT
:
394 case MODE_COMPLEX_FLOAT
:
396 case MODE_DECIMAL_FLOAT
:
397 case MODE_VECTOR_INT
:
398 case MODE_VECTOR_FLOAT
:
403 case MODE_VECTOR_FRACT
:
404 case MODE_VECTOR_ACCUM
:
405 case MODE_VECTOR_UFRACT
:
406 case MODE_VECTOR_UACCUM
:
407 mode
= mode_for_size (GET_MODE_BITSIZE (mode
), MODE_INT
, 0);
414 /* ... fall through ... */
424 /* Find a mode that can be used for efficient bitwise operations on MODE.
425 Return BLKmode if no such mode exists. */
428 bitwise_mode_for_mode (enum machine_mode mode
)
430 /* Quick exit if we already have a suitable mode. */
431 unsigned int bitsize
= GET_MODE_BITSIZE (mode
);
432 if (SCALAR_INT_MODE_P (mode
) && bitsize
<= MAX_FIXED_MODE_SIZE
)
435 /* Reuse the sanity checks from int_mode_for_mode. */
436 gcc_checking_assert ((int_mode_for_mode (mode
), true));
438 /* Try to replace complex modes with complex modes. In general we
439 expect both components to be processed independently, so we only
440 care whether there is a register for the inner mode. */
441 if (COMPLEX_MODE_P (mode
))
443 enum machine_mode trial
= mode
;
444 if (GET_MODE_CLASS (mode
) != MODE_COMPLEX_INT
)
445 trial
= mode_for_size (bitsize
, MODE_COMPLEX_INT
, false);
447 && have_regs_of_mode
[GET_MODE_INNER (trial
)])
451 /* Try to replace vector modes with vector modes. Also try using vector
452 modes if an integer mode would be too big. */
453 if (VECTOR_MODE_P (mode
) || bitsize
> MAX_FIXED_MODE_SIZE
)
455 enum machine_mode trial
= mode
;
456 if (GET_MODE_CLASS (mode
) != MODE_VECTOR_INT
)
457 trial
= mode_for_size (bitsize
, MODE_VECTOR_INT
, 0);
459 && have_regs_of_mode
[trial
]
460 && targetm
.vector_mode_supported_p (trial
))
464 /* Otherwise fall back on integers while honoring MAX_FIXED_MODE_SIZE. */
465 return mode_for_size (bitsize
, MODE_INT
, true);
468 /* Find a type that can be used for efficient bitwise operations on MODE.
469 Return null if no such mode exists. */
472 bitwise_type_for_mode (enum machine_mode mode
)
474 mode
= bitwise_mode_for_mode (mode
);
478 unsigned int inner_size
= GET_MODE_UNIT_BITSIZE (mode
);
479 tree inner_type
= build_nonstandard_integer_type (inner_size
, true);
481 if (VECTOR_MODE_P (mode
))
482 return build_vector_type_for_mode (inner_type
, mode
);
484 if (COMPLEX_MODE_P (mode
))
485 return build_complex_type (inner_type
);
487 gcc_checking_assert (GET_MODE_INNER (mode
) == VOIDmode
);
491 /* Find a mode that is suitable for representing a vector with
492 NUNITS elements of mode INNERMODE. Returns BLKmode if there
493 is no suitable mode. */
496 mode_for_vector (enum machine_mode innermode
, unsigned nunits
)
498 enum machine_mode mode
;
500 /* First, look for a supported vector type. */
501 if (SCALAR_FLOAT_MODE_P (innermode
))
502 mode
= MIN_MODE_VECTOR_FLOAT
;
503 else if (SCALAR_FRACT_MODE_P (innermode
))
504 mode
= MIN_MODE_VECTOR_FRACT
;
505 else if (SCALAR_UFRACT_MODE_P (innermode
))
506 mode
= MIN_MODE_VECTOR_UFRACT
;
507 else if (SCALAR_ACCUM_MODE_P (innermode
))
508 mode
= MIN_MODE_VECTOR_ACCUM
;
509 else if (SCALAR_UACCUM_MODE_P (innermode
))
510 mode
= MIN_MODE_VECTOR_UACCUM
;
512 mode
= MIN_MODE_VECTOR_INT
;
514 /* Do not check vector_mode_supported_p here. We'll do that
515 later in vector_type_mode. */
516 for (; mode
!= VOIDmode
; mode
= GET_MODE_WIDER_MODE (mode
))
517 if (GET_MODE_NUNITS (mode
) == nunits
518 && GET_MODE_INNER (mode
) == innermode
)
521 /* For integers, try mapping it to a same-sized scalar mode. */
523 && GET_MODE_CLASS (innermode
) == MODE_INT
)
524 mode
= mode_for_size (nunits
* GET_MODE_BITSIZE (innermode
),
528 || (GET_MODE_CLASS (mode
) == MODE_INT
529 && !have_regs_of_mode
[mode
]))
535 /* Return the alignment of MODE. This will be bounded by 1 and
536 BIGGEST_ALIGNMENT. */
539 get_mode_alignment (enum machine_mode mode
)
541 return MIN (BIGGEST_ALIGNMENT
, MAX (1, mode_base_align
[mode
]*BITS_PER_UNIT
));
544 /* Return the precision of the mode, or for a complex or vector mode the
545 precision of the mode of its elements. */
548 element_precision (enum machine_mode mode
)
550 if (COMPLEX_MODE_P (mode
) || VECTOR_MODE_P (mode
))
551 mode
= GET_MODE_INNER (mode
);
553 return GET_MODE_PRECISION (mode
);
556 /* Return the natural mode of an array, given that it is SIZE bytes in
557 total and has elements of type ELEM_TYPE. */
559 static enum machine_mode
560 mode_for_array (tree elem_type
, tree size
)
563 unsigned HOST_WIDE_INT int_size
, int_elem_size
;
566 /* One-element arrays get the component type's mode. */
567 elem_size
= TYPE_SIZE (elem_type
);
568 if (simple_cst_equal (size
, elem_size
))
569 return TYPE_MODE (elem_type
);
572 if (tree_fits_uhwi_p (size
) && tree_fits_uhwi_p (elem_size
))
574 int_size
= tree_to_uhwi (size
);
575 int_elem_size
= tree_to_uhwi (elem_size
);
576 if (int_elem_size
> 0
577 && int_size
% int_elem_size
== 0
578 && targetm
.array_mode_supported_p (TYPE_MODE (elem_type
),
579 int_size
/ int_elem_size
))
582 return mode_for_size_tree (size
, MODE_INT
, limit_p
);
585 /* Subroutine of layout_decl: Force alignment required for the data type.
586 But if the decl itself wants greater alignment, don't override that. */
589 do_type_align (tree type
, tree decl
)
591 if (TYPE_ALIGN (type
) > DECL_ALIGN (decl
))
593 DECL_ALIGN (decl
) = TYPE_ALIGN (type
);
594 if (TREE_CODE (decl
) == FIELD_DECL
)
595 DECL_USER_ALIGN (decl
) = TYPE_USER_ALIGN (type
);
599 /* Set the size, mode and alignment of a ..._DECL node.
600 TYPE_DECL does need this for C++.
601 Note that LABEL_DECL and CONST_DECL nodes do not need this,
602 and FUNCTION_DECL nodes have them set up in a special (and simple) way.
603 Don't call layout_decl for them.
605 KNOWN_ALIGN is the amount of alignment we can assume this
606 decl has with no special effort. It is relevant only for FIELD_DECLs
607 and depends on the previous fields.
608 All that matters about KNOWN_ALIGN is which powers of 2 divide it.
609 If KNOWN_ALIGN is 0, it means, "as much alignment as you like":
610 the record will be aligned to suit. */
613 layout_decl (tree decl
, unsigned int known_align
)
615 tree type
= TREE_TYPE (decl
);
616 enum tree_code code
= TREE_CODE (decl
);
618 location_t loc
= DECL_SOURCE_LOCATION (decl
);
620 if (code
== CONST_DECL
)
623 gcc_assert (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
624 || code
== TYPE_DECL
||code
== FIELD_DECL
);
626 rtl
= DECL_RTL_IF_SET (decl
);
628 if (type
== error_mark_node
)
629 type
= void_type_node
;
631 /* Usually the size and mode come from the data type without change,
632 however, the front-end may set the explicit width of the field, so its
633 size may not be the same as the size of its type. This happens with
634 bitfields, of course (an `int' bitfield may be only 2 bits, say), but it
635 also happens with other fields. For example, the C++ front-end creates
636 zero-sized fields corresponding to empty base classes, and depends on
637 layout_type setting DECL_FIELD_BITPOS correctly for the field. Set the
638 size in bytes from the size in bits. If we have already set the mode,
639 don't set it again since we can be called twice for FIELD_DECLs. */
641 DECL_UNSIGNED (decl
) = TYPE_UNSIGNED (type
);
642 if (DECL_MODE (decl
) == VOIDmode
)
643 DECL_MODE (decl
) = TYPE_MODE (type
);
645 if (DECL_SIZE (decl
) == 0)
647 DECL_SIZE (decl
) = TYPE_SIZE (type
);
648 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (type
);
650 else if (DECL_SIZE_UNIT (decl
) == 0)
651 DECL_SIZE_UNIT (decl
)
652 = fold_convert_loc (loc
, sizetype
,
653 size_binop_loc (loc
, CEIL_DIV_EXPR
, DECL_SIZE (decl
),
656 if (code
!= FIELD_DECL
)
657 /* For non-fields, update the alignment from the type. */
658 do_type_align (type
, decl
);
660 /* For fields, it's a bit more complicated... */
662 bool old_user_align
= DECL_USER_ALIGN (decl
);
663 bool zero_bitfield
= false;
664 bool packed_p
= DECL_PACKED (decl
);
667 if (DECL_BIT_FIELD (decl
))
669 DECL_BIT_FIELD_TYPE (decl
) = type
;
671 /* A zero-length bit-field affects the alignment of the next
672 field. In essence such bit-fields are not influenced by
673 any packing due to #pragma pack or attribute packed. */
674 if (integer_zerop (DECL_SIZE (decl
))
675 && ! targetm
.ms_bitfield_layout_p (DECL_FIELD_CONTEXT (decl
)))
677 zero_bitfield
= true;
679 #ifdef PCC_BITFIELD_TYPE_MATTERS
680 if (PCC_BITFIELD_TYPE_MATTERS
)
681 do_type_align (type
, decl
);
685 #ifdef EMPTY_FIELD_BOUNDARY
686 if (EMPTY_FIELD_BOUNDARY
> DECL_ALIGN (decl
))
688 DECL_ALIGN (decl
) = EMPTY_FIELD_BOUNDARY
;
689 DECL_USER_ALIGN (decl
) = 0;
695 /* See if we can use an ordinary integer mode for a bit-field.
696 Conditions are: a fixed size that is correct for another mode,
697 occupying a complete byte or bytes on proper boundary. */
698 if (TYPE_SIZE (type
) != 0
699 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
700 && GET_MODE_CLASS (TYPE_MODE (type
)) == MODE_INT
)
702 enum machine_mode xmode
703 = mode_for_size_tree (DECL_SIZE (decl
), MODE_INT
, 1);
704 unsigned int xalign
= GET_MODE_ALIGNMENT (xmode
);
707 && !(xalign
> BITS_PER_UNIT
&& DECL_PACKED (decl
))
708 && (known_align
== 0 || known_align
>= xalign
))
710 DECL_ALIGN (decl
) = MAX (xalign
, DECL_ALIGN (decl
));
711 DECL_MODE (decl
) = xmode
;
712 DECL_BIT_FIELD (decl
) = 0;
716 /* Turn off DECL_BIT_FIELD if we won't need it set. */
717 if (TYPE_MODE (type
) == BLKmode
&& DECL_MODE (decl
) == BLKmode
718 && known_align
>= TYPE_ALIGN (type
)
719 && DECL_ALIGN (decl
) >= TYPE_ALIGN (type
))
720 DECL_BIT_FIELD (decl
) = 0;
722 else if (packed_p
&& DECL_USER_ALIGN (decl
))
723 /* Don't touch DECL_ALIGN. For other packed fields, go ahead and
724 round up; we'll reduce it again below. We want packing to
725 supersede USER_ALIGN inherited from the type, but defer to
726 alignment explicitly specified on the field decl. */;
728 do_type_align (type
, decl
);
730 /* If the field is packed and not explicitly aligned, give it the
731 minimum alignment. Note that do_type_align may set
732 DECL_USER_ALIGN, so we need to check old_user_align instead. */
735 DECL_ALIGN (decl
) = MIN (DECL_ALIGN (decl
), BITS_PER_UNIT
);
737 if (! packed_p
&& ! DECL_USER_ALIGN (decl
))
739 /* Some targets (i.e. i386, VMS) limit struct field alignment
740 to a lower boundary than alignment of variables unless
741 it was overridden by attribute aligned. */
742 #ifdef BIGGEST_FIELD_ALIGNMENT
744 = MIN (DECL_ALIGN (decl
), (unsigned) BIGGEST_FIELD_ALIGNMENT
);
746 #ifdef ADJUST_FIELD_ALIGN
747 DECL_ALIGN (decl
) = ADJUST_FIELD_ALIGN (decl
, DECL_ALIGN (decl
));
752 mfa
= initial_max_fld_align
* BITS_PER_UNIT
;
754 mfa
= maximum_field_alignment
;
755 /* Should this be controlled by DECL_USER_ALIGN, too? */
757 DECL_ALIGN (decl
) = MIN (DECL_ALIGN (decl
), mfa
);
760 /* Evaluate nonconstant size only once, either now or as soon as safe. */
761 if (DECL_SIZE (decl
) != 0 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
762 DECL_SIZE (decl
) = variable_size (DECL_SIZE (decl
));
763 if (DECL_SIZE_UNIT (decl
) != 0
764 && TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
)
765 DECL_SIZE_UNIT (decl
) = variable_size (DECL_SIZE_UNIT (decl
));
767 /* If requested, warn about definitions of large data objects. */
769 && (code
== VAR_DECL
|| code
== PARM_DECL
)
770 && ! DECL_EXTERNAL (decl
))
772 tree size
= DECL_SIZE_UNIT (decl
);
774 if (size
!= 0 && TREE_CODE (size
) == INTEGER_CST
775 && compare_tree_int (size
, larger_than_size
) > 0)
777 int size_as_int
= TREE_INT_CST_LOW (size
);
779 if (compare_tree_int (size
, size_as_int
) == 0)
780 warning (OPT_Wlarger_than_
, "size of %q+D is %d bytes", decl
, size_as_int
);
782 warning (OPT_Wlarger_than_
, "size of %q+D is larger than %wd bytes",
783 decl
, larger_than_size
);
787 /* If the RTL was already set, update its mode and mem attributes. */
790 PUT_MODE (rtl
, DECL_MODE (decl
));
791 SET_DECL_RTL (decl
, 0);
792 set_mem_attributes (rtl
, decl
, 1);
793 SET_DECL_RTL (decl
, rtl
);
797 /* Given a VAR_DECL, PARM_DECL or RESULT_DECL, clears the results of
798 a previous call to layout_decl and calls it again. */
801 relayout_decl (tree decl
)
803 DECL_SIZE (decl
) = DECL_SIZE_UNIT (decl
) = 0;
804 DECL_MODE (decl
) = VOIDmode
;
805 if (!DECL_USER_ALIGN (decl
))
806 DECL_ALIGN (decl
) = 0;
807 SET_DECL_RTL (decl
, 0);
809 layout_decl (decl
, 0);
812 /* Begin laying out type T, which may be a RECORD_TYPE, UNION_TYPE, or
813 QUAL_UNION_TYPE. Return a pointer to a struct record_layout_info which
814 is to be passed to all other layout functions for this record. It is the
815 responsibility of the caller to call `free' for the storage returned.
816 Note that garbage collection is not permitted until we finish laying
820 start_record_layout (tree t
)
822 record_layout_info rli
= XNEW (struct record_layout_info_s
);
826 /* If the type has a minimum specified alignment (via an attribute
827 declaration, for example) use it -- otherwise, start with a
828 one-byte alignment. */
829 rli
->record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (t
));
830 rli
->unpacked_align
= rli
->record_align
;
831 rli
->offset_align
= MAX (rli
->record_align
, BIGGEST_ALIGNMENT
);
833 #ifdef STRUCTURE_SIZE_BOUNDARY
834 /* Packed structures don't need to have minimum size. */
835 if (! TYPE_PACKED (t
))
839 /* #pragma pack overrides STRUCTURE_SIZE_BOUNDARY. */
840 tmp
= (unsigned) STRUCTURE_SIZE_BOUNDARY
;
841 if (maximum_field_alignment
!= 0)
842 tmp
= MIN (tmp
, maximum_field_alignment
);
843 rli
->record_align
= MAX (rli
->record_align
, tmp
);
847 rli
->offset
= size_zero_node
;
848 rli
->bitpos
= bitsize_zero_node
;
850 rli
->pending_statics
= 0;
851 rli
->packed_maybe_necessary
= 0;
852 rli
->remaining_in_alignment
= 0;
857 /* Return the combined bit position for the byte offset OFFSET and the
860 These functions operate on byte and bit positions present in FIELD_DECLs
861 and assume that these expressions result in no (intermediate) overflow.
862 This assumption is necessary to fold the expressions as much as possible,
863 so as to avoid creating artificially variable-sized types in languages
864 supporting variable-sized types like Ada. */
867 bit_from_pos (tree offset
, tree bitpos
)
869 if (TREE_CODE (offset
) == PLUS_EXPR
)
870 offset
= size_binop (PLUS_EXPR
,
871 fold_convert (bitsizetype
, TREE_OPERAND (offset
, 0)),
872 fold_convert (bitsizetype
, TREE_OPERAND (offset
, 1)));
874 offset
= fold_convert (bitsizetype
, offset
);
875 return size_binop (PLUS_EXPR
, bitpos
,
876 size_binop (MULT_EXPR
, offset
, bitsize_unit_node
));
879 /* Return the combined truncated byte position for the byte offset OFFSET and
880 the bit position BITPOS. */
883 byte_from_pos (tree offset
, tree bitpos
)
886 if (TREE_CODE (bitpos
) == MULT_EXPR
887 && tree_int_cst_equal (TREE_OPERAND (bitpos
, 1), bitsize_unit_node
))
888 bytepos
= TREE_OPERAND (bitpos
, 0);
890 bytepos
= size_binop (TRUNC_DIV_EXPR
, bitpos
, bitsize_unit_node
);
891 return size_binop (PLUS_EXPR
, offset
, fold_convert (sizetype
, bytepos
));
894 /* Split the bit position POS into a byte offset *POFFSET and a bit
895 position *PBITPOS with the byte offset aligned to OFF_ALIGN bits. */
898 pos_from_bit (tree
*poffset
, tree
*pbitpos
, unsigned int off_align
,
901 tree toff_align
= bitsize_int (off_align
);
902 if (TREE_CODE (pos
) == MULT_EXPR
903 && tree_int_cst_equal (TREE_OPERAND (pos
, 1), toff_align
))
905 *poffset
= size_binop (MULT_EXPR
,
906 fold_convert (sizetype
, TREE_OPERAND (pos
, 0)),
907 size_int (off_align
/ BITS_PER_UNIT
));
908 *pbitpos
= bitsize_zero_node
;
912 *poffset
= size_binop (MULT_EXPR
,
913 fold_convert (sizetype
,
914 size_binop (FLOOR_DIV_EXPR
, pos
,
916 size_int (off_align
/ BITS_PER_UNIT
));
917 *pbitpos
= size_binop (FLOOR_MOD_EXPR
, pos
, toff_align
);
921 /* Given a pointer to bit and byte offsets and an offset alignment,
922 normalize the offsets so they are within the alignment. */
925 normalize_offset (tree
*poffset
, tree
*pbitpos
, unsigned int off_align
)
927 /* If the bit position is now larger than it should be, adjust it
929 if (compare_tree_int (*pbitpos
, off_align
) >= 0)
932 pos_from_bit (&offset
, &bitpos
, off_align
, *pbitpos
);
933 *poffset
= size_binop (PLUS_EXPR
, *poffset
, offset
);
938 /* Print debugging information about the information in RLI. */
941 debug_rli (record_layout_info rli
)
943 print_node_brief (stderr
, "type", rli
->t
, 0);
944 print_node_brief (stderr
, "\noffset", rli
->offset
, 0);
945 print_node_brief (stderr
, " bitpos", rli
->bitpos
, 0);
947 fprintf (stderr
, "\naligns: rec = %u, unpack = %u, off = %u\n",
948 rli
->record_align
, rli
->unpacked_align
,
951 /* The ms_struct code is the only that uses this. */
952 if (targetm
.ms_bitfield_layout_p (rli
->t
))
953 fprintf (stderr
, "remaining in alignment = %u\n", rli
->remaining_in_alignment
);
955 if (rli
->packed_maybe_necessary
)
956 fprintf (stderr
, "packed may be necessary\n");
958 if (!vec_safe_is_empty (rli
->pending_statics
))
960 fprintf (stderr
, "pending statics:\n");
961 debug_vec_tree (rli
->pending_statics
);
965 /* Given an RLI with a possibly-incremented BITPOS, adjust OFFSET and
966 BITPOS if necessary to keep BITPOS below OFFSET_ALIGN. */
969 normalize_rli (record_layout_info rli
)
971 normalize_offset (&rli
->offset
, &rli
->bitpos
, rli
->offset_align
);
974 /* Returns the size in bytes allocated so far. */
977 rli_size_unit_so_far (record_layout_info rli
)
979 return byte_from_pos (rli
->offset
, rli
->bitpos
);
982 /* Returns the size in bits allocated so far. */
985 rli_size_so_far (record_layout_info rli
)
987 return bit_from_pos (rli
->offset
, rli
->bitpos
);
990 /* FIELD is about to be added to RLI->T. The alignment (in bits) of
991 the next available location within the record is given by KNOWN_ALIGN.
992 Update the variable alignment fields in RLI, and return the alignment
993 to give the FIELD. */
996 update_alignment_for_field (record_layout_info rli
, tree field
,
997 unsigned int known_align
)
999 /* The alignment required for FIELD. */
1000 unsigned int desired_align
;
1001 /* The type of this field. */
1002 tree type
= TREE_TYPE (field
);
1003 /* True if the field was explicitly aligned by the user. */
1007 /* Do not attempt to align an ERROR_MARK node */
1008 if (TREE_CODE (type
) == ERROR_MARK
)
1011 /* Lay out the field so we know what alignment it needs. */
1012 layout_decl (field
, known_align
);
1013 desired_align
= DECL_ALIGN (field
);
1014 user_align
= DECL_USER_ALIGN (field
);
1016 is_bitfield
= (type
!= error_mark_node
1017 && DECL_BIT_FIELD_TYPE (field
)
1018 && ! integer_zerop (TYPE_SIZE (type
)));
1020 /* Record must have at least as much alignment as any field.
1021 Otherwise, the alignment of the field within the record is
1023 if (targetm
.ms_bitfield_layout_p (rli
->t
))
1025 /* Here, the alignment of the underlying type of a bitfield can
1026 affect the alignment of a record; even a zero-sized field
1027 can do this. The alignment should be to the alignment of
1028 the type, except that for zero-size bitfields this only
1029 applies if there was an immediately prior, nonzero-size
1030 bitfield. (That's the way it is, experimentally.) */
1031 if ((!is_bitfield
&& !DECL_PACKED (field
))
1032 || ((DECL_SIZE (field
) == NULL_TREE
1033 || !integer_zerop (DECL_SIZE (field
)))
1034 ? !DECL_PACKED (field
)
1036 && DECL_BIT_FIELD_TYPE (rli
->prev_field
)
1037 && ! integer_zerop (DECL_SIZE (rli
->prev_field
)))))
1039 unsigned int type_align
= TYPE_ALIGN (type
);
1040 type_align
= MAX (type_align
, desired_align
);
1041 if (maximum_field_alignment
!= 0)
1042 type_align
= MIN (type_align
, maximum_field_alignment
);
1043 rli
->record_align
= MAX (rli
->record_align
, type_align
);
1044 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
1047 #ifdef PCC_BITFIELD_TYPE_MATTERS
1048 else if (is_bitfield
&& PCC_BITFIELD_TYPE_MATTERS
)
1050 /* Named bit-fields cause the entire structure to have the
1051 alignment implied by their type. Some targets also apply the same
1052 rules to unnamed bitfields. */
1053 if (DECL_NAME (field
) != 0
1054 || targetm
.align_anon_bitfield ())
1056 unsigned int type_align
= TYPE_ALIGN (type
);
1058 #ifdef ADJUST_FIELD_ALIGN
1059 if (! TYPE_USER_ALIGN (type
))
1060 type_align
= ADJUST_FIELD_ALIGN (field
, type_align
);
1063 /* Targets might chose to handle unnamed and hence possibly
1064 zero-width bitfield. Those are not influenced by #pragmas
1065 or packed attributes. */
1066 if (integer_zerop (DECL_SIZE (field
)))
1068 if (initial_max_fld_align
)
1069 type_align
= MIN (type_align
,
1070 initial_max_fld_align
* BITS_PER_UNIT
);
1072 else if (maximum_field_alignment
!= 0)
1073 type_align
= MIN (type_align
, maximum_field_alignment
);
1074 else if (DECL_PACKED (field
))
1075 type_align
= MIN (type_align
, BITS_PER_UNIT
);
1077 /* The alignment of the record is increased to the maximum
1078 of the current alignment, the alignment indicated on the
1079 field (i.e., the alignment specified by an __aligned__
1080 attribute), and the alignment indicated by the type of
1082 rli
->record_align
= MAX (rli
->record_align
, desired_align
);
1083 rli
->record_align
= MAX (rli
->record_align
, type_align
);
1086 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
1087 user_align
|= TYPE_USER_ALIGN (type
);
1093 rli
->record_align
= MAX (rli
->record_align
, desired_align
);
1094 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
1097 TYPE_USER_ALIGN (rli
->t
) |= user_align
;
1099 return desired_align
;
1102 /* Called from place_field to handle unions. */
1105 place_union_field (record_layout_info rli
, tree field
)
1107 update_alignment_for_field (rli
, field
, /*known_align=*/0);
1109 DECL_FIELD_OFFSET (field
) = size_zero_node
;
1110 DECL_FIELD_BIT_OFFSET (field
) = bitsize_zero_node
;
1111 SET_DECL_OFFSET_ALIGN (field
, BIGGEST_ALIGNMENT
);
1113 /* If this is an ERROR_MARK return *after* having set the
1114 field at the start of the union. This helps when parsing
1116 if (TREE_CODE (TREE_TYPE (field
)) == ERROR_MARK
)
1119 /* We assume the union's size will be a multiple of a byte so we don't
1120 bother with BITPOS. */
1121 if (TREE_CODE (rli
->t
) == UNION_TYPE
)
1122 rli
->offset
= size_binop (MAX_EXPR
, rli
->offset
, DECL_SIZE_UNIT (field
));
1123 else if (TREE_CODE (rli
->t
) == QUAL_UNION_TYPE
)
1124 rli
->offset
= fold_build3 (COND_EXPR
, sizetype
, DECL_QUALIFIER (field
),
1125 DECL_SIZE_UNIT (field
), rli
->offset
);
1128 #if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED)
1129 /* A bitfield of SIZE with a required access alignment of ALIGN is allocated
1130 at BYTE_OFFSET / BIT_OFFSET. Return nonzero if the field would span more
1131 units of alignment than the underlying TYPE. */
1133 excess_unit_span (HOST_WIDE_INT byte_offset
, HOST_WIDE_INT bit_offset
,
1134 HOST_WIDE_INT size
, HOST_WIDE_INT align
, tree type
)
1136 /* Note that the calculation of OFFSET might overflow; we calculate it so
1137 that we still get the right result as long as ALIGN is a power of two. */
1138 unsigned HOST_WIDE_INT offset
= byte_offset
* BITS_PER_UNIT
+ bit_offset
;
1140 offset
= offset
% align
;
1141 return ((offset
+ size
+ align
- 1) / align
1142 > tree_to_uhwi (TYPE_SIZE (type
)) / align
);
1146 /* RLI contains information about the layout of a RECORD_TYPE. FIELD
1147 is a FIELD_DECL to be added after those fields already present in
1148 T. (FIELD is not actually added to the TYPE_FIELDS list here;
1149 callers that desire that behavior must manually perform that step.) */
1152 place_field (record_layout_info rli
, tree field
)
1154 /* The alignment required for FIELD. */
1155 unsigned int desired_align
;
1156 /* The alignment FIELD would have if we just dropped it into the
1157 record as it presently stands. */
1158 unsigned int known_align
;
1159 unsigned int actual_align
;
1160 /* The type of this field. */
1161 tree type
= TREE_TYPE (field
);
1163 gcc_assert (TREE_CODE (field
) != ERROR_MARK
);
1165 /* If FIELD is static, then treat it like a separate variable, not
1166 really like a structure field. If it is a FUNCTION_DECL, it's a
1167 method. In both cases, all we do is lay out the decl, and we do
1168 it *after* the record is laid out. */
1169 if (TREE_CODE (field
) == VAR_DECL
)
1171 vec_safe_push (rli
->pending_statics
, field
);
1175 /* Enumerators and enum types which are local to this class need not
1176 be laid out. Likewise for initialized constant fields. */
1177 else if (TREE_CODE (field
) != FIELD_DECL
)
1180 /* Unions are laid out very differently than records, so split
1181 that code off to another function. */
1182 else if (TREE_CODE (rli
->t
) != RECORD_TYPE
)
1184 place_union_field (rli
, field
);
1188 else if (TREE_CODE (type
) == ERROR_MARK
)
1190 /* Place this field at the current allocation position, so we
1191 maintain monotonicity. */
1192 DECL_FIELD_OFFSET (field
) = rli
->offset
;
1193 DECL_FIELD_BIT_OFFSET (field
) = rli
->bitpos
;
1194 SET_DECL_OFFSET_ALIGN (field
, rli
->offset_align
);
1198 /* Work out the known alignment so far. Note that A & (-A) is the
1199 value of the least-significant bit in A that is one. */
1200 if (! integer_zerop (rli
->bitpos
))
1201 known_align
= (tree_to_uhwi (rli
->bitpos
)
1202 & - tree_to_uhwi (rli
->bitpos
));
1203 else if (integer_zerop (rli
->offset
))
1205 else if (tree_fits_uhwi_p (rli
->offset
))
1206 known_align
= (BITS_PER_UNIT
1207 * (tree_to_uhwi (rli
->offset
)
1208 & - tree_to_uhwi (rli
->offset
)));
1210 known_align
= rli
->offset_align
;
1212 desired_align
= update_alignment_for_field (rli
, field
, known_align
);
1213 if (known_align
== 0)
1214 known_align
= MAX (BIGGEST_ALIGNMENT
, rli
->record_align
);
1216 if (warn_packed
&& DECL_PACKED (field
))
1218 if (known_align
>= TYPE_ALIGN (type
))
1220 if (TYPE_ALIGN (type
) > desired_align
)
1222 if (STRICT_ALIGNMENT
)
1223 warning (OPT_Wattributes
, "packed attribute causes "
1224 "inefficient alignment for %q+D", field
);
1225 /* Don't warn if DECL_PACKED was set by the type. */
1226 else if (!TYPE_PACKED (rli
->t
))
1227 warning (OPT_Wattributes
, "packed attribute is "
1228 "unnecessary for %q+D", field
);
1232 rli
->packed_maybe_necessary
= 1;
1235 /* Does this field automatically have alignment it needs by virtue
1236 of the fields that precede it and the record's own alignment? */
1237 if (known_align
< desired_align
)
1239 /* No, we need to skip space before this field.
1240 Bump the cumulative size to multiple of field alignment. */
1242 if (!targetm
.ms_bitfield_layout_p (rli
->t
)
1243 && DECL_SOURCE_LOCATION (field
) != BUILTINS_LOCATION
)
1244 warning (OPT_Wpadded
, "padding struct to align %q+D", field
);
1246 /* If the alignment is still within offset_align, just align
1247 the bit position. */
1248 if (desired_align
< rli
->offset_align
)
1249 rli
->bitpos
= round_up (rli
->bitpos
, desired_align
);
1252 /* First adjust OFFSET by the partial bits, then align. */
1254 = size_binop (PLUS_EXPR
, rli
->offset
,
1255 fold_convert (sizetype
,
1256 size_binop (CEIL_DIV_EXPR
, rli
->bitpos
,
1257 bitsize_unit_node
)));
1258 rli
->bitpos
= bitsize_zero_node
;
1260 rli
->offset
= round_up (rli
->offset
, desired_align
/ BITS_PER_UNIT
);
1263 if (! TREE_CONSTANT (rli
->offset
))
1264 rli
->offset_align
= desired_align
;
1265 if (targetm
.ms_bitfield_layout_p (rli
->t
))
1266 rli
->prev_field
= NULL
;
1269 /* Handle compatibility with PCC. Note that if the record has any
1270 variable-sized fields, we need not worry about compatibility. */
1271 #ifdef PCC_BITFIELD_TYPE_MATTERS
1272 if (PCC_BITFIELD_TYPE_MATTERS
1273 && ! targetm
.ms_bitfield_layout_p (rli
->t
)
1274 && TREE_CODE (field
) == FIELD_DECL
1275 && type
!= error_mark_node
1276 && DECL_BIT_FIELD (field
)
1277 && (! DECL_PACKED (field
)
1278 /* Enter for these packed fields only to issue a warning. */
1279 || TYPE_ALIGN (type
) <= BITS_PER_UNIT
)
1280 && maximum_field_alignment
== 0
1281 && ! integer_zerop (DECL_SIZE (field
))
1282 && tree_fits_uhwi_p (DECL_SIZE (field
))
1283 && tree_fits_uhwi_p (rli
->offset
)
1284 && tree_fits_uhwi_p (TYPE_SIZE (type
)))
1286 unsigned int type_align
= TYPE_ALIGN (type
);
1287 tree dsize
= DECL_SIZE (field
);
1288 HOST_WIDE_INT field_size
= tree_to_uhwi (dsize
);
1289 HOST_WIDE_INT offset
= tree_to_uhwi (rli
->offset
);
1290 HOST_WIDE_INT bit_offset
= tree_to_shwi (rli
->bitpos
);
1292 #ifdef ADJUST_FIELD_ALIGN
1293 if (! TYPE_USER_ALIGN (type
))
1294 type_align
= ADJUST_FIELD_ALIGN (field
, type_align
);
1297 /* A bit field may not span more units of alignment of its type
1298 than its type itself. Advance to next boundary if necessary. */
1299 if (excess_unit_span (offset
, bit_offset
, field_size
, type_align
, type
))
1301 if (DECL_PACKED (field
))
1303 if (warn_packed_bitfield_compat
== 1)
1306 "offset of packed bit-field %qD has changed in GCC 4.4",
1310 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1313 if (! DECL_PACKED (field
))
1314 TYPE_USER_ALIGN (rli
->t
) |= TYPE_USER_ALIGN (type
);
1318 #ifdef BITFIELD_NBYTES_LIMITED
1319 if (BITFIELD_NBYTES_LIMITED
1320 && ! targetm
.ms_bitfield_layout_p (rli
->t
)
1321 && TREE_CODE (field
) == FIELD_DECL
1322 && type
!= error_mark_node
1323 && DECL_BIT_FIELD_TYPE (field
)
1324 && ! DECL_PACKED (field
)
1325 && ! integer_zerop (DECL_SIZE (field
))
1326 && tree_fits_uhwi_p (DECL_SIZE (field
))
1327 && tree_fits_uhwi_p (rli
->offset
)
1328 && tree_fits_uhwi_p (TYPE_SIZE (type
)))
1330 unsigned int type_align
= TYPE_ALIGN (type
);
1331 tree dsize
= DECL_SIZE (field
);
1332 HOST_WIDE_INT field_size
= tree_to_uhwi (dsize
);
1333 HOST_WIDE_INT offset
= tree_to_uhwi (rli
->offset
);
1334 HOST_WIDE_INT bit_offset
= tree_to_shwi (rli
->bitpos
);
1336 #ifdef ADJUST_FIELD_ALIGN
1337 if (! TYPE_USER_ALIGN (type
))
1338 type_align
= ADJUST_FIELD_ALIGN (field
, type_align
);
1341 if (maximum_field_alignment
!= 0)
1342 type_align
= MIN (type_align
, maximum_field_alignment
);
1343 /* ??? This test is opposite the test in the containing if
1344 statement, so this code is unreachable currently. */
1345 else if (DECL_PACKED (field
))
1346 type_align
= MIN (type_align
, BITS_PER_UNIT
);
1348 /* A bit field may not span the unit of alignment of its type.
1349 Advance to next boundary if necessary. */
1350 if (excess_unit_span (offset
, bit_offset
, field_size
, type_align
, type
))
1351 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1353 TYPE_USER_ALIGN (rli
->t
) |= TYPE_USER_ALIGN (type
);
1357 /* See the docs for TARGET_MS_BITFIELD_LAYOUT_P for details.
1359 When a bit field is inserted into a packed record, the whole
1360 size of the underlying type is used by one or more same-size
1361 adjacent bitfields. (That is, if its long:3, 32 bits is
1362 used in the record, and any additional adjacent long bitfields are
1363 packed into the same chunk of 32 bits. However, if the size
1364 changes, a new field of that size is allocated.) In an unpacked
1365 record, this is the same as using alignment, but not equivalent
1368 Note: for compatibility, we use the type size, not the type alignment
1369 to determine alignment, since that matches the documentation */
1371 if (targetm
.ms_bitfield_layout_p (rli
->t
))
1373 tree prev_saved
= rli
->prev_field
;
1374 tree prev_type
= prev_saved
? DECL_BIT_FIELD_TYPE (prev_saved
) : NULL
;
1376 /* This is a bitfield if it exists. */
1377 if (rli
->prev_field
)
1379 /* If both are bitfields, nonzero, and the same size, this is
1380 the middle of a run. Zero declared size fields are special
1381 and handled as "end of run". (Note: it's nonzero declared
1382 size, but equal type sizes!) (Since we know that both
1383 the current and previous fields are bitfields by the
1384 time we check it, DECL_SIZE must be present for both.) */
1385 if (DECL_BIT_FIELD_TYPE (field
)
1386 && !integer_zerop (DECL_SIZE (field
))
1387 && !integer_zerop (DECL_SIZE (rli
->prev_field
))
1388 && tree_fits_shwi_p (DECL_SIZE (rli
->prev_field
))
1389 && tree_fits_uhwi_p (TYPE_SIZE (type
))
1390 && simple_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (prev_type
)))
1392 /* We're in the middle of a run of equal type size fields; make
1393 sure we realign if we run out of bits. (Not decl size,
1395 HOST_WIDE_INT bitsize
= tree_to_uhwi (DECL_SIZE (field
));
1397 if (rli
->remaining_in_alignment
< bitsize
)
1399 HOST_WIDE_INT typesize
= tree_to_uhwi (TYPE_SIZE (type
));
1401 /* out of bits; bump up to next 'word'. */
1403 = size_binop (PLUS_EXPR
, rli
->bitpos
,
1404 bitsize_int (rli
->remaining_in_alignment
));
1405 rli
->prev_field
= field
;
1406 if (typesize
< bitsize
)
1407 rli
->remaining_in_alignment
= 0;
1409 rli
->remaining_in_alignment
= typesize
- bitsize
;
1412 rli
->remaining_in_alignment
-= bitsize
;
1416 /* End of a run: if leaving a run of bitfields of the same type
1417 size, we have to "use up" the rest of the bits of the type
1420 Compute the new position as the sum of the size for the prior
1421 type and where we first started working on that type.
1422 Note: since the beginning of the field was aligned then
1423 of course the end will be too. No round needed. */
1425 if (!integer_zerop (DECL_SIZE (rli
->prev_field
)))
1428 = size_binop (PLUS_EXPR
, rli
->bitpos
,
1429 bitsize_int (rli
->remaining_in_alignment
));
1432 /* We "use up" size zero fields; the code below should behave
1433 as if the prior field was not a bitfield. */
1436 /* Cause a new bitfield to be captured, either this time (if
1437 currently a bitfield) or next time we see one. */
1438 if (!DECL_BIT_FIELD_TYPE (field
)
1439 || integer_zerop (DECL_SIZE (field
)))
1440 rli
->prev_field
= NULL
;
1443 normalize_rli (rli
);
1446 /* If we're starting a new run of same type size bitfields
1447 (or a run of non-bitfields), set up the "first of the run"
1450 That is, if the current field is not a bitfield, or if there
1451 was a prior bitfield the type sizes differ, or if there wasn't
1452 a prior bitfield the size of the current field is nonzero.
1454 Note: we must be sure to test ONLY the type size if there was
1455 a prior bitfield and ONLY for the current field being zero if
1458 if (!DECL_BIT_FIELD_TYPE (field
)
1459 || (prev_saved
!= NULL
1460 ? !simple_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (prev_type
))
1461 : !integer_zerop (DECL_SIZE (field
)) ))
1463 /* Never smaller than a byte for compatibility. */
1464 unsigned int type_align
= BITS_PER_UNIT
;
1466 /* (When not a bitfield), we could be seeing a flex array (with
1467 no DECL_SIZE). Since we won't be using remaining_in_alignment
1468 until we see a bitfield (and come by here again) we just skip
1470 if (DECL_SIZE (field
) != NULL
1471 && tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (field
)))
1472 && tree_fits_uhwi_p (DECL_SIZE (field
)))
1474 unsigned HOST_WIDE_INT bitsize
1475 = tree_to_uhwi (DECL_SIZE (field
));
1476 unsigned HOST_WIDE_INT typesize
1477 = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (field
)));
1479 if (typesize
< bitsize
)
1480 rli
->remaining_in_alignment
= 0;
1482 rli
->remaining_in_alignment
= typesize
- bitsize
;
1485 /* Now align (conventionally) for the new type. */
1486 type_align
= TYPE_ALIGN (TREE_TYPE (field
));
1488 if (maximum_field_alignment
!= 0)
1489 type_align
= MIN (type_align
, maximum_field_alignment
);
1491 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1493 /* If we really aligned, don't allow subsequent bitfields
1495 rli
->prev_field
= NULL
;
1499 /* Offset so far becomes the position of this field after normalizing. */
1500 normalize_rli (rli
);
1501 DECL_FIELD_OFFSET (field
) = rli
->offset
;
1502 DECL_FIELD_BIT_OFFSET (field
) = rli
->bitpos
;
1503 SET_DECL_OFFSET_ALIGN (field
, rli
->offset_align
);
1505 /* Evaluate nonconstant offsets only once, either now or as soon as safe. */
1506 if (TREE_CODE (DECL_FIELD_OFFSET (field
)) != INTEGER_CST
)
1507 DECL_FIELD_OFFSET (field
) = variable_size (DECL_FIELD_OFFSET (field
));
1509 /* If this field ended up more aligned than we thought it would be (we
1510 approximate this by seeing if its position changed), lay out the field
1511 again; perhaps we can use an integral mode for it now. */
1512 if (! integer_zerop (DECL_FIELD_BIT_OFFSET (field
)))
1513 actual_align
= (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field
))
1514 & - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field
)));
1515 else if (integer_zerop (DECL_FIELD_OFFSET (field
)))
1516 actual_align
= MAX (BIGGEST_ALIGNMENT
, rli
->record_align
);
1517 else if (tree_fits_uhwi_p (DECL_FIELD_OFFSET (field
)))
1518 actual_align
= (BITS_PER_UNIT
1519 * (tree_to_uhwi (DECL_FIELD_OFFSET (field
))
1520 & - tree_to_uhwi (DECL_FIELD_OFFSET (field
))));
1522 actual_align
= DECL_OFFSET_ALIGN (field
);
1523 /* ACTUAL_ALIGN is still the actual alignment *within the record* .
1524 store / extract bit field operations will check the alignment of the
1525 record against the mode of bit fields. */
1527 if (known_align
!= actual_align
)
1528 layout_decl (field
, actual_align
);
1530 if (rli
->prev_field
== NULL
&& DECL_BIT_FIELD_TYPE (field
))
1531 rli
->prev_field
= field
;
1533 /* Now add size of this field to the size of the record. If the size is
1534 not constant, treat the field as being a multiple of bytes and just
1535 adjust the offset, resetting the bit position. Otherwise, apportion the
1536 size amongst the bit position and offset. First handle the case of an
1537 unspecified size, which can happen when we have an invalid nested struct
1538 definition, such as struct j { struct j { int i; } }. The error message
1539 is printed in finish_struct. */
1540 if (DECL_SIZE (field
) == 0)
1542 else if (TREE_CODE (DECL_SIZE (field
)) != INTEGER_CST
1543 || TREE_OVERFLOW (DECL_SIZE (field
)))
1546 = size_binop (PLUS_EXPR
, rli
->offset
,
1547 fold_convert (sizetype
,
1548 size_binop (CEIL_DIV_EXPR
, rli
->bitpos
,
1549 bitsize_unit_node
)));
1551 = size_binop (PLUS_EXPR
, rli
->offset
, DECL_SIZE_UNIT (field
));
1552 rli
->bitpos
= bitsize_zero_node
;
1553 rli
->offset_align
= MIN (rli
->offset_align
, desired_align
);
1555 else if (targetm
.ms_bitfield_layout_p (rli
->t
))
1557 rli
->bitpos
= size_binop (PLUS_EXPR
, rli
->bitpos
, DECL_SIZE (field
));
1559 /* If we ended a bitfield before the full length of the type then
1560 pad the struct out to the full length of the last type. */
1561 if ((DECL_CHAIN (field
) == NULL
1562 || TREE_CODE (DECL_CHAIN (field
)) != FIELD_DECL
)
1563 && DECL_BIT_FIELD_TYPE (field
)
1564 && !integer_zerop (DECL_SIZE (field
)))
1565 rli
->bitpos
= size_binop (PLUS_EXPR
, rli
->bitpos
,
1566 bitsize_int (rli
->remaining_in_alignment
));
1568 normalize_rli (rli
);
1572 rli
->bitpos
= size_binop (PLUS_EXPR
, rli
->bitpos
, DECL_SIZE (field
));
1573 normalize_rli (rli
);
1577 /* Assuming that all the fields have been laid out, this function uses
1578 RLI to compute the final TYPE_SIZE, TYPE_ALIGN, etc. for the type
1579 indicated by RLI. */
1582 finalize_record_size (record_layout_info rli
)
1584 tree unpadded_size
, unpadded_size_unit
;
1586 /* Now we want just byte and bit offsets, so set the offset alignment
1587 to be a byte and then normalize. */
1588 rli
->offset_align
= BITS_PER_UNIT
;
1589 normalize_rli (rli
);
1591 /* Determine the desired alignment. */
1592 #ifdef ROUND_TYPE_ALIGN
1593 TYPE_ALIGN (rli
->t
) = ROUND_TYPE_ALIGN (rli
->t
, TYPE_ALIGN (rli
->t
),
1596 TYPE_ALIGN (rli
->t
) = MAX (TYPE_ALIGN (rli
->t
), rli
->record_align
);
1599 /* Compute the size so far. Be sure to allow for extra bits in the
1600 size in bytes. We have guaranteed above that it will be no more
1601 than a single byte. */
1602 unpadded_size
= rli_size_so_far (rli
);
1603 unpadded_size_unit
= rli_size_unit_so_far (rli
);
1604 if (! integer_zerop (rli
->bitpos
))
1606 = size_binop (PLUS_EXPR
, unpadded_size_unit
, size_one_node
);
1608 if (TREE_CODE (unpadded_size_unit
) == INTEGER_CST
1609 && !TREE_OVERFLOW (unpadded_size_unit
)
1610 && !valid_constant_size_p (unpadded_size_unit
))
1611 error ("type %qT is too large", rli
->t
);
1613 /* Round the size up to be a multiple of the required alignment. */
1614 TYPE_SIZE (rli
->t
) = round_up (unpadded_size
, TYPE_ALIGN (rli
->t
));
1615 TYPE_SIZE_UNIT (rli
->t
)
1616 = round_up (unpadded_size_unit
, TYPE_ALIGN_UNIT (rli
->t
));
1618 if (TREE_CONSTANT (unpadded_size
)
1619 && simple_cst_equal (unpadded_size
, TYPE_SIZE (rli
->t
)) == 0
1620 && input_location
!= BUILTINS_LOCATION
)
1621 warning (OPT_Wpadded
, "padding struct size to alignment boundary");
1623 if (warn_packed
&& TREE_CODE (rli
->t
) == RECORD_TYPE
1624 && TYPE_PACKED (rli
->t
) && ! rli
->packed_maybe_necessary
1625 && TREE_CONSTANT (unpadded_size
))
1629 #ifdef ROUND_TYPE_ALIGN
1631 = ROUND_TYPE_ALIGN (rli
->t
, TYPE_ALIGN (rli
->t
), rli
->unpacked_align
);
1633 rli
->unpacked_align
= MAX (TYPE_ALIGN (rli
->t
), rli
->unpacked_align
);
1636 unpacked_size
= round_up (TYPE_SIZE (rli
->t
), rli
->unpacked_align
);
1637 if (simple_cst_equal (unpacked_size
, TYPE_SIZE (rli
->t
)))
1639 if (TYPE_NAME (rli
->t
))
1643 if (TREE_CODE (TYPE_NAME (rli
->t
)) == IDENTIFIER_NODE
)
1644 name
= TYPE_NAME (rli
->t
);
1646 name
= DECL_NAME (TYPE_NAME (rli
->t
));
1648 if (STRICT_ALIGNMENT
)
1649 warning (OPT_Wpacked
, "packed attribute causes inefficient "
1650 "alignment for %qE", name
);
1652 warning (OPT_Wpacked
,
1653 "packed attribute is unnecessary for %qE", name
);
1657 if (STRICT_ALIGNMENT
)
1658 warning (OPT_Wpacked
,
1659 "packed attribute causes inefficient alignment");
1661 warning (OPT_Wpacked
, "packed attribute is unnecessary");
1667 /* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE). */
1670 compute_record_mode (tree type
)
1673 enum machine_mode mode
= VOIDmode
;
1675 /* Most RECORD_TYPEs have BLKmode, so we start off assuming that.
1676 However, if possible, we use a mode that fits in a register
1677 instead, in order to allow for better optimization down the
1679 SET_TYPE_MODE (type
, BLKmode
);
1681 if (! tree_fits_uhwi_p (TYPE_SIZE (type
)))
1684 /* A record which has any BLKmode members must itself be
1685 BLKmode; it can't go in a register. Unless the member is
1686 BLKmode only because it isn't aligned. */
1687 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1689 if (TREE_CODE (field
) != FIELD_DECL
)
1692 if (TREE_CODE (TREE_TYPE (field
)) == ERROR_MARK
1693 || (TYPE_MODE (TREE_TYPE (field
)) == BLKmode
1694 && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field
))
1695 && !(TYPE_SIZE (TREE_TYPE (field
)) != 0
1696 && integer_zerop (TYPE_SIZE (TREE_TYPE (field
)))))
1697 || ! tree_fits_uhwi_p (bit_position (field
))
1698 || DECL_SIZE (field
) == 0
1699 || ! tree_fits_uhwi_p (DECL_SIZE (field
)))
1702 /* If this field is the whole struct, remember its mode so
1703 that, say, we can put a double in a class into a DF
1704 register instead of forcing it to live in the stack. */
1705 if (simple_cst_equal (TYPE_SIZE (type
), DECL_SIZE (field
)))
1706 mode
= DECL_MODE (field
);
1708 /* With some targets, it is sub-optimal to access an aligned
1709 BLKmode structure as a scalar. */
1710 if (targetm
.member_type_forces_blk (field
, mode
))
1714 /* If we only have one real field; use its mode if that mode's size
1715 matches the type's size. This only applies to RECORD_TYPE. This
1716 does not apply to unions. */
1717 if (TREE_CODE (type
) == RECORD_TYPE
&& mode
!= VOIDmode
1718 && tree_fits_uhwi_p (TYPE_SIZE (type
))
1719 && GET_MODE_BITSIZE (mode
) == tree_to_uhwi (TYPE_SIZE (type
)))
1720 SET_TYPE_MODE (type
, mode
);
1722 SET_TYPE_MODE (type
, mode_for_size_tree (TYPE_SIZE (type
), MODE_INT
, 1));
1724 /* If structure's known alignment is less than what the scalar
1725 mode would need, and it matters, then stick with BLKmode. */
1726 if (TYPE_MODE (type
) != BLKmode
1728 && ! (TYPE_ALIGN (type
) >= BIGGEST_ALIGNMENT
1729 || TYPE_ALIGN (type
) >= GET_MODE_ALIGNMENT (TYPE_MODE (type
))))
1731 /* If this is the only reason this type is BLKmode, then
1732 don't force containing types to be BLKmode. */
1733 TYPE_NO_FORCE_BLK (type
) = 1;
1734 SET_TYPE_MODE (type
, BLKmode
);
1738 /* Compute TYPE_SIZE and TYPE_ALIGN for TYPE, once it has been laid
1742 finalize_type_size (tree type
)
1744 /* Normally, use the alignment corresponding to the mode chosen.
1745 However, where strict alignment is not required, avoid
1746 over-aligning structures, since most compilers do not do this
1749 if (TYPE_MODE (type
) != BLKmode
&& TYPE_MODE (type
) != VOIDmode
1750 && (STRICT_ALIGNMENT
1751 || (TREE_CODE (type
) != RECORD_TYPE
&& TREE_CODE (type
) != UNION_TYPE
1752 && TREE_CODE (type
) != QUAL_UNION_TYPE
1753 && TREE_CODE (type
) != ARRAY_TYPE
)))
1755 unsigned mode_align
= GET_MODE_ALIGNMENT (TYPE_MODE (type
));
1757 /* Don't override a larger alignment requirement coming from a user
1758 alignment of one of the fields. */
1759 if (mode_align
>= TYPE_ALIGN (type
))
1761 TYPE_ALIGN (type
) = mode_align
;
1762 TYPE_USER_ALIGN (type
) = 0;
1766 /* Do machine-dependent extra alignment. */
1767 #ifdef ROUND_TYPE_ALIGN
1769 = ROUND_TYPE_ALIGN (type
, TYPE_ALIGN (type
), BITS_PER_UNIT
);
1772 /* If we failed to find a simple way to calculate the unit size
1773 of the type, find it by division. */
1774 if (TYPE_SIZE_UNIT (type
) == 0 && TYPE_SIZE (type
) != 0)
1775 /* TYPE_SIZE (type) is computed in bitsizetype. After the division, the
1776 result will fit in sizetype. We will get more efficient code using
1777 sizetype, so we force a conversion. */
1778 TYPE_SIZE_UNIT (type
)
1779 = fold_convert (sizetype
,
1780 size_binop (FLOOR_DIV_EXPR
, TYPE_SIZE (type
),
1781 bitsize_unit_node
));
1783 if (TYPE_SIZE (type
) != 0)
1785 TYPE_SIZE (type
) = round_up (TYPE_SIZE (type
), TYPE_ALIGN (type
));
1786 TYPE_SIZE_UNIT (type
)
1787 = round_up (TYPE_SIZE_UNIT (type
), TYPE_ALIGN_UNIT (type
));
1790 /* Evaluate nonconstant sizes only once, either now or as soon as safe. */
1791 if (TYPE_SIZE (type
) != 0 && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1792 TYPE_SIZE (type
) = variable_size (TYPE_SIZE (type
));
1793 if (TYPE_SIZE_UNIT (type
) != 0
1794 && TREE_CODE (TYPE_SIZE_UNIT (type
)) != INTEGER_CST
)
1795 TYPE_SIZE_UNIT (type
) = variable_size (TYPE_SIZE_UNIT (type
));
1797 /* Also layout any other variants of the type. */
1798 if (TYPE_NEXT_VARIANT (type
)
1799 || type
!= TYPE_MAIN_VARIANT (type
))
1802 /* Record layout info of this variant. */
1803 tree size
= TYPE_SIZE (type
);
1804 tree size_unit
= TYPE_SIZE_UNIT (type
);
1805 unsigned int align
= TYPE_ALIGN (type
);
1806 unsigned int precision
= TYPE_PRECISION (type
);
1807 unsigned int user_align
= TYPE_USER_ALIGN (type
);
1808 enum machine_mode mode
= TYPE_MODE (type
);
1810 /* Copy it into all variants. */
1811 for (variant
= TYPE_MAIN_VARIANT (type
);
1813 variant
= TYPE_NEXT_VARIANT (variant
))
1815 TYPE_SIZE (variant
) = size
;
1816 TYPE_SIZE_UNIT (variant
) = size_unit
;
1817 TYPE_ALIGN (variant
) = align
;
1818 TYPE_PRECISION (variant
) = precision
;
1819 TYPE_USER_ALIGN (variant
) = user_align
;
1820 SET_TYPE_MODE (variant
, mode
);
1825 /* Return a new underlying object for a bitfield started with FIELD. */
1828 start_bitfield_representative (tree field
)
1830 tree repr
= make_node (FIELD_DECL
);
1831 DECL_FIELD_OFFSET (repr
) = DECL_FIELD_OFFSET (field
);
1832 /* Force the representative to begin at a BITS_PER_UNIT aligned
1833 boundary - C++ may use tail-padding of a base object to
1834 continue packing bits so the bitfield region does not start
1835 at bit zero (see g++.dg/abi/bitfield5.C for example).
1836 Unallocated bits may happen for other reasons as well,
1837 for example Ada which allows explicit bit-granular structure layout. */
1838 DECL_FIELD_BIT_OFFSET (repr
)
1839 = size_binop (BIT_AND_EXPR
,
1840 DECL_FIELD_BIT_OFFSET (field
),
1841 bitsize_int (~(BITS_PER_UNIT
- 1)));
1842 SET_DECL_OFFSET_ALIGN (repr
, DECL_OFFSET_ALIGN (field
));
1843 DECL_SIZE (repr
) = DECL_SIZE (field
);
1844 DECL_SIZE_UNIT (repr
) = DECL_SIZE_UNIT (field
);
1845 DECL_PACKED (repr
) = DECL_PACKED (field
);
1846 DECL_CONTEXT (repr
) = DECL_CONTEXT (field
);
1850 /* Finish up a bitfield group that was started by creating the underlying
1851 object REPR with the last field in the bitfield group FIELD. */
1854 finish_bitfield_representative (tree repr
, tree field
)
1856 unsigned HOST_WIDE_INT bitsize
, maxbitsize
;
1857 enum machine_mode mode
;
1860 size
= size_diffop (DECL_FIELD_OFFSET (field
),
1861 DECL_FIELD_OFFSET (repr
));
1862 gcc_assert (tree_fits_uhwi_p (size
));
1863 bitsize
= (tree_to_uhwi (size
) * BITS_PER_UNIT
1864 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field
))
1865 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr
))
1866 + tree_to_uhwi (DECL_SIZE (field
)));
1868 /* Round up bitsize to multiples of BITS_PER_UNIT. */
1869 bitsize
= (bitsize
+ BITS_PER_UNIT
- 1) & ~(BITS_PER_UNIT
- 1);
1871 /* Now nothing tells us how to pad out bitsize ... */
1872 nextf
= DECL_CHAIN (field
);
1873 while (nextf
&& TREE_CODE (nextf
) != FIELD_DECL
)
1874 nextf
= DECL_CHAIN (nextf
);
1878 /* If there was an error, the field may be not laid out
1879 correctly. Don't bother to do anything. */
1880 if (TREE_TYPE (nextf
) == error_mark_node
)
1882 maxsize
= size_diffop (DECL_FIELD_OFFSET (nextf
),
1883 DECL_FIELD_OFFSET (repr
));
1884 if (tree_fits_uhwi_p (maxsize
))
1886 maxbitsize
= (tree_to_uhwi (maxsize
) * BITS_PER_UNIT
1887 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (nextf
))
1888 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr
)));
1889 /* If the group ends within a bitfield nextf does not need to be
1890 aligned to BITS_PER_UNIT. Thus round up. */
1891 maxbitsize
= (maxbitsize
+ BITS_PER_UNIT
- 1) & ~(BITS_PER_UNIT
- 1);
1894 maxbitsize
= bitsize
;
1898 /* ??? If you consider that tail-padding of this struct might be
1899 re-used when deriving from it we cannot really do the following
1900 and thus need to set maxsize to bitsize? Also we cannot
1901 generally rely on maxsize to fold to an integer constant, so
1902 use bitsize as fallback for this case. */
1903 tree maxsize
= size_diffop (TYPE_SIZE_UNIT (DECL_CONTEXT (field
)),
1904 DECL_FIELD_OFFSET (repr
));
1905 if (tree_fits_uhwi_p (maxsize
))
1906 maxbitsize
= (tree_to_uhwi (maxsize
) * BITS_PER_UNIT
1907 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr
)));
1909 maxbitsize
= bitsize
;
1912 /* Only if we don't artificially break up the representative in
1913 the middle of a large bitfield with different possibly
1914 overlapping representatives. And all representatives start
1916 gcc_assert (maxbitsize
% BITS_PER_UNIT
== 0);
1918 /* Find the smallest nice mode to use. */
1919 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_INT
); mode
!= VOIDmode
;
1920 mode
= GET_MODE_WIDER_MODE (mode
))
1921 if (GET_MODE_BITSIZE (mode
) >= bitsize
)
1923 if (mode
!= VOIDmode
1924 && (GET_MODE_BITSIZE (mode
) > maxbitsize
1925 || GET_MODE_BITSIZE (mode
) > MAX_FIXED_MODE_SIZE
))
1928 if (mode
== VOIDmode
)
1930 /* We really want a BLKmode representative only as a last resort,
1931 considering the member b in
1932 struct { int a : 7; int b : 17; int c; } __attribute__((packed));
1933 Otherwise we simply want to split the representative up
1934 allowing for overlaps within the bitfield region as required for
1935 struct { int a : 7; int b : 7;
1936 int c : 10; int d; } __attribute__((packed));
1937 [0, 15] HImode for a and b, [8, 23] HImode for c. */
1938 DECL_SIZE (repr
) = bitsize_int (bitsize
);
1939 DECL_SIZE_UNIT (repr
) = size_int (bitsize
/ BITS_PER_UNIT
);
1940 DECL_MODE (repr
) = BLKmode
;
1941 TREE_TYPE (repr
) = build_array_type_nelts (unsigned_char_type_node
,
1942 bitsize
/ BITS_PER_UNIT
);
1946 unsigned HOST_WIDE_INT modesize
= GET_MODE_BITSIZE (mode
);
1947 DECL_SIZE (repr
) = bitsize_int (modesize
);
1948 DECL_SIZE_UNIT (repr
) = size_int (modesize
/ BITS_PER_UNIT
);
1949 DECL_MODE (repr
) = mode
;
1950 TREE_TYPE (repr
) = lang_hooks
.types
.type_for_mode (mode
, 1);
1953 /* Remember whether the bitfield group is at the end of the
1954 structure or not. */
1955 DECL_CHAIN (repr
) = nextf
;
1958 /* Compute and set FIELD_DECLs for the underlying objects we should
1959 use for bitfield access for the structure laid out with RLI. */
1962 finish_bitfield_layout (record_layout_info rli
)
1965 tree repr
= NULL_TREE
;
1967 /* Unions would be special, for the ease of type-punning optimizations
1968 we could use the underlying type as hint for the representative
1969 if the bitfield would fit and the representative would not exceed
1970 the union in size. */
1971 if (TREE_CODE (rli
->t
) != RECORD_TYPE
)
1974 for (prev
= NULL_TREE
, field
= TYPE_FIELDS (rli
->t
);
1975 field
; field
= DECL_CHAIN (field
))
1977 if (TREE_CODE (field
) != FIELD_DECL
)
1980 /* In the C++ memory model, consecutive bit fields in a structure are
1981 considered one memory location and updating a memory location
1982 may not store into adjacent memory locations. */
1984 && DECL_BIT_FIELD_TYPE (field
))
1986 /* Start new representative. */
1987 repr
= start_bitfield_representative (field
);
1990 && ! DECL_BIT_FIELD_TYPE (field
))
1992 /* Finish off new representative. */
1993 finish_bitfield_representative (repr
, prev
);
1996 else if (DECL_BIT_FIELD_TYPE (field
))
1998 gcc_assert (repr
!= NULL_TREE
);
2000 /* Zero-size bitfields finish off a representative and
2001 do not have a representative themselves. This is
2002 required by the C++ memory model. */
2003 if (integer_zerop (DECL_SIZE (field
)))
2005 finish_bitfield_representative (repr
, prev
);
2009 /* We assume that either DECL_FIELD_OFFSET of the representative
2010 and each bitfield member is a constant or they are equal.
2011 This is because we need to be able to compute the bit-offset
2012 of each field relative to the representative in get_bit_range
2013 during RTL expansion.
2014 If these constraints are not met, simply force a new
2015 representative to be generated. That will at most
2016 generate worse code but still maintain correctness with
2017 respect to the C++ memory model. */
2018 else if (!((tree_fits_uhwi_p (DECL_FIELD_OFFSET (repr
))
2019 && tree_fits_uhwi_p (DECL_FIELD_OFFSET (field
)))
2020 || operand_equal_p (DECL_FIELD_OFFSET (repr
),
2021 DECL_FIELD_OFFSET (field
), 0)))
2023 finish_bitfield_representative (repr
, prev
);
2024 repr
= start_bitfield_representative (field
);
2031 DECL_BIT_FIELD_REPRESENTATIVE (field
) = repr
;
2037 finish_bitfield_representative (repr
, prev
);
2040 /* Do all of the work required to layout the type indicated by RLI,
2041 once the fields have been laid out. This function will call `free'
2042 for RLI, unless FREE_P is false. Passing a value other than false
2043 for FREE_P is bad practice; this option only exists to support the
2047 finish_record_layout (record_layout_info rli
, int free_p
)
2051 /* Compute the final size. */
2052 finalize_record_size (rli
);
2054 /* Compute the TYPE_MODE for the record. */
2055 compute_record_mode (rli
->t
);
2057 /* Perform any last tweaks to the TYPE_SIZE, etc. */
2058 finalize_type_size (rli
->t
);
2060 /* Compute bitfield representatives. */
2061 finish_bitfield_layout (rli
);
2063 /* Propagate TYPE_PACKED to variants. With C++ templates,
2064 handle_packed_attribute is too early to do this. */
2065 for (variant
= TYPE_NEXT_VARIANT (rli
->t
); variant
;
2066 variant
= TYPE_NEXT_VARIANT (variant
))
2067 TYPE_PACKED (variant
) = TYPE_PACKED (rli
->t
);
2069 /* Lay out any static members. This is done now because their type
2070 may use the record's type. */
2071 while (!vec_safe_is_empty (rli
->pending_statics
))
2072 layout_decl (rli
->pending_statics
->pop (), 0);
2077 vec_free (rli
->pending_statics
);
2083 /* Finish processing a builtin RECORD_TYPE type TYPE. It's name is
2084 NAME, its fields are chained in reverse on FIELDS.
2086 If ALIGN_TYPE is non-null, it is given the same alignment as
2090 finish_builtin_struct (tree type
, const char *name
, tree fields
,
2095 for (tail
= NULL_TREE
; fields
; tail
= fields
, fields
= next
)
2097 DECL_FIELD_CONTEXT (fields
) = type
;
2098 next
= DECL_CHAIN (fields
);
2099 DECL_CHAIN (fields
) = tail
;
2101 TYPE_FIELDS (type
) = tail
;
2105 TYPE_ALIGN (type
) = TYPE_ALIGN (align_type
);
2106 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (align_type
);
2110 #if 0 /* not yet, should get fixed properly later */
2111 TYPE_NAME (type
) = make_type_decl (get_identifier (name
), type
);
2113 TYPE_NAME (type
) = build_decl (BUILTINS_LOCATION
,
2114 TYPE_DECL
, get_identifier (name
), type
);
2116 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
2117 layout_decl (TYPE_NAME (type
), 0);
2120 /* Calculate the mode, size, and alignment for TYPE.
2121 For an array type, calculate the element separation as well.
2122 Record TYPE on the chain of permanent or temporary types
2123 so that dbxout will find out about it.
2125 TYPE_SIZE of a type is nonzero if the type has been laid out already.
2126 layout_type does nothing on such a type.
2128 If the type is incomplete, its TYPE_SIZE remains zero. */
2131 layout_type (tree type
)
2135 if (type
== error_mark_node
)
2138 /* Do nothing if type has been laid out before. */
2139 if (TYPE_SIZE (type
))
2142 switch (TREE_CODE (type
))
2145 /* This kind of type is the responsibility
2146 of the language-specific code. */
2152 SET_TYPE_MODE (type
,
2153 smallest_mode_for_size (TYPE_PRECISION (type
), MODE_INT
));
2154 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2155 /* Don't set TYPE_PRECISION here, as it may be set by a bitfield. */
2156 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2160 SET_TYPE_MODE (type
,
2161 mode_for_size (TYPE_PRECISION (type
), MODE_FLOAT
, 0));
2162 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2163 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2166 case FIXED_POINT_TYPE
:
2167 /* TYPE_MODE (type) has been set already. */
2168 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2169 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2173 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TREE_TYPE (type
));
2174 SET_TYPE_MODE (type
,
2175 mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type
)),
2176 (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
2177 ? MODE_COMPLEX_FLOAT
: MODE_COMPLEX_INT
),
2179 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2180 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2185 int nunits
= TYPE_VECTOR_SUBPARTS (type
);
2186 tree innertype
= TREE_TYPE (type
);
2188 gcc_assert (!(nunits
& (nunits
- 1)));
2190 /* Find an appropriate mode for the vector type. */
2191 if (TYPE_MODE (type
) == VOIDmode
)
2192 SET_TYPE_MODE (type
,
2193 mode_for_vector (TYPE_MODE (innertype
), nunits
));
2195 TYPE_SATURATING (type
) = TYPE_SATURATING (TREE_TYPE (type
));
2196 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TREE_TYPE (type
));
2197 TYPE_SIZE_UNIT (type
) = int_const_binop (MULT_EXPR
,
2198 TYPE_SIZE_UNIT (innertype
),
2200 TYPE_SIZE (type
) = int_const_binop (MULT_EXPR
, TYPE_SIZE (innertype
),
2201 bitsize_int (nunits
));
2203 /* For vector types, we do not default to the mode's alignment.
2204 Instead, query a target hook, defaulting to natural alignment.
2205 This prevents ABI changes depending on whether or not native
2206 vector modes are supported. */
2207 TYPE_ALIGN (type
) = targetm
.vector_alignment (type
);
2209 /* However, if the underlying mode requires a bigger alignment than
2210 what the target hook provides, we cannot use the mode. For now,
2211 simply reject that case. */
2212 gcc_assert (TYPE_ALIGN (type
)
2213 >= GET_MODE_ALIGNMENT (TYPE_MODE (type
)));
2218 /* This is an incomplete type and so doesn't have a size. */
2219 TYPE_ALIGN (type
) = 1;
2220 TYPE_USER_ALIGN (type
) = 0;
2221 SET_TYPE_MODE (type
, VOIDmode
);
2225 TYPE_SIZE (type
) = bitsize_int (POINTER_SIZE
);
2226 TYPE_SIZE_UNIT (type
) = size_int (POINTER_SIZE_UNITS
);
2227 /* A pointer might be MODE_PARTIAL_INT, but ptrdiff_t must be
2228 integral, which may be an __intN. */
2229 SET_TYPE_MODE (type
, mode_for_size (POINTER_SIZE
, MODE_INT
, 0));
2230 TYPE_PRECISION (type
) = POINTER_SIZE
;
2235 /* It's hard to see what the mode and size of a function ought to
2236 be, but we do know the alignment is FUNCTION_BOUNDARY, so
2237 make it consistent with that. */
2238 SET_TYPE_MODE (type
, mode_for_size (FUNCTION_BOUNDARY
, MODE_INT
, 0));
2239 TYPE_SIZE (type
) = bitsize_int (FUNCTION_BOUNDARY
);
2240 TYPE_SIZE_UNIT (type
) = size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
2244 case REFERENCE_TYPE
:
2246 enum machine_mode mode
= TYPE_MODE (type
);
2247 if (TREE_CODE (type
) == REFERENCE_TYPE
&& reference_types_internal
)
2249 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (type
));
2250 mode
= targetm
.addr_space
.address_mode (as
);
2253 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (mode
));
2254 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (mode
));
2255 TYPE_UNSIGNED (type
) = 1;
2256 TYPE_PRECISION (type
) = GET_MODE_PRECISION (mode
);
2262 tree index
= TYPE_DOMAIN (type
);
2263 tree element
= TREE_TYPE (type
);
2265 build_pointer_type (element
);
2267 /* We need to know both bounds in order to compute the size. */
2268 if (index
&& TYPE_MAX_VALUE (index
) && TYPE_MIN_VALUE (index
)
2269 && TYPE_SIZE (element
))
2271 tree ub
= TYPE_MAX_VALUE (index
);
2272 tree lb
= TYPE_MIN_VALUE (index
);
2273 tree element_size
= TYPE_SIZE (element
);
2276 /* Make sure that an array of zero-sized element is zero-sized
2277 regardless of its extent. */
2278 if (integer_zerop (element_size
))
2279 length
= size_zero_node
;
2281 /* The computation should happen in the original signedness so
2282 that (possible) negative values are handled appropriately
2283 when determining overflow. */
2286 /* ??? When it is obvious that the range is signed
2287 represent it using ssizetype. */
2288 if (TREE_CODE (lb
) == INTEGER_CST
2289 && TREE_CODE (ub
) == INTEGER_CST
2290 && TYPE_UNSIGNED (TREE_TYPE (lb
))
2291 && tree_int_cst_lt (ub
, lb
))
2293 lb
= wide_int_to_tree (ssizetype
,
2294 offset_int::from (lb
, SIGNED
));
2295 ub
= wide_int_to_tree (ssizetype
,
2296 offset_int::from (ub
, SIGNED
));
2299 = fold_convert (sizetype
,
2300 size_binop (PLUS_EXPR
,
2301 build_int_cst (TREE_TYPE (lb
), 1),
2302 size_binop (MINUS_EXPR
, ub
, lb
)));
2305 /* ??? We have no way to distinguish a null-sized array from an
2306 array spanning the whole sizetype range, so we arbitrarily
2307 decide that [0, -1] is the only valid representation. */
2308 if (integer_zerop (length
)
2309 && TREE_OVERFLOW (length
)
2310 && integer_zerop (lb
))
2311 length
= size_zero_node
;
2313 TYPE_SIZE (type
) = size_binop (MULT_EXPR
, element_size
,
2314 fold_convert (bitsizetype
,
2317 /* If we know the size of the element, calculate the total size
2318 directly, rather than do some division thing below. This
2319 optimization helps Fortran assumed-size arrays (where the
2320 size of the array is determined at runtime) substantially. */
2321 if (TYPE_SIZE_UNIT (element
))
2322 TYPE_SIZE_UNIT (type
)
2323 = size_binop (MULT_EXPR
, TYPE_SIZE_UNIT (element
), length
);
2326 /* Now round the alignment and size,
2327 using machine-dependent criteria if any. */
2329 #ifdef ROUND_TYPE_ALIGN
2331 = ROUND_TYPE_ALIGN (type
, TYPE_ALIGN (element
), BITS_PER_UNIT
);
2333 TYPE_ALIGN (type
) = MAX (TYPE_ALIGN (element
), BITS_PER_UNIT
);
2335 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (element
);
2336 SET_TYPE_MODE (type
, BLKmode
);
2337 if (TYPE_SIZE (type
) != 0
2338 && ! targetm
.member_type_forces_blk (type
, VOIDmode
)
2339 /* BLKmode elements force BLKmode aggregate;
2340 else extract/store fields may lose. */
2341 && (TYPE_MODE (TREE_TYPE (type
)) != BLKmode
2342 || TYPE_NO_FORCE_BLK (TREE_TYPE (type
))))
2344 SET_TYPE_MODE (type
, mode_for_array (TREE_TYPE (type
),
2346 if (TYPE_MODE (type
) != BLKmode
2347 && STRICT_ALIGNMENT
&& TYPE_ALIGN (type
) < BIGGEST_ALIGNMENT
2348 && TYPE_ALIGN (type
) < GET_MODE_ALIGNMENT (TYPE_MODE (type
)))
2350 TYPE_NO_FORCE_BLK (type
) = 1;
2351 SET_TYPE_MODE (type
, BLKmode
);
2354 /* When the element size is constant, check that it is at least as
2355 large as the element alignment. */
2356 if (TYPE_SIZE_UNIT (element
)
2357 && TREE_CODE (TYPE_SIZE_UNIT (element
)) == INTEGER_CST
2358 /* If TYPE_SIZE_UNIT overflowed, then it is certainly larger than
2360 && !TREE_OVERFLOW (TYPE_SIZE_UNIT (element
))
2361 && !integer_zerop (TYPE_SIZE_UNIT (element
))
2362 && compare_tree_int (TYPE_SIZE_UNIT (element
),
2363 TYPE_ALIGN_UNIT (element
)) < 0)
2364 error ("alignment of array elements is greater than element size");
2370 case QUAL_UNION_TYPE
:
2373 record_layout_info rli
;
2375 /* Initialize the layout information. */
2376 rli
= start_record_layout (type
);
2378 /* If this is a QUAL_UNION_TYPE, we want to process the fields
2379 in the reverse order in building the COND_EXPR that denotes
2380 its size. We reverse them again later. */
2381 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
2382 TYPE_FIELDS (type
) = nreverse (TYPE_FIELDS (type
));
2384 /* Place all the fields. */
2385 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
2386 place_field (rli
, field
);
2388 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
2389 TYPE_FIELDS (type
) = nreverse (TYPE_FIELDS (type
));
2391 /* Finish laying out the record. */
2392 finish_record_layout (rli
, /*free_p=*/true);
2400 /* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE. For
2401 records and unions, finish_record_layout already called this
2403 if (TREE_CODE (type
) != RECORD_TYPE
2404 && TREE_CODE (type
) != UNION_TYPE
2405 && TREE_CODE (type
) != QUAL_UNION_TYPE
)
2406 finalize_type_size (type
);
2408 /* We should never see alias sets on incomplete aggregates. And we
2409 should not call layout_type on not incomplete aggregates. */
2410 if (AGGREGATE_TYPE_P (type
))
2411 gcc_assert (!TYPE_ALIAS_SET_KNOWN_P (type
));
2414 /* Return the least alignment required for type TYPE. */
2417 min_align_of_type (tree type
)
2419 unsigned int align
= TYPE_ALIGN (type
);
2420 align
= MIN (align
, BIGGEST_ALIGNMENT
);
2421 if (!TYPE_USER_ALIGN (type
))
2423 #ifdef BIGGEST_FIELD_ALIGNMENT
2424 align
= MIN (align
, BIGGEST_FIELD_ALIGNMENT
);
2426 unsigned int field_align
= align
;
2427 #ifdef ADJUST_FIELD_ALIGN
2428 tree field
= build_decl (UNKNOWN_LOCATION
, FIELD_DECL
, NULL_TREE
, type
);
2429 field_align
= ADJUST_FIELD_ALIGN (field
, field_align
);
2432 align
= MIN (align
, field_align
);
2434 return align
/ BITS_PER_UNIT
;
2437 /* Vector types need to re-check the target flags each time we report
2438 the machine mode. We need to do this because attribute target can
2439 change the result of vector_mode_supported_p and have_regs_of_mode
2440 on a per-function basis. Thus the TYPE_MODE of a VECTOR_TYPE can
2441 change on a per-function basis. */
2442 /* ??? Possibly a better solution is to run through all the types
2443 referenced by a function and re-compute the TYPE_MODE once, rather
2444 than make the TYPE_MODE macro call a function. */
2447 vector_type_mode (const_tree t
)
2449 enum machine_mode mode
;
2451 gcc_assert (TREE_CODE (t
) == VECTOR_TYPE
);
2453 mode
= t
->type_common
.mode
;
2454 if (VECTOR_MODE_P (mode
)
2455 && (!targetm
.vector_mode_supported_p (mode
)
2456 || !have_regs_of_mode
[mode
]))
2458 enum machine_mode innermode
= TREE_TYPE (t
)->type_common
.mode
;
2460 /* For integers, try mapping it to a same-sized scalar mode. */
2461 if (GET_MODE_CLASS (innermode
) == MODE_INT
)
2463 mode
= mode_for_size (TYPE_VECTOR_SUBPARTS (t
)
2464 * GET_MODE_BITSIZE (innermode
), MODE_INT
, 0);
2466 if (mode
!= VOIDmode
&& have_regs_of_mode
[mode
])
2476 /* Create and return a type for signed integers of PRECISION bits. */
2479 make_signed_type (int precision
)
2481 tree type
= make_node (INTEGER_TYPE
);
2483 TYPE_PRECISION (type
) = precision
;
2485 fixup_signed_type (type
);
2489 /* Create and return a type for unsigned integers of PRECISION bits. */
2492 make_unsigned_type (int precision
)
2494 tree type
= make_node (INTEGER_TYPE
);
2496 TYPE_PRECISION (type
) = precision
;
2498 fixup_unsigned_type (type
);
2502 /* Create and return a type for fract of PRECISION bits, UNSIGNEDP,
2506 make_fract_type (int precision
, int unsignedp
, int satp
)
2508 tree type
= make_node (FIXED_POINT_TYPE
);
2510 TYPE_PRECISION (type
) = precision
;
2513 TYPE_SATURATING (type
) = 1;
2515 /* Lay out the type: set its alignment, size, etc. */
2518 TYPE_UNSIGNED (type
) = 1;
2519 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_UFRACT
, 0));
2522 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_FRACT
, 0));
2528 /* Create and return a type for accum of PRECISION bits, UNSIGNEDP,
2532 make_accum_type (int precision
, int unsignedp
, int satp
)
2534 tree type
= make_node (FIXED_POINT_TYPE
);
2536 TYPE_PRECISION (type
) = precision
;
2539 TYPE_SATURATING (type
) = 1;
2541 /* Lay out the type: set its alignment, size, etc. */
2544 TYPE_UNSIGNED (type
) = 1;
2545 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_UACCUM
, 0));
2548 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_ACCUM
, 0));
2554 /* Initialize sizetypes so layout_type can use them. */
2557 initialize_sizetypes (void)
2559 int precision
, bprecision
;
2561 /* Get sizetypes precision from the SIZE_TYPE target macro. */
2562 if (strcmp (SIZETYPE
, "unsigned int") == 0)
2563 precision
= INT_TYPE_SIZE
;
2564 else if (strcmp (SIZETYPE
, "long unsigned int") == 0)
2565 precision
= LONG_TYPE_SIZE
;
2566 else if (strcmp (SIZETYPE
, "long long unsigned int") == 0)
2567 precision
= LONG_LONG_TYPE_SIZE
;
2568 else if (strcmp (SIZETYPE
, "short unsigned int") == 0)
2569 precision
= SHORT_TYPE_SIZE
;
2575 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2576 if (int_n_enabled_p
[i
])
2579 sprintf (name
, "__int%d unsigned", int_n_data
[i
].bitsize
);
2581 if (strcmp (name
, SIZETYPE
) == 0)
2583 precision
= int_n_data
[i
].bitsize
;
2586 if (precision
== -1)
2591 = MIN (precision
+ BITS_PER_UNIT_LOG
+ 1, MAX_FIXED_MODE_SIZE
);
2593 = GET_MODE_PRECISION (smallest_mode_for_size (bprecision
, MODE_INT
));
2594 if (bprecision
> HOST_BITS_PER_DOUBLE_INT
)
2595 bprecision
= HOST_BITS_PER_DOUBLE_INT
;
2597 /* Create stubs for sizetype and bitsizetype so we can create constants. */
2598 sizetype
= make_node (INTEGER_TYPE
);
2599 TYPE_NAME (sizetype
) = get_identifier ("sizetype");
2600 TYPE_PRECISION (sizetype
) = precision
;
2601 TYPE_UNSIGNED (sizetype
) = 1;
2602 bitsizetype
= make_node (INTEGER_TYPE
);
2603 TYPE_NAME (bitsizetype
) = get_identifier ("bitsizetype");
2604 TYPE_PRECISION (bitsizetype
) = bprecision
;
2605 TYPE_UNSIGNED (bitsizetype
) = 1;
2607 /* Now layout both types manually. */
2608 SET_TYPE_MODE (sizetype
, smallest_mode_for_size (precision
, MODE_INT
));
2609 TYPE_ALIGN (sizetype
) = GET_MODE_ALIGNMENT (TYPE_MODE (sizetype
));
2610 TYPE_SIZE (sizetype
) = bitsize_int (precision
);
2611 TYPE_SIZE_UNIT (sizetype
) = size_int (GET_MODE_SIZE (TYPE_MODE (sizetype
)));
2612 set_min_and_max_values_for_integral_type (sizetype
, precision
, UNSIGNED
);
2614 SET_TYPE_MODE (bitsizetype
, smallest_mode_for_size (bprecision
, MODE_INT
));
2615 TYPE_ALIGN (bitsizetype
) = GET_MODE_ALIGNMENT (TYPE_MODE (bitsizetype
));
2616 TYPE_SIZE (bitsizetype
) = bitsize_int (bprecision
);
2617 TYPE_SIZE_UNIT (bitsizetype
)
2618 = size_int (GET_MODE_SIZE (TYPE_MODE (bitsizetype
)));
2619 set_min_and_max_values_for_integral_type (bitsizetype
, bprecision
, UNSIGNED
);
2621 /* Create the signed variants of *sizetype. */
2622 ssizetype
= make_signed_type (TYPE_PRECISION (sizetype
));
2623 TYPE_NAME (ssizetype
) = get_identifier ("ssizetype");
2624 sbitsizetype
= make_signed_type (TYPE_PRECISION (bitsizetype
));
2625 TYPE_NAME (sbitsizetype
) = get_identifier ("sbitsizetype");
2628 /* TYPE is an integral type, i.e., an INTEGRAL_TYPE, ENUMERAL_TYPE
2629 or BOOLEAN_TYPE. Set TYPE_MIN_VALUE and TYPE_MAX_VALUE
2630 for TYPE, based on the PRECISION and whether or not the TYPE
2631 IS_UNSIGNED. PRECISION need not correspond to a width supported
2632 natively by the hardware; for example, on a machine with 8-bit,
2633 16-bit, and 32-bit register modes, PRECISION might be 7, 23, or
2637 set_min_and_max_values_for_integral_type (tree type
,
2641 /* For bitfields with zero width we end up creating integer types
2642 with zero precision. Don't assign any minimum/maximum values
2643 to those types, they don't have any valid value. */
2647 TYPE_MIN_VALUE (type
)
2648 = wide_int_to_tree (type
, wi::min_value (precision
, sgn
));
2649 TYPE_MAX_VALUE (type
)
2650 = wide_int_to_tree (type
, wi::max_value (precision
, sgn
));
2653 /* Set the extreme values of TYPE based on its precision in bits,
2654 then lay it out. Used when make_signed_type won't do
2655 because the tree code is not INTEGER_TYPE.
2656 E.g. for Pascal, when the -fsigned-char option is given. */
2659 fixup_signed_type (tree type
)
2661 int precision
= TYPE_PRECISION (type
);
2663 set_min_and_max_values_for_integral_type (type
, precision
, SIGNED
);
2665 /* Lay out the type: set its alignment, size, etc. */
2669 /* Set the extreme values of TYPE based on its precision in bits,
2670 then lay it out. This is used both in `make_unsigned_type'
2671 and for enumeral types. */
2674 fixup_unsigned_type (tree type
)
2676 int precision
= TYPE_PRECISION (type
);
2678 TYPE_UNSIGNED (type
) = 1;
2680 set_min_and_max_values_for_integral_type (type
, precision
, UNSIGNED
);
2682 /* Lay out the type: set its alignment, size, etc. */
2686 /* Construct an iterator for a bitfield that spans BITSIZE bits,
2689 BITREGION_START is the bit position of the first bit in this
2690 sequence of bit fields. BITREGION_END is the last bit in this
2691 sequence. If these two fields are non-zero, we should restrict the
2692 memory access to that range. Otherwise, we are allowed to touch
2693 any adjacent non bit-fields.
2695 ALIGN is the alignment of the underlying object in bits.
2696 VOLATILEP says whether the bitfield is volatile. */
2698 bit_field_mode_iterator
2699 ::bit_field_mode_iterator (HOST_WIDE_INT bitsize
, HOST_WIDE_INT bitpos
,
2700 HOST_WIDE_INT bitregion_start
,
2701 HOST_WIDE_INT bitregion_end
,
2702 unsigned int align
, bool volatilep
)
2703 : m_mode (GET_CLASS_NARROWEST_MODE (MODE_INT
)), m_bitsize (bitsize
),
2704 m_bitpos (bitpos
), m_bitregion_start (bitregion_start
),
2705 m_bitregion_end (bitregion_end
), m_align (align
),
2706 m_volatilep (volatilep
), m_count (0)
2708 if (!m_bitregion_end
)
2710 /* We can assume that any aligned chunk of ALIGN bits that overlaps
2711 the bitfield is mapped and won't trap, provided that ALIGN isn't
2712 too large. The cap is the biggest required alignment for data,
2713 or at least the word size. And force one such chunk at least. */
2714 unsigned HOST_WIDE_INT units
2715 = MIN (align
, MAX (BIGGEST_ALIGNMENT
, BITS_PER_WORD
));
2718 m_bitregion_end
= bitpos
+ bitsize
+ units
- 1;
2719 m_bitregion_end
-= m_bitregion_end
% units
+ 1;
2723 /* Calls to this function return successively larger modes that can be used
2724 to represent the bitfield. Return true if another bitfield mode is
2725 available, storing it in *OUT_MODE if so. */
2728 bit_field_mode_iterator::next_mode (enum machine_mode
*out_mode
)
2730 for (; m_mode
!= VOIDmode
; m_mode
= GET_MODE_WIDER_MODE (m_mode
))
2732 unsigned int unit
= GET_MODE_BITSIZE (m_mode
);
2734 /* Skip modes that don't have full precision. */
2735 if (unit
!= GET_MODE_PRECISION (m_mode
))
2738 /* Stop if the mode is too wide to handle efficiently. */
2739 if (unit
> MAX_FIXED_MODE_SIZE
)
2742 /* Don't deliver more than one multiword mode; the smallest one
2744 if (m_count
> 0 && unit
> BITS_PER_WORD
)
2747 /* Skip modes that are too small. */
2748 unsigned HOST_WIDE_INT substart
= (unsigned HOST_WIDE_INT
) m_bitpos
% unit
;
2749 unsigned HOST_WIDE_INT subend
= substart
+ m_bitsize
;
2753 /* Stop if the mode goes outside the bitregion. */
2754 HOST_WIDE_INT start
= m_bitpos
- substart
;
2755 if (m_bitregion_start
&& start
< m_bitregion_start
)
2757 HOST_WIDE_INT end
= start
+ unit
;
2758 if (end
> m_bitregion_end
+ 1)
2761 /* Stop if the mode requires too much alignment. */
2762 if (GET_MODE_ALIGNMENT (m_mode
) > m_align
2763 && SLOW_UNALIGNED_ACCESS (m_mode
, m_align
))
2767 m_mode
= GET_MODE_WIDER_MODE (m_mode
);
2774 /* Return true if smaller modes are generally preferred for this kind
2778 bit_field_mode_iterator::prefer_smaller_modes ()
2781 ? targetm
.narrow_volatile_bitfield ()
2782 : !SLOW_BYTE_ACCESS
);
2785 /* Find the best machine mode to use when referencing a bit field of length
2786 BITSIZE bits starting at BITPOS.
2788 BITREGION_START is the bit position of the first bit in this
2789 sequence of bit fields. BITREGION_END is the last bit in this
2790 sequence. If these two fields are non-zero, we should restrict the
2791 memory access to that range. Otherwise, we are allowed to touch
2792 any adjacent non bit-fields.
2794 The underlying object is known to be aligned to a boundary of ALIGN bits.
2795 If LARGEST_MODE is not VOIDmode, it means that we should not use a mode
2796 larger than LARGEST_MODE (usually SImode).
2798 If no mode meets all these conditions, we return VOIDmode.
2800 If VOLATILEP is false and SLOW_BYTE_ACCESS is false, we return the
2801 smallest mode meeting these conditions.
2803 If VOLATILEP is false and SLOW_BYTE_ACCESS is true, we return the
2804 largest mode (but a mode no wider than UNITS_PER_WORD) that meets
2807 If VOLATILEP is true the narrow_volatile_bitfields target hook is used to
2808 decide which of the above modes should be used. */
2811 get_best_mode (int bitsize
, int bitpos
,
2812 unsigned HOST_WIDE_INT bitregion_start
,
2813 unsigned HOST_WIDE_INT bitregion_end
,
2815 enum machine_mode largest_mode
, bool volatilep
)
2817 bit_field_mode_iterator
iter (bitsize
, bitpos
, bitregion_start
,
2818 bitregion_end
, align
, volatilep
);
2819 enum machine_mode widest_mode
= VOIDmode
;
2820 enum machine_mode mode
;
2821 while (iter
.next_mode (&mode
)
2822 /* ??? For historical reasons, reject modes that would normally
2823 receive greater alignment, even if unaligned accesses are
2824 acceptable. This has both advantages and disadvantages.
2825 Removing this check means that something like:
2827 struct s { unsigned int x; unsigned int y; };
2828 int f (struct s *s) { return s->x == 0 && s->y == 0; }
2830 can be implemented using a single load and compare on
2831 64-bit machines that have no alignment restrictions.
2832 For example, on powerpc64-linux-gnu, we would generate:
2854 However, accessing more than one field can make life harder
2855 for the gimple optimizers. For example, gcc.dg/vect/bb-slp-5.c
2856 has a series of unsigned short copies followed by a series of
2857 unsigned short comparisons. With this check, both the copies
2858 and comparisons remain 16-bit accesses and FRE is able
2859 to eliminate the latter. Without the check, the comparisons
2860 can be done using 2 64-bit operations, which FRE isn't able
2861 to handle in the same way.
2863 Either way, it would probably be worth disabling this check
2864 during expand. One particular example where removing the
2865 check would help is the get_best_mode call in store_bit_field.
2866 If we are given a memory bitregion of 128 bits that is aligned
2867 to a 64-bit boundary, and the bitfield we want to modify is
2868 in the second half of the bitregion, this check causes
2869 store_bitfield to turn the memory into a 64-bit reference
2870 to the _first_ half of the region. We later use
2871 adjust_bitfield_address to get a reference to the correct half,
2872 but doing so looks to adjust_bitfield_address as though we are
2873 moving past the end of the original object, so it drops the
2874 associated MEM_EXPR and MEM_OFFSET. Removing the check
2875 causes store_bit_field to keep a 128-bit memory reference,
2876 so that the final bitfield reference still has a MEM_EXPR
2878 && GET_MODE_ALIGNMENT (mode
) <= align
2879 && (largest_mode
== VOIDmode
2880 || GET_MODE_SIZE (mode
) <= GET_MODE_SIZE (largest_mode
)))
2883 if (iter
.prefer_smaller_modes ())
2889 /* Gets minimal and maximal values for MODE (signed or unsigned depending on
2890 SIGN). The returned constants are made to be usable in TARGET_MODE. */
2893 get_mode_bounds (enum machine_mode mode
, int sign
,
2894 enum machine_mode target_mode
,
2895 rtx
*mmin
, rtx
*mmax
)
2897 unsigned size
= GET_MODE_PRECISION (mode
);
2898 unsigned HOST_WIDE_INT min_val
, max_val
;
2900 gcc_assert (size
<= HOST_BITS_PER_WIDE_INT
);
2902 /* Special case BImode, which has values 0 and STORE_FLAG_VALUE. */
2905 if (STORE_FLAG_VALUE
< 0)
2907 min_val
= STORE_FLAG_VALUE
;
2913 max_val
= STORE_FLAG_VALUE
;
2918 min_val
= -((unsigned HOST_WIDE_INT
) 1 << (size
- 1));
2919 max_val
= ((unsigned HOST_WIDE_INT
) 1 << (size
- 1)) - 1;
2924 max_val
= ((unsigned HOST_WIDE_INT
) 1 << (size
- 1) << 1) - 1;
2927 *mmin
= gen_int_mode (min_val
, target_mode
);
2928 *mmax
= gen_int_mode (max_val
, target_mode
);
2931 #include "gt-stor-layout.h"