1 /* C-compiler utilities for types and variables storage layout
2 Copyright (C) 1987-2013 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
31 #include "diagnostic-core.h"
34 #include "langhooks.h"
38 #include "tree-inline.h"
39 #include "tree-dump.h"
42 /* Data type for the expressions representing sizes of data types.
43 It is the first integer type laid out. */
44 tree sizetype_tab
[(int) stk_type_kind_last
];
46 /* If nonzero, this is an upper limit on alignment of structure fields.
47 The value is measured in bits. */
48 unsigned int maximum_field_alignment
= TARGET_DEFAULT_PACK_STRUCT
* BITS_PER_UNIT
;
50 /* Nonzero if all REFERENCE_TYPEs are internal and hence should be allocated
51 in the address spaces' address_mode, not pointer_mode. Set only by
52 internal_reference_types called only by a front end. */
53 static int reference_types_internal
= 0;
55 static tree
self_referential_size (tree
);
56 static void finalize_record_size (record_layout_info
);
57 static void finalize_type_size (tree
);
58 static void place_union_field (record_layout_info
, tree
);
59 #if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED)
60 static int excess_unit_span (HOST_WIDE_INT
, HOST_WIDE_INT
, HOST_WIDE_INT
,
63 extern void debug_rli (record_layout_info
);
65 /* Show that REFERENCE_TYPES are internal and should use address_mode.
66 Called only by front end. */
69 internal_reference_types (void)
71 reference_types_internal
= 1;
74 /* Given a size SIZE that may not be a constant, return a SAVE_EXPR
75 to serve as the actual size-expression for a type or decl. */
78 variable_size (tree size
)
81 if (TREE_CONSTANT (size
))
84 /* If the size is self-referential, we can't make a SAVE_EXPR (see
85 save_expr for the rationale). But we can do something else. */
86 if (CONTAINS_PLACEHOLDER_P (size
))
87 return self_referential_size (size
);
89 /* If we are in the global binding level, we can't make a SAVE_EXPR
90 since it may end up being shared across functions, so it is up
91 to the front-end to deal with this case. */
92 if (lang_hooks
.decls
.global_bindings_p ())
95 return save_expr (size
);
98 /* An array of functions used for self-referential size computation. */
99 static GTY(()) vec
<tree
, va_gc
> *size_functions
;
101 /* Similar to copy_tree_r but do not copy component references involving
102 PLACEHOLDER_EXPRs. These nodes are spotted in find_placeholder_in_expr
103 and substituted in substitute_in_expr. */
106 copy_self_referential_tree_r (tree
*tp
, int *walk_subtrees
, void *data
)
108 enum tree_code code
= TREE_CODE (*tp
);
110 /* Stop at types, decls, constants like copy_tree_r. */
111 if (TREE_CODE_CLASS (code
) == tcc_type
112 || TREE_CODE_CLASS (code
) == tcc_declaration
113 || TREE_CODE_CLASS (code
) == tcc_constant
)
119 /* This is the pattern built in ada/make_aligning_type. */
120 else if (code
== ADDR_EXPR
121 && TREE_CODE (TREE_OPERAND (*tp
, 0)) == PLACEHOLDER_EXPR
)
127 /* Default case: the component reference. */
128 else if (code
== COMPONENT_REF
)
131 for (inner
= TREE_OPERAND (*tp
, 0);
132 REFERENCE_CLASS_P (inner
);
133 inner
= TREE_OPERAND (inner
, 0))
136 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
)
143 /* We're not supposed to have them in self-referential size trees
144 because we wouldn't properly control when they are evaluated.
145 However, not creating superfluous SAVE_EXPRs requires accurate
146 tracking of readonly-ness all the way down to here, which we
147 cannot always guarantee in practice. So punt in this case. */
148 else if (code
== SAVE_EXPR
)
149 return error_mark_node
;
151 else if (code
== STATEMENT_LIST
)
154 return copy_tree_r (tp
, walk_subtrees
, data
);
157 /* Given a SIZE expression that is self-referential, return an equivalent
158 expression to serve as the actual size expression for a type. */
161 self_referential_size (tree size
)
163 static unsigned HOST_WIDE_INT fnno
= 0;
164 vec
<tree
> self_refs
= vNULL
;
165 tree param_type_list
= NULL
, param_decl_list
= NULL
;
166 tree t
, ref
, return_type
, fntype
, fnname
, fndecl
;
169 vec
<tree
, va_gc
> *args
= NULL
;
171 /* Do not factor out simple operations. */
172 t
= skip_simple_constant_arithmetic (size
);
173 if (TREE_CODE (t
) == CALL_EXPR
)
176 /* Collect the list of self-references in the expression. */
177 find_placeholder_in_expr (size
, &self_refs
);
178 gcc_assert (self_refs
.length () > 0);
180 /* Obtain a private copy of the expression. */
182 if (walk_tree (&t
, copy_self_referential_tree_r
, NULL
, NULL
) != NULL_TREE
)
186 /* Build the parameter and argument lists in parallel; also
187 substitute the former for the latter in the expression. */
188 vec_alloc (args
, self_refs
.length ());
189 FOR_EACH_VEC_ELT (self_refs
, i
, ref
)
191 tree subst
, param_name
, param_type
, param_decl
;
195 /* We shouldn't have true variables here. */
196 gcc_assert (TREE_READONLY (ref
));
199 /* This is the pattern built in ada/make_aligning_type. */
200 else if (TREE_CODE (ref
) == ADDR_EXPR
)
202 /* Default case: the component reference. */
204 subst
= TREE_OPERAND (ref
, 1);
206 sprintf (buf
, "p%d", i
);
207 param_name
= get_identifier (buf
);
208 param_type
= TREE_TYPE (ref
);
210 = build_decl (input_location
, PARM_DECL
, param_name
, param_type
);
211 if (targetm
.calls
.promote_prototypes (NULL_TREE
)
212 && INTEGRAL_TYPE_P (param_type
)
213 && TYPE_PRECISION (param_type
) < TYPE_PRECISION (integer_type_node
))
214 DECL_ARG_TYPE (param_decl
) = integer_type_node
;
216 DECL_ARG_TYPE (param_decl
) = param_type
;
217 DECL_ARTIFICIAL (param_decl
) = 1;
218 TREE_READONLY (param_decl
) = 1;
220 size
= substitute_in_expr (size
, subst
, param_decl
);
222 param_type_list
= tree_cons (NULL_TREE
, param_type
, param_type_list
);
223 param_decl_list
= chainon (param_decl
, param_decl_list
);
224 args
->quick_push (ref
);
227 self_refs
.release ();
229 /* Append 'void' to indicate that the number of parameters is fixed. */
230 param_type_list
= tree_cons (NULL_TREE
, void_type_node
, param_type_list
);
232 /* The 3 lists have been created in reverse order. */
233 param_type_list
= nreverse (param_type_list
);
234 param_decl_list
= nreverse (param_decl_list
);
236 /* Build the function type. */
237 return_type
= TREE_TYPE (size
);
238 fntype
= build_function_type (return_type
, param_type_list
);
240 /* Build the function declaration. */
241 sprintf (buf
, "SZ"HOST_WIDE_INT_PRINT_UNSIGNED
, fnno
++);
242 fnname
= get_file_function_name (buf
);
243 fndecl
= build_decl (input_location
, FUNCTION_DECL
, fnname
, fntype
);
244 for (t
= param_decl_list
; t
; t
= DECL_CHAIN (t
))
245 DECL_CONTEXT (t
) = fndecl
;
246 DECL_ARGUMENTS (fndecl
) = param_decl_list
;
248 = build_decl (input_location
, RESULT_DECL
, 0, return_type
);
249 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
251 /* The function has been created by the compiler and we don't
252 want to emit debug info for it. */
253 DECL_ARTIFICIAL (fndecl
) = 1;
254 DECL_IGNORED_P (fndecl
) = 1;
256 /* It is supposed to be "const" and never throw. */
257 TREE_READONLY (fndecl
) = 1;
258 TREE_NOTHROW (fndecl
) = 1;
260 /* We want it to be inlined when this is deemed profitable, as
261 well as discarded if every call has been integrated. */
262 DECL_DECLARED_INLINE_P (fndecl
) = 1;
264 /* It is made up of a unique return statement. */
265 DECL_INITIAL (fndecl
) = make_node (BLOCK
);
266 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
267 t
= build2 (MODIFY_EXPR
, return_type
, DECL_RESULT (fndecl
), size
);
268 DECL_SAVED_TREE (fndecl
) = build1 (RETURN_EXPR
, void_type_node
, t
);
269 TREE_STATIC (fndecl
) = 1;
271 /* Put it onto the list of size functions. */
272 vec_safe_push (size_functions
, fndecl
);
274 /* Replace the original expression with a call to the size function. */
275 return build_call_expr_loc_vec (UNKNOWN_LOCATION
, fndecl
, args
);
278 /* Take, queue and compile all the size functions. It is essential that
279 the size functions be gimplified at the very end of the compilation
280 in order to guarantee transparent handling of self-referential sizes.
281 Otherwise the GENERIC inliner would not be able to inline them back
282 at each of their call sites, thus creating artificial non-constant
283 size expressions which would trigger nasty problems later on. */
286 finalize_size_functions (void)
291 for (i
= 0; size_functions
&& size_functions
->iterate (i
, &fndecl
); i
++)
293 allocate_struct_function (fndecl
, false);
295 dump_function (TDI_original
, fndecl
);
296 gimplify_function_tree (fndecl
);
297 dump_function (TDI_generic
, fndecl
);
298 cgraph_finalize_function (fndecl
, false);
301 vec_free (size_functions
);
304 /* Return the machine mode to use for a nonscalar of SIZE bits. The
305 mode must be in class MCLASS, and have exactly that many value bits;
306 it may have padding as well. If LIMIT is nonzero, modes of wider
307 than MAX_FIXED_MODE_SIZE will not be used. */
310 mode_for_size (unsigned int size
, enum mode_class mclass
, int limit
)
312 enum machine_mode mode
;
314 if (limit
&& size
> MAX_FIXED_MODE_SIZE
)
317 /* Get the first mode which has this size, in the specified class. */
318 for (mode
= GET_CLASS_NARROWEST_MODE (mclass
); mode
!= VOIDmode
;
319 mode
= GET_MODE_WIDER_MODE (mode
))
320 if (GET_MODE_PRECISION (mode
) == size
)
326 /* Similar, except passed a tree node. */
329 mode_for_size_tree (const_tree size
, enum mode_class mclass
, int limit
)
331 unsigned HOST_WIDE_INT uhwi
;
334 if (!tree_fits_uhwi_p (size
))
336 uhwi
= tree_to_uhwi (size
);
340 return mode_for_size (ui
, mclass
, limit
);
343 /* Similar, but never return BLKmode; return the narrowest mode that
344 contains at least the requested number of value bits. */
347 smallest_mode_for_size (unsigned int size
, enum mode_class mclass
)
349 enum machine_mode mode
;
351 /* Get the first mode which has at least this size, in the
353 for (mode
= GET_CLASS_NARROWEST_MODE (mclass
); mode
!= VOIDmode
;
354 mode
= GET_MODE_WIDER_MODE (mode
))
355 if (GET_MODE_PRECISION (mode
) >= size
)
361 /* Find an integer mode of the exact same size, or BLKmode on failure. */
364 int_mode_for_mode (enum machine_mode mode
)
366 switch (GET_MODE_CLASS (mode
))
369 case MODE_PARTIAL_INT
:
372 case MODE_COMPLEX_INT
:
373 case MODE_COMPLEX_FLOAT
:
375 case MODE_DECIMAL_FLOAT
:
376 case MODE_VECTOR_INT
:
377 case MODE_VECTOR_FLOAT
:
382 case MODE_VECTOR_FRACT
:
383 case MODE_VECTOR_ACCUM
:
384 case MODE_VECTOR_UFRACT
:
385 case MODE_VECTOR_UACCUM
:
386 case MODE_POINTER_BOUNDS
:
387 mode
= mode_for_size (GET_MODE_BITSIZE (mode
), MODE_INT
, 0);
394 /* ... fall through ... */
404 /* Find a mode that is suitable for representing a vector with
405 NUNITS elements of mode INNERMODE. Returns BLKmode if there
406 is no suitable mode. */
409 mode_for_vector (enum machine_mode innermode
, unsigned nunits
)
411 enum machine_mode mode
;
413 /* First, look for a supported vector type. */
414 if (SCALAR_FLOAT_MODE_P (innermode
))
415 mode
= MIN_MODE_VECTOR_FLOAT
;
416 else if (SCALAR_FRACT_MODE_P (innermode
))
417 mode
= MIN_MODE_VECTOR_FRACT
;
418 else if (SCALAR_UFRACT_MODE_P (innermode
))
419 mode
= MIN_MODE_VECTOR_UFRACT
;
420 else if (SCALAR_ACCUM_MODE_P (innermode
))
421 mode
= MIN_MODE_VECTOR_ACCUM
;
422 else if (SCALAR_UACCUM_MODE_P (innermode
))
423 mode
= MIN_MODE_VECTOR_UACCUM
;
425 mode
= MIN_MODE_VECTOR_INT
;
427 /* Do not check vector_mode_supported_p here. We'll do that
428 later in vector_type_mode. */
429 for (; mode
!= VOIDmode
; mode
= GET_MODE_WIDER_MODE (mode
))
430 if (GET_MODE_NUNITS (mode
) == nunits
431 && GET_MODE_INNER (mode
) == innermode
)
434 /* For integers, try mapping it to a same-sized scalar mode. */
436 && GET_MODE_CLASS (innermode
) == MODE_INT
)
437 mode
= mode_for_size (nunits
* GET_MODE_BITSIZE (innermode
),
441 || (GET_MODE_CLASS (mode
) == MODE_INT
442 && !have_regs_of_mode
[mode
]))
448 /* Return the alignment of MODE. This will be bounded by 1 and
449 BIGGEST_ALIGNMENT. */
452 get_mode_alignment (enum machine_mode mode
)
454 return MIN (BIGGEST_ALIGNMENT
, MAX (1, mode_base_align
[mode
]*BITS_PER_UNIT
));
457 /* Return the precision of the mode, or for a complex or vector mode the
458 precision of the mode of its elements. */
461 element_precision (enum machine_mode mode
)
463 if (COMPLEX_MODE_P (mode
) || VECTOR_MODE_P (mode
))
464 mode
= GET_MODE_INNER (mode
);
466 return GET_MODE_PRECISION (mode
);
469 /* Return the natural mode of an array, given that it is SIZE bytes in
470 total and has elements of type ELEM_TYPE. */
472 static enum machine_mode
473 mode_for_array (tree elem_type
, tree size
)
476 unsigned HOST_WIDE_INT int_size
, int_elem_size
;
479 /* One-element arrays get the component type's mode. */
480 elem_size
= TYPE_SIZE (elem_type
);
481 if (simple_cst_equal (size
, elem_size
))
482 return TYPE_MODE (elem_type
);
485 if (tree_fits_uhwi_p (size
) && tree_fits_uhwi_p (elem_size
))
487 int_size
= tree_to_uhwi (size
);
488 int_elem_size
= tree_to_uhwi (elem_size
);
489 if (int_elem_size
> 0
490 && int_size
% int_elem_size
== 0
491 && targetm
.array_mode_supported_p (TYPE_MODE (elem_type
),
492 int_size
/ int_elem_size
))
495 return mode_for_size_tree (size
, MODE_INT
, limit_p
);
498 /* Subroutine of layout_decl: Force alignment required for the data type.
499 But if the decl itself wants greater alignment, don't override that. */
502 do_type_align (tree type
, tree decl
)
504 if (TYPE_ALIGN (type
) > DECL_ALIGN (decl
))
506 DECL_ALIGN (decl
) = TYPE_ALIGN (type
);
507 if (TREE_CODE (decl
) == FIELD_DECL
)
508 DECL_USER_ALIGN (decl
) = TYPE_USER_ALIGN (type
);
512 /* Set the size, mode and alignment of a ..._DECL node.
513 TYPE_DECL does need this for C++.
514 Note that LABEL_DECL and CONST_DECL nodes do not need this,
515 and FUNCTION_DECL nodes have them set up in a special (and simple) way.
516 Don't call layout_decl for them.
518 KNOWN_ALIGN is the amount of alignment we can assume this
519 decl has with no special effort. It is relevant only for FIELD_DECLs
520 and depends on the previous fields.
521 All that matters about KNOWN_ALIGN is which powers of 2 divide it.
522 If KNOWN_ALIGN is 0, it means, "as much alignment as you like":
523 the record will be aligned to suit. */
526 layout_decl (tree decl
, unsigned int known_align
)
528 tree type
= TREE_TYPE (decl
);
529 enum tree_code code
= TREE_CODE (decl
);
531 location_t loc
= DECL_SOURCE_LOCATION (decl
);
533 if (code
== CONST_DECL
)
536 gcc_assert (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
537 || code
== TYPE_DECL
||code
== FIELD_DECL
);
539 rtl
= DECL_RTL_IF_SET (decl
);
541 if (type
== error_mark_node
)
542 type
= void_type_node
;
544 /* Usually the size and mode come from the data type without change,
545 however, the front-end may set the explicit width of the field, so its
546 size may not be the same as the size of its type. This happens with
547 bitfields, of course (an `int' bitfield may be only 2 bits, say), but it
548 also happens with other fields. For example, the C++ front-end creates
549 zero-sized fields corresponding to empty base classes, and depends on
550 layout_type setting DECL_FIELD_BITPOS correctly for the field. Set the
551 size in bytes from the size in bits. If we have already set the mode,
552 don't set it again since we can be called twice for FIELD_DECLs. */
554 DECL_UNSIGNED (decl
) = TYPE_UNSIGNED (type
);
555 if (DECL_MODE (decl
) == VOIDmode
)
556 DECL_MODE (decl
) = TYPE_MODE (type
);
558 if (DECL_SIZE (decl
) == 0)
560 DECL_SIZE (decl
) = TYPE_SIZE (type
);
561 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (type
);
563 else if (DECL_SIZE_UNIT (decl
) == 0)
564 DECL_SIZE_UNIT (decl
)
565 = fold_convert_loc (loc
, sizetype
,
566 size_binop_loc (loc
, CEIL_DIV_EXPR
, DECL_SIZE (decl
),
569 if (code
!= FIELD_DECL
)
570 /* For non-fields, update the alignment from the type. */
571 do_type_align (type
, decl
);
573 /* For fields, it's a bit more complicated... */
575 bool old_user_align
= DECL_USER_ALIGN (decl
);
576 bool zero_bitfield
= false;
577 bool packed_p
= DECL_PACKED (decl
);
580 if (DECL_BIT_FIELD (decl
))
582 DECL_BIT_FIELD_TYPE (decl
) = type
;
584 /* A zero-length bit-field affects the alignment of the next
585 field. In essence such bit-fields are not influenced by
586 any packing due to #pragma pack or attribute packed. */
587 if (integer_zerop (DECL_SIZE (decl
))
588 && ! targetm
.ms_bitfield_layout_p (DECL_FIELD_CONTEXT (decl
)))
590 zero_bitfield
= true;
592 #ifdef PCC_BITFIELD_TYPE_MATTERS
593 if (PCC_BITFIELD_TYPE_MATTERS
)
594 do_type_align (type
, decl
);
598 #ifdef EMPTY_FIELD_BOUNDARY
599 if (EMPTY_FIELD_BOUNDARY
> DECL_ALIGN (decl
))
601 DECL_ALIGN (decl
) = EMPTY_FIELD_BOUNDARY
;
602 DECL_USER_ALIGN (decl
) = 0;
608 /* See if we can use an ordinary integer mode for a bit-field.
609 Conditions are: a fixed size that is correct for another mode,
610 occupying a complete byte or bytes on proper boundary. */
611 if (TYPE_SIZE (type
) != 0
612 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
613 && GET_MODE_CLASS (TYPE_MODE (type
)) == MODE_INT
)
615 enum machine_mode xmode
616 = mode_for_size_tree (DECL_SIZE (decl
), MODE_INT
, 1);
617 unsigned int xalign
= GET_MODE_ALIGNMENT (xmode
);
620 && !(xalign
> BITS_PER_UNIT
&& DECL_PACKED (decl
))
621 && (known_align
== 0 || known_align
>= xalign
))
623 DECL_ALIGN (decl
) = MAX (xalign
, DECL_ALIGN (decl
));
624 DECL_MODE (decl
) = xmode
;
625 DECL_BIT_FIELD (decl
) = 0;
629 /* Turn off DECL_BIT_FIELD if we won't need it set. */
630 if (TYPE_MODE (type
) == BLKmode
&& DECL_MODE (decl
) == BLKmode
631 && known_align
>= TYPE_ALIGN (type
)
632 && DECL_ALIGN (decl
) >= TYPE_ALIGN (type
))
633 DECL_BIT_FIELD (decl
) = 0;
635 else if (packed_p
&& DECL_USER_ALIGN (decl
))
636 /* Don't touch DECL_ALIGN. For other packed fields, go ahead and
637 round up; we'll reduce it again below. We want packing to
638 supersede USER_ALIGN inherited from the type, but defer to
639 alignment explicitly specified on the field decl. */;
641 do_type_align (type
, decl
);
643 /* If the field is packed and not explicitly aligned, give it the
644 minimum alignment. Note that do_type_align may set
645 DECL_USER_ALIGN, so we need to check old_user_align instead. */
648 DECL_ALIGN (decl
) = MIN (DECL_ALIGN (decl
), BITS_PER_UNIT
);
650 if (! packed_p
&& ! DECL_USER_ALIGN (decl
))
652 /* Some targets (i.e. i386, VMS) limit struct field alignment
653 to a lower boundary than alignment of variables unless
654 it was overridden by attribute aligned. */
655 #ifdef BIGGEST_FIELD_ALIGNMENT
657 = MIN (DECL_ALIGN (decl
), (unsigned) BIGGEST_FIELD_ALIGNMENT
);
659 #ifdef ADJUST_FIELD_ALIGN
660 DECL_ALIGN (decl
) = ADJUST_FIELD_ALIGN (decl
, DECL_ALIGN (decl
));
665 mfa
= initial_max_fld_align
* BITS_PER_UNIT
;
667 mfa
= maximum_field_alignment
;
668 /* Should this be controlled by DECL_USER_ALIGN, too? */
670 DECL_ALIGN (decl
) = MIN (DECL_ALIGN (decl
), mfa
);
673 /* Evaluate nonconstant size only once, either now or as soon as safe. */
674 if (DECL_SIZE (decl
) != 0 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
675 DECL_SIZE (decl
) = variable_size (DECL_SIZE (decl
));
676 if (DECL_SIZE_UNIT (decl
) != 0
677 && TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
)
678 DECL_SIZE_UNIT (decl
) = variable_size (DECL_SIZE_UNIT (decl
));
680 /* If requested, warn about definitions of large data objects. */
682 && (code
== VAR_DECL
|| code
== PARM_DECL
)
683 && ! DECL_EXTERNAL (decl
))
685 tree size
= DECL_SIZE_UNIT (decl
);
687 if (size
!= 0 && TREE_CODE (size
) == INTEGER_CST
688 && compare_tree_int (size
, larger_than_size
) > 0)
690 int size_as_int
= tree_to_hwi (size
);
692 if (compare_tree_int (size
, size_as_int
) == 0)
693 warning (OPT_Wlarger_than_
, "size of %q+D is %d bytes", decl
, size_as_int
);
695 warning (OPT_Wlarger_than_
, "size of %q+D is larger than %wd bytes",
696 decl
, larger_than_size
);
700 /* If the RTL was already set, update its mode and mem attributes. */
703 PUT_MODE (rtl
, DECL_MODE (decl
));
704 SET_DECL_RTL (decl
, 0);
705 set_mem_attributes (rtl
, decl
, 1);
706 SET_DECL_RTL (decl
, rtl
);
710 /* Given a VAR_DECL, PARM_DECL or RESULT_DECL, clears the results of
711 a previous call to layout_decl and calls it again. */
714 relayout_decl (tree decl
)
716 DECL_SIZE (decl
) = DECL_SIZE_UNIT (decl
) = 0;
717 DECL_MODE (decl
) = VOIDmode
;
718 if (!DECL_USER_ALIGN (decl
))
719 DECL_ALIGN (decl
) = 0;
720 SET_DECL_RTL (decl
, 0);
722 layout_decl (decl
, 0);
725 /* Begin laying out type T, which may be a RECORD_TYPE, UNION_TYPE, or
726 QUAL_UNION_TYPE. Return a pointer to a struct record_layout_info which
727 is to be passed to all other layout functions for this record. It is the
728 responsibility of the caller to call `free' for the storage returned.
729 Note that garbage collection is not permitted until we finish laying
733 start_record_layout (tree t
)
735 record_layout_info rli
= XNEW (struct record_layout_info_s
);
739 /* If the type has a minimum specified alignment (via an attribute
740 declaration, for example) use it -- otherwise, start with a
741 one-byte alignment. */
742 rli
->record_align
= MAX (BITS_PER_UNIT
, TYPE_ALIGN (t
));
743 rli
->unpacked_align
= rli
->record_align
;
744 rli
->offset_align
= MAX (rli
->record_align
, BIGGEST_ALIGNMENT
);
746 #ifdef STRUCTURE_SIZE_BOUNDARY
747 /* Packed structures don't need to have minimum size. */
748 if (! TYPE_PACKED (t
))
752 /* #pragma pack overrides STRUCTURE_SIZE_BOUNDARY. */
753 tmp
= (unsigned) STRUCTURE_SIZE_BOUNDARY
;
754 if (maximum_field_alignment
!= 0)
755 tmp
= MIN (tmp
, maximum_field_alignment
);
756 rli
->record_align
= MAX (rli
->record_align
, tmp
);
760 rli
->offset
= size_zero_node
;
761 rli
->bitpos
= bitsize_zero_node
;
763 rli
->pending_statics
= 0;
764 rli
->packed_maybe_necessary
= 0;
765 rli
->remaining_in_alignment
= 0;
770 /* Return the combined bit position for the byte offset OFFSET and the
773 These functions operate on byte and bit positions present in FIELD_DECLs
774 and assume that these expressions result in no (intermediate) overflow.
775 This assumption is necessary to fold the expressions as much as possible,
776 so as to avoid creating artificially variable-sized types in languages
777 supporting variable-sized types like Ada. */
780 bit_from_pos (tree offset
, tree bitpos
)
782 if (TREE_CODE (offset
) == PLUS_EXPR
)
783 offset
= size_binop (PLUS_EXPR
,
784 fold_convert (bitsizetype
, TREE_OPERAND (offset
, 0)),
785 fold_convert (bitsizetype
, TREE_OPERAND (offset
, 1)));
787 offset
= fold_convert (bitsizetype
, offset
);
788 return size_binop (PLUS_EXPR
, bitpos
,
789 size_binop (MULT_EXPR
, offset
, bitsize_unit_node
));
792 /* Return the combined truncated byte position for the byte offset OFFSET and
793 the bit position BITPOS. */
796 byte_from_pos (tree offset
, tree bitpos
)
799 if (TREE_CODE (bitpos
) == MULT_EXPR
800 && tree_int_cst_equal (TREE_OPERAND (bitpos
, 1), bitsize_unit_node
))
801 bytepos
= TREE_OPERAND (bitpos
, 0);
803 bytepos
= size_binop (TRUNC_DIV_EXPR
, bitpos
, bitsize_unit_node
);
804 return size_binop (PLUS_EXPR
, offset
, fold_convert (sizetype
, bytepos
));
807 /* Split the bit position POS into a byte offset *POFFSET and a bit
808 position *PBITPOS with the byte offset aligned to OFF_ALIGN bits. */
811 pos_from_bit (tree
*poffset
, tree
*pbitpos
, unsigned int off_align
,
814 tree toff_align
= bitsize_int (off_align
);
815 if (TREE_CODE (pos
) == MULT_EXPR
816 && tree_int_cst_equal (TREE_OPERAND (pos
, 1), toff_align
))
818 *poffset
= size_binop (MULT_EXPR
,
819 fold_convert (sizetype
, TREE_OPERAND (pos
, 0)),
820 size_int (off_align
/ BITS_PER_UNIT
));
821 *pbitpos
= bitsize_zero_node
;
825 *poffset
= size_binop (MULT_EXPR
,
826 fold_convert (sizetype
,
827 size_binop (FLOOR_DIV_EXPR
, pos
,
829 size_int (off_align
/ BITS_PER_UNIT
));
830 *pbitpos
= size_binop (FLOOR_MOD_EXPR
, pos
, toff_align
);
834 /* Given a pointer to bit and byte offsets and an offset alignment,
835 normalize the offsets so they are within the alignment. */
838 normalize_offset (tree
*poffset
, tree
*pbitpos
, unsigned int off_align
)
840 /* If the bit position is now larger than it should be, adjust it
842 if (compare_tree_int (*pbitpos
, off_align
) >= 0)
845 pos_from_bit (&offset
, &bitpos
, off_align
, *pbitpos
);
846 *poffset
= size_binop (PLUS_EXPR
, *poffset
, offset
);
851 /* Print debugging information about the information in RLI. */
854 debug_rli (record_layout_info rli
)
856 print_node_brief (stderr
, "type", rli
->t
, 0);
857 print_node_brief (stderr
, "\noffset", rli
->offset
, 0);
858 print_node_brief (stderr
, " bitpos", rli
->bitpos
, 0);
860 fprintf (stderr
, "\naligns: rec = %u, unpack = %u, off = %u\n",
861 rli
->record_align
, rli
->unpacked_align
,
864 /* The ms_struct code is the only that uses this. */
865 if (targetm
.ms_bitfield_layout_p (rli
->t
))
866 fprintf (stderr
, "remaining in alignment = %u\n", rli
->remaining_in_alignment
);
868 if (rli
->packed_maybe_necessary
)
869 fprintf (stderr
, "packed may be necessary\n");
871 if (!vec_safe_is_empty (rli
->pending_statics
))
873 fprintf (stderr
, "pending statics:\n");
874 debug_vec_tree (rli
->pending_statics
);
878 /* Given an RLI with a possibly-incremented BITPOS, adjust OFFSET and
879 BITPOS if necessary to keep BITPOS below OFFSET_ALIGN. */
882 normalize_rli (record_layout_info rli
)
884 normalize_offset (&rli
->offset
, &rli
->bitpos
, rli
->offset_align
);
887 /* Returns the size in bytes allocated so far. */
890 rli_size_unit_so_far (record_layout_info rli
)
892 return byte_from_pos (rli
->offset
, rli
->bitpos
);
895 /* Returns the size in bits allocated so far. */
898 rli_size_so_far (record_layout_info rli
)
900 return bit_from_pos (rli
->offset
, rli
->bitpos
);
903 /* FIELD is about to be added to RLI->T. The alignment (in bits) of
904 the next available location within the record is given by KNOWN_ALIGN.
905 Update the variable alignment fields in RLI, and return the alignment
906 to give the FIELD. */
909 update_alignment_for_field (record_layout_info rli
, tree field
,
910 unsigned int known_align
)
912 /* The alignment required for FIELD. */
913 unsigned int desired_align
;
914 /* The type of this field. */
915 tree type
= TREE_TYPE (field
);
916 /* True if the field was explicitly aligned by the user. */
920 /* Do not attempt to align an ERROR_MARK node */
921 if (TREE_CODE (type
) == ERROR_MARK
)
924 /* Lay out the field so we know what alignment it needs. */
925 layout_decl (field
, known_align
);
926 desired_align
= DECL_ALIGN (field
);
927 user_align
= DECL_USER_ALIGN (field
);
929 is_bitfield
= (type
!= error_mark_node
930 && DECL_BIT_FIELD_TYPE (field
)
931 && ! integer_zerop (TYPE_SIZE (type
)));
933 /* Record must have at least as much alignment as any field.
934 Otherwise, the alignment of the field within the record is
936 if (targetm
.ms_bitfield_layout_p (rli
->t
))
938 /* Here, the alignment of the underlying type of a bitfield can
939 affect the alignment of a record; even a zero-sized field
940 can do this. The alignment should be to the alignment of
941 the type, except that for zero-size bitfields this only
942 applies if there was an immediately prior, nonzero-size
943 bitfield. (That's the way it is, experimentally.) */
944 if ((!is_bitfield
&& !DECL_PACKED (field
))
945 || ((DECL_SIZE (field
) == NULL_TREE
946 || !integer_zerop (DECL_SIZE (field
)))
947 ? !DECL_PACKED (field
)
949 && DECL_BIT_FIELD_TYPE (rli
->prev_field
)
950 && ! integer_zerop (DECL_SIZE (rli
->prev_field
)))))
952 unsigned int type_align
= TYPE_ALIGN (type
);
953 type_align
= MAX (type_align
, desired_align
);
954 if (maximum_field_alignment
!= 0)
955 type_align
= MIN (type_align
, maximum_field_alignment
);
956 rli
->record_align
= MAX (rli
->record_align
, type_align
);
957 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
960 #ifdef PCC_BITFIELD_TYPE_MATTERS
961 else if (is_bitfield
&& PCC_BITFIELD_TYPE_MATTERS
)
963 /* Named bit-fields cause the entire structure to have the
964 alignment implied by their type. Some targets also apply the same
965 rules to unnamed bitfields. */
966 if (DECL_NAME (field
) != 0
967 || targetm
.align_anon_bitfield ())
969 unsigned int type_align
= TYPE_ALIGN (type
);
971 #ifdef ADJUST_FIELD_ALIGN
972 if (! TYPE_USER_ALIGN (type
))
973 type_align
= ADJUST_FIELD_ALIGN (field
, type_align
);
976 /* Targets might chose to handle unnamed and hence possibly
977 zero-width bitfield. Those are not influenced by #pragmas
978 or packed attributes. */
979 if (integer_zerop (DECL_SIZE (field
)))
981 if (initial_max_fld_align
)
982 type_align
= MIN (type_align
,
983 initial_max_fld_align
* BITS_PER_UNIT
);
985 else if (maximum_field_alignment
!= 0)
986 type_align
= MIN (type_align
, maximum_field_alignment
);
987 else if (DECL_PACKED (field
))
988 type_align
= MIN (type_align
, BITS_PER_UNIT
);
990 /* The alignment of the record is increased to the maximum
991 of the current alignment, the alignment indicated on the
992 field (i.e., the alignment specified by an __aligned__
993 attribute), and the alignment indicated by the type of
995 rli
->record_align
= MAX (rli
->record_align
, desired_align
);
996 rli
->record_align
= MAX (rli
->record_align
, type_align
);
999 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
1000 user_align
|= TYPE_USER_ALIGN (type
);
1006 rli
->record_align
= MAX (rli
->record_align
, desired_align
);
1007 rli
->unpacked_align
= MAX (rli
->unpacked_align
, TYPE_ALIGN (type
));
1010 TYPE_USER_ALIGN (rli
->t
) |= user_align
;
1012 return desired_align
;
1015 /* Called from place_field to handle unions. */
1018 place_union_field (record_layout_info rli
, tree field
)
1020 update_alignment_for_field (rli
, field
, /*known_align=*/0);
1022 DECL_FIELD_OFFSET (field
) = size_zero_node
;
1023 DECL_FIELD_BIT_OFFSET (field
) = bitsize_zero_node
;
1024 SET_DECL_OFFSET_ALIGN (field
, BIGGEST_ALIGNMENT
);
1026 /* If this is an ERROR_MARK return *after* having set the
1027 field at the start of the union. This helps when parsing
1029 if (TREE_CODE (TREE_TYPE (field
)) == ERROR_MARK
)
1032 /* We assume the union's size will be a multiple of a byte so we don't
1033 bother with BITPOS. */
1034 if (TREE_CODE (rli
->t
) == UNION_TYPE
)
1035 rli
->offset
= size_binop (MAX_EXPR
, rli
->offset
, DECL_SIZE_UNIT (field
));
1036 else if (TREE_CODE (rli
->t
) == QUAL_UNION_TYPE
)
1037 rli
->offset
= fold_build3 (COND_EXPR
, sizetype
, DECL_QUALIFIER (field
),
1038 DECL_SIZE_UNIT (field
), rli
->offset
);
1041 #if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED)
1042 /* A bitfield of SIZE with a required access alignment of ALIGN is allocated
1043 at BYTE_OFFSET / BIT_OFFSET. Return nonzero if the field would span more
1044 units of alignment than the underlying TYPE. */
1046 excess_unit_span (HOST_WIDE_INT byte_offset
, HOST_WIDE_INT bit_offset
,
1047 HOST_WIDE_INT size
, HOST_WIDE_INT align
, tree type
)
1049 /* Note that the calculation of OFFSET might overflow; we calculate it so
1050 that we still get the right result as long as ALIGN is a power of two. */
1051 unsigned HOST_WIDE_INT offset
= byte_offset
* BITS_PER_UNIT
+ bit_offset
;
1053 offset
= offset
% align
;
1054 return ((offset
+ size
+ align
- 1) / align
1055 > ((unsigned HOST_WIDE_INT
) tree_to_uhwi (TYPE_SIZE (type
))
1060 /* RLI contains information about the layout of a RECORD_TYPE. FIELD
1061 is a FIELD_DECL to be added after those fields already present in
1062 T. (FIELD is not actually added to the TYPE_FIELDS list here;
1063 callers that desire that behavior must manually perform that step.) */
1066 place_field (record_layout_info rli
, tree field
)
1068 /* The alignment required for FIELD. */
1069 unsigned int desired_align
;
1070 /* The alignment FIELD would have if we just dropped it into the
1071 record as it presently stands. */
1072 unsigned int known_align
;
1073 unsigned int actual_align
;
1074 /* The type of this field. */
1075 tree type
= TREE_TYPE (field
);
1077 gcc_assert (TREE_CODE (field
) != ERROR_MARK
);
1079 /* If FIELD is static, then treat it like a separate variable, not
1080 really like a structure field. If it is a FUNCTION_DECL, it's a
1081 method. In both cases, all we do is lay out the decl, and we do
1082 it *after* the record is laid out. */
1083 if (TREE_CODE (field
) == VAR_DECL
)
1085 vec_safe_push (rli
->pending_statics
, field
);
1089 /* Enumerators and enum types which are local to this class need not
1090 be laid out. Likewise for initialized constant fields. */
1091 else if (TREE_CODE (field
) != FIELD_DECL
)
1094 /* Unions are laid out very differently than records, so split
1095 that code off to another function. */
1096 else if (TREE_CODE (rli
->t
) != RECORD_TYPE
)
1098 place_union_field (rli
, field
);
1102 else if (TREE_CODE (type
) == ERROR_MARK
)
1104 /* Place this field at the current allocation position, so we
1105 maintain monotonicity. */
1106 DECL_FIELD_OFFSET (field
) = rli
->offset
;
1107 DECL_FIELD_BIT_OFFSET (field
) = rli
->bitpos
;
1108 SET_DECL_OFFSET_ALIGN (field
, rli
->offset_align
);
1112 /* Work out the known alignment so far. Note that A & (-A) is the
1113 value of the least-significant bit in A that is one. */
1114 if (! integer_zerop (rli
->bitpos
))
1115 known_align
= (tree_to_uhwi (rli
->bitpos
)
1116 & - tree_to_uhwi (rli
->bitpos
));
1117 else if (integer_zerop (rli
->offset
))
1119 else if (tree_fits_uhwi_p (rli
->offset
))
1120 known_align
= (BITS_PER_UNIT
1121 * (tree_to_uhwi (rli
->offset
)
1122 & - tree_to_uhwi (rli
->offset
)));
1124 known_align
= rli
->offset_align
;
1126 desired_align
= update_alignment_for_field (rli
, field
, known_align
);
1127 if (known_align
== 0)
1128 known_align
= MAX (BIGGEST_ALIGNMENT
, rli
->record_align
);
1130 if (warn_packed
&& DECL_PACKED (field
))
1132 if (known_align
>= TYPE_ALIGN (type
))
1134 if (TYPE_ALIGN (type
) > desired_align
)
1136 if (STRICT_ALIGNMENT
)
1137 warning (OPT_Wattributes
, "packed attribute causes "
1138 "inefficient alignment for %q+D", field
);
1139 /* Don't warn if DECL_PACKED was set by the type. */
1140 else if (!TYPE_PACKED (rli
->t
))
1141 warning (OPT_Wattributes
, "packed attribute is "
1142 "unnecessary for %q+D", field
);
1146 rli
->packed_maybe_necessary
= 1;
1149 /* Does this field automatically have alignment it needs by virtue
1150 of the fields that precede it and the record's own alignment? */
1151 if (known_align
< desired_align
)
1153 /* No, we need to skip space before this field.
1154 Bump the cumulative size to multiple of field alignment. */
1156 if (!targetm
.ms_bitfield_layout_p (rli
->t
)
1157 && DECL_SOURCE_LOCATION (field
) != BUILTINS_LOCATION
)
1158 warning (OPT_Wpadded
, "padding struct to align %q+D", field
);
1160 /* If the alignment is still within offset_align, just align
1161 the bit position. */
1162 if (desired_align
< rli
->offset_align
)
1163 rli
->bitpos
= round_up (rli
->bitpos
, desired_align
);
1166 /* First adjust OFFSET by the partial bits, then align. */
1168 = size_binop (PLUS_EXPR
, rli
->offset
,
1169 fold_convert (sizetype
,
1170 size_binop (CEIL_DIV_EXPR
, rli
->bitpos
,
1171 bitsize_unit_node
)));
1172 rli
->bitpos
= bitsize_zero_node
;
1174 rli
->offset
= round_up (rli
->offset
, desired_align
/ BITS_PER_UNIT
);
1177 if (! TREE_CONSTANT (rli
->offset
))
1178 rli
->offset_align
= desired_align
;
1179 if (targetm
.ms_bitfield_layout_p (rli
->t
))
1180 rli
->prev_field
= NULL
;
1183 /* Handle compatibility with PCC. Note that if the record has any
1184 variable-sized fields, we need not worry about compatibility. */
1185 #ifdef PCC_BITFIELD_TYPE_MATTERS
1186 if (PCC_BITFIELD_TYPE_MATTERS
1187 && ! targetm
.ms_bitfield_layout_p (rli
->t
)
1188 && TREE_CODE (field
) == FIELD_DECL
1189 && type
!= error_mark_node
1190 && DECL_BIT_FIELD (field
)
1191 && (! DECL_PACKED (field
)
1192 /* Enter for these packed fields only to issue a warning. */
1193 || TYPE_ALIGN (type
) <= BITS_PER_UNIT
)
1194 && maximum_field_alignment
== 0
1195 && ! integer_zerop (DECL_SIZE (field
))
1196 && tree_fits_uhwi_p (DECL_SIZE (field
))
1197 /* BUG!!! rli->offset is checked as unsigned but used as signed. */
1198 && tree_fits_uhwi_p (rli
->offset
)
1199 && tree_fits_uhwi_p (TYPE_SIZE (type
)))
1201 unsigned int type_align
= TYPE_ALIGN (type
);
1202 tree dsize
= DECL_SIZE (field
);
1203 HOST_WIDE_INT field_size
= tree_to_uhwi (dsize
);
1204 HOST_WIDE_INT offset
= tree_to_shwi (rli
->offset
);
1205 HOST_WIDE_INT bit_offset
= tree_to_shwi (rli
->bitpos
);
1207 #ifdef ADJUST_FIELD_ALIGN
1208 if (! TYPE_USER_ALIGN (type
))
1209 type_align
= ADJUST_FIELD_ALIGN (field
, type_align
);
1212 /* A bit field may not span more units of alignment of its type
1213 than its type itself. Advance to next boundary if necessary. */
1214 if (excess_unit_span (offset
, bit_offset
, field_size
, type_align
, type
))
1216 if (DECL_PACKED (field
))
1218 if (warn_packed_bitfield_compat
== 1)
1221 "offset of packed bit-field %qD has changed in GCC 4.4",
1225 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1228 if (! DECL_PACKED (field
))
1229 TYPE_USER_ALIGN (rli
->t
) |= TYPE_USER_ALIGN (type
);
1233 #ifdef BITFIELD_NBYTES_LIMITED
1234 if (BITFIELD_NBYTES_LIMITED
1235 && ! targetm
.ms_bitfield_layout_p (rli
->t
)
1236 && TREE_CODE (field
) == FIELD_DECL
1237 && type
!= error_mark_node
1238 && DECL_BIT_FIELD_TYPE (field
)
1239 && ! DECL_PACKED (field
)
1240 && ! integer_zerop (DECL_SIZE (field
))
1241 && tree_fits_uhwi_p (DECL_SIZE (field
))
1242 /* BUG!!! rli->offset is checked as unsigned but used as signed. */
1243 && tree_fits_shwi_p (rli
->offset
)
1244 && tree_fits_uhwi_p (TYPE_SIZE (type
)))
1246 unsigned int type_align
= TYPE_ALIGN (type
);
1247 tree dsize
= DECL_SIZE (field
);
1248 HOST_WIDE_INT field_size
= tree_to_uhwi (dsize
);
1249 HOST_WIDE_INT offset
= tree_to_shwi (rli
->offset
);
1250 HOST_WIDE_INT bit_offset
= tree_to_shwi (rli
->bitpos
);
1252 #ifdef ADJUST_FIELD_ALIGN
1253 if (! TYPE_USER_ALIGN (type
))
1254 type_align
= ADJUST_FIELD_ALIGN (field
, type_align
);
1257 if (maximum_field_alignment
!= 0)
1258 type_align
= MIN (type_align
, maximum_field_alignment
);
1259 /* ??? This test is opposite the test in the containing if
1260 statement, so this code is unreachable currently. */
1261 else if (DECL_PACKED (field
))
1262 type_align
= MIN (type_align
, BITS_PER_UNIT
);
1264 /* A bit field may not span the unit of alignment of its type.
1265 Advance to next boundary if necessary. */
1266 if (excess_unit_span (offset
, bit_offset
, field_size
, type_align
, type
))
1267 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1269 TYPE_USER_ALIGN (rli
->t
) |= TYPE_USER_ALIGN (type
);
1273 /* See the docs for TARGET_MS_BITFIELD_LAYOUT_P for details.
1275 When a bit field is inserted into a packed record, the whole
1276 size of the underlying type is used by one or more same-size
1277 adjacent bitfields. (That is, if its long:3, 32 bits is
1278 used in the record, and any additional adjacent long bitfields are
1279 packed into the same chunk of 32 bits. However, if the size
1280 changes, a new field of that size is allocated.) In an unpacked
1281 record, this is the same as using alignment, but not equivalent
1284 Note: for compatibility, we use the type size, not the type alignment
1285 to determine alignment, since that matches the documentation */
1287 if (targetm
.ms_bitfield_layout_p (rli
->t
))
1289 tree prev_saved
= rli
->prev_field
;
1290 tree prev_type
= prev_saved
? DECL_BIT_FIELD_TYPE (prev_saved
) : NULL
;
1292 /* This is a bitfield if it exists. */
1293 if (rli
->prev_field
)
1295 /* If both are bitfields, nonzero, and the same size, this is
1296 the middle of a run. Zero declared size fields are special
1297 and handled as "end of run". (Note: it's nonzero declared
1298 size, but equal type sizes!) (Since we know that both
1299 the current and previous fields are bitfields by the
1300 time we check it, DECL_SIZE must be present for both.) */
1301 if (DECL_BIT_FIELD_TYPE (field
)
1302 && !integer_zerop (DECL_SIZE (field
))
1303 && !integer_zerop (DECL_SIZE (rli
->prev_field
))
1304 && tree_fits_shwi_p (DECL_SIZE (rli
->prev_field
))
1305 /* BUG!!! TYPE_SIZE (type) is checked as unsigned but used as signed. */
1306 && tree_fits_shwi_p (TYPE_SIZE (type
))
1307 && simple_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (prev_type
)))
1309 /* We're in the middle of a run of equal type size fields; make
1310 sure we realign if we run out of bits. (Not decl size,
1312 HOST_WIDE_INT bitsize
= tree_to_uhwi (DECL_SIZE (field
));
1314 if (rli
->remaining_in_alignment
< bitsize
)
1316 HOST_WIDE_INT typesize
= tree_to_uhwi (TYPE_SIZE (type
));
1318 /* out of bits; bump up to next 'word'. */
1320 = size_binop (PLUS_EXPR
, rli
->bitpos
,
1321 bitsize_int (rli
->remaining_in_alignment
));
1322 rli
->prev_field
= field
;
1323 if (typesize
< bitsize
)
1324 rli
->remaining_in_alignment
= 0;
1326 rli
->remaining_in_alignment
= typesize
- bitsize
;
1329 rli
->remaining_in_alignment
-= bitsize
;
1333 /* End of a run: if leaving a run of bitfields of the same type
1334 size, we have to "use up" the rest of the bits of the type
1337 Compute the new position as the sum of the size for the prior
1338 type and where we first started working on that type.
1339 Note: since the beginning of the field was aligned then
1340 of course the end will be too. No round needed. */
1342 if (!integer_zerop (DECL_SIZE (rli
->prev_field
)))
1345 = size_binop (PLUS_EXPR
, rli
->bitpos
,
1346 bitsize_int (rli
->remaining_in_alignment
));
1349 /* We "use up" size zero fields; the code below should behave
1350 as if the prior field was not a bitfield. */
1353 /* Cause a new bitfield to be captured, either this time (if
1354 currently a bitfield) or next time we see one. */
1355 if (!DECL_BIT_FIELD_TYPE (field
)
1356 || integer_zerop (DECL_SIZE (field
)))
1357 rli
->prev_field
= NULL
;
1360 normalize_rli (rli
);
1363 /* If we're starting a new run of same type size bitfields
1364 (or a run of non-bitfields), set up the "first of the run"
1367 That is, if the current field is not a bitfield, or if there
1368 was a prior bitfield the type sizes differ, or if there wasn't
1369 a prior bitfield the size of the current field is nonzero.
1371 Note: we must be sure to test ONLY the type size if there was
1372 a prior bitfield and ONLY for the current field being zero if
1375 if (!DECL_BIT_FIELD_TYPE (field
)
1376 || (prev_saved
!= NULL
1377 ? !simple_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (prev_type
))
1378 : !integer_zerop (DECL_SIZE (field
)) ))
1380 /* Never smaller than a byte for compatibility. */
1381 unsigned int type_align
= BITS_PER_UNIT
;
1383 /* (When not a bitfield), we could be seeing a flex array (with
1384 no DECL_SIZE). Since we won't be using remaining_in_alignment
1385 until we see a bitfield (and come by here again) we just skip
1387 if (DECL_SIZE (field
) != NULL
1388 && tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (field
)))
1389 && tree_fits_uhwi_p (DECL_SIZE (field
)))
1391 unsigned HOST_WIDE_INT bitsize
1392 = tree_to_uhwi (DECL_SIZE (field
));
1393 unsigned HOST_WIDE_INT typesize
1394 = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (field
)));
1396 if (typesize
< bitsize
)
1397 rli
->remaining_in_alignment
= 0;
1399 rli
->remaining_in_alignment
= typesize
- bitsize
;
1402 /* Now align (conventionally) for the new type. */
1403 type_align
= TYPE_ALIGN (TREE_TYPE (field
));
1405 if (maximum_field_alignment
!= 0)
1406 type_align
= MIN (type_align
, maximum_field_alignment
);
1408 rli
->bitpos
= round_up (rli
->bitpos
, type_align
);
1410 /* If we really aligned, don't allow subsequent bitfields
1412 rli
->prev_field
= NULL
;
1416 /* Offset so far becomes the position of this field after normalizing. */
1417 normalize_rli (rli
);
1418 DECL_FIELD_OFFSET (field
) = rli
->offset
;
1419 DECL_FIELD_BIT_OFFSET (field
) = rli
->bitpos
;
1420 SET_DECL_OFFSET_ALIGN (field
, rli
->offset_align
);
1422 /* If this field ended up more aligned than we thought it would be (we
1423 approximate this by seeing if its position changed), lay out the field
1424 again; perhaps we can use an integral mode for it now. */
1425 if (! integer_zerop (DECL_FIELD_BIT_OFFSET (field
)))
1426 actual_align
= (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field
))
1427 & - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field
)));
1428 else if (integer_zerop (DECL_FIELD_OFFSET (field
)))
1429 actual_align
= MAX (BIGGEST_ALIGNMENT
, rli
->record_align
);
1430 else if (tree_fits_uhwi_p (DECL_FIELD_OFFSET (field
)))
1431 actual_align
= (BITS_PER_UNIT
1432 * (tree_to_uhwi (DECL_FIELD_OFFSET (field
))
1433 & - tree_to_uhwi (DECL_FIELD_OFFSET (field
))));
1435 actual_align
= DECL_OFFSET_ALIGN (field
);
1436 /* ACTUAL_ALIGN is still the actual alignment *within the record* .
1437 store / extract bit field operations will check the alignment of the
1438 record against the mode of bit fields. */
1440 if (known_align
!= actual_align
)
1441 layout_decl (field
, actual_align
);
1443 if (rli
->prev_field
== NULL
&& DECL_BIT_FIELD_TYPE (field
))
1444 rli
->prev_field
= field
;
1446 /* Now add size of this field to the size of the record. If the size is
1447 not constant, treat the field as being a multiple of bytes and just
1448 adjust the offset, resetting the bit position. Otherwise, apportion the
1449 size amongst the bit position and offset. First handle the case of an
1450 unspecified size, which can happen when we have an invalid nested struct
1451 definition, such as struct j { struct j { int i; } }. The error message
1452 is printed in finish_struct. */
1453 if (DECL_SIZE (field
) == 0)
1455 else if (TREE_CODE (DECL_SIZE (field
)) != INTEGER_CST
1456 || TREE_OVERFLOW (DECL_SIZE (field
)))
1459 = size_binop (PLUS_EXPR
, rli
->offset
,
1460 fold_convert (sizetype
,
1461 size_binop (CEIL_DIV_EXPR
, rli
->bitpos
,
1462 bitsize_unit_node
)));
1464 = size_binop (PLUS_EXPR
, rli
->offset
, DECL_SIZE_UNIT (field
));
1465 rli
->bitpos
= bitsize_zero_node
;
1466 rli
->offset_align
= MIN (rli
->offset_align
, desired_align
);
1468 else if (targetm
.ms_bitfield_layout_p (rli
->t
))
1470 rli
->bitpos
= size_binop (PLUS_EXPR
, rli
->bitpos
, DECL_SIZE (field
));
1472 /* If we ended a bitfield before the full length of the type then
1473 pad the struct out to the full length of the last type. */
1474 if ((DECL_CHAIN (field
) == NULL
1475 || TREE_CODE (DECL_CHAIN (field
)) != FIELD_DECL
)
1476 && DECL_BIT_FIELD_TYPE (field
)
1477 && !integer_zerop (DECL_SIZE (field
)))
1478 rli
->bitpos
= size_binop (PLUS_EXPR
, rli
->bitpos
,
1479 bitsize_int (rli
->remaining_in_alignment
));
1481 normalize_rli (rli
);
1485 rli
->bitpos
= size_binop (PLUS_EXPR
, rli
->bitpos
, DECL_SIZE (field
));
1486 normalize_rli (rli
);
1490 /* Assuming that all the fields have been laid out, this function uses
1491 RLI to compute the final TYPE_SIZE, TYPE_ALIGN, etc. for the type
1492 indicated by RLI. */
1495 finalize_record_size (record_layout_info rli
)
1497 tree unpadded_size
, unpadded_size_unit
;
1499 /* Now we want just byte and bit offsets, so set the offset alignment
1500 to be a byte and then normalize. */
1501 rli
->offset_align
= BITS_PER_UNIT
;
1502 normalize_rli (rli
);
1504 /* Determine the desired alignment. */
1505 #ifdef ROUND_TYPE_ALIGN
1506 TYPE_ALIGN (rli
->t
) = ROUND_TYPE_ALIGN (rli
->t
, TYPE_ALIGN (rli
->t
),
1509 TYPE_ALIGN (rli
->t
) = MAX (TYPE_ALIGN (rli
->t
), rli
->record_align
);
1512 /* Compute the size so far. Be sure to allow for extra bits in the
1513 size in bytes. We have guaranteed above that it will be no more
1514 than a single byte. */
1515 unpadded_size
= rli_size_so_far (rli
);
1516 unpadded_size_unit
= rli_size_unit_so_far (rli
);
1517 if (! integer_zerop (rli
->bitpos
))
1519 = size_binop (PLUS_EXPR
, unpadded_size_unit
, size_one_node
);
1521 /* Round the size up to be a multiple of the required alignment. */
1522 TYPE_SIZE (rli
->t
) = round_up (unpadded_size
, TYPE_ALIGN (rli
->t
));
1523 TYPE_SIZE_UNIT (rli
->t
)
1524 = round_up (unpadded_size_unit
, TYPE_ALIGN_UNIT (rli
->t
));
1526 if (TREE_CONSTANT (unpadded_size
)
1527 && simple_cst_equal (unpadded_size
, TYPE_SIZE (rli
->t
)) == 0
1528 && input_location
!= BUILTINS_LOCATION
)
1529 warning (OPT_Wpadded
, "padding struct size to alignment boundary");
1531 if (warn_packed
&& TREE_CODE (rli
->t
) == RECORD_TYPE
1532 && TYPE_PACKED (rli
->t
) && ! rli
->packed_maybe_necessary
1533 && TREE_CONSTANT (unpadded_size
))
1537 #ifdef ROUND_TYPE_ALIGN
1539 = ROUND_TYPE_ALIGN (rli
->t
, TYPE_ALIGN (rli
->t
), rli
->unpacked_align
);
1541 rli
->unpacked_align
= MAX (TYPE_ALIGN (rli
->t
), rli
->unpacked_align
);
1544 unpacked_size
= round_up (TYPE_SIZE (rli
->t
), rli
->unpacked_align
);
1545 if (simple_cst_equal (unpacked_size
, TYPE_SIZE (rli
->t
)))
1547 if (TYPE_NAME (rli
->t
))
1551 if (TREE_CODE (TYPE_NAME (rli
->t
)) == IDENTIFIER_NODE
)
1552 name
= TYPE_NAME (rli
->t
);
1554 name
= DECL_NAME (TYPE_NAME (rli
->t
));
1556 if (STRICT_ALIGNMENT
)
1557 warning (OPT_Wpacked
, "packed attribute causes inefficient "
1558 "alignment for %qE", name
);
1560 warning (OPT_Wpacked
,
1561 "packed attribute is unnecessary for %qE", name
);
1565 if (STRICT_ALIGNMENT
)
1566 warning (OPT_Wpacked
,
1567 "packed attribute causes inefficient alignment");
1569 warning (OPT_Wpacked
, "packed attribute is unnecessary");
1575 /* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE). */
1578 compute_record_mode (tree type
)
1581 enum machine_mode mode
= VOIDmode
;
1583 /* Most RECORD_TYPEs have BLKmode, so we start off assuming that.
1584 However, if possible, we use a mode that fits in a register
1585 instead, in order to allow for better optimization down the
1587 SET_TYPE_MODE (type
, BLKmode
);
1589 if (! tree_fits_uhwi_p (TYPE_SIZE (type
)))
1592 /* A record which has any BLKmode members must itself be
1593 BLKmode; it can't go in a register. Unless the member is
1594 BLKmode only because it isn't aligned. */
1595 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
1597 if (TREE_CODE (field
) != FIELD_DECL
)
1600 if (TREE_CODE (TREE_TYPE (field
)) == ERROR_MARK
1601 || (TYPE_MODE (TREE_TYPE (field
)) == BLKmode
1602 && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field
))
1603 && !(TYPE_SIZE (TREE_TYPE (field
)) != 0
1604 && integer_zerop (TYPE_SIZE (TREE_TYPE (field
)))))
1605 || ! tree_fits_uhwi_p (bit_position (field
))
1606 || DECL_SIZE (field
) == 0
1607 || ! tree_fits_uhwi_p (DECL_SIZE (field
)))
1610 /* If this field is the whole struct, remember its mode so
1611 that, say, we can put a double in a class into a DF
1612 register instead of forcing it to live in the stack. */
1613 if (simple_cst_equal (TYPE_SIZE (type
), DECL_SIZE (field
)))
1614 mode
= DECL_MODE (field
);
1616 /* With some targets, it is sub-optimal to access an aligned
1617 BLKmode structure as a scalar. */
1618 if (targetm
.member_type_forces_blk (field
, mode
))
1622 /* If we only have one real field; use its mode if that mode's size
1623 matches the type's size. This only applies to RECORD_TYPE. This
1624 does not apply to unions. */
1625 if (TREE_CODE (type
) == RECORD_TYPE
&& mode
!= VOIDmode
1626 && tree_fits_uhwi_p (TYPE_SIZE (type
))
1627 && GET_MODE_BITSIZE (mode
) == tree_to_uhwi (TYPE_SIZE (type
)))
1628 SET_TYPE_MODE (type
, mode
);
1630 SET_TYPE_MODE (type
, mode_for_size_tree (TYPE_SIZE (type
), MODE_INT
, 1));
1632 /* If structure's known alignment is less than what the scalar
1633 mode would need, and it matters, then stick with BLKmode. */
1634 if (TYPE_MODE (type
) != BLKmode
1636 && ! (TYPE_ALIGN (type
) >= BIGGEST_ALIGNMENT
1637 || TYPE_ALIGN (type
) >= GET_MODE_ALIGNMENT (TYPE_MODE (type
))))
1639 /* If this is the only reason this type is BLKmode, then
1640 don't force containing types to be BLKmode. */
1641 TYPE_NO_FORCE_BLK (type
) = 1;
1642 SET_TYPE_MODE (type
, BLKmode
);
1646 /* Compute TYPE_SIZE and TYPE_ALIGN for TYPE, once it has been laid
1650 finalize_type_size (tree type
)
1652 /* Normally, use the alignment corresponding to the mode chosen.
1653 However, where strict alignment is not required, avoid
1654 over-aligning structures, since most compilers do not do this
1657 if (TYPE_MODE (type
) != BLKmode
&& TYPE_MODE (type
) != VOIDmode
1658 && (STRICT_ALIGNMENT
1659 || (TREE_CODE (type
) != RECORD_TYPE
&& TREE_CODE (type
) != UNION_TYPE
1660 && TREE_CODE (type
) != QUAL_UNION_TYPE
1661 && TREE_CODE (type
) != ARRAY_TYPE
)))
1663 unsigned mode_align
= GET_MODE_ALIGNMENT (TYPE_MODE (type
));
1665 /* Don't override a larger alignment requirement coming from a user
1666 alignment of one of the fields. */
1667 if (mode_align
>= TYPE_ALIGN (type
))
1669 TYPE_ALIGN (type
) = mode_align
;
1670 TYPE_USER_ALIGN (type
) = 0;
1674 /* Do machine-dependent extra alignment. */
1675 #ifdef ROUND_TYPE_ALIGN
1677 = ROUND_TYPE_ALIGN (type
, TYPE_ALIGN (type
), BITS_PER_UNIT
);
1680 /* If we failed to find a simple way to calculate the unit size
1681 of the type, find it by division. */
1682 if (TYPE_SIZE_UNIT (type
) == 0 && TYPE_SIZE (type
) != 0)
1683 /* TYPE_SIZE (type) is computed in bitsizetype. After the division, the
1684 result will fit in sizetype. We will get more efficient code using
1685 sizetype, so we force a conversion. */
1686 TYPE_SIZE_UNIT (type
)
1687 = fold_convert (sizetype
,
1688 size_binop (FLOOR_DIV_EXPR
, TYPE_SIZE (type
),
1689 bitsize_unit_node
));
1691 if (TYPE_SIZE (type
) != 0)
1693 TYPE_SIZE (type
) = round_up (TYPE_SIZE (type
), TYPE_ALIGN (type
));
1694 TYPE_SIZE_UNIT (type
)
1695 = round_up (TYPE_SIZE_UNIT (type
), TYPE_ALIGN_UNIT (type
));
1698 /* Evaluate nonconstant sizes only once, either now or as soon as safe. */
1699 if (TYPE_SIZE (type
) != 0 && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1700 TYPE_SIZE (type
) = variable_size (TYPE_SIZE (type
));
1701 if (TYPE_SIZE_UNIT (type
) != 0
1702 && TREE_CODE (TYPE_SIZE_UNIT (type
)) != INTEGER_CST
)
1703 TYPE_SIZE_UNIT (type
) = variable_size (TYPE_SIZE_UNIT (type
));
1705 /* Also layout any other variants of the type. */
1706 if (TYPE_NEXT_VARIANT (type
)
1707 || type
!= TYPE_MAIN_VARIANT (type
))
1710 /* Record layout info of this variant. */
1711 tree size
= TYPE_SIZE (type
);
1712 tree size_unit
= TYPE_SIZE_UNIT (type
);
1713 unsigned int align
= TYPE_ALIGN (type
);
1714 unsigned int user_align
= TYPE_USER_ALIGN (type
);
1715 enum machine_mode mode
= TYPE_MODE (type
);
1717 /* Copy it into all variants. */
1718 for (variant
= TYPE_MAIN_VARIANT (type
);
1720 variant
= TYPE_NEXT_VARIANT (variant
))
1722 TYPE_SIZE (variant
) = size
;
1723 TYPE_SIZE_UNIT (variant
) = size_unit
;
1724 TYPE_ALIGN (variant
) = align
;
1725 TYPE_USER_ALIGN (variant
) = user_align
;
1726 SET_TYPE_MODE (variant
, mode
);
1731 /* Return a new underlying object for a bitfield started with FIELD. */
1734 start_bitfield_representative (tree field
)
1736 tree repr
= make_node (FIELD_DECL
);
1737 DECL_FIELD_OFFSET (repr
) = DECL_FIELD_OFFSET (field
);
1738 /* Force the representative to begin at a BITS_PER_UNIT aligned
1739 boundary - C++ may use tail-padding of a base object to
1740 continue packing bits so the bitfield region does not start
1741 at bit zero (see g++.dg/abi/bitfield5.C for example).
1742 Unallocated bits may happen for other reasons as well,
1743 for example Ada which allows explicit bit-granular structure layout. */
1744 DECL_FIELD_BIT_OFFSET (repr
)
1745 = size_binop (BIT_AND_EXPR
,
1746 DECL_FIELD_BIT_OFFSET (field
),
1747 bitsize_int (~(BITS_PER_UNIT
- 1)));
1748 SET_DECL_OFFSET_ALIGN (repr
, DECL_OFFSET_ALIGN (field
));
1749 DECL_SIZE (repr
) = DECL_SIZE (field
);
1750 DECL_SIZE_UNIT (repr
) = DECL_SIZE_UNIT (field
);
1751 DECL_PACKED (repr
) = DECL_PACKED (field
);
1752 DECL_CONTEXT (repr
) = DECL_CONTEXT (field
);
1756 /* Finish up a bitfield group that was started by creating the underlying
1757 object REPR with the last field in the bitfield group FIELD. */
1760 finish_bitfield_representative (tree repr
, tree field
)
1762 unsigned HOST_WIDE_INT bitsize
, maxbitsize
;
1763 enum machine_mode mode
;
1766 size
= size_diffop (DECL_FIELD_OFFSET (field
),
1767 DECL_FIELD_OFFSET (repr
));
1768 gcc_assert (tree_fits_uhwi_p (size
));
1769 bitsize
= (tree_to_uhwi (size
) * BITS_PER_UNIT
1770 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field
))
1771 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr
))
1772 + tree_to_uhwi (DECL_SIZE (field
)));
1774 /* Round up bitsize to multiples of BITS_PER_UNIT. */
1775 bitsize
= (bitsize
+ BITS_PER_UNIT
- 1) & ~(BITS_PER_UNIT
- 1);
1777 /* Now nothing tells us how to pad out bitsize ... */
1778 nextf
= DECL_CHAIN (field
);
1779 while (nextf
&& TREE_CODE (nextf
) != FIELD_DECL
)
1780 nextf
= DECL_CHAIN (nextf
);
1784 /* If there was an error, the field may be not laid out
1785 correctly. Don't bother to do anything. */
1786 if (TREE_TYPE (nextf
) == error_mark_node
)
1788 maxsize
= size_diffop (DECL_FIELD_OFFSET (nextf
),
1789 DECL_FIELD_OFFSET (repr
));
1790 if (tree_fits_uhwi_p (maxsize
))
1792 maxbitsize
= (tree_to_uhwi (maxsize
) * BITS_PER_UNIT
1793 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (nextf
))
1794 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr
)));
1795 /* If the group ends within a bitfield nextf does not need to be
1796 aligned to BITS_PER_UNIT. Thus round up. */
1797 maxbitsize
= (maxbitsize
+ BITS_PER_UNIT
- 1) & ~(BITS_PER_UNIT
- 1);
1800 maxbitsize
= bitsize
;
1804 /* ??? If you consider that tail-padding of this struct might be
1805 re-used when deriving from it we cannot really do the following
1806 and thus need to set maxsize to bitsize? Also we cannot
1807 generally rely on maxsize to fold to an integer constant, so
1808 use bitsize as fallback for this case. */
1809 tree maxsize
= size_diffop (TYPE_SIZE_UNIT (DECL_CONTEXT (field
)),
1810 DECL_FIELD_OFFSET (repr
));
1811 if (tree_fits_uhwi_p (maxsize
))
1812 maxbitsize
= (tree_to_uhwi (maxsize
) * BITS_PER_UNIT
1813 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr
)));
1815 maxbitsize
= bitsize
;
1818 /* Only if we don't artificially break up the representative in
1819 the middle of a large bitfield with different possibly
1820 overlapping representatives. And all representatives start
1822 gcc_assert (maxbitsize
% BITS_PER_UNIT
== 0);
1824 /* Find the smallest nice mode to use. */
1825 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_INT
); mode
!= VOIDmode
;
1826 mode
= GET_MODE_WIDER_MODE (mode
))
1827 if (GET_MODE_BITSIZE (mode
) >= bitsize
)
1829 if (mode
!= VOIDmode
1830 && (GET_MODE_BITSIZE (mode
) > maxbitsize
1831 || GET_MODE_BITSIZE (mode
) > MAX_FIXED_MODE_SIZE
))
1834 if (mode
== VOIDmode
)
1836 /* We really want a BLKmode representative only as a last resort,
1837 considering the member b in
1838 struct { int a : 7; int b : 17; int c; } __attribute__((packed));
1839 Otherwise we simply want to split the representative up
1840 allowing for overlaps within the bitfield region as required for
1841 struct { int a : 7; int b : 7;
1842 int c : 10; int d; } __attribute__((packed));
1843 [0, 15] HImode for a and b, [8, 23] HImode for c. */
1844 DECL_SIZE (repr
) = bitsize_int (bitsize
);
1845 DECL_SIZE_UNIT (repr
) = size_int (bitsize
/ BITS_PER_UNIT
);
1846 DECL_MODE (repr
) = BLKmode
;
1847 TREE_TYPE (repr
) = build_array_type_nelts (unsigned_char_type_node
,
1848 bitsize
/ BITS_PER_UNIT
);
1852 unsigned HOST_WIDE_INT modesize
= GET_MODE_BITSIZE (mode
);
1853 DECL_SIZE (repr
) = bitsize_int (modesize
);
1854 DECL_SIZE_UNIT (repr
) = size_int (modesize
/ BITS_PER_UNIT
);
1855 DECL_MODE (repr
) = mode
;
1856 TREE_TYPE (repr
) = lang_hooks
.types
.type_for_mode (mode
, 1);
1859 /* Remember whether the bitfield group is at the end of the
1860 structure or not. */
1861 DECL_CHAIN (repr
) = nextf
;
1864 /* Compute and set FIELD_DECLs for the underlying objects we should
1865 use for bitfield access for the structure laid out with RLI. */
1868 finish_bitfield_layout (record_layout_info rli
)
1871 tree repr
= NULL_TREE
;
1873 /* Unions would be special, for the ease of type-punning optimizations
1874 we could use the underlying type as hint for the representative
1875 if the bitfield would fit and the representative would not exceed
1876 the union in size. */
1877 if (TREE_CODE (rli
->t
) != RECORD_TYPE
)
1880 for (prev
= NULL_TREE
, field
= TYPE_FIELDS (rli
->t
);
1881 field
; field
= DECL_CHAIN (field
))
1883 if (TREE_CODE (field
) != FIELD_DECL
)
1886 /* In the C++ memory model, consecutive bit fields in a structure are
1887 considered one memory location and updating a memory location
1888 may not store into adjacent memory locations. */
1890 && DECL_BIT_FIELD_TYPE (field
))
1892 /* Start new representative. */
1893 repr
= start_bitfield_representative (field
);
1896 && ! DECL_BIT_FIELD_TYPE (field
))
1898 /* Finish off new representative. */
1899 finish_bitfield_representative (repr
, prev
);
1902 else if (DECL_BIT_FIELD_TYPE (field
))
1904 gcc_assert (repr
!= NULL_TREE
);
1906 /* Zero-size bitfields finish off a representative and
1907 do not have a representative themselves. This is
1908 required by the C++ memory model. */
1909 if (integer_zerop (DECL_SIZE (field
)))
1911 finish_bitfield_representative (repr
, prev
);
1915 /* We assume that either DECL_FIELD_OFFSET of the representative
1916 and each bitfield member is a constant or they are equal.
1917 This is because we need to be able to compute the bit-offset
1918 of each field relative to the representative in get_bit_range
1919 during RTL expansion.
1920 If these constraints are not met, simply force a new
1921 representative to be generated. That will at most
1922 generate worse code but still maintain correctness with
1923 respect to the C++ memory model. */
1924 else if (!((tree_fits_uhwi_p (DECL_FIELD_OFFSET (repr
))
1925 && tree_fits_uhwi_p (DECL_FIELD_OFFSET (field
)))
1926 || operand_equal_p (DECL_FIELD_OFFSET (repr
),
1927 DECL_FIELD_OFFSET (field
), 0)))
1929 finish_bitfield_representative (repr
, prev
);
1930 repr
= start_bitfield_representative (field
);
1937 DECL_BIT_FIELD_REPRESENTATIVE (field
) = repr
;
1943 finish_bitfield_representative (repr
, prev
);
1946 /* Do all of the work required to layout the type indicated by RLI,
1947 once the fields have been laid out. This function will call `free'
1948 for RLI, unless FREE_P is false. Passing a value other than false
1949 for FREE_P is bad practice; this option only exists to support the
1953 finish_record_layout (record_layout_info rli
, int free_p
)
1957 /* Compute the final size. */
1958 finalize_record_size (rli
);
1960 /* Compute the TYPE_MODE for the record. */
1961 compute_record_mode (rli
->t
);
1963 /* Perform any last tweaks to the TYPE_SIZE, etc. */
1964 finalize_type_size (rli
->t
);
1966 /* Compute bitfield representatives. */
1967 finish_bitfield_layout (rli
);
1969 /* Propagate TYPE_PACKED to variants. With C++ templates,
1970 handle_packed_attribute is too early to do this. */
1971 for (variant
= TYPE_NEXT_VARIANT (rli
->t
); variant
;
1972 variant
= TYPE_NEXT_VARIANT (variant
))
1973 TYPE_PACKED (variant
) = TYPE_PACKED (rli
->t
);
1975 /* Lay out any static members. This is done now because their type
1976 may use the record's type. */
1977 while (!vec_safe_is_empty (rli
->pending_statics
))
1978 layout_decl (rli
->pending_statics
->pop (), 0);
1983 vec_free (rli
->pending_statics
);
1989 /* Finish processing a builtin RECORD_TYPE type TYPE. It's name is
1990 NAME, its fields are chained in reverse on FIELDS.
1992 If ALIGN_TYPE is non-null, it is given the same alignment as
1996 finish_builtin_struct (tree type
, const char *name
, tree fields
,
2001 for (tail
= NULL_TREE
; fields
; tail
= fields
, fields
= next
)
2003 DECL_FIELD_CONTEXT (fields
) = type
;
2004 next
= DECL_CHAIN (fields
);
2005 DECL_CHAIN (fields
) = tail
;
2007 TYPE_FIELDS (type
) = tail
;
2011 TYPE_ALIGN (type
) = TYPE_ALIGN (align_type
);
2012 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (align_type
);
2016 #if 0 /* not yet, should get fixed properly later */
2017 TYPE_NAME (type
) = make_type_decl (get_identifier (name
), type
);
2019 TYPE_NAME (type
) = build_decl (BUILTINS_LOCATION
,
2020 TYPE_DECL
, get_identifier (name
), type
);
2022 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
2023 layout_decl (TYPE_NAME (type
), 0);
2026 /* Calculate the mode, size, and alignment for TYPE.
2027 For an array type, calculate the element separation as well.
2028 Record TYPE on the chain of permanent or temporary types
2029 so that dbxout will find out about it.
2031 TYPE_SIZE of a type is nonzero if the type has been laid out already.
2032 layout_type does nothing on such a type.
2034 If the type is incomplete, its TYPE_SIZE remains zero. */
2037 layout_type (tree type
)
2041 if (type
== error_mark_node
)
2044 /* Do nothing if type has been laid out before. */
2045 if (TYPE_SIZE (type
))
2048 switch (TREE_CODE (type
))
2051 /* This kind of type is the responsibility
2052 of the language-specific code. */
2058 SET_TYPE_MODE (type
,
2059 smallest_mode_for_size (TYPE_PRECISION (type
), MODE_INT
));
2060 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2061 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2065 SET_TYPE_MODE (type
,
2066 mode_for_size (TYPE_PRECISION (type
), MODE_FLOAT
, 0));
2067 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2068 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2071 case FIXED_POINT_TYPE
:
2072 /* TYPE_MODE (type) has been set already. */
2073 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2074 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2078 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TREE_TYPE (type
));
2079 SET_TYPE_MODE (type
,
2080 mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type
)),
2081 (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
2082 ? MODE_COMPLEX_FLOAT
: MODE_COMPLEX_INT
),
2084 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2085 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2090 int nunits
= TYPE_VECTOR_SUBPARTS (type
);
2091 tree innertype
= TREE_TYPE (type
);
2093 gcc_assert (!(nunits
& (nunits
- 1)));
2095 /* Find an appropriate mode for the vector type. */
2096 if (TYPE_MODE (type
) == VOIDmode
)
2097 SET_TYPE_MODE (type
,
2098 mode_for_vector (TYPE_MODE (innertype
), nunits
));
2100 TYPE_SATURATING (type
) = TYPE_SATURATING (TREE_TYPE (type
));
2101 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TREE_TYPE (type
));
2102 TYPE_SIZE_UNIT (type
) = int_const_binop (MULT_EXPR
,
2103 TYPE_SIZE_UNIT (innertype
),
2105 TYPE_SIZE (type
) = int_const_binop (MULT_EXPR
, TYPE_SIZE (innertype
),
2106 bitsize_int (nunits
));
2108 /* For vector types, we do not default to the mode's alignment.
2109 Instead, query a target hook, defaulting to natural alignment.
2110 This prevents ABI changes depending on whether or not native
2111 vector modes are supported. */
2112 TYPE_ALIGN (type
) = targetm
.vector_alignment (type
);
2114 /* However, if the underlying mode requires a bigger alignment than
2115 what the target hook provides, we cannot use the mode. For now,
2116 simply reject that case. */
2117 gcc_assert (TYPE_ALIGN (type
)
2118 >= GET_MODE_ALIGNMENT (TYPE_MODE (type
)));
2123 /* This is an incomplete type and so doesn't have a size. */
2124 TYPE_ALIGN (type
) = 1;
2125 TYPE_USER_ALIGN (type
) = 0;
2126 SET_TYPE_MODE (type
, VOIDmode
);
2129 case POINTER_BOUNDS_TYPE
:
2130 SET_TYPE_MODE (type
,
2131 mode_for_size (TYPE_PRECISION (type
),
2132 MODE_POINTER_BOUNDS
, 0));
2133 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type
)));
2134 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (TYPE_MODE (type
)));
2138 TYPE_SIZE (type
) = bitsize_int (POINTER_SIZE
);
2139 TYPE_SIZE_UNIT (type
) = size_int (POINTER_SIZE
/ BITS_PER_UNIT
);
2140 /* A pointer might be MODE_PARTIAL_INT,
2141 but ptrdiff_t must be integral. */
2142 SET_TYPE_MODE (type
, mode_for_size (POINTER_SIZE
, MODE_INT
, 0));
2143 TYPE_PRECISION (type
) = POINTER_SIZE
;
2148 /* It's hard to see what the mode and size of a function ought to
2149 be, but we do know the alignment is FUNCTION_BOUNDARY, so
2150 make it consistent with that. */
2151 SET_TYPE_MODE (type
, mode_for_size (FUNCTION_BOUNDARY
, MODE_INT
, 0));
2152 TYPE_SIZE (type
) = bitsize_int (FUNCTION_BOUNDARY
);
2153 TYPE_SIZE_UNIT (type
) = size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
2157 case REFERENCE_TYPE
:
2159 enum machine_mode mode
= TYPE_MODE (type
);
2160 if (TREE_CODE (type
) == REFERENCE_TYPE
&& reference_types_internal
)
2162 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (type
));
2163 mode
= targetm
.addr_space
.address_mode (as
);
2166 TYPE_SIZE (type
) = bitsize_int (GET_MODE_BITSIZE (mode
));
2167 TYPE_SIZE_UNIT (type
) = size_int (GET_MODE_SIZE (mode
));
2168 TYPE_UNSIGNED (type
) = 1;
2169 TYPE_PRECISION (type
) = GET_MODE_BITSIZE (mode
);
2175 tree index
= TYPE_DOMAIN (type
);
2176 tree element
= TREE_TYPE (type
);
2178 build_pointer_type (element
);
2180 /* We need to know both bounds in order to compute the size. */
2181 if (index
&& TYPE_MAX_VALUE (index
) && TYPE_MIN_VALUE (index
)
2182 && TYPE_SIZE (element
))
2184 tree ub
= TYPE_MAX_VALUE (index
);
2185 tree lb
= TYPE_MIN_VALUE (index
);
2186 tree element_size
= TYPE_SIZE (element
);
2189 /* Make sure that an array of zero-sized element is zero-sized
2190 regardless of its extent. */
2191 if (integer_zerop (element_size
))
2192 length
= size_zero_node
;
2194 /* The computation should happen in the original signedness so
2195 that (possible) negative values are handled appropriately
2196 when determining overflow. */
2199 /* ??? When it is obvious that the range is signed
2200 represent it using ssizetype. */
2201 if (TREE_CODE (lb
) == INTEGER_CST
2202 && TREE_CODE (ub
) == INTEGER_CST
2203 && TYPE_UNSIGNED (TREE_TYPE (lb
))
2204 && tree_int_cst_lt (ub
, lb
))
2206 lb
= wide_int_to_tree (ssizetype
,
2207 offset_int::from (lb
, SIGNED
));
2208 ub
= wide_int_to_tree (ssizetype
,
2209 offset_int::from (ub
, SIGNED
));
2212 = fold_convert (sizetype
,
2213 size_binop (PLUS_EXPR
,
2214 build_int_cst (TREE_TYPE (lb
), 1),
2215 size_binop (MINUS_EXPR
, ub
, lb
)));
2218 /* ??? We have no way to distinguish a null-sized array from an
2219 array spanning the whole sizetype range, so we arbitrarily
2220 decide that [0, -1] is the only valid representation. */
2221 if (integer_zerop (length
)
2222 && TREE_OVERFLOW (length
)
2223 && integer_zerop (lb
))
2224 length
= size_zero_node
;
2226 TYPE_SIZE (type
) = size_binop (MULT_EXPR
, element_size
,
2227 fold_convert (bitsizetype
,
2230 /* If we know the size of the element, calculate the total size
2231 directly, rather than do some division thing below. This
2232 optimization helps Fortran assumed-size arrays (where the
2233 size of the array is determined at runtime) substantially. */
2234 if (TYPE_SIZE_UNIT (element
))
2235 TYPE_SIZE_UNIT (type
)
2236 = size_binop (MULT_EXPR
, TYPE_SIZE_UNIT (element
), length
);
2239 /* Now round the alignment and size,
2240 using machine-dependent criteria if any. */
2242 #ifdef ROUND_TYPE_ALIGN
2244 = ROUND_TYPE_ALIGN (type
, TYPE_ALIGN (element
), BITS_PER_UNIT
);
2246 TYPE_ALIGN (type
) = MAX (TYPE_ALIGN (element
), BITS_PER_UNIT
);
2248 TYPE_USER_ALIGN (type
) = TYPE_USER_ALIGN (element
);
2249 SET_TYPE_MODE (type
, BLKmode
);
2250 if (TYPE_SIZE (type
) != 0
2251 && ! targetm
.member_type_forces_blk (type
, VOIDmode
)
2252 /* BLKmode elements force BLKmode aggregate;
2253 else extract/store fields may lose. */
2254 && (TYPE_MODE (TREE_TYPE (type
)) != BLKmode
2255 || TYPE_NO_FORCE_BLK (TREE_TYPE (type
))))
2257 SET_TYPE_MODE (type
, mode_for_array (TREE_TYPE (type
),
2259 if (TYPE_MODE (type
) != BLKmode
2260 && STRICT_ALIGNMENT
&& TYPE_ALIGN (type
) < BIGGEST_ALIGNMENT
2261 && TYPE_ALIGN (type
) < GET_MODE_ALIGNMENT (TYPE_MODE (type
)))
2263 TYPE_NO_FORCE_BLK (type
) = 1;
2264 SET_TYPE_MODE (type
, BLKmode
);
2267 /* When the element size is constant, check that it is at least as
2268 large as the element alignment. */
2269 if (TYPE_SIZE_UNIT (element
)
2270 && TREE_CODE (TYPE_SIZE_UNIT (element
)) == INTEGER_CST
2271 /* If TYPE_SIZE_UNIT overflowed, then it is certainly larger than
2273 && !TREE_OVERFLOW (TYPE_SIZE_UNIT (element
))
2274 && !integer_zerop (TYPE_SIZE_UNIT (element
))
2275 && compare_tree_int (TYPE_SIZE_UNIT (element
),
2276 TYPE_ALIGN_UNIT (element
)) < 0)
2277 error ("alignment of array elements is greater than element size");
2283 case QUAL_UNION_TYPE
:
2286 record_layout_info rli
;
2288 /* Initialize the layout information. */
2289 rli
= start_record_layout (type
);
2291 /* If this is a QUAL_UNION_TYPE, we want to process the fields
2292 in the reverse order in building the COND_EXPR that denotes
2293 its size. We reverse them again later. */
2294 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
2295 TYPE_FIELDS (type
) = nreverse (TYPE_FIELDS (type
));
2297 /* Place all the fields. */
2298 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
2299 place_field (rli
, field
);
2301 if (TREE_CODE (type
) == QUAL_UNION_TYPE
)
2302 TYPE_FIELDS (type
) = nreverse (TYPE_FIELDS (type
));
2304 /* Finish laying out the record. */
2305 finish_record_layout (rli
, /*free_p=*/true);
2313 /* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE. For
2314 records and unions, finish_record_layout already called this
2316 if (TREE_CODE (type
) != RECORD_TYPE
2317 && TREE_CODE (type
) != UNION_TYPE
2318 && TREE_CODE (type
) != QUAL_UNION_TYPE
)
2319 finalize_type_size (type
);
2321 /* We should never see alias sets on incomplete aggregates. And we
2322 should not call layout_type on not incomplete aggregates. */
2323 if (AGGREGATE_TYPE_P (type
))
2324 gcc_assert (!TYPE_ALIAS_SET_KNOWN_P (type
));
2327 /* Vector types need to re-check the target flags each time we report
2328 the machine mode. We need to do this because attribute target can
2329 change the result of vector_mode_supported_p and have_regs_of_mode
2330 on a per-function basis. Thus the TYPE_MODE of a VECTOR_TYPE can
2331 change on a per-function basis. */
2332 /* ??? Possibly a better solution is to run through all the types
2333 referenced by a function and re-compute the TYPE_MODE once, rather
2334 than make the TYPE_MODE macro call a function. */
2337 vector_type_mode (const_tree t
)
2339 enum machine_mode mode
;
2341 gcc_assert (TREE_CODE (t
) == VECTOR_TYPE
);
2343 mode
= t
->type_common
.mode
;
2344 if (VECTOR_MODE_P (mode
)
2345 && (!targetm
.vector_mode_supported_p (mode
)
2346 || !have_regs_of_mode
[mode
]))
2348 enum machine_mode innermode
= TREE_TYPE (t
)->type_common
.mode
;
2350 /* For integers, try mapping it to a same-sized scalar mode. */
2351 if (GET_MODE_CLASS (innermode
) == MODE_INT
)
2353 mode
= mode_for_size (TYPE_VECTOR_SUBPARTS (t
)
2354 * GET_MODE_BITSIZE (innermode
), MODE_INT
, 0);
2356 if (mode
!= VOIDmode
&& have_regs_of_mode
[mode
])
2366 /* Create and return a type for signed integers of PRECISION bits. */
2369 make_signed_type (int precision
)
2371 tree type
= make_node (INTEGER_TYPE
);
2373 TYPE_PRECISION (type
) = precision
;
2375 fixup_signed_type (type
);
2379 /* Create and return a type for unsigned integers of PRECISION bits. */
2382 make_unsigned_type (int precision
)
2384 tree type
= make_node (INTEGER_TYPE
);
2386 TYPE_PRECISION (type
) = precision
;
2388 fixup_unsigned_type (type
);
2392 /* Create and return a type for fract of PRECISION bits, UNSIGNEDP,
2396 make_fract_type (int precision
, int unsignedp
, int satp
)
2398 tree type
= make_node (FIXED_POINT_TYPE
);
2400 TYPE_PRECISION (type
) = precision
;
2403 TYPE_SATURATING (type
) = 1;
2405 /* Lay out the type: set its alignment, size, etc. */
2408 TYPE_UNSIGNED (type
) = 1;
2409 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_UFRACT
, 0));
2412 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_FRACT
, 0));
2418 /* Create and return a type for accum of PRECISION bits, UNSIGNEDP,
2422 make_accum_type (int precision
, int unsignedp
, int satp
)
2424 tree type
= make_node (FIXED_POINT_TYPE
);
2426 TYPE_PRECISION (type
) = precision
;
2429 TYPE_SATURATING (type
) = 1;
2431 /* Lay out the type: set its alignment, size, etc. */
2434 TYPE_UNSIGNED (type
) = 1;
2435 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_UACCUM
, 0));
2438 SET_TYPE_MODE (type
, mode_for_size (precision
, MODE_ACCUM
, 0));
2444 /* Initialize sizetypes so layout_type can use them. */
2447 initialize_sizetypes (void)
2449 int precision
, bprecision
;
2451 /* Get sizetypes precision from the SIZE_TYPE target macro. */
2452 if (strcmp (SIZETYPE
, "unsigned int") == 0)
2453 precision
= INT_TYPE_SIZE
;
2454 else if (strcmp (SIZETYPE
, "long unsigned int") == 0)
2455 precision
= LONG_TYPE_SIZE
;
2456 else if (strcmp (SIZETYPE
, "long long unsigned int") == 0)
2457 precision
= LONG_LONG_TYPE_SIZE
;
2458 else if (strcmp (SIZETYPE
, "short unsigned int") == 0)
2459 precision
= SHORT_TYPE_SIZE
;
2464 = MIN (precision
+ BITS_PER_UNIT_LOG
+ 1, MAX_FIXED_MODE_SIZE
);
2466 = GET_MODE_PRECISION (smallest_mode_for_size (bprecision
, MODE_INT
));
2467 if (bprecision
> HOST_BITS_PER_DOUBLE_INT
)
2468 bprecision
= HOST_BITS_PER_DOUBLE_INT
;
2470 /* Create stubs for sizetype and bitsizetype so we can create constants. */
2471 sizetype
= make_node (INTEGER_TYPE
);
2472 TYPE_NAME (sizetype
) = get_identifier ("sizetype");
2473 TYPE_PRECISION (sizetype
) = precision
;
2474 TYPE_UNSIGNED (sizetype
) = 1;
2475 bitsizetype
= make_node (INTEGER_TYPE
);
2476 TYPE_NAME (bitsizetype
) = get_identifier ("bitsizetype");
2477 TYPE_PRECISION (bitsizetype
) = bprecision
;
2478 TYPE_UNSIGNED (bitsizetype
) = 1;
2480 /* Now layout both types manually. */
2481 SET_TYPE_MODE (sizetype
, smallest_mode_for_size (precision
, MODE_INT
));
2482 TYPE_ALIGN (sizetype
) = GET_MODE_ALIGNMENT (TYPE_MODE (sizetype
));
2483 TYPE_SIZE (sizetype
) = bitsize_int (precision
);
2484 TYPE_SIZE_UNIT (sizetype
) = size_int (GET_MODE_SIZE (TYPE_MODE (sizetype
)));
2485 set_min_and_max_values_for_integral_type (sizetype
, precision
, UNSIGNED
);
2487 SET_TYPE_MODE (bitsizetype
, smallest_mode_for_size (bprecision
, MODE_INT
));
2488 TYPE_ALIGN (bitsizetype
) = GET_MODE_ALIGNMENT (TYPE_MODE (bitsizetype
));
2489 TYPE_SIZE (bitsizetype
) = bitsize_int (bprecision
);
2490 TYPE_SIZE_UNIT (bitsizetype
)
2491 = size_int (GET_MODE_SIZE (TYPE_MODE (bitsizetype
)));
2492 set_min_and_max_values_for_integral_type (bitsizetype
, bprecision
, UNSIGNED
);
2494 /* Create the signed variants of *sizetype. */
2495 ssizetype
= make_signed_type (TYPE_PRECISION (sizetype
));
2496 TYPE_NAME (ssizetype
) = get_identifier ("ssizetype");
2497 sbitsizetype
= make_signed_type (TYPE_PRECISION (bitsizetype
));
2498 TYPE_NAME (sbitsizetype
) = get_identifier ("sbitsizetype");
2501 /* TYPE is an integral type, i.e., an INTEGRAL_TYPE, ENUMERAL_TYPE
2502 or BOOLEAN_TYPE. Set TYPE_MIN_VALUE and TYPE_MAX_VALUE
2503 for TYPE, based on the PRECISION and whether or not the TYPE
2504 IS_UNSIGNED. PRECISION need not correspond to a width supported
2505 natively by the hardware; for example, on a machine with 8-bit,
2506 16-bit, and 32-bit register modes, PRECISION might be 7, 23, or
2510 set_min_and_max_values_for_integral_type (tree type
,
2514 /* For bitfields with zero width we end up creating integer types
2515 with zero precision. Don't assign any minimum/maximum values
2516 to those types, they don't have any valid value. */
2520 TYPE_MIN_VALUE (type
)
2521 = wide_int_to_tree (type
, wi::min_value (precision
, sgn
));
2522 TYPE_MAX_VALUE (type
)
2523 = wide_int_to_tree (type
, wi::max_value (precision
, sgn
));
2526 /* Set the extreme values of TYPE based on its precision in bits,
2527 then lay it out. Used when make_signed_type won't do
2528 because the tree code is not INTEGER_TYPE.
2529 E.g. for Pascal, when the -fsigned-char option is given. */
2532 fixup_signed_type (tree type
)
2534 int precision
= TYPE_PRECISION (type
);
2536 set_min_and_max_values_for_integral_type (type
, precision
, SIGNED
);
2538 /* Lay out the type: set its alignment, size, etc. */
2542 /* Set the extreme values of TYPE based on its precision in bits,
2543 then lay it out. This is used both in `make_unsigned_type'
2544 and for enumeral types. */
2547 fixup_unsigned_type (tree type
)
2549 int precision
= TYPE_PRECISION (type
);
2551 TYPE_UNSIGNED (type
) = 1;
2553 set_min_and_max_values_for_integral_type (type
, precision
, UNSIGNED
);
2555 /* Lay out the type: set its alignment, size, etc. */
2559 /* Construct an iterator for a bitfield that spans BITSIZE bits,
2562 BITREGION_START is the bit position of the first bit in this
2563 sequence of bit fields. BITREGION_END is the last bit in this
2564 sequence. If these two fields are non-zero, we should restrict the
2565 memory access to that range. Otherwise, we are allowed to touch
2566 any adjacent non bit-fields.
2568 ALIGN is the alignment of the underlying object in bits.
2569 VOLATILEP says whether the bitfield is volatile. */
2571 bit_field_mode_iterator
2572 ::bit_field_mode_iterator (HOST_WIDE_INT bitsize
, HOST_WIDE_INT bitpos
,
2573 HOST_WIDE_INT bitregion_start
,
2574 HOST_WIDE_INT bitregion_end
,
2575 unsigned int align
, bool volatilep
)
2576 : m_mode (GET_CLASS_NARROWEST_MODE (MODE_INT
)), m_bitsize (bitsize
),
2577 m_bitpos (bitpos
), m_bitregion_start (bitregion_start
),
2578 m_bitregion_end (bitregion_end
), m_align (align
),
2579 m_volatilep (volatilep
), m_count (0)
2581 if (!m_bitregion_end
)
2583 /* We can assume that any aligned chunk of ALIGN bits that overlaps
2584 the bitfield is mapped and won't trap, provided that ALIGN isn't
2585 too large. The cap is the biggest required alignment for data,
2586 or at least the word size. And force one such chunk at least. */
2587 unsigned HOST_WIDE_INT units
2588 = MIN (align
, MAX (BIGGEST_ALIGNMENT
, BITS_PER_WORD
));
2591 m_bitregion_end
= bitpos
+ bitsize
+ units
- 1;
2592 m_bitregion_end
-= m_bitregion_end
% units
+ 1;
2596 /* Calls to this function return successively larger modes that can be used
2597 to represent the bitfield. Return true if another bitfield mode is
2598 available, storing it in *OUT_MODE if so. */
2601 bit_field_mode_iterator::next_mode (enum machine_mode
*out_mode
)
2603 for (; m_mode
!= VOIDmode
; m_mode
= GET_MODE_WIDER_MODE (m_mode
))
2605 unsigned int unit
= GET_MODE_BITSIZE (m_mode
);
2607 /* Skip modes that don't have full precision. */
2608 if (unit
!= GET_MODE_PRECISION (m_mode
))
2611 /* Stop if the mode is too wide to handle efficiently. */
2612 if (unit
> MAX_FIXED_MODE_SIZE
)
2615 /* Don't deliver more than one multiword mode; the smallest one
2617 if (m_count
> 0 && unit
> BITS_PER_WORD
)
2620 /* Skip modes that are too small. */
2621 unsigned HOST_WIDE_INT substart
= (unsigned HOST_WIDE_INT
) m_bitpos
% unit
;
2622 unsigned HOST_WIDE_INT subend
= substart
+ m_bitsize
;
2626 /* Stop if the mode goes outside the bitregion. */
2627 HOST_WIDE_INT start
= m_bitpos
- substart
;
2628 if (m_bitregion_start
&& start
< m_bitregion_start
)
2630 HOST_WIDE_INT end
= start
+ unit
;
2631 if (end
> m_bitregion_end
+ 1)
2634 /* Stop if the mode requires too much alignment. */
2635 if (GET_MODE_ALIGNMENT (m_mode
) > m_align
2636 && SLOW_UNALIGNED_ACCESS (m_mode
, m_align
))
2640 m_mode
= GET_MODE_WIDER_MODE (m_mode
);
2647 /* Return true if smaller modes are generally preferred for this kind
2651 bit_field_mode_iterator::prefer_smaller_modes ()
2654 ? targetm
.narrow_volatile_bitfield ()
2655 : !SLOW_BYTE_ACCESS
);
2658 /* Find the best machine mode to use when referencing a bit field of length
2659 BITSIZE bits starting at BITPOS.
2661 BITREGION_START is the bit position of the first bit in this
2662 sequence of bit fields. BITREGION_END is the last bit in this
2663 sequence. If these two fields are non-zero, we should restrict the
2664 memory access to that range. Otherwise, we are allowed to touch
2665 any adjacent non bit-fields.
2667 The underlying object is known to be aligned to a boundary of ALIGN bits.
2668 If LARGEST_MODE is not VOIDmode, it means that we should not use a mode
2669 larger than LARGEST_MODE (usually SImode).
2671 If no mode meets all these conditions, we return VOIDmode.
2673 If VOLATILEP is false and SLOW_BYTE_ACCESS is false, we return the
2674 smallest mode meeting these conditions.
2676 If VOLATILEP is false and SLOW_BYTE_ACCESS is true, we return the
2677 largest mode (but a mode no wider than UNITS_PER_WORD) that meets
2680 If VOLATILEP is true the narrow_volatile_bitfields target hook is used to
2681 decide which of the above modes should be used. */
2684 get_best_mode (int bitsize
, int bitpos
,
2685 unsigned HOST_WIDE_INT bitregion_start
,
2686 unsigned HOST_WIDE_INT bitregion_end
,
2688 enum machine_mode largest_mode
, bool volatilep
)
2690 bit_field_mode_iterator
iter (bitsize
, bitpos
, bitregion_start
,
2691 bitregion_end
, align
, volatilep
);
2692 enum machine_mode widest_mode
= VOIDmode
;
2693 enum machine_mode mode
;
2694 while (iter
.next_mode (&mode
)
2695 /* ??? For historical reasons, reject modes that would normally
2696 receive greater alignment, even if unaligned accesses are
2697 acceptable. This has both advantages and disadvantages.
2698 Removing this check means that something like:
2700 struct s { unsigned int x; unsigned int y; };
2701 int f (struct s *s) { return s->x == 0 && s->y == 0; }
2703 can be implemented using a single load and compare on
2704 64-bit machines that have no alignment restrictions.
2705 For example, on powerpc64-linux-gnu, we would generate:
2727 However, accessing more than one field can make life harder
2728 for the gimple optimizers. For example, gcc.dg/vect/bb-slp-5.c
2729 has a series of unsigned short copies followed by a series of
2730 unsigned short comparisons. With this check, both the copies
2731 and comparisons remain 16-bit accesses and FRE is able
2732 to eliminate the latter. Without the check, the comparisons
2733 can be done using 2 64-bit operations, which FRE isn't able
2734 to handle in the same way.
2736 Either way, it would probably be worth disabling this check
2737 during expand. One particular example where removing the
2738 check would help is the get_best_mode call in store_bit_field.
2739 If we are given a memory bitregion of 128 bits that is aligned
2740 to a 64-bit boundary, and the bitfield we want to modify is
2741 in the second half of the bitregion, this check causes
2742 store_bitfield to turn the memory into a 64-bit reference
2743 to the _first_ half of the region. We later use
2744 adjust_bitfield_address to get a reference to the correct half,
2745 but doing so looks to adjust_bitfield_address as though we are
2746 moving past the end of the original object, so it drops the
2747 associated MEM_EXPR and MEM_OFFSET. Removing the check
2748 causes store_bit_field to keep a 128-bit memory reference,
2749 so that the final bitfield reference still has a MEM_EXPR
2751 && GET_MODE_ALIGNMENT (mode
) <= align
2752 && (largest_mode
== VOIDmode
2753 || GET_MODE_SIZE (mode
) <= GET_MODE_SIZE (largest_mode
)))
2756 if (iter
.prefer_smaller_modes ())
2762 /* Gets minimal and maximal values for MODE (signed or unsigned depending on
2763 SIGN). The returned constants are made to be usable in TARGET_MODE. */
2766 get_mode_bounds (enum machine_mode mode
, int sign
,
2767 enum machine_mode target_mode
,
2768 rtx
*mmin
, rtx
*mmax
)
2770 unsigned size
= GET_MODE_BITSIZE (mode
);
2771 unsigned HOST_WIDE_INT min_val
, max_val
;
2773 gcc_assert (size
<= HOST_BITS_PER_WIDE_INT
);
2777 min_val
= -((unsigned HOST_WIDE_INT
) 1 << (size
- 1));
2778 max_val
= ((unsigned HOST_WIDE_INT
) 1 << (size
- 1)) - 1;
2783 max_val
= ((unsigned HOST_WIDE_INT
) 1 << (size
- 1) << 1) - 1;
2786 *mmin
= gen_int_mode (min_val
, target_mode
);
2787 *mmax
= gen_int_mode (max_val
, target_mode
);
2790 #include "gt-stor-layout.h"