1/* C-compiler utilities for types and variables storage layout
2 Copyright (C) 1987-2017 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20
21#include "config.h"
22#include "system.h"
23#include "coretypes.h"
24#include "target.h"
25#include "function.h"
26#include "rtl.h"
27#include "tree.h"
28#include "memmodel.h"
29#include "tm_p.h"
30#include "stringpool.h"
31#include "regs.h"
32#include "emit-rtl.h"
33#include "cgraph.h"
34#include "diagnostic-core.h"
35#include "fold-const.h"
36#include "stor-layout.h"
37#include "varasm.h"
38#include "print-tree.h"
39#include "langhooks.h"
40#include "tree-inline.h"
41#include "dumpfile.h"
42#include "gimplify.h"
43#include "attribs.h"
44#include "debug.h"
45
46/* Data type for the expressions representing sizes of data types.
47 It is the first integer type laid out. */
48tree sizetype_tab[(int) stk_type_kind_last];
49
50/* If nonzero, this is an upper limit on alignment of structure fields.
51 The value is measured in bits. */
52unsigned int maximum_field_alignment = TARGET_DEFAULT_PACK_STRUCT * BITS_PER_UNIT;
53
54static tree self_referential_size (tree);
55static void finalize_record_size (record_layout_info);
56static void finalize_type_size (tree);
57static void place_union_field (record_layout_info, tree);
58static int excess_unit_span (HOST_WIDE_INT, HOST_WIDE_INT, HOST_WIDE_INT,
59 HOST_WIDE_INT, tree);
60extern void debug_rli (record_layout_info);
61
62/* Given a size SIZE that may not be a constant, return a SAVE_EXPR
63 to serve as the actual size-expression for a type or decl. */
64
65tree
66variable_size (tree size)
67{
68 /* Obviously. */
69 if (TREE_CONSTANT (size))
70 return size;
71
72 /* If the size is self-referential, we can't make a SAVE_EXPR (see
73 save_expr for the rationale). But we can do something else. */
74 if (CONTAINS_PLACEHOLDER_P (size))
75 return self_referential_size (size);
76
77 /* If we are in the global binding level, we can't make a SAVE_EXPR
78 since it may end up being shared across functions, so it is up
79 to the front-end to deal with this case. */
80 if (lang_hooks.decls.global_bindings_p ())
81 return size;
82
83 return save_expr (size);
84}
85
86/* An array of functions used for self-referential size computation. */
87static GTY(()) vec<tree, va_gc> *size_functions;
88
89/* Return true if T is a self-referential component reference. */
90
91static bool
92self_referential_component_ref_p (tree t)
93{
94 if (TREE_CODE (t) != COMPONENT_REF)
95 return false;
96
97 while (REFERENCE_CLASS_P (t))
98 t = TREE_OPERAND (t, 0);
99
100 return (TREE_CODE (t) == PLACEHOLDER_EXPR);
101}
102
103/* Similar to copy_tree_r but do not copy component references involving
104 PLACEHOLDER_EXPRs. These nodes are spotted in find_placeholder_in_expr
105 and substituted in substitute_in_expr. */
106
107static tree
108copy_self_referential_tree_r (tree *tp, int *walk_subtrees, void *data)
109{
110 enum tree_code code = TREE_CODE (*tp);
111
112 /* Stop at types, decls, constants like copy_tree_r. */
113 if (TREE_CODE_CLASS (code) == tcc_type
114 || TREE_CODE_CLASS (code) == tcc_declaration
115 || TREE_CODE_CLASS (code) == tcc_constant)
116 {
117 *walk_subtrees = 0;
118 return NULL_TREE;
119 }
120
121 /* This is the pattern built in ada/make_aligning_type. */
122 else if (code == ADDR_EXPR
123 && TREE_CODE (TREE_OPERAND (*tp, 0)) == PLACEHOLDER_EXPR)
124 {
125 *walk_subtrees = 0;
126 return NULL_TREE;
127 }
128
129 /* Default case: the component reference. */
130 else if (self_referential_component_ref_p (*tp))
131 {
132 *walk_subtrees = 0;
133 return NULL_TREE;
134 }
135
136 /* We're not supposed to have them in self-referential size trees
137 because we wouldn't properly control when they are evaluated.
138 However, not creating superfluous SAVE_EXPRs requires accurate
139 tracking of readonly-ness all the way down to here, which we
140 cannot always guarantee in practice. So punt in this case. */
141 else if (code == SAVE_EXPR)
142 return error_mark_node;
143
144 else if (code == STATEMENT_LIST)
145 gcc_unreachable ();
146
147 return copy_tree_r (tp, walk_subtrees, data);
148}
149
150/* Given a SIZE expression that is self-referential, return an equivalent
151 expression to serve as the actual size expression for a type. */
152
153static tree
154self_referential_size (tree size)
155{
156 static unsigned HOST_WIDE_INT fnno = 0;
157 vec<tree> self_refs = vNULL;
158 tree param_type_list = NULL, param_decl_list = NULL;
159 tree t, ref, return_type, fntype, fnname, fndecl;
160 unsigned int i;
161 char buf[128];
162 vec<tree, va_gc> *args = NULL;
163
164 /* Do not factor out simple operations. */
165 t = skip_simple_constant_arithmetic (size);
166 if (TREE_CODE (t) == CALL_EXPR || self_referential_component_ref_p (t))
167 return size;
168
169 /* Collect the list of self-references in the expression. */
170 find_placeholder_in_expr (size, &self_refs);
171 gcc_assert (self_refs.length () > 0);
172
173 /* Obtain a private copy of the expression. */
174 t = size;
175 if (walk_tree (&t, copy_self_referential_tree_r, NULL, NULL) != NULL_TREE)
176 return size;
177 size = t;
178
179 /* Build the parameter and argument lists in parallel; also
180 substitute the former for the latter in the expression. */
181 vec_alloc (args, self_refs.length ());
182 FOR_EACH_VEC_ELT (self_refs, i, ref)
183 {
184 tree subst, param_name, param_type, param_decl;
185
186 if (DECL_P (ref))
187 {
188 /* We shouldn't have true variables here. */
189 gcc_assert (TREE_READONLY (ref));
190 subst = ref;
191 }
192 /* This is the pattern built in ada/make_aligning_type. */
193 else if (TREE_CODE (ref) == ADDR_EXPR)
194 subst = ref;
195 /* Default case: the component reference. */
196 else
197 subst = TREE_OPERAND (ref, 1);
198
199 sprintf (buf, "p%d", i);
200 param_name = get_identifier (buf);
201 param_type = TREE_TYPE (ref);
202 param_decl
203 = build_decl (input_location, PARM_DECL, param_name, param_type);
204 DECL_ARG_TYPE (param_decl) = param_type;
205 DECL_ARTIFICIAL (param_decl) = 1;
206 TREE_READONLY (param_decl) = 1;
207
208 size = substitute_in_expr (size, subst, param_decl);
209
210 param_type_list = tree_cons (NULL_TREE, param_type, param_type_list);
211 param_decl_list = chainon (param_decl, param_decl_list);
212 args->quick_push (ref);
213 }
214
215 self_refs.release ();
216
217 /* Append 'void' to indicate that the number of parameters is fixed. */
218 param_type_list = tree_cons (NULL_TREE, void_type_node, param_type_list);
219
220 /* The 3 lists have been created in reverse order. */
221 param_type_list = nreverse (param_type_list);
222 param_decl_list = nreverse (param_decl_list);
223
224 /* Build the function type. */
225 return_type = TREE_TYPE (size);
226 fntype = build_function_type (return_type, param_type_list);
227
228 /* Build the function declaration. */
229 sprintf (buf, "SZ" HOST_WIDE_INT_PRINT_UNSIGNED, fnno++);
230 fnname = get_file_function_name (buf);
231 fndecl = build_decl (input_location, FUNCTION_DECL, fnname, fntype);
232 for (t = param_decl_list; t; t = DECL_CHAIN (t))
233 DECL_CONTEXT (t) = fndecl;
234 DECL_ARGUMENTS (fndecl) = param_decl_list;
235 DECL_RESULT (fndecl)
236 = build_decl (input_location, RESULT_DECL, 0, return_type);
237 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
238
239 /* The function has been created by the compiler and we don't
240 want to emit debug info for it. */
241 DECL_ARTIFICIAL (fndecl) = 1;
242 DECL_IGNORED_P (fndecl) = 1;
243
244 /* It is supposed to be "const" and never throw. */
245 TREE_READONLY (fndecl) = 1;
246 TREE_NOTHROW (fndecl) = 1;
247
248 /* We want it to be inlined when this is deemed profitable, as
249 well as discarded if every call has been integrated. */
250 DECL_DECLARED_INLINE_P (fndecl) = 1;
251
252 /* It is made up of a unique return statement. */
253 DECL_INITIAL (fndecl) = make_node (BLOCK);
254 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
255 t = build2 (MODIFY_EXPR, return_type, DECL_RESULT (fndecl), size);
256 DECL_SAVED_TREE (fndecl) = build1 (RETURN_EXPR, void_type_node, t);
257 TREE_STATIC (fndecl) = 1;
258
259 /* Put it onto the list of size functions. */
260 vec_safe_push (size_functions, fndecl);
261
262 /* Replace the original expression with a call to the size function. */
263 return build_call_expr_loc_vec (UNKNOWN_LOCATION, fndecl, args);
264}
265
266/* Take, queue and compile all the size functions. It is essential that
267 the size functions be gimplified at the very end of the compilation
268 in order to guarantee transparent handling of self-referential sizes.
269 Otherwise the GENERIC inliner would not be able to inline them back
270 at each of their call sites, thus creating artificial non-constant
271 size expressions which would trigger nasty problems later on. */
272
273void
274finalize_size_functions (void)
275{
276 unsigned int i;
277 tree fndecl;
278
279 for (i = 0; size_functions && size_functions->iterate (i, &fndecl); i++)
280 {
281 allocate_struct_function (fndecl, false);
282 set_cfun (NULL);
283 dump_function (TDI_original, fndecl);
284
285 /* As these functions are used to describe the layout of variable-length
286 structures, debug info generation needs their implementation. */
287 debug_hooks->size_function (fndecl);
288 gimplify_function_tree (fndecl);
289 cgraph_node::finalize_function (fndecl, false);
290 }
291
292 vec_free (size_functions);
293}
294
295/* Return a machine mode of class MCLASS with SIZE bits of precision,
296 if one exists. The mode may have padding bits as well the SIZE
297 value bits. If LIMIT is nonzero, disregard modes wider than
298 MAX_FIXED_MODE_SIZE. */
299
300opt_machine_mode
301mode_for_size (unsigned int size, enum mode_class mclass, int limit)
302{
303 machine_mode mode;
304 int i;
305
306 if (limit && size > MAX_FIXED_MODE_SIZE)
307 return opt_machine_mode ();
308
309 /* Get the first mode which has this size, in the specified class. */
310 FOR_EACH_MODE_IN_CLASS (mode, mclass)
311 if (GET_MODE_PRECISION (mode) == size)
312 return mode;
313
314 if (mclass == MODE_INT || mclass == MODE_PARTIAL_INT)
315 for (i = 0; i < NUM_INT_N_ENTS; i ++)
316 if (int_n_data[i].bitsize == size
317 && int_n_enabled_p[i])
318 return int_n_data[i].m;
319
320 return opt_machine_mode ();
321}
322
323/* Similar, except passed a tree node. */
324
325opt_machine_mode
326mode_for_size_tree (const_tree size, enum mode_class mclass, int limit)
327{
328 unsigned HOST_WIDE_INT uhwi;
329 unsigned int ui;
330
331 if (!tree_fits_uhwi_p (size))
332 return opt_machine_mode ();
333 uhwi = tree_to_uhwi (size);
334 ui = uhwi;
335 if (uhwi != ui)
336 return opt_machine_mode ();
337 return mode_for_size (ui, mclass, limit);
338}
339
340/* Return the narrowest mode of class MCLASS that contains at least
341 SIZE bits. Abort if no such mode exists. */
342
343machine_mode
344smallest_mode_for_size (unsigned int size, enum mode_class mclass)
345{
346 machine_mode mode = VOIDmode;
347 int i;
348
349 /* Get the first mode which has at least this size, in the
350 specified class. */
351 FOR_EACH_MODE_IN_CLASS (mode, mclass)
352 if (GET_MODE_PRECISION (mode) >= size)
353 break;
354
355 if (mclass == MODE_INT || mclass == MODE_PARTIAL_INT)
356 for (i = 0; i < NUM_INT_N_ENTS; i ++)
357 if (int_n_data[i].bitsize >= size
358 && int_n_data[i].bitsize < GET_MODE_PRECISION (mode)
359 && int_n_enabled_p[i])
360 mode = int_n_data[i].m;
361
362 if (mode == VOIDmode)
363 gcc_unreachable ();
364
365 return mode;
366}
367
368/* Return an integer mode of exactly the same size as MODE, if one exists. */
369
370opt_scalar_int_mode
371int_mode_for_mode (machine_mode mode)
372{
373 switch (GET_MODE_CLASS (mode))
374 {
375 case MODE_INT:
376 case MODE_PARTIAL_INT:
377 return as_a <scalar_int_mode> (mode);
378
379 case MODE_COMPLEX_INT:
380 case MODE_COMPLEX_FLOAT:
381 case MODE_FLOAT:
382 case MODE_DECIMAL_FLOAT:
383 case MODE_VECTOR_INT:
384 case MODE_VECTOR_FLOAT:
385 case MODE_FRACT:
386 case MODE_ACCUM:
387 case MODE_UFRACT:
388 case MODE_UACCUM:
389 case MODE_VECTOR_FRACT:
390 case MODE_VECTOR_ACCUM:
391 case MODE_VECTOR_UFRACT:
392 case MODE_VECTOR_UACCUM:
393 case MODE_POINTER_BOUNDS:
394 return int_mode_for_size (GET_MODE_BITSIZE (mode), 0);
395
396 case MODE_RANDOM:
397 if (mode == BLKmode)
398 return opt_scalar_int_mode ();
399
400 /* fall through */
401
402 case MODE_CC:
403 default:
404 gcc_unreachable ();
405 }
406}
407
408/* Find a mode that can be used for efficient bitwise operations on MODE,
409 if one exists. */
410
411opt_machine_mode
412bitwise_mode_for_mode (machine_mode mode)
413{
414 /* Quick exit if we already have a suitable mode. */
415 unsigned int bitsize = GET_MODE_BITSIZE (mode);
416 scalar_int_mode int_mode;
417 if (is_a <scalar_int_mode> (mode, &int_mode)
418 && GET_MODE_BITSIZE (int_mode) <= MAX_FIXED_MODE_SIZE)
419 return int_mode;
420
421 /* Reuse the sanity checks from int_mode_for_mode. */
422 gcc_checking_assert ((int_mode_for_mode (mode), true));
423
424 /* Try to replace complex modes with complex modes. In general we
425 expect both components to be processed independently, so we only
426 care whether there is a register for the inner mode. */
427 if (COMPLEX_MODE_P (mode))
428 {
429 machine_mode trial = mode;
430 if ((GET_MODE_CLASS (trial) == MODE_COMPLEX_INT
431 || mode_for_size (bitsize, MODE_COMPLEX_INT, false).exists (&trial))
432 && have_regs_of_mode[GET_MODE_INNER (trial)])
433 return trial;
434 }
435
436 /* Try to replace vector modes with vector modes. Also try using vector
437 modes if an integer mode would be too big. */
438 if (VECTOR_MODE_P (mode) || bitsize > MAX_FIXED_MODE_SIZE)
439 {
440 machine_mode trial = mode;
441 if ((GET_MODE_CLASS (trial) == MODE_VECTOR_INT
442 || mode_for_size (bitsize, MODE_VECTOR_INT, 0).exists (&trial))
443 && have_regs_of_mode[trial]
444 && targetm.vector_mode_supported_p (trial))
445 return trial;
446 }
447
448 /* Otherwise fall back on integers while honoring MAX_FIXED_MODE_SIZE. */
449 return mode_for_size (bitsize, MODE_INT, true);
450}
451
452/* Find a type that can be used for efficient bitwise operations on MODE.
453 Return null if no such mode exists. */
454
455tree
456bitwise_type_for_mode (machine_mode mode)
457{
458 if (!bitwise_mode_for_mode (mode).exists (&mode))
459 return NULL_TREE;
460
461 unsigned int inner_size = GET_MODE_UNIT_BITSIZE (mode);
462 tree inner_type = build_nonstandard_integer_type (inner_size, true);
463
464 if (VECTOR_MODE_P (mode))
465 return build_vector_type_for_mode (inner_type, mode);
466
467 if (COMPLEX_MODE_P (mode))
468 return build_complex_type (inner_type);
469
470 gcc_checking_assert (GET_MODE_INNER (mode) == mode);
471 return inner_type;
472}
473
474/* Find a mode that is suitable for representing a vector with NUNITS
475 elements of mode INNERMODE, if one exists. The returned mode can be
476 either an integer mode or a vector mode. */
477
478opt_machine_mode
479mode_for_vector (scalar_mode innermode, unsigned nunits)
480{
481 machine_mode mode;
482
483 /* First, look for a supported vector type. */
484 if (SCALAR_FLOAT_MODE_P (innermode))
485 mode = MIN_MODE_VECTOR_FLOAT;
486 else if (SCALAR_FRACT_MODE_P (innermode))
487 mode = MIN_MODE_VECTOR_FRACT;
488 else if (SCALAR_UFRACT_MODE_P (innermode))
489 mode = MIN_MODE_VECTOR_UFRACT;
490 else if (SCALAR_ACCUM_MODE_P (innermode))
491 mode = MIN_MODE_VECTOR_ACCUM;
492 else if (SCALAR_UACCUM_MODE_P (innermode))
493 mode = MIN_MODE_VECTOR_UACCUM;
494 else
495 mode = MIN_MODE_VECTOR_INT;
496
497 /* Do not check vector_mode_supported_p here. We'll do that
498 later in vector_type_mode. */
499 FOR_EACH_MODE_FROM (mode, mode)
500 if (GET_MODE_NUNITS (mode) == nunits
501 && GET_MODE_INNER (mode) == innermode)
502 return mode;
503
504 /* For integers, try mapping it to a same-sized scalar mode. */
505 if (GET_MODE_CLASS (innermode) == MODE_INT)
506 {
507 unsigned int nbits = nunits * GET_MODE_BITSIZE (innermode);
508 if (int_mode_for_size (nbits, 0).exists (&mode)
509 && have_regs_of_mode[mode])
510 return mode;
511 }
512
513 return opt_machine_mode ();
514}
515
516/* Return the mode for a vector that has NUNITS integer elements of
517 INT_BITS bits each, if such a mode exists. The mode can be either
518 an integer mode or a vector mode. */
519
520opt_machine_mode
521mode_for_int_vector (unsigned int int_bits, unsigned int nunits)
522{
523 scalar_int_mode int_mode;
524 machine_mode vec_mode;
525 if (int_mode_for_size (int_bits, 0).exists (&int_mode)
526 && mode_for_vector (int_mode, nunits).exists (&vec_mode))
527 return vec_mode;
528 return opt_machine_mode ();
529}
530
531/* Return the alignment of MODE. This will be bounded by 1 and
532 BIGGEST_ALIGNMENT. */
533
534unsigned int
535get_mode_alignment (machine_mode mode)
536{
537 return MIN (BIGGEST_ALIGNMENT, MAX (1, mode_base_align[mode]*BITS_PER_UNIT));
538}
539
540/* Return the natural mode of an array, given that it is SIZE bytes in
541 total and has elements of type ELEM_TYPE. */
542
543static machine_mode
544mode_for_array (tree elem_type, tree size)
545{
546 tree elem_size;
547 unsigned HOST_WIDE_INT int_size, int_elem_size;
548 bool limit_p;
549
550 /* One-element arrays get the component type's mode. */
551 elem_size = TYPE_SIZE (elem_type);
552 if (simple_cst_equal (size, elem_size))
553 return TYPE_MODE (elem_type);
554
555 limit_p = true;
556 if (tree_fits_uhwi_p (size) && tree_fits_uhwi_p (elem_size))
557 {
558 int_size = tree_to_uhwi (size);
559 int_elem_size = tree_to_uhwi (elem_size);
560 if (int_elem_size > 0
561 && int_size % int_elem_size == 0
562 && targetm.array_mode_supported_p (TYPE_MODE (elem_type),
563 int_size / int_elem_size))
564 limit_p = false;
565 }
566 return mode_for_size_tree (size, MODE_INT, limit_p).else_blk ();
567}
568
569/* Subroutine of layout_decl: Force alignment required for the data type.
570 But if the decl itself wants greater alignment, don't override that. */
571
572static inline void
573do_type_align (tree type, tree decl)
574{
575 if (TYPE_ALIGN (type) > DECL_ALIGN (decl))
576 {
577 SET_DECL_ALIGN (decl, TYPE_ALIGN (type));
578 if (TREE_CODE (decl) == FIELD_DECL)
579 DECL_USER_ALIGN (decl) = TYPE_USER_ALIGN (type);
580 }
581 if (TYPE_WARN_IF_NOT_ALIGN (type) > DECL_WARN_IF_NOT_ALIGN (decl))
582 SET_DECL_WARN_IF_NOT_ALIGN (decl, TYPE_WARN_IF_NOT_ALIGN (type));
583}
584
585/* Set the size, mode and alignment of a ..._DECL node.
586 TYPE_DECL does need this for C++.
587 Note that LABEL_DECL and CONST_DECL nodes do not need this,
588 and FUNCTION_DECL nodes have them set up in a special (and simple) way.
589 Don't call layout_decl for them.
590
591 KNOWN_ALIGN is the amount of alignment we can assume this
592 decl has with no special effort. It is relevant only for FIELD_DECLs
593 and depends on the previous fields.
594 All that matters about KNOWN_ALIGN is which powers of 2 divide it.
595 If KNOWN_ALIGN is 0, it means, "as much alignment as you like":
596 the record will be aligned to suit. */
597
598void
599layout_decl (tree decl, unsigned int known_align)
600{
601 tree type = TREE_TYPE (decl);
602 enum tree_code code = TREE_CODE (decl);
603 rtx rtl = NULL_RTX;
604 location_t loc = DECL_SOURCE_LOCATION (decl);
605
606 if (code == CONST_DECL)
607 return;
608
609 gcc_assert (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL
610 || code == TYPE_DECL || code == FIELD_DECL);
611
612 rtl = DECL_RTL_IF_SET (decl);
613
614 if (type == error_mark_node)
615 type = void_type_node;
616
617 /* Usually the size and mode come from the data type without change,
618 however, the front-end may set the explicit width of the field, so its
619 size may not be the same as the size of its type. This happens with
620 bitfields, of course (an `int' bitfield may be only 2 bits, say), but it
621 also happens with other fields. For example, the C++ front-end creates
622 zero-sized fields corresponding to empty base classes, and depends on
623 layout_type setting DECL_FIELD_BITPOS correctly for the field. Set the
624 size in bytes from the size in bits. If we have already set the mode,
625 don't set it again since we can be called twice for FIELD_DECLs. */
626
627 DECL_UNSIGNED (decl) = TYPE_UNSIGNED (type);
628 if (DECL_MODE (decl) == VOIDmode)
629 SET_DECL_MODE (decl, TYPE_MODE (type));
630
631 if (DECL_SIZE (decl) == 0)
632 {
633 DECL_SIZE (decl) = TYPE_SIZE (type);
634 DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (type);
635 }
636 else if (DECL_SIZE_UNIT (decl) == 0)
637 DECL_SIZE_UNIT (decl)
638 = fold_convert_loc (loc, sizetype,
639 size_binop_loc (loc, CEIL_DIV_EXPR, DECL_SIZE (decl),
640 bitsize_unit_node));
641
642 if (code != FIELD_DECL)
643 /* For non-fields, update the alignment from the type. */
644 do_type_align (type, decl);
645 else
646 /* For fields, it's a bit more complicated... */
647 {
648 bool old_user_align = DECL_USER_ALIGN (decl);
649 bool zero_bitfield = false;
650 bool packed_p = DECL_PACKED (decl);
651 unsigned int mfa;
652
653 if (DECL_BIT_FIELD (decl))
654 {
655 DECL_BIT_FIELD_TYPE (decl) = type;
656
657 /* A zero-length bit-field affects the alignment of the next
658 field. In essence such bit-fields are not influenced by
659 any packing due to #pragma pack or attribute packed. */
660 if (integer_zerop (DECL_SIZE (decl))
661 && ! targetm.ms_bitfield_layout_p (DECL_FIELD_CONTEXT (decl)))
662 {
663 zero_bitfield = true;
664 packed_p = false;
665 if (PCC_BITFIELD_TYPE_MATTERS)
666 do_type_align (type, decl);
667 else
668 {
669#ifdef EMPTY_FIELD_BOUNDARY
670 if (EMPTY_FIELD_BOUNDARY > DECL_ALIGN (decl))
671 {
672 SET_DECL_ALIGN (decl, EMPTY_FIELD_BOUNDARY);
673 DECL_USER_ALIGN (decl) = 0;
674 }
675#endif
676 }
677 }
678
679 /* See if we can use an ordinary integer mode for a bit-field.
680 Conditions are: a fixed size that is correct for another mode,
681 occupying a complete byte or bytes on proper boundary. */
682 if (TYPE_SIZE (type) != 0
683 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
684 && GET_MODE_CLASS (TYPE_MODE (type)) == MODE_INT)
685 {
686 machine_mode xmode;
687 if (mode_for_size_tree (DECL_SIZE (decl),
688 MODE_INT, 1).exists (&xmode))
689 {
690 unsigned int xalign = GET_MODE_ALIGNMENT (xmode);
691 if (!(xalign > BITS_PER_UNIT && DECL_PACKED (decl))
692 && (known_align == 0 || known_align >= xalign))
693 {
694 SET_DECL_ALIGN (decl, MAX (xalign, DECL_ALIGN (decl)));
695 SET_DECL_MODE (decl, xmode);
696 DECL_BIT_FIELD (decl) = 0;
697 }
698 }
699 }
700
701 /* Turn off DECL_BIT_FIELD if we won't need it set. */
702 if (TYPE_MODE (type) == BLKmode && DECL_MODE (decl) == BLKmode
703 && known_align >= TYPE_ALIGN (type)
704 && DECL_ALIGN (decl) >= TYPE_ALIGN (type))
705 DECL_BIT_FIELD (decl) = 0;
706 }
707 else if (packed_p && DECL_USER_ALIGN (decl))
708 /* Don't touch DECL_ALIGN. For other packed fields, go ahead and
709 round up; we'll reduce it again below. We want packing to
710 supersede USER_ALIGN inherited from the type, but defer to
711 alignment explicitly specified on the field decl. */;
712 else
713 do_type_align (type, decl);
714
715 /* If the field is packed and not explicitly aligned, give it the
716 minimum alignment. Note that do_type_align may set
717 DECL_USER_ALIGN, so we need to check old_user_align instead. */
718 if (packed_p
719 && !old_user_align)
720 SET_DECL_ALIGN (decl, MIN (DECL_ALIGN (decl), BITS_PER_UNIT));
721
722 if (! packed_p && ! DECL_USER_ALIGN (decl))
723 {
724 /* Some targets (i.e. i386, VMS) limit struct field alignment
725 to a lower boundary than alignment of variables unless
726 it was overridden by attribute aligned. */
727#ifdef BIGGEST_FIELD_ALIGNMENT
728 SET_DECL_ALIGN (decl, MIN (DECL_ALIGN (decl),
729 (unsigned) BIGGEST_FIELD_ALIGNMENT));
730#endif
731#ifdef ADJUST_FIELD_ALIGN
732 SET_DECL_ALIGN (decl, ADJUST_FIELD_ALIGN (decl, TREE_TYPE (decl),
733 DECL_ALIGN (decl)));
734#endif
735 }
736
737 if (zero_bitfield)
738 mfa = initial_max_fld_align * BITS_PER_UNIT;
739 else
740 mfa = maximum_field_alignment;
741 /* Should this be controlled by DECL_USER_ALIGN, too? */
742 if (mfa != 0)
743 SET_DECL_ALIGN (decl, MIN (DECL_ALIGN (decl), mfa));
744 }
745
746 /* Evaluate nonconstant size only once, either now or as soon as safe. */
747 if (DECL_SIZE (decl) != 0 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
748 DECL_SIZE (decl) = variable_size (DECL_SIZE (decl));
749 if (DECL_SIZE_UNIT (decl) != 0
750 && TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST)
751 DECL_SIZE_UNIT (decl) = variable_size (DECL_SIZE_UNIT (decl));
752
753 /* If requested, warn about definitions of large data objects. */
754 if (warn_larger_than
755 && (code == VAR_DECL || code == PARM_DECL)
756 && ! DECL_EXTERNAL (decl))
757 {
758 tree size = DECL_SIZE_UNIT (decl);
759
760 if (size != 0 && TREE_CODE (size) == INTEGER_CST
761 && compare_tree_int (size, larger_than_size) > 0)
762 {
763 int size_as_int = TREE_INT_CST_LOW (size);
764
765 if (compare_tree_int (size, size_as_int) == 0)
766 warning (OPT_Wlarger_than_, "size of %q+D is %d bytes", decl, size_as_int);
767 else
768 warning (OPT_Wlarger_than_, "size of %q+D is larger than %wd bytes",
769 decl, larger_than_size);
770 }
771 }
772
773 /* If the RTL was already set, update its mode and mem attributes. */
774 if (rtl)
775 {
776 PUT_MODE (rtl, DECL_MODE (decl));
777 SET_DECL_RTL (decl, 0);
778 if (MEM_P (rtl))
779 set_mem_attributes (rtl, decl, 1);
780 SET_DECL_RTL (decl, rtl);
781 }
782}
783
784/* Given a VAR_DECL, PARM_DECL, RESULT_DECL, or FIELD_DECL, clears the
785 results of a previous call to layout_decl and calls it again. */
786
787void
788relayout_decl (tree decl)
789{
790 DECL_SIZE (decl) = DECL_SIZE_UNIT (decl) = 0;
791 SET_DECL_MODE (decl, VOIDmode);
792 if (!DECL_USER_ALIGN (decl))
793 SET_DECL_ALIGN (decl, 0);
794 if (DECL_RTL_SET_P (decl))
795 SET_DECL_RTL (decl, 0);
796
797 layout_decl (decl, 0);
798}
799
800/* Begin laying out type T, which may be a RECORD_TYPE, UNION_TYPE, or
801 QUAL_UNION_TYPE. Return a pointer to a struct record_layout_info which
802 is to be passed to all other layout functions for this record. It is the
803 responsibility of the caller to call `free' for the storage returned.
804 Note that garbage collection is not permitted until we finish laying
805 out the record. */
806
807record_layout_info
808start_record_layout (tree t)
809{
810 record_layout_info rli = XNEW (struct record_layout_info_s);
811
812 rli->t = t;
813
814 /* If the type has a minimum specified alignment (via an attribute
815 declaration, for example) use it -- otherwise, start with a
816 one-byte alignment. */
817 rli->record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (t));
818 rli->unpacked_align = rli->record_align;
819 rli->offset_align = MAX (rli->record_align, BIGGEST_ALIGNMENT);
820
821#ifdef STRUCTURE_SIZE_BOUNDARY
822 /* Packed structures don't need to have minimum size. */
823 if (! TYPE_PACKED (t))
824 {
825 unsigned tmp;
826
827 /* #pragma pack overrides STRUCTURE_SIZE_BOUNDARY. */
828 tmp = (unsigned) STRUCTURE_SIZE_BOUNDARY;
829 if (maximum_field_alignment != 0)
830 tmp = MIN (tmp, maximum_field_alignment);
831 rli->record_align = MAX (rli->record_align, tmp);
832 }
833#endif
834
835 rli->offset = size_zero_node;
836 rli->bitpos = bitsize_zero_node;
837 rli->prev_field = 0;
838 rli->pending_statics = 0;
839 rli->packed_maybe_necessary = 0;
840 rli->remaining_in_alignment = 0;
841
842 return rli;
843}
844
845/* Return the combined bit position for the byte offset OFFSET and the
846 bit position BITPOS.
847
848 These functions operate on byte and bit positions present in FIELD_DECLs
849 and assume that these expressions result in no (intermediate) overflow.
850 This assumption is necessary to fold the expressions as much as possible,
851 so as to avoid creating artificially variable-sized types in languages
852 supporting variable-sized types like Ada. */
853
854tree
855bit_from_pos (tree offset, tree bitpos)
856{
857 return size_binop (PLUS_EXPR, bitpos,
858 size_binop (MULT_EXPR,
859 fold_convert (bitsizetype, offset),
860 bitsize_unit_node));
861}
862
863/* Return the combined truncated byte position for the byte offset OFFSET and
864 the bit position BITPOS. */
865
866tree
867byte_from_pos (tree offset, tree bitpos)
868{
869 tree bytepos;
870 if (TREE_CODE (bitpos) == MULT_EXPR
871 && tree_int_cst_equal (TREE_OPERAND (bitpos, 1), bitsize_unit_node))
872 bytepos = TREE_OPERAND (bitpos, 0);
873 else
874 bytepos = size_binop (TRUNC_DIV_EXPR, bitpos, bitsize_unit_node);
875 return size_binop (PLUS_EXPR, offset, fold_convert (sizetype, bytepos));
876}
877
878/* Split the bit position POS into a byte offset *POFFSET and a bit
879 position *PBITPOS with the byte offset aligned to OFF_ALIGN bits. */
880
881void
882pos_from_bit (tree *poffset, tree *pbitpos, unsigned int off_align,
883 tree pos)
884{
885 tree toff_align = bitsize_int (off_align);
886 if (TREE_CODE (pos) == MULT_EXPR
887 && tree_int_cst_equal (TREE_OPERAND (pos, 1), toff_align))
888 {
889 *poffset = size_binop (MULT_EXPR,
890 fold_convert (sizetype, TREE_OPERAND (pos, 0)),
891 size_int (off_align / BITS_PER_UNIT));
892 *pbitpos = bitsize_zero_node;
893 }
894 else
895 {
896 *poffset = size_binop (MULT_EXPR,
897 fold_convert (sizetype,
898 size_binop (FLOOR_DIV_EXPR, pos,
899 toff_align)),
900 size_int (off_align / BITS_PER_UNIT));
901 *pbitpos = size_binop (FLOOR_MOD_EXPR, pos, toff_align);
902 }
903}
904
905/* Given a pointer to bit and byte offsets and an offset alignment,
906 normalize the offsets so they are within the alignment. */
907
908void
909normalize_offset (tree *poffset, tree *pbitpos, unsigned int off_align)
910{
911 /* If the bit position is now larger than it should be, adjust it
912 downwards. */
913 if (compare_tree_int (*pbitpos, off_align) >= 0)
914 {
915 tree offset, bitpos;
916 pos_from_bit (&offset, &bitpos, off_align, *pbitpos);
917 *poffset = size_binop (PLUS_EXPR, *poffset, offset);
918 *pbitpos = bitpos;
919 }
920}
921
922/* Print debugging information about the information in RLI. */
923
924DEBUG_FUNCTION void
925debug_rli (record_layout_info rli)
926{
927 print_node_brief (stderr, "type", rli->t, 0);
928 print_node_brief (stderr, "\noffset", rli->offset, 0);
929 print_node_brief (stderr, " bitpos", rli->bitpos, 0);
930
931 fprintf (stderr, "\naligns: rec = %u, unpack = %u, off = %u\n",
932 rli->record_align, rli->unpacked_align,
933 rli->offset_align);
934
935 /* The ms_struct code is the only that uses this. */
936 if (targetm.ms_bitfield_layout_p (rli->t))
937 fprintf (stderr, "remaining in alignment = %u\n", rli->remaining_in_alignment);
938
939 if (rli->packed_maybe_necessary)
940 fprintf (stderr, "packed may be necessary\n");
941
942 if (!vec_safe_is_empty (rli->pending_statics))
943 {
944 fprintf (stderr, "pending statics:\n");
945 debug (rli->pending_statics);
946 }
947}
948
949/* Given an RLI with a possibly-incremented BITPOS, adjust OFFSET and
950 BITPOS if necessary to keep BITPOS below OFFSET_ALIGN. */
951
952void
953normalize_rli (record_layout_info rli)
954{
955 normalize_offset (&rli->offset, &rli->bitpos, rli->offset_align);
956}
957
958/* Returns the size in bytes allocated so far. */
959
960tree
961rli_size_unit_so_far (record_layout_info rli)
962{
963 return byte_from_pos (rli->offset, rli->bitpos);
964}
965
966/* Returns the size in bits allocated so far. */
967
968tree
969rli_size_so_far (record_layout_info rli)
970{
971 return bit_from_pos (rli->offset, rli->bitpos);
972}
973
974/* FIELD is about to be added to RLI->T. The alignment (in bits) of
975 the next available location within the record is given by KNOWN_ALIGN.
976 Update the variable alignment fields in RLI, and return the alignment
977 to give the FIELD. */
978
979unsigned int
980update_alignment_for_field (record_layout_info rli, tree field,
981 unsigned int known_align)
982{
983 /* The alignment required for FIELD. */
984 unsigned int desired_align;
985 /* The type of this field. */
986 tree type = TREE_TYPE (field);
987 /* True if the field was explicitly aligned by the user. */
988 bool user_align;
989 bool is_bitfield;
990
991 /* Do not attempt to align an ERROR_MARK node */
992 if (TREE_CODE (type) == ERROR_MARK)
993 return 0;
994
995 /* Lay out the field so we know what alignment it needs. */
996 layout_decl (field, known_align);
997 desired_align = DECL_ALIGN (field);
998 user_align = DECL_USER_ALIGN (field);
999
1000 is_bitfield = (type != error_mark_node
1001 && DECL_BIT_FIELD_TYPE (field)
1002 && ! integer_zerop (TYPE_SIZE (type)));
1003
1004 /* Record must have at least as much alignment as any field.
1005 Otherwise, the alignment of the field within the record is
1006 meaningless. */
1007 if (targetm.ms_bitfield_layout_p (rli->t))
1008 {
1009 /* Here, the alignment of the underlying type of a bitfield can
1010 affect the alignment of a record; even a zero-sized field
1011 can do this. The alignment should be to the alignment of
1012 the type, except that for zero-size bitfields this only
1013 applies if there was an immediately prior, nonzero-size
1014 bitfield. (That's the way it is, experimentally.) */
1015 if ((!is_bitfield && !DECL_PACKED (field))
1016 || ((DECL_SIZE (field) == NULL_TREE
1017 || !integer_zerop (DECL_SIZE (field)))
1018 ? !DECL_PACKED (field)
1019 : (rli->prev_field
1020 && DECL_BIT_FIELD_TYPE (rli->prev_field)
1021 && ! integer_zerop (DECL_SIZE (rli->prev_field)))))
1022 {
1023 unsigned int type_align = TYPE_ALIGN (type);
1024 type_align = MAX (type_align, desired_align);
1025 if (maximum_field_alignment != 0)
1026 type_align = MIN (type_align, maximum_field_alignment);
1027 rli->record_align = MAX (rli->record_align, type_align);
1028 rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type));
1029 }
1030 }
1031 else if (is_bitfield && PCC_BITFIELD_TYPE_MATTERS)
1032 {
1033 /* Named bit-fields cause the entire structure to have the
1034 alignment implied by their type. Some targets also apply the same
1035 rules to unnamed bitfields. */
1036 if (DECL_NAME (field) != 0
1037 || targetm.align_anon_bitfield ())
1038 {
1039 unsigned int type_align = TYPE_ALIGN (type);
1040
1041#ifdef ADJUST_FIELD_ALIGN
1042 if (! TYPE_USER_ALIGN (type))
1043 type_align = ADJUST_FIELD_ALIGN (field, type, type_align);
1044#endif
1045
1046 /* Targets might chose to handle unnamed and hence possibly
1047 zero-width bitfield. Those are not influenced by #pragmas
1048 or packed attributes. */
1049 if (integer_zerop (DECL_SIZE (field)))
1050 {
1051 if (initial_max_fld_align)
1052 type_align = MIN (type_align,
1053 initial_max_fld_align * BITS_PER_UNIT);
1054 }
1055 else if (maximum_field_alignment != 0)
1056 type_align = MIN (type_align, maximum_field_alignment);
1057 else if (DECL_PACKED (field))
1058 type_align = MIN (type_align, BITS_PER_UNIT);
1059
1060 /* The alignment of the record is increased to the maximum
1061 of the current alignment, the alignment indicated on the
1062 field (i.e., the alignment specified by an __aligned__
1063 attribute), and the alignment indicated by the type of
1064 the field. */
1065 rli->record_align = MAX (rli->record_align, desired_align);
1066 rli->record_align = MAX (rli->record_align, type_align);
1067
1068 if (warn_packed)
1069 rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type));
1070 user_align |= TYPE_USER_ALIGN (type);
1071 }
1072 }
1073 else
1074 {
1075 rli->record_align = MAX (rli->record_align, desired_align);
1076 rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type));
1077 }
1078
1079 TYPE_USER_ALIGN (rli->t) |= user_align;
1080
1081 return desired_align;
1082}
1083
1084/* Issue a warning if the record alignment, RECORD_ALIGN, is less than
1085 the field alignment of FIELD or FIELD isn't aligned. */
1086
1087static void
1088handle_warn_if_not_align (tree field, unsigned int record_align)
1089{
1090 tree type = TREE_TYPE (field);
1091
1092 if (type == error_mark_node)
1093 return;
1094
1095 unsigned int warn_if_not_align = 0;
1096
1097 int opt_w = 0;
1098
1099 if (warn_if_not_aligned)
1100 {
1101 warn_if_not_align = DECL_WARN_IF_NOT_ALIGN (field);
1102 if (!warn_if_not_align)
1103 warn_if_not_align = TYPE_WARN_IF_NOT_ALIGN (type);
1104 if (warn_if_not_align)
1105 opt_w = OPT_Wif_not_aligned;
1106 }
1107
1108 if (!warn_if_not_align
1109 && warn_packed_not_aligned
1110 && lookup_attribute ("aligned", TYPE_ATTRIBUTES (type)))
1111 {
1112 warn_if_not_align = TYPE_ALIGN (type);
1113 opt_w = OPT_Wpacked_not_aligned;
1114 }
1115
1116 if (!warn_if_not_align)
1117 return;
1118
1119 tree context = DECL_CONTEXT (field);
1120
1121 warn_if_not_align /= BITS_PER_UNIT;
1122 record_align /= BITS_PER_UNIT;
1123 if ((record_align % warn_if_not_align) != 0)
1124 warning (opt_w, "alignment %u of %qT is less than %u",
1125 record_align, context, warn_if_not_align);
1126
1127 unsigned HOST_WIDE_INT off
1128 = (tree_to_uhwi (DECL_FIELD_OFFSET (field))
1129 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field)) / BITS_PER_UNIT);
1130 if ((off % warn_if_not_align) != 0)
1131 warning (opt_w, "%q+D offset %wu in %qT isn't aligned to %u",
1132 field, off, context, warn_if_not_align);
1133}
1134
1135/* Called from place_field to handle unions. */
1136
1137static void
1138place_union_field (record_layout_info rli, tree field)
1139{
1140 update_alignment_for_field (rli, field, /*known_align=*/0);
1141
1142 DECL_FIELD_OFFSET (field) = size_zero_node;
1143 DECL_FIELD_BIT_OFFSET (field) = bitsize_zero_node;
1144 SET_DECL_OFFSET_ALIGN (field, BIGGEST_ALIGNMENT);
1145 handle_warn_if_not_align (field, rli->record_align);
1146
1147 /* If this is an ERROR_MARK return *after* having set the
1148 field at the start of the union. This helps when parsing
1149 invalid fields. */
1150 if (TREE_CODE (TREE_TYPE (field)) == ERROR_MARK)
1151 return;
1152
1153 if (AGGREGATE_TYPE_P (TREE_TYPE (field))
1154 && TYPE_TYPELESS_STORAGE (TREE_TYPE (field)))
1155 TYPE_TYPELESS_STORAGE (rli->t) = 1;
1156
1157 /* We assume the union's size will be a multiple of a byte so we don't
1158 bother with BITPOS. */
1159 if (TREE_CODE (rli->t) == UNION_TYPE)
1160 rli->offset = size_binop (MAX_EXPR, rli->offset, DECL_SIZE_UNIT (field));
1161 else if (TREE_CODE (rli->t) == QUAL_UNION_TYPE)
1162 rli->offset = fold_build3 (COND_EXPR, sizetype, DECL_QUALIFIER (field),
1163 DECL_SIZE_UNIT (field), rli->offset);
1164}
1165
1166/* A bitfield of SIZE with a required access alignment of ALIGN is allocated
1167 at BYTE_OFFSET / BIT_OFFSET. Return nonzero if the field would span more
1168 units of alignment than the underlying TYPE. */
1169static int
1170excess_unit_span (HOST_WIDE_INT byte_offset, HOST_WIDE_INT bit_offset,
1171 HOST_WIDE_INT size, HOST_WIDE_INT align, tree type)
1172{
1173 /* Note that the calculation of OFFSET might overflow; we calculate it so
1174 that we still get the right result as long as ALIGN is a power of two. */
1175 unsigned HOST_WIDE_INT offset = byte_offset * BITS_PER_UNIT + bit_offset;
1176
1177 offset = offset % align;
1178 return ((offset + size + align - 1) / align
1179 > tree_to_uhwi (TYPE_SIZE (type)) / align);
1180}
1181
1182/* RLI contains information about the layout of a RECORD_TYPE. FIELD
1183 is a FIELD_DECL to be added after those fields already present in
1184 T. (FIELD is not actually added to the TYPE_FIELDS list here;
1185 callers that desire that behavior must manually perform that step.) */
1186
1187void
1188place_field (record_layout_info rli, tree field)
1189{
1190 /* The alignment required for FIELD. */
1191 unsigned int desired_align;
1192 /* The alignment FIELD would have if we just dropped it into the
1193 record as it presently stands. */
1194 unsigned int known_align;
1195 unsigned int actual_align;
1196 /* The type of this field. */
1197 tree type = TREE_TYPE (field);
1198
1199 gcc_assert (TREE_CODE (field) != ERROR_MARK);
1200
1201 /* If FIELD is static, then treat it like a separate variable, not
1202 really like a structure field. If it is a FUNCTION_DECL, it's a
1203 method. In both cases, all we do is lay out the decl, and we do
1204 it *after* the record is laid out. */
1205 if (VAR_P (field))
1206 {
1207 vec_safe_push (rli->pending_statics, field);
1208 return;
1209 }
1210
1211 /* Enumerators and enum types which are local to this class need not
1212 be laid out. Likewise for initialized constant fields. */
1213 else if (TREE_CODE (field) != FIELD_DECL)
1214 return;
1215
1216 /* Unions are laid out very differently than records, so split
1217 that code off to another function. */
1218 else if (TREE_CODE (rli->t) != RECORD_TYPE)
1219 {
1220 place_union_field (rli, field);
1221 return;
1222 }
1223
1224 else if (TREE_CODE (type) == ERROR_MARK)
1225 {
1226 /* Place this field at the current allocation position, so we
1227 maintain monotonicity. */
1228 DECL_FIELD_OFFSET (field) = rli->offset;
1229 DECL_FIELD_BIT_OFFSET (field) = rli->bitpos;
1230 SET_DECL_OFFSET_ALIGN (field, rli->offset_align);
1231 handle_warn_if_not_align (field, rli->record_align);
1232 return;
1233 }
1234
1235 if (AGGREGATE_TYPE_P (type)
1236 && TYPE_TYPELESS_STORAGE (type))
1237 TYPE_TYPELESS_STORAGE (rli->t) = 1;
1238
1239 /* Work out the known alignment so far. Note that A & (-A) is the
1240 value of the least-significant bit in A that is one. */
1241 if (! integer_zerop (rli->bitpos))
1242 known_align = least_bit_hwi (tree_to_uhwi (rli->bitpos));
1243 else if (integer_zerop (rli->offset))
1244 known_align = 0;
1245 else if (tree_fits_uhwi_p (rli->offset))
1246 known_align = (BITS_PER_UNIT
1247 * least_bit_hwi (tree_to_uhwi (rli->offset)));
1248 else
1249 known_align = rli->offset_align;
1250
1251 desired_align = update_alignment_for_field (rli, field, known_align);
1252 if (known_align == 0)
1253 known_align = MAX (BIGGEST_ALIGNMENT, rli->record_align);
1254
1255 if (warn_packed && DECL_PACKED (field))
1256 {
1257 if (known_align >= TYPE_ALIGN (type))
1258 {
1259 if (TYPE_ALIGN (type) > desired_align)
1260 {
1261 if (STRICT_ALIGNMENT)
1262 warning (OPT_Wattributes, "packed attribute causes "
1263 "inefficient alignment for %q+D", field);
1264 /* Don't warn if DECL_PACKED was set by the type. */
1265 else if (!TYPE_PACKED (rli->t))
1266 warning (OPT_Wattributes, "packed attribute is "
1267 "unnecessary for %q+D", field);
1268 }
1269 }
1270 else
1271 rli->packed_maybe_necessary = 1;
1272 }
1273
1274 /* Does this field automatically have alignment it needs by virtue
1275 of the fields that precede it and the record's own alignment? */
1276 if (known_align < desired_align)
1277 {
1278 /* No, we need to skip space before this field.
1279 Bump the cumulative size to multiple of field alignment. */
1280
1281 if (!targetm.ms_bitfield_layout_p (rli->t)
1282 && DECL_SOURCE_LOCATION (field) != BUILTINS_LOCATION)
1283 warning (OPT_Wpadded, "padding struct to align %q+D", field);
1284
1285 /* If the alignment is still within offset_align, just align
1286 the bit position. */
1287 if (desired_align < rli->offset_align)
1288 rli->bitpos = round_up (rli->bitpos, desired_align);
1289 else
1290 {
1291 /* First adjust OFFSET by the partial bits, then align. */
1292 rli->offset
1293 = size_binop (PLUS_EXPR, rli->offset,
1294 fold_convert (sizetype,
1295 size_binop (CEIL_DIV_EXPR, rli->bitpos,
1296 bitsize_unit_node)));
1297 rli->bitpos = bitsize_zero_node;
1298
1299 rli->offset = round_up (rli->offset, desired_align / BITS_PER_UNIT);
1300 }
1301
1302 if (! TREE_CONSTANT (rli->offset))
1303 rli->offset_align = desired_align;
1304 if (targetm.ms_bitfield_layout_p (rli->t))
1305 rli->prev_field = NULL;
1306 }
1307
1308 /* Handle compatibility with PCC. Note that if the record has any
1309 variable-sized fields, we need not worry about compatibility. */
1310 if (PCC_BITFIELD_TYPE_MATTERS
1311 && ! targetm.ms_bitfield_layout_p (rli->t)
1312 && TREE_CODE (field) == FIELD_DECL
1313 && type != error_mark_node
1314 && DECL_BIT_FIELD (field)
1315 && (! DECL_PACKED (field)
1316 /* Enter for these packed fields only to issue a warning. */
1317 || TYPE_ALIGN (type) <= BITS_PER_UNIT)
1318 && maximum_field_alignment == 0
1319 && ! integer_zerop (DECL_SIZE (field))
1320 && tree_fits_uhwi_p (DECL_SIZE (field))
1321 && tree_fits_uhwi_p (rli->offset)
1322 && tree_fits_uhwi_p (TYPE_SIZE (type)))
1323 {
1324 unsigned int type_align = TYPE_ALIGN (type);
1325 tree dsize = DECL_SIZE (field);
1326 HOST_WIDE_INT field_size = tree_to_uhwi (dsize);
1327 HOST_WIDE_INT offset = tree_to_uhwi (rli->offset);
1328 HOST_WIDE_INT bit_offset = tree_to_shwi (rli->bitpos);
1329
1330#ifdef ADJUST_FIELD_ALIGN
1331 if (! TYPE_USER_ALIGN (type))
1332 type_align = ADJUST_FIELD_ALIGN (field, type, type_align);
1333#endif
1334
1335 /* A bit field may not span more units of alignment of its type
1336 than its type itself. Advance to next boundary if necessary. */
1337 if (excess_unit_span (offset, bit_offset, field_size, type_align, type))
1338 {
1339 if (DECL_PACKED (field))
1340 {
1341 if (warn_packed_bitfield_compat == 1)
1342 inform
1343 (input_location,
1344 "offset of packed bit-field %qD has changed in GCC 4.4",
1345 field);
1346 }
1347 else
1348 rli->bitpos = round_up (rli->bitpos, type_align);
1349 }
1350
1351 if (! DECL_PACKED (field))
1352 TYPE_USER_ALIGN (rli->t) |= TYPE_USER_ALIGN (type);
1353
1354 SET_TYPE_WARN_IF_NOT_ALIGN (rli->t,
1355 TYPE_WARN_IF_NOT_ALIGN (type));
1356 }
1357
1358#ifdef BITFIELD_NBYTES_LIMITED
1359 if (BITFIELD_NBYTES_LIMITED
1360 && ! targetm.ms_bitfield_layout_p (rli->t)
1361 && TREE_CODE (field) == FIELD_DECL
1362 && type != error_mark_node
1363 && DECL_BIT_FIELD_TYPE (field)
1364 && ! DECL_PACKED (field)
1365 && ! integer_zerop (DECL_SIZE (field))
1366 && tree_fits_uhwi_p (DECL_SIZE (field))
1367 && tree_fits_uhwi_p (rli->offset)
1368 && tree_fits_uhwi_p (TYPE_SIZE (type)))
1369 {
1370 unsigned int type_align = TYPE_ALIGN (type);
1371 tree dsize = DECL_SIZE (field);
1372 HOST_WIDE_INT field_size = tree_to_uhwi (dsize);
1373 HOST_WIDE_INT offset = tree_to_uhwi (rli->offset);
1374 HOST_WIDE_INT bit_offset = tree_to_shwi (rli->bitpos);
1375
1376#ifdef ADJUST_FIELD_ALIGN
1377 if (! TYPE_USER_ALIGN (type))
1378 type_align = ADJUST_FIELD_ALIGN (field, type, type_align);
1379#endif
1380
1381 if (maximum_field_alignment != 0)
1382 type_align = MIN (type_align, maximum_field_alignment);
1383 /* ??? This test is opposite the test in the containing if
1384 statement, so this code is unreachable currently. */
1385 else if (DECL_PACKED (field))
1386 type_align = MIN (type_align, BITS_PER_UNIT);
1387
1388 /* A bit field may not span the unit of alignment of its type.
1389 Advance to next boundary if necessary. */
1390 if (excess_unit_span (offset, bit_offset, field_size, type_align, type))
1391 rli->bitpos = round_up (rli->bitpos, type_align);
1392
1393 TYPE_USER_ALIGN (rli->t) |= TYPE_USER_ALIGN (type);
1394 SET_TYPE_WARN_IF_NOT_ALIGN (rli->t,
1395 TYPE_WARN_IF_NOT_ALIGN (type));
1396 }
1397#endif
1398
1399 /* See the docs for TARGET_MS_BITFIELD_LAYOUT_P for details.
1400 A subtlety:
1401 When a bit field is inserted into a packed record, the whole
1402 size of the underlying type is used by one or more same-size
1403 adjacent bitfields. (That is, if its long:3, 32 bits is
1404 used in the record, and any additional adjacent long bitfields are
1405 packed into the same chunk of 32 bits. However, if the size
1406 changes, a new field of that size is allocated.) In an unpacked
1407 record, this is the same as using alignment, but not equivalent
1408 when packing.
1409
1410 Note: for compatibility, we use the type size, not the type alignment
1411 to determine alignment, since that matches the documentation */
1412
1413 if (targetm.ms_bitfield_layout_p (rli->t))
1414 {
1415 tree prev_saved = rli->prev_field;
1416 tree prev_type = prev_saved ? DECL_BIT_FIELD_TYPE (prev_saved) : NULL;
1417
1418 /* This is a bitfield if it exists. */
1419 if (rli->prev_field)
1420 {
1421 /* If both are bitfields, nonzero, and the same size, this is
1422 the middle of a run. Zero declared size fields are special
1423 and handled as "end of run". (Note: it's nonzero declared
1424 size, but equal type sizes!) (Since we know that both
1425 the current and previous fields are bitfields by the
1426 time we check it, DECL_SIZE must be present for both.) */
1427 if (DECL_BIT_FIELD_TYPE (field)
1428 && !integer_zerop (DECL_SIZE (field))
1429 && !integer_zerop (DECL_SIZE (rli->prev_field))
1430 && tree_fits_shwi_p (DECL_SIZE (rli->prev_field))
1431 && tree_fits_uhwi_p (TYPE_SIZE (type))
1432 && simple_cst_equal (TYPE_SIZE (type), TYPE_SIZE (prev_type)))
1433 {
1434 /* We're in the middle of a run of equal type size fields; make
1435 sure we realign if we run out of bits. (Not decl size,
1436 type size!) */
1437 HOST_WIDE_INT bitsize = tree_to_uhwi (DECL_SIZE (field));
1438
1439 if (rli->remaining_in_alignment < bitsize)
1440 {
1441 HOST_WIDE_INT typesize = tree_to_uhwi (TYPE_SIZE (type));
1442
1443 /* out of bits; bump up to next 'word'. */
1444 rli->bitpos
1445 = size_binop (PLUS_EXPR, rli->bitpos,
1446 bitsize_int (rli->remaining_in_alignment));
1447 rli->prev_field = field;
1448 if (typesize < bitsize)
1449 rli->remaining_in_alignment = 0;
1450 else
1451 rli->remaining_in_alignment = typesize - bitsize;
1452 }
1453 else
1454 rli->remaining_in_alignment -= bitsize;
1455 }
1456 else
1457 {
1458 /* End of a run: if leaving a run of bitfields of the same type
1459 size, we have to "use up" the rest of the bits of the type
1460 size.
1461
1462 Compute the new position as the sum of the size for the prior
1463 type and where we first started working on that type.
1464 Note: since the beginning of the field was aligned then
1465 of course the end will be too. No round needed. */
1466
1467 if (!integer_zerop (DECL_SIZE (rli->prev_field)))
1468 {
1469 rli->bitpos
1470 = size_binop (PLUS_EXPR, rli->bitpos,
1471 bitsize_int (rli->remaining_in_alignment));
1472 }
1473 else
1474 /* We "use up" size zero fields; the code below should behave
1475 as if the prior field was not a bitfield. */
1476 prev_saved = NULL;
1477
1478 /* Cause a new bitfield to be captured, either this time (if
1479 currently a bitfield) or next time we see one. */
1480 if (!DECL_BIT_FIELD_TYPE (field)
1481 || integer_zerop (DECL_SIZE (field)))
1482 rli->prev_field = NULL;
1483 }
1484
1485 normalize_rli (rli);
1486 }
1487
1488 /* If we're starting a new run of same type size bitfields
1489 (or a run of non-bitfields), set up the "first of the run"
1490 fields.
1491
1492 That is, if the current field is not a bitfield, or if there
1493 was a prior bitfield the type sizes differ, or if there wasn't
1494 a prior bitfield the size of the current field is nonzero.
1495
1496 Note: we must be sure to test ONLY the type size if there was
1497 a prior bitfield and ONLY for the current field being zero if
1498 there wasn't. */
1499
1500 if (!DECL_BIT_FIELD_TYPE (field)
1501 || (prev_saved != NULL
1502 ? !simple_cst_equal (TYPE_SIZE (type), TYPE_SIZE (prev_type))
1503 : !integer_zerop (DECL_SIZE (field)) ))
1504 {
1505 /* Never smaller than a byte for compatibility. */
1506 unsigned int type_align = BITS_PER_UNIT;
1507
1508 /* (When not a bitfield), we could be seeing a flex array (with
1509 no DECL_SIZE). Since we won't be using remaining_in_alignment
1510 until we see a bitfield (and come by here again) we just skip
1511 calculating it. */
1512 if (DECL_SIZE (field) != NULL
1513 && tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (field)))
1514 && tree_fits_uhwi_p (DECL_SIZE (field)))
1515 {
1516 unsigned HOST_WIDE_INT bitsize
1517 = tree_to_uhwi (DECL_SIZE (field));
1518 unsigned HOST_WIDE_INT typesize
1519 = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (field)));
1520
1521 if (typesize < bitsize)
1522 rli->remaining_in_alignment = 0;
1523 else
1524 rli->remaining_in_alignment = typesize - bitsize;
1525 }
1526
1527 /* Now align (conventionally) for the new type. */
1528 type_align = TYPE_ALIGN (TREE_TYPE (field));
1529
1530 if (maximum_field_alignment != 0)
1531 type_align = MIN (type_align, maximum_field_alignment);
1532
1533 rli->bitpos = round_up (rli->bitpos, type_align);
1534
1535 /* If we really aligned, don't allow subsequent bitfields
1536 to undo that. */
1537 rli->prev_field = NULL;
1538 }
1539 }
1540
1541 /* Offset so far becomes the position of this field after normalizing. */
1542 normalize_rli (rli);
1543 DECL_FIELD_OFFSET (field) = rli->offset;
1544 DECL_FIELD_BIT_OFFSET (field) = rli->bitpos;
1545 SET_DECL_OFFSET_ALIGN (field, rli->offset_align);
1546 handle_warn_if_not_align (field, rli->record_align);
1547
1548 /* Evaluate nonconstant offsets only once, either now or as soon as safe. */
1549 if (TREE_CODE (DECL_FIELD_OFFSET (field)) != INTEGER_CST)
1550 DECL_FIELD_OFFSET (field) = variable_size (DECL_FIELD_OFFSET (field));
1551
1552 /* If this field ended up more aligned than we thought it would be (we
1553 approximate this by seeing if its position changed), lay out the field
1554 again; perhaps we can use an integral mode for it now. */
1555 if (! integer_zerop (DECL_FIELD_BIT_OFFSET (field)))
1556 actual_align = least_bit_hwi (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field)));
1557 else if (integer_zerop (DECL_FIELD_OFFSET (field)))
1558 actual_align = MAX (BIGGEST_ALIGNMENT, rli->record_align);
1559 else if (tree_fits_uhwi_p (DECL_FIELD_OFFSET (field)))
1560 actual_align = (BITS_PER_UNIT
1561 * least_bit_hwi (tree_to_uhwi (DECL_FIELD_OFFSET (field))));
1562 else
1563 actual_align = DECL_OFFSET_ALIGN (field);
1564 /* ACTUAL_ALIGN is still the actual alignment *within the record* .
1565 store / extract bit field operations will check the alignment of the
1566 record against the mode of bit fields. */
1567
1568 if (known_align != actual_align)
1569 layout_decl (field, actual_align);
1570
1571 if (rli->prev_field == NULL && DECL_BIT_FIELD_TYPE (field))
1572 rli->prev_field = field;
1573
1574 /* Now add size of this field to the size of the record. If the size is
1575 not constant, treat the field as being a multiple of bytes and just
1576 adjust the offset, resetting the bit position. Otherwise, apportion the
1577 size amongst the bit position and offset. First handle the case of an
1578 unspecified size, which can happen when we have an invalid nested struct
1579 definition, such as struct j { struct j { int i; } }. The error message
1580 is printed in finish_struct. */
1581 if (DECL_SIZE (field) == 0)
1582 /* Do nothing. */;
1583 else if (TREE_CODE (DECL_SIZE (field)) != INTEGER_CST
1584 || TREE_OVERFLOW (DECL_SIZE (field)))
1585 {
1586 rli->offset
1587 = size_binop (PLUS_EXPR, rli->offset,
1588 fold_convert (sizetype,
1589 size_binop (CEIL_DIV_EXPR, rli->bitpos,
1590 bitsize_unit_node)));
1591 rli->offset
1592 = size_binop (PLUS_EXPR, rli->offset, DECL_SIZE_UNIT (field));
1593 rli->bitpos = bitsize_zero_node;
1594 rli->offset_align = MIN (rli->offset_align, desired_align);
1595 }
1596 else if (targetm.ms_bitfield_layout_p (rli->t))
1597 {
1598 rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, DECL_SIZE (field));
1599
1600 /* If we ended a bitfield before the full length of the type then
1601 pad the struct out to the full length of the last type. */
1602 if ((DECL_CHAIN (field) == NULL
1603 || TREE_CODE (DECL_CHAIN (field)) != FIELD_DECL)
1604 && DECL_BIT_FIELD_TYPE (field)
1605 && !integer_zerop (DECL_SIZE (field)))
1606 rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos,
1607 bitsize_int (rli->remaining_in_alignment));
1608
1609 normalize_rli (rli);
1610 }
1611 else
1612 {
1613 rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, DECL_SIZE (field));
1614 normalize_rli (rli);
1615 }
1616}
1617
1618/* Assuming that all the fields have been laid out, this function uses
1619 RLI to compute the final TYPE_SIZE, TYPE_ALIGN, etc. for the type
1620 indicated by RLI. */
1621
1622static void
1623finalize_record_size (record_layout_info rli)
1624{
1625 tree unpadded_size, unpadded_size_unit;
1626
1627 /* Now we want just byte and bit offsets, so set the offset alignment
1628 to be a byte and then normalize. */
1629 rli->offset_align = BITS_PER_UNIT;
1630 normalize_rli (rli);
1631
1632 /* Determine the desired alignment. */
1633#ifdef ROUND_TYPE_ALIGN
1634 SET_TYPE_ALIGN (rli->t, ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t),
1635 rli->record_align));
1636#else
1637 SET_TYPE_ALIGN (rli->t, MAX (TYPE_ALIGN (rli->t), rli->record_align));
1638#endif
1639
1640 /* Compute the size so far. Be sure to allow for extra bits in the
1641 size in bytes. We have guaranteed above that it will be no more
1642 than a single byte. */
1643 unpadded_size = rli_size_so_far (rli);
1644 unpadded_size_unit = rli_size_unit_so_far (rli);
1645 if (! integer_zerop (rli->bitpos))
1646 unpadded_size_unit
1647 = size_binop (PLUS_EXPR, unpadded_size_unit, size_one_node);
1648
1649 /* Round the size up to be a multiple of the required alignment. */
1650 TYPE_SIZE (rli->t) = round_up (unpadded_size, TYPE_ALIGN (rli->t));
1651 TYPE_SIZE_UNIT (rli->t)
1652 = round_up (unpadded_size_unit, TYPE_ALIGN_UNIT (rli->t));
1653
1654 if (TREE_CONSTANT (unpadded_size)
1655 && simple_cst_equal (unpadded_size, TYPE_SIZE (rli->t)) == 0
1656 && input_location != BUILTINS_LOCATION)
1657 warning (OPT_Wpadded, "padding struct size to alignment boundary");
1658
1659 if (warn_packed && TREE_CODE (rli->t) == RECORD_TYPE
1660 && TYPE_PACKED (rli->t) && ! rli->packed_maybe_necessary
1661 && TREE_CONSTANT (unpadded_size))
1662 {
1663 tree unpacked_size;
1664
1665#ifdef ROUND_TYPE_ALIGN
1666 rli->unpacked_align
1667 = ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t), rli->unpacked_align);
1668#else
1669 rli->unpacked_align = MAX (TYPE_ALIGN (rli->t), rli->unpacked_align);
1670#endif
1671
1672 unpacked_size = round_up (TYPE_SIZE (rli->t), rli->unpacked_align);
1673 if (simple_cst_equal (unpacked_size, TYPE_SIZE (rli->t)))
1674 {
1675 if (TYPE_NAME (rli->t))
1676 {
1677 tree name;
1678
1679 if (TREE_CODE (TYPE_NAME (rli->t)) == IDENTIFIER_NODE)
1680 name = TYPE_NAME (rli->t);
1681 else
1682 name = DECL_NAME (TYPE_NAME (rli->t));
1683
1684 if (STRICT_ALIGNMENT)
1685 warning (OPT_Wpacked, "packed attribute causes inefficient "
1686 "alignment for %qE", name);
1687 else
1688 warning (OPT_Wpacked,
1689 "packed attribute is unnecessary for %qE", name);
1690 }
1691 else
1692 {
1693 if (STRICT_ALIGNMENT)
1694 warning (OPT_Wpacked,
1695 "packed attribute causes inefficient alignment");
1696 else
1697 warning (OPT_Wpacked, "packed attribute is unnecessary");
1698 }
1699 }
1700 }
1701}
1702
1703/* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE). */
1704
1705void
1706compute_record_mode (tree type)
1707{
1708 tree field;
1709 machine_mode mode = VOIDmode;
1710
1711 /* Most RECORD_TYPEs have BLKmode, so we start off assuming that.
1712 However, if possible, we use a mode that fits in a register
1713 instead, in order to allow for better optimization down the
1714 line. */
1715 SET_TYPE_MODE (type, BLKmode);
1716
1717 if (! tree_fits_uhwi_p (TYPE_SIZE (type)))
1718 return;
1719
1720 /* A record which has any BLKmode members must itself be
1721 BLKmode; it can't go in a register. Unless the member is
1722 BLKmode only because it isn't aligned. */
1723 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
1724 {
1725 if (TREE_CODE (field) != FIELD_DECL)
1726 continue;
1727
1728 if (TREE_CODE (TREE_TYPE (field)) == ERROR_MARK
1729 || (TYPE_MODE (TREE_TYPE (field)) == BLKmode
1730 && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field))
1731 && !(TYPE_SIZE (TREE_TYPE (field)) != 0
1732 && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))))
1733 || ! tree_fits_uhwi_p (bit_position (field))
1734 || DECL_SIZE (field) == 0
1735 || ! tree_fits_uhwi_p (DECL_SIZE (field)))
1736 return;
1737
1738 /* If this field is the whole struct, remember its mode so
1739 that, say, we can put a double in a class into a DF
1740 register instead of forcing it to live in the stack. */
1741 if (simple_cst_equal (TYPE_SIZE (type), DECL_SIZE (field)))
1742 mode = DECL_MODE (field);
1743
1744 /* With some targets, it is sub-optimal to access an aligned
1745 BLKmode structure as a scalar. */
1746 if (targetm.member_type_forces_blk (field, mode))
1747 return;
1748 }
1749
1750 /* If we only have one real field; use its mode if that mode's size
1751 matches the type's size. This only applies to RECORD_TYPE. This
1752 does not apply to unions. */
1753 if (TREE_CODE (type) == RECORD_TYPE && mode != VOIDmode
1754 && tree_fits_uhwi_p (TYPE_SIZE (type))
1755 && GET_MODE_BITSIZE (mode) == tree_to_uhwi (TYPE_SIZE (type)))
1756 ;
1757 else
1758 mode = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1).else_blk ();
1759
1760 /* If structure's known alignment is less than what the scalar
1761 mode would need, and it matters, then stick with BLKmode. */
1762 if (mode != BLKmode
1763 && STRICT_ALIGNMENT
1764 && ! (TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT
1765 || TYPE_ALIGN (type) >= GET_MODE_ALIGNMENT (mode)))
1766 {
1767 /* If this is the only reason this type is BLKmode, then
1768 don't force containing types to be BLKmode. */
1769 TYPE_NO_FORCE_BLK (type) = 1;
1770 mode = BLKmode;
1771 }
1772
1773 SET_TYPE_MODE (type, mode);
1774}
1775
1776/* Compute TYPE_SIZE and TYPE_ALIGN for TYPE, once it has been laid
1777 out. */
1778
1779static void
1780finalize_type_size (tree type)
1781{
1782 /* Normally, use the alignment corresponding to the mode chosen.
1783 However, where strict alignment is not required, avoid
1784 over-aligning structures, since most compilers do not do this
1785 alignment. */
1786 if (TYPE_MODE (type) != BLKmode
1787 && TYPE_MODE (type) != VOIDmode
1788 && (STRICT_ALIGNMENT || !AGGREGATE_TYPE_P (type)))
1789 {
1790 unsigned mode_align = GET_MODE_ALIGNMENT (TYPE_MODE (type));
1791
1792 /* Don't override a larger alignment requirement coming from a user
1793 alignment of one of the fields. */
1794 if (mode_align >= TYPE_ALIGN (type))
1795 {
1796 SET_TYPE_ALIGN (type, mode_align);
1797 TYPE_USER_ALIGN (type) = 0;
1798 }
1799 }
1800
1801 /* Do machine-dependent extra alignment. */
1802#ifdef ROUND_TYPE_ALIGN
1803 SET_TYPE_ALIGN (type,
1804 ROUND_TYPE_ALIGN (type, TYPE_ALIGN (type), BITS_PER_UNIT));
1805#endif
1806
1807 /* If we failed to find a simple way to calculate the unit size
1808 of the type, find it by division. */
1809 if (TYPE_SIZE_UNIT (type) == 0 && TYPE_SIZE (type) != 0)
1810 /* TYPE_SIZE (type) is computed in bitsizetype. After the division, the
1811 result will fit in sizetype. We will get more efficient code using
1812 sizetype, so we force a conversion. */
1813 TYPE_SIZE_UNIT (type)
1814 = fold_convert (sizetype,
1815 size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (type),
1816 bitsize_unit_node));
1817
1818 if (TYPE_SIZE (type) != 0)
1819 {
1820 TYPE_SIZE (type) = round_up (TYPE_SIZE (type), TYPE_ALIGN (type));
1821 TYPE_SIZE_UNIT (type)
1822 = round_up (TYPE_SIZE_UNIT (type), TYPE_ALIGN_UNIT (type));
1823 }
1824
1825 /* Evaluate nonconstant sizes only once, either now or as soon as safe. */
1826 if (TYPE_SIZE (type) != 0 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1827 TYPE_SIZE (type) = variable_size (TYPE_SIZE (type));
1828 if (TYPE_SIZE_UNIT (type) != 0
1829 && TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST)
1830 TYPE_SIZE_UNIT (type) = variable_size (TYPE_SIZE_UNIT (type));
1831
1832 /* Also layout any other variants of the type. */
1833 if (TYPE_NEXT_VARIANT (type)
1834 || type != TYPE_MAIN_VARIANT (type))
1835 {
1836 tree variant;
1837 /* Record layout info of this variant. */
1838 tree size = TYPE_SIZE (type);
1839 tree size_unit = TYPE_SIZE_UNIT (type);
1840 unsigned int align = TYPE_ALIGN (type);
1841 unsigned int precision = TYPE_PRECISION (type);
1842 unsigned int user_align = TYPE_USER_ALIGN (type);
1843 machine_mode mode = TYPE_MODE (type);
1844
1845 /* Copy it into all variants. */
1846 for (variant = TYPE_MAIN_VARIANT (type);
1847 variant != 0;
1848 variant = TYPE_NEXT_VARIANT (variant))
1849 {
1850 TYPE_SIZE (variant) = size;
1851 TYPE_SIZE_UNIT (variant) = size_unit;
1852 unsigned valign = align;
1853 if (TYPE_USER_ALIGN (variant))
1854 valign = MAX (valign, TYPE_ALIGN (variant));
1855 else
1856 TYPE_USER_ALIGN (variant) = user_align;
1857 SET_TYPE_ALIGN (variant, valign);
1858 TYPE_PRECISION (variant) = precision;
1859 SET_TYPE_MODE (variant, mode);
1860 }
1861 }
1862
1863 /* Handle empty records as per the x86-64 psABI. */
1864 TYPE_EMPTY_P (type) = targetm.calls.empty_record_p (type);
1865}
1866
1867/* Return a new underlying object for a bitfield started with FIELD. */
1868
1869static tree
1870start_bitfield_representative (tree field)
1871{
1872 tree repr = make_node (FIELD_DECL);
1873 DECL_FIELD_OFFSET (repr) = DECL_FIELD_OFFSET (field);
1874 /* Force the representative to begin at a BITS_PER_UNIT aligned
1875 boundary - C++ may use tail-padding of a base object to
1876 continue packing bits so the bitfield region does not start
1877 at bit zero (see g++.dg/abi/bitfield5.C for example).
1878 Unallocated bits may happen for other reasons as well,
1879 for example Ada which allows explicit bit-granular structure layout. */
1880 DECL_FIELD_BIT_OFFSET (repr)
1881 = size_binop (BIT_AND_EXPR,
1882 DECL_FIELD_BIT_OFFSET (field),
1883 bitsize_int (~(BITS_PER_UNIT - 1)));
1884 SET_DECL_OFFSET_ALIGN (repr, DECL_OFFSET_ALIGN (field));
1885 DECL_SIZE (repr) = DECL_SIZE (field);
1886 DECL_SIZE_UNIT (repr) = DECL_SIZE_UNIT (field);
1887 DECL_PACKED (repr) = DECL_PACKED (field);
1888 DECL_CONTEXT (repr) = DECL_CONTEXT (field);
1889 /* There are no indirect accesses to this field. If we introduce
1890 some then they have to use the record alias set. This makes
1891 sure to properly conflict with [indirect] accesses to addressable
1892 fields of the bitfield group. */
1893 DECL_NONADDRESSABLE_P (repr) = 1;
1894 return repr;
1895}
1896
1897/* Finish up a bitfield group that was started by creating the underlying
1898 object REPR with the last field in the bitfield group FIELD. */
1899
1900static void
1901finish_bitfield_representative (tree repr, tree field)
1902{
1903 unsigned HOST_WIDE_INT bitsize, maxbitsize;
1904 tree nextf, size;
1905
1906 size = size_diffop (DECL_FIELD_OFFSET (field),
1907 DECL_FIELD_OFFSET (repr));
1908 while (TREE_CODE (size) == COMPOUND_EXPR)
1909 size = TREE_OPERAND (size, 1);
1910 gcc_assert (tree_fits_uhwi_p (size));
1911 bitsize = (tree_to_uhwi (size) * BITS_PER_UNIT
1912 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field))
1913 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr))
1914 + tree_to_uhwi (DECL_SIZE (field)));
1915
1916 /* Round up bitsize to multiples of BITS_PER_UNIT. */
1917 bitsize = (bitsize + BITS_PER_UNIT - 1) & ~(BITS_PER_UNIT - 1);
1918
1919 /* Now nothing tells us how to pad out bitsize ... */
1920 nextf = DECL_CHAIN (field);
1921 while (nextf && TREE_CODE (nextf) != FIELD_DECL)
1922 nextf = DECL_CHAIN (nextf);
1923 if (nextf)
1924 {
1925 tree maxsize;
1926 /* If there was an error, the field may be not laid out
1927 correctly. Don't bother to do anything. */
1928 if (TREE_TYPE (nextf) == error_mark_node)
1929 return;
1930 maxsize = size_diffop (DECL_FIELD_OFFSET (nextf),
1931 DECL_FIELD_OFFSET (repr));
1932 if (tree_fits_uhwi_p (maxsize))
1933 {
1934 maxbitsize = (tree_to_uhwi (maxsize) * BITS_PER_UNIT
1935 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (nextf))
1936 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr)));
1937 /* If the group ends within a bitfield nextf does not need to be
1938 aligned to BITS_PER_UNIT. Thus round up. */
1939 maxbitsize = (maxbitsize + BITS_PER_UNIT - 1) & ~(BITS_PER_UNIT - 1);
1940 }
1941 else
1942 maxbitsize = bitsize;
1943 }
1944 else
1945 {
1946 /* Note that if the C++ FE sets up tail-padding to be re-used it
1947 creates a as-base variant of the type with TYPE_SIZE adjusted
1948 accordingly. So it is safe to include tail-padding here. */
1949 tree aggsize = lang_hooks.types.unit_size_without_reusable_padding
1950 (DECL_CONTEXT (field));
1951 tree maxsize = size_diffop (aggsize, DECL_FIELD_OFFSET (repr));
1952 /* We cannot generally rely on maxsize to fold to an integer constant,
1953 so use bitsize as fallback for this case. */
1954 if (tree_fits_uhwi_p (maxsize))
1955 maxbitsize = (tree_to_uhwi (maxsize) * BITS_PER_UNIT
1956 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr)));
1957 else
1958 maxbitsize = bitsize;
1959 }
1960
1961 /* Only if we don't artificially break up the representative in
1962 the middle of a large bitfield with different possibly
1963 overlapping representatives. And all representatives start
1964 at byte offset. */
1965 gcc_assert (maxbitsize % BITS_PER_UNIT == 0);
1966
1967 /* Find the smallest nice mode to use. */
1968 opt_scalar_int_mode mode_iter;
1969 FOR_EACH_MODE_IN_CLASS (mode_iter, MODE_INT)
1970 if (GET_MODE_BITSIZE (mode_iter.require ()) >= bitsize)
1971 break;
1972
1973 scalar_int_mode mode;
1974 if (!mode_iter.exists (&mode)
1975 || GET_MODE_BITSIZE (mode) > maxbitsize
1976 || GET_MODE_BITSIZE (mode) > MAX_FIXED_MODE_SIZE)
1977 {
1978 /* We really want a BLKmode representative only as a last resort,
1979 considering the member b in
1980 struct { int a : 7; int b : 17; int c; } __attribute__((packed));
1981 Otherwise we simply want to split the representative up
1982 allowing for overlaps within the bitfield region as required for
1983 struct { int a : 7; int b : 7;
1984 int c : 10; int d; } __attribute__((packed));
1985 [0, 15] HImode for a and b, [8, 23] HImode for c. */
1986 DECL_SIZE (repr) = bitsize_int (bitsize);
1987 DECL_SIZE_UNIT (repr) = size_int (bitsize / BITS_PER_UNIT);
1988 SET_DECL_MODE (repr, BLKmode);
1989 TREE_TYPE (repr) = build_array_type_nelts (unsigned_char_type_node,
1990 bitsize / BITS_PER_UNIT);
1991 }
1992 else
1993 {
1994 unsigned HOST_WIDE_INT modesize = GET_MODE_BITSIZE (mode);
1995 DECL_SIZE (repr) = bitsize_int (modesize);
1996 DECL_SIZE_UNIT (repr) = size_int (modesize / BITS_PER_UNIT);
1997 SET_DECL_MODE (repr, mode);
1998 TREE_TYPE (repr) = lang_hooks.types.type_for_mode (mode, 1);
1999 }
2000
2001 /* Remember whether the bitfield group is at the end of the
2002 structure or not. */
2003 DECL_CHAIN (repr) = nextf;
2004}
2005
2006/* Compute and set FIELD_DECLs for the underlying objects we should
2007 use for bitfield access for the structure T. */
2008
2009void
2010finish_bitfield_layout (tree t)
2011{
2012 tree field, prev;
2013 tree repr = NULL_TREE;
2014
2015 /* Unions would be special, for the ease of type-punning optimizations
2016 we could use the underlying type as hint for the representative
2017 if the bitfield would fit and the representative would not exceed
2018 the union in size. */
2019 if (TREE_CODE (t) != RECORD_TYPE)
2020 return;
2021
2022 for (prev = NULL_TREE, field = TYPE_FIELDS (t);
2023 field; field = DECL_CHAIN (field))
2024 {
2025 if (TREE_CODE (field) != FIELD_DECL)
2026 continue;
2027
2028 /* In the C++ memory model, consecutive bit fields in a structure are
2029 considered one memory location and updating a memory location
2030 may not store into adjacent memory locations. */
2031 if (!repr
2032 && DECL_BIT_FIELD_TYPE (field))
2033 {
2034 /* Start new representative. */
2035 repr = start_bitfield_representative (field);
2036 }
2037 else if (repr
2038 && ! DECL_BIT_FIELD_TYPE (field))
2039 {
2040 /* Finish off new representative. */
2041 finish_bitfield_representative (repr, prev);
2042 repr = NULL_TREE;
2043 }
2044 else if (DECL_BIT_FIELD_TYPE (field))
2045 {
2046 gcc_assert (repr != NULL_TREE);
2047
2048 /* Zero-size bitfields finish off a representative and
2049 do not have a representative themselves. This is
2050 required by the C++ memory model. */
2051 if (integer_zerop (DECL_SIZE (field)))
2052 {
2053 finish_bitfield_representative (repr, prev);
2054 repr = NULL_TREE;
2055 }
2056
2057 /* We assume that either DECL_FIELD_OFFSET of the representative
2058 and each bitfield member is a constant or they are equal.
2059 This is because we need to be able to compute the bit-offset
2060 of each field relative to the representative in get_bit_range
2061 during RTL expansion.
2062 If these constraints are not met, simply force a new
2063 representative to be generated. That will at most
2064 generate worse code but still maintain correctness with
2065 respect to the C++ memory model. */
2066 else if (!((tree_fits_uhwi_p (DECL_FIELD_OFFSET (repr))
2067 && tree_fits_uhwi_p (DECL_FIELD_OFFSET (field)))
2068 || operand_equal_p (DECL_FIELD_OFFSET (repr),
2069 DECL_FIELD_OFFSET (field), 0)))
2070 {
2071 finish_bitfield_representative (repr, prev);
2072 repr = start_bitfield_representative (field);
2073 }
2074 }
2075 else
2076 continue;
2077
2078 if (repr)
2079 DECL_BIT_FIELD_REPRESENTATIVE (field) = repr;
2080
2081 prev = field;
2082 }
2083
2084 if (repr)
2085 finish_bitfield_representative (repr, prev);
2086}
2087
2088/* Do all of the work required to layout the type indicated by RLI,
2089 once the fields have been laid out. This function will call `free'
2090 for RLI, unless FREE_P is false. Passing a value other than false
2091 for FREE_P is bad practice; this option only exists to support the
2092 G++ 3.2 ABI. */
2093
2094void
2095finish_record_layout (record_layout_info rli, int free_p)
2096{
2097 tree variant;
2098
2099 /* Compute the final size. */
2100 finalize_record_size (rli);
2101
2102 /* Compute the TYPE_MODE for the record. */
2103 compute_record_mode (rli->t);
2104
2105 /* Perform any last tweaks to the TYPE_SIZE, etc. */
2106 finalize_type_size (rli->t);
2107
2108 /* Compute bitfield representatives. */
2109 finish_bitfield_layout (rli->t);
2110
2111 /* Propagate TYPE_PACKED and TYPE_REVERSE_STORAGE_ORDER to variants.
2112 With C++ templates, it is too early to do this when the attribute
2113 is being parsed. */
2114 for (variant = TYPE_NEXT_VARIANT (rli->t); variant;
2115 variant = TYPE_NEXT_VARIANT (variant))
2116 {
2117 TYPE_PACKED (variant) = TYPE_PACKED (rli->t);
2118 TYPE_REVERSE_STORAGE_ORDER (variant)
2119 = TYPE_REVERSE_STORAGE_ORDER (rli->t);
2120 }
2121
2122 /* Lay out any static members. This is done now because their type
2123 may use the record's type. */
2124 while (!vec_safe_is_empty (rli->pending_statics))
2125 layout_decl (rli->pending_statics->pop (), 0);
2126
2127 /* Clean up. */
2128 if (free_p)
2129 {
2130 vec_free (rli->pending_statics);
2131 free (rli);
2132 }
2133}
2134
2135
2136/* Finish processing a builtin RECORD_TYPE type TYPE. It's name is
2137 NAME, its fields are chained in reverse on FIELDS.
2138
2139 If ALIGN_TYPE is non-null, it is given the same alignment as
2140 ALIGN_TYPE. */
2141
2142void
2143finish_builtin_struct (tree type, const char *name, tree fields,
2144 tree align_type)
2145{
2146 tree tail, next;
2147
2148 for (tail = NULL_TREE; fields; tail = fields, fields = next)
2149 {
2150 DECL_FIELD_CONTEXT (fields) = type;
2151 next = DECL_CHAIN (fields);
2152 DECL_CHAIN (fields) = tail;
2153 }
2154 TYPE_FIELDS (type) = tail;
2155
2156 if (align_type)
2157 {
2158 SET_TYPE_ALIGN (type, TYPE_ALIGN (align_type));
2159 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (align_type);
2160 SET_TYPE_WARN_IF_NOT_ALIGN (type,
2161 TYPE_WARN_IF_NOT_ALIGN (align_type));
2162 }
2163
2164 layout_type (type);
2165#if 0 /* not yet, should get fixed properly later */
2166 TYPE_NAME (type) = make_type_decl (get_identifier (name), type);
2167#else
2168 TYPE_NAME (type) = build_decl (BUILTINS_LOCATION,
2169 TYPE_DECL, get_identifier (name), type);
2170#endif
2171 TYPE_STUB_DECL (type) = TYPE_NAME (type);
2172 layout_decl (TYPE_NAME (type), 0);
2173}
2174
2175/* Calculate the mode, size, and alignment for TYPE.
2176 For an array type, calculate the element separation as well.
2177 Record TYPE on the chain of permanent or temporary types
2178 so that dbxout will find out about it.
2179
2180 TYPE_SIZE of a type is nonzero if the type has been laid out already.
2181 layout_type does nothing on such a type.
2182
2183 If the type is incomplete, its TYPE_SIZE remains zero. */
2184
2185void
2186layout_type (tree type)
2187{
2188 gcc_assert (type);
2189
2190 if (type == error_mark_node)
2191 return;
2192
2193 /* We don't want finalize_type_size to copy an alignment attribute to
2194 variants that don't have it. */
2195 type = TYPE_MAIN_VARIANT (type);
2196
2197 /* Do nothing if type has been laid out before. */
2198 if (TYPE_SIZE (type))
2199 return;
2200
2201 switch (TREE_CODE (type))
2202 {
2203 case LANG_TYPE:
2204 /* This kind of type is the responsibility
2205 of the language-specific code. */
2206 gcc_unreachable ();
2207
2208 case BOOLEAN_TYPE:
2209 case INTEGER_TYPE:
2210 case ENUMERAL_TYPE:
2211 {
2212 scalar_int_mode mode
2213 = smallest_int_mode_for_size (TYPE_PRECISION (type));
2214 SET_TYPE_MODE (type, mode);
2215 TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (mode));
2216 /* Don't set TYPE_PRECISION here, as it may be set by a bitfield. */
2217 TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (mode));
2218 break;
2219 }
2220
2221 case REAL_TYPE:
2222 {
2223 /* Allow the caller to choose the type mode, which is how decimal
2224 floats are distinguished from binary ones. */
2225 if (TYPE_MODE (type) == VOIDmode)
2226 SET_TYPE_MODE
2227 (type, float_mode_for_size (TYPE_PRECISION (type)).require ());
2228 scalar_float_mode mode = as_a <scalar_float_mode> (TYPE_MODE (type));
2229 TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (mode));
2230 TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (mode));
2231 break;
2232 }
2233
2234 case FIXED_POINT_TYPE:
2235 {
2236 /* TYPE_MODE (type) has been set already. */
2237 scalar_mode mode = SCALAR_TYPE_MODE (type);
2238 TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (mode));
2239 TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (mode));
2240 break;
2241 }
2242
2243 case COMPLEX_TYPE:
2244 TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TREE_TYPE (type));
2245 SET_TYPE_MODE (type,
2246 GET_MODE_COMPLEX_MODE (TYPE_MODE (TREE_TYPE (type))));
2247
2248 TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
2249 TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
2250 break;
2251
2252 case VECTOR_TYPE:
2253 {
2254 int nunits = TYPE_VECTOR_SUBPARTS (type);
2255 tree innertype = TREE_TYPE (type);
2256
2257 gcc_assert (!(nunits & (nunits - 1)));
2258
2259 /* Find an appropriate mode for the vector type. */
2260 if (TYPE_MODE (type) == VOIDmode)
2261 SET_TYPE_MODE (type,
2262 mode_for_vector (SCALAR_TYPE_MODE (innertype),
2263 nunits).else_blk ());
2264
2265 TYPE_SATURATING (type) = TYPE_SATURATING (TREE_TYPE (type));
2266 TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TREE_TYPE (type));
2267 /* Several boolean vector elements may fit in a single unit. */
2268 if (VECTOR_BOOLEAN_TYPE_P (type)
2269 && type->type_common.mode != BLKmode)
2270 TYPE_SIZE_UNIT (type)
2271 = size_int (GET_MODE_SIZE (type->type_common.mode));
2272 else
2273 TYPE_SIZE_UNIT (type) = int_const_binop (MULT_EXPR,
2274 TYPE_SIZE_UNIT (innertype),
2275 size_int (nunits));
2276 TYPE_SIZE (type) = int_const_binop (MULT_EXPR,
2277 TYPE_SIZE (innertype),
2278 bitsize_int (nunits));
2279
2280 /* For vector types, we do not default to the mode's alignment.
2281 Instead, query a target hook, defaulting to natural alignment.
2282 This prevents ABI changes depending on whether or not native
2283 vector modes are supported. */
2284 SET_TYPE_ALIGN (type, targetm.vector_alignment (type));
2285
2286 /* However, if the underlying mode requires a bigger alignment than
2287 what the target hook provides, we cannot use the mode. For now,
2288 simply reject that case. */
2289 gcc_assert (TYPE_ALIGN (type)
2290 >= GET_MODE_ALIGNMENT (TYPE_MODE (type)));
2291 break;
2292 }
2293
2294 case VOID_TYPE:
2295 /* This is an incomplete type and so doesn't have a size. */
2296 SET_TYPE_ALIGN (type, 1);
2297 TYPE_USER_ALIGN (type) = 0;
2298 SET_TYPE_MODE (type, VOIDmode);
2299 break;
2300
2301 case POINTER_BOUNDS_TYPE:
2302 TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
2303 TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
2304 break;
2305
2306 case OFFSET_TYPE:
2307 TYPE_SIZE (type) = bitsize_int (POINTER_SIZE);
2308 TYPE_SIZE_UNIT (type) = size_int (POINTER_SIZE_UNITS);
2309 /* A pointer might be MODE_PARTIAL_INT, but ptrdiff_t must be
2310 integral, which may be an __intN. */
2311 SET_TYPE_MODE (type, int_mode_for_size (POINTER_SIZE, 0).require ());
2312 TYPE_PRECISION (type) = POINTER_SIZE;
2313 break;
2314
2315 case FUNCTION_TYPE:
2316 case METHOD_TYPE:
2317 /* It's hard to see what the mode and size of a function ought to
2318 be, but we do know the alignment is FUNCTION_BOUNDARY, so
2319 make it consistent with that. */
2320 SET_TYPE_MODE (type,
2321 int_mode_for_size (FUNCTION_BOUNDARY, 0).else_blk ());
2322 TYPE_SIZE (type) = bitsize_int (FUNCTION_BOUNDARY);
2323 TYPE_SIZE_UNIT (type) = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2324 break;
2325
2326 case POINTER_TYPE:
2327 case REFERENCE_TYPE:
2328 {
2329 scalar_int_mode mode = SCALAR_INT_TYPE_MODE (type);
2330 TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (mode));
2331 TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (mode));
2332 TYPE_UNSIGNED (type) = 1;
2333 TYPE_PRECISION (type) = GET_MODE_PRECISION (mode);
2334 }
2335 break;
2336
2337 case ARRAY_TYPE:
2338 {
2339 tree index = TYPE_DOMAIN (type);
2340 tree element = TREE_TYPE (type);
2341
2342 /* We need to know both bounds in order to compute the size. */
2343 if (index && TYPE_MAX_VALUE (index) && TYPE_MIN_VALUE (index)
2344 && TYPE_SIZE (element))
2345 {
2346 tree ub = TYPE_MAX_VALUE (index);
2347 tree lb = TYPE_MIN_VALUE (index);
2348 tree element_size = TYPE_SIZE (element);
2349 tree length;
2350
2351 /* Make sure that an array of zero-sized element is zero-sized
2352 regardless of its extent. */
2353 if (integer_zerop (element_size))
2354 length = size_zero_node;
2355
2356 /* The computation should happen in the original signedness so
2357 that (possible) negative values are handled appropriately
2358 when determining overflow. */
2359 else
2360 {
2361 /* ??? When it is obvious that the range is signed
2362 represent it using ssizetype. */
2363 if (TREE_CODE (lb) == INTEGER_CST
2364 && TREE_CODE (ub) == INTEGER_CST
2365 && TYPE_UNSIGNED (TREE_TYPE (lb))
2366 && tree_int_cst_lt (ub, lb))
2367 {
2368 lb = wide_int_to_tree (ssizetype,
2369 offset_int::from (wi::to_wide (lb),
2370 SIGNED));
2371 ub = wide_int_to_tree (ssizetype,
2372 offset_int::from (wi::to_wide (ub),
2373 SIGNED));
2374 }
2375 length
2376 = fold_convert (sizetype,
2377 size_binop (PLUS_EXPR,
2378 build_int_cst (TREE_TYPE (lb), 1),
2379 size_binop (MINUS_EXPR, ub, lb)));
2380 }
2381
2382 /* ??? We have no way to distinguish a null-sized array from an
2383 array spanning the whole sizetype range, so we arbitrarily
2384 decide that [0, -1] is the only valid representation. */
2385 if (integer_zerop (length)
2386 && TREE_OVERFLOW (length)
2387 && integer_zerop (lb))
2388 length = size_zero_node;
2389
2390 TYPE_SIZE (type) = size_binop (MULT_EXPR, element_size,
2391 fold_convert (bitsizetype,
2392 length));
2393
2394 /* If we know the size of the element, calculate the total size
2395 directly, rather than do some division thing below. This
2396 optimization helps Fortran assumed-size arrays (where the
2397 size of the array is determined at runtime) substantially. */
2398 if (TYPE_SIZE_UNIT (element))
2399 TYPE_SIZE_UNIT (type)
2400 = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (element), length);
2401 }
2402
2403 /* Now round the alignment and size,
2404 using machine-dependent criteria if any. */
2405
2406 unsigned align = TYPE_ALIGN (element);
2407 if (TYPE_USER_ALIGN (type))
2408 align = MAX (align, TYPE_ALIGN (type));
2409 else
2410 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (element);
2411 if (!TYPE_WARN_IF_NOT_ALIGN (type))
2412 SET_TYPE_WARN_IF_NOT_ALIGN (type,
2413 TYPE_WARN_IF_NOT_ALIGN (element));
2414#ifdef ROUND_TYPE_ALIGN
2415 align = ROUND_TYPE_ALIGN (type, align, BITS_PER_UNIT);
2416#else
2417 align = MAX (align, BITS_PER_UNIT);
2418#endif
2419 SET_TYPE_ALIGN (type, align);
2420 SET_TYPE_MODE (type, BLKmode);
2421 if (TYPE_SIZE (type) != 0
2422 && ! targetm.member_type_forces_blk (type, VOIDmode)
2423 /* BLKmode elements force BLKmode aggregate;
2424 else extract/store fields may lose. */
2425 && (TYPE_MODE (TREE_TYPE (type)) != BLKmode
2426 || TYPE_NO_FORCE_BLK (TREE_TYPE (type))))
2427 {
2428 SET_TYPE_MODE (type, mode_for_array (TREE_TYPE (type),
2429 TYPE_SIZE (type)));
2430 if (TYPE_MODE (type) != BLKmode
2431 && STRICT_ALIGNMENT && TYPE_ALIGN (type) < BIGGEST_ALIGNMENT
2432 && TYPE_ALIGN (type) < GET_MODE_ALIGNMENT (TYPE_MODE (type)))
2433 {
2434 TYPE_NO_FORCE_BLK (type) = 1;
2435 SET_TYPE_MODE (type, BLKmode);
2436 }
2437 }
2438 if (AGGREGATE_TYPE_P (element))
2439 TYPE_TYPELESS_STORAGE (type) = TYPE_TYPELESS_STORAGE (element);
2440 /* When the element size is constant, check that it is at least as
2441 large as the element alignment. */
2442 if (TYPE_SIZE_UNIT (element)
2443 && TREE_CODE (TYPE_SIZE_UNIT (element)) == INTEGER_CST
2444 /* If TYPE_SIZE_UNIT overflowed, then it is certainly larger than
2445 TYPE_ALIGN_UNIT. */
2446 && !TREE_OVERFLOW (TYPE_SIZE_UNIT (element))
2447 && !integer_zerop (TYPE_SIZE_UNIT (element))
2448 && compare_tree_int (TYPE_SIZE_UNIT (element),
2449 TYPE_ALIGN_UNIT (element)) < 0)
2450 error ("alignment of array elements is greater than element size");
2451 break;
2452 }
2453
2454 case RECORD_TYPE:
2455 case UNION_TYPE:
2456 case QUAL_UNION_TYPE:
2457 {
2458 tree field;
2459 record_layout_info rli;
2460
2461 /* Initialize the layout information. */
2462 rli = start_record_layout (type);
2463
2464 /* If this is a QUAL_UNION_TYPE, we want to process the fields
2465 in the reverse order in building the COND_EXPR that denotes
2466 its size. We reverse them again later. */
2467 if (TREE_CODE (type) == QUAL_UNION_TYPE)
2468 TYPE_FIELDS (type) = nreverse (TYPE_FIELDS (type));
2469
2470 /* Place all the fields. */
2471 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
2472 place_field (rli, field);
2473
2474 if (TREE_CODE (type) == QUAL_UNION_TYPE)
2475 TYPE_FIELDS (type) = nreverse (TYPE_FIELDS (type));
2476
2477 /* Finish laying out the record. */
2478 finish_record_layout (rli, /*free_p=*/true);
2479 }
2480 break;
2481
2482 default:
2483 gcc_unreachable ();
2484 }
2485
2486 /* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE. For
2487 records and unions, finish_record_layout already called this
2488 function. */
2489 if (!RECORD_OR_UNION_TYPE_P (type))
2490 finalize_type_size (type);
2491
2492 /* We should never see alias sets on incomplete aggregates. And we
2493 should not call layout_type on not incomplete aggregates. */
2494 if (AGGREGATE_TYPE_P (type))
2495 gcc_assert (!TYPE_ALIAS_SET_KNOWN_P (type));
2496}
2497
2498/* Return the least alignment required for type TYPE. */
2499
2500unsigned int
2501min_align_of_type (tree type)
2502{
2503 unsigned int align = TYPE_ALIGN (type);
2504 if (!TYPE_USER_ALIGN (type))
2505 {
2506 align = MIN (align, BIGGEST_ALIGNMENT);
2507#ifdef BIGGEST_FIELD_ALIGNMENT
2508 align = MIN (align, BIGGEST_FIELD_ALIGNMENT);
2509#endif
2510 unsigned int field_align = align;
2511#ifdef ADJUST_FIELD_ALIGN
2512 field_align = ADJUST_FIELD_ALIGN (NULL_TREE, type, field_align);
2513#endif
2514 align = MIN (align, field_align);
2515 }
2516 return align / BITS_PER_UNIT;
2517}
2518
2519/* Create and return a type for signed integers of PRECISION bits. */
2520
2521tree
2522make_signed_type (int precision)
2523{
2524 tree type = make_node (INTEGER_TYPE);
2525
2526 TYPE_PRECISION (type) = precision;
2527
2528 fixup_signed_type (type);
2529 return type;
2530}
2531
2532/* Create and return a type for unsigned integers of PRECISION bits. */
2533
2534tree
2535make_unsigned_type (int precision)
2536{
2537 tree type = make_node (INTEGER_TYPE);
2538
2539 TYPE_PRECISION (type) = precision;
2540
2541 fixup_unsigned_type (type);
2542 return type;
2543}
2544
2545/* Create and return a type for fract of PRECISION bits, UNSIGNEDP,
2546 and SATP. */
2547
2548tree
2549make_fract_type (int precision, int unsignedp, int satp)
2550{
2551 tree type = make_node (FIXED_POINT_TYPE);
2552
2553 TYPE_PRECISION (type) = precision;
2554
2555 if (satp)
2556 TYPE_SATURATING (type) = 1;
2557
2558 /* Lay out the type: set its alignment, size, etc. */
2559 TYPE_UNSIGNED (type) = unsignedp;
2560 enum mode_class mclass = unsignedp ? MODE_UFRACT : MODE_FRACT;
2561 SET_TYPE_MODE (type, mode_for_size (precision, mclass, 0).require ());
2562 layout_type (type);
2563
2564 return type;
2565}
2566
2567/* Create and return a type for accum of PRECISION bits, UNSIGNEDP,
2568 and SATP. */
2569
2570tree
2571make_accum_type (int precision, int unsignedp, int satp)
2572{
2573 tree type = make_node (FIXED_POINT_TYPE);
2574
2575 TYPE_PRECISION (type) = precision;
2576
2577 if (satp)
2578 TYPE_SATURATING (type) = 1;
2579
2580 /* Lay out the type: set its alignment, size, etc. */
2581 TYPE_UNSIGNED (type) = unsignedp;
2582 enum mode_class mclass = unsignedp ? MODE_UACCUM : MODE_ACCUM;
2583 SET_TYPE_MODE (type, mode_for_size (precision, mclass, 0).require ());
2584 layout_type (type);
2585
2586 return type;
2587}
2588
2589/* Initialize sizetypes so layout_type can use them. */
2590
2591void
2592initialize_sizetypes (void)
2593{
2594 int precision, bprecision;
2595
2596 /* Get sizetypes precision from the SIZE_TYPE target macro. */
2597 if (strcmp (SIZETYPE, "unsigned int") == 0)
2598 precision = INT_TYPE_SIZE;
2599 else if (strcmp (SIZETYPE, "long unsigned int") == 0)
2600 precision = LONG_TYPE_SIZE;
2601 else if (strcmp (SIZETYPE, "long long unsigned int") == 0)
2602 precision = LONG_LONG_TYPE_SIZE;
2603 else if (strcmp (SIZETYPE, "short unsigned int") == 0)
2604 precision = SHORT_TYPE_SIZE;
2605 else
2606 {
2607 int i;
2608
2609 precision = -1;
2610 for (i = 0; i < NUM_INT_N_ENTS; i++)
2611 if (int_n_enabled_p[i])
2612 {
2613 char name[50];
2614 sprintf (name, "__int%d unsigned", int_n_data[i].bitsize);
2615
2616 if (strcmp (name, SIZETYPE) == 0)
2617 {
2618 precision = int_n_data[i].bitsize;
2619 }
2620 }
2621 if (precision == -1)
2622 gcc_unreachable ();
2623 }
2624
2625 bprecision
2626 = MIN (precision + LOG2_BITS_PER_UNIT + 1, MAX_FIXED_MODE_SIZE);
2627 bprecision = GET_MODE_PRECISION (smallest_int_mode_for_size (bprecision));
2628 if (bprecision > HOST_BITS_PER_DOUBLE_INT)
2629 bprecision = HOST_BITS_PER_DOUBLE_INT;
2630
2631 /* Create stubs for sizetype and bitsizetype so we can create constants. */
2632 sizetype = make_node (INTEGER_TYPE);
2633 TYPE_NAME (sizetype) = get_identifier ("sizetype");
2634 TYPE_PRECISION (sizetype) = precision;
2635 TYPE_UNSIGNED (sizetype) = 1;
2636 bitsizetype = make_node (INTEGER_TYPE);
2637 TYPE_NAME (bitsizetype) = get_identifier ("bitsizetype");
2638 TYPE_PRECISION (bitsizetype) = bprecision;
2639 TYPE_UNSIGNED (bitsizetype) = 1;
2640
2641 /* Now layout both types manually. */
2642 scalar_int_mode mode = smallest_int_mode_for_size (precision);
2643 SET_TYPE_MODE (sizetype, mode);
2644 SET_TYPE_ALIGN (sizetype, GET_MODE_ALIGNMENT (TYPE_MODE (sizetype)));
2645 TYPE_SIZE (sizetype) = bitsize_int (precision);
2646 TYPE_SIZE_UNIT (sizetype) = size_int (GET_MODE_SIZE (mode));
2647 set_min_and_max_values_for_integral_type (sizetype, precision, UNSIGNED);
2648
2649 mode = smallest_int_mode_for_size (bprecision);
2650 SET_TYPE_MODE (bitsizetype, mode);
2651 SET_TYPE_ALIGN (bitsizetype, GET_MODE_ALIGNMENT (TYPE_MODE (bitsizetype)));
2652 TYPE_SIZE (bitsizetype) = bitsize_int (bprecision);
2653 TYPE_SIZE_UNIT (bitsizetype) = size_int (GET_MODE_SIZE (mode));
2654 set_min_and_max_values_for_integral_type (bitsizetype, bprecision, UNSIGNED);
2655
2656 /* Create the signed variants of *sizetype. */
2657 ssizetype = make_signed_type (TYPE_PRECISION (sizetype));
2658 TYPE_NAME (ssizetype) = get_identifier ("ssizetype");
2659 sbitsizetype = make_signed_type (TYPE_PRECISION (bitsizetype));
2660 TYPE_NAME (sbitsizetype) = get_identifier ("sbitsizetype");
2661}
2662
2663/* TYPE is an integral type, i.e., an INTEGRAL_TYPE, ENUMERAL_TYPE
2664 or BOOLEAN_TYPE. Set TYPE_MIN_VALUE and TYPE_MAX_VALUE
2665 for TYPE, based on the PRECISION and whether or not the TYPE
2666 IS_UNSIGNED. PRECISION need not correspond to a width supported
2667 natively by the hardware; for example, on a machine with 8-bit,
2668 16-bit, and 32-bit register modes, PRECISION might be 7, 23, or
2669 61. */
2670
2671void
2672set_min_and_max_values_for_integral_type (tree type,
2673 int precision,
2674 signop sgn)
2675{
2676 /* For bitfields with zero width we end up creating integer types
2677 with zero precision. Don't assign any minimum/maximum values
2678 to those types, they don't have any valid value. */
2679 if (precision < 1)
2680 return;
2681
2682 TYPE_MIN_VALUE (type)
2683 = wide_int_to_tree (type, wi::min_value (precision, sgn));
2684 TYPE_MAX_VALUE (type)
2685 = wide_int_to_tree (type, wi::max_value (precision, sgn));
2686}
2687
2688/* Set the extreme values of TYPE based on its precision in bits,
2689 then lay it out. Used when make_signed_type won't do
2690 because the tree code is not INTEGER_TYPE. */
2691
2692void
2693fixup_signed_type (tree type)
2694{
2695 int precision = TYPE_PRECISION (type);
2696
2697 set_min_and_max_values_for_integral_type (type, precision, SIGNED);
2698
2699 /* Lay out the type: set its alignment, size, etc. */
2700 layout_type (type);
2701}
2702
2703/* Set the extreme values of TYPE based on its precision in bits,
2704 then lay it out. This is used both in `make_unsigned_type'
2705 and for enumeral types. */
2706
2707void
2708fixup_unsigned_type (tree type)
2709{
2710 int precision = TYPE_PRECISION (type);
2711
2712 TYPE_UNSIGNED (type) = 1;
2713
2714 set_min_and_max_values_for_integral_type (type, precision, UNSIGNED);
2715
2716 /* Lay out the type: set its alignment, size, etc. */
2717 layout_type (type);
2718}
2719
2720/* Construct an iterator for a bitfield that spans BITSIZE bits,
2721 starting at BITPOS.
2722
2723 BITREGION_START is the bit position of the first bit in this
2724 sequence of bit fields. BITREGION_END is the last bit in this
2725 sequence. If these two fields are non-zero, we should restrict the
2726 memory access to that range. Otherwise, we are allowed to touch
2727 any adjacent non bit-fields.
2728
2729 ALIGN is the alignment of the underlying object in bits.
2730 VOLATILEP says whether the bitfield is volatile. */
2731
2732bit_field_mode_iterator
2733::bit_field_mode_iterator (HOST_WIDE_INT bitsize, HOST_WIDE_INT bitpos,
2734 HOST_WIDE_INT bitregion_start,
2735 HOST_WIDE_INT bitregion_end,
2736 unsigned int align, bool volatilep)
2737: m_mode (NARROWEST_INT_MODE), m_bitsize (bitsize),
2738 m_bitpos (bitpos), m_bitregion_start (bitregion_start),
2739 m_bitregion_end (bitregion_end), m_align (align),
2740 m_volatilep (volatilep), m_count (0)
2741{
2742 if (!m_bitregion_end)
2743 {
2744 /* We can assume that any aligned chunk of ALIGN bits that overlaps
2745 the bitfield is mapped and won't trap, provided that ALIGN isn't
2746 too large. The cap is the biggest required alignment for data,
2747 or at least the word size. And force one such chunk at least. */
2748 unsigned HOST_WIDE_INT units
2749 = MIN (align, MAX (BIGGEST_ALIGNMENT, BITS_PER_WORD));
2750 if (bitsize <= 0)
2751 bitsize = 1;
2752 m_bitregion_end = bitpos + bitsize + units - 1;
2753 m_bitregion_end -= m_bitregion_end % units + 1;
2754 }
2755}
2756
2757/* Calls to this function return successively larger modes that can be used
2758 to represent the bitfield. Return true if another bitfield mode is
2759 available, storing it in *OUT_MODE if so. */
2760
2761bool
2762bit_field_mode_iterator::next_mode (scalar_int_mode *out_mode)
2763{
2764 scalar_int_mode mode;
2765 for (; m_mode.exists (&mode); m_mode = GET_MODE_WIDER_MODE (mode))
2766 {
2767 unsigned int unit = GET_MODE_BITSIZE (mode);
2768
2769 /* Skip modes that don't have full precision. */
2770 if (unit != GET_MODE_PRECISION (mode))
2771 continue;
2772
2773 /* Stop if the mode is too wide to handle efficiently. */
2774 if (unit > MAX_FIXED_MODE_SIZE)
2775 break;
2776
2777 /* Don't deliver more than one multiword mode; the smallest one
2778 should be used. */
2779 if (m_count > 0 && unit > BITS_PER_WORD)
2780 break;
2781
2782 /* Skip modes that are too small. */
2783 unsigned HOST_WIDE_INT substart = (unsigned HOST_WIDE_INT) m_bitpos % unit;
2784 unsigned HOST_WIDE_INT subend = substart + m_bitsize;
2785 if (subend > unit)
2786 continue;
2787
2788 /* Stop if the mode goes outside the bitregion. */
2789 HOST_WIDE_INT start = m_bitpos - substart;
2790 if (m_bitregion_start && start < m_bitregion_start)
2791 break;
2792 HOST_WIDE_INT end = start + unit;
2793 if (end > m_bitregion_end + 1)
2794 break;
2795
2796 /* Stop if the mode requires too much alignment. */
2797 if (GET_MODE_ALIGNMENT (mode) > m_align
2798 && targetm.slow_unaligned_access (mode, m_align))
2799 break;
2800
2801 *out_mode = mode;
2802 m_mode = GET_MODE_WIDER_MODE (mode);
2803 m_count++;
2804 return true;
2805 }
2806 return false;
2807}
2808
2809/* Return true if smaller modes are generally preferred for this kind
2810 of bitfield. */
2811
2812bool
2813bit_field_mode_iterator::prefer_smaller_modes ()
2814{
2815 return (m_volatilep
2816 ? targetm.narrow_volatile_bitfield ()
2817 : !SLOW_BYTE_ACCESS);
2818}
2819
2820/* Find the best machine mode to use when referencing a bit field of length
2821 BITSIZE bits starting at BITPOS.
2822
2823 BITREGION_START is the bit position of the first bit in this
2824 sequence of bit fields. BITREGION_END is the last bit in this
2825 sequence. If these two fields are non-zero, we should restrict the
2826 memory access to that range. Otherwise, we are allowed to touch
2827 any adjacent non bit-fields.
2828
2829 The chosen mode must have no more than LARGEST_MODE_BITSIZE bits.
2830 INT_MAX is a suitable value for LARGEST_MODE_BITSIZE if the caller
2831 doesn't want to apply a specific limit.
2832
2833 If no mode meets all these conditions, we return VOIDmode.
2834
2835 The underlying object is known to be aligned to a boundary of ALIGN bits.
2836
2837 If VOLATILEP is false and SLOW_BYTE_ACCESS is false, we return the
2838 smallest mode meeting these conditions.
2839
2840 If VOLATILEP is false and SLOW_BYTE_ACCESS is true, we return the
2841 largest mode (but a mode no wider than UNITS_PER_WORD) that meets
2842 all the conditions.
2843
2844 If VOLATILEP is true the narrow_volatile_bitfields target hook is used to
2845 decide which of the above modes should be used. */
2846
2847bool
2848get_best_mode (int bitsize, int bitpos,
2849 unsigned HOST_WIDE_INT bitregion_start,
2850 unsigned HOST_WIDE_INT bitregion_end,
2851 unsigned int align,
2852 unsigned HOST_WIDE_INT largest_mode_bitsize, bool volatilep,
2853 scalar_int_mode *best_mode)
2854{
2855 bit_field_mode_iterator iter (bitsize, bitpos, bitregion_start,
2856 bitregion_end, align, volatilep);
2857 scalar_int_mode mode;
2858 bool found = false;
2859 while (iter.next_mode (&mode)
2860 /* ??? For historical reasons, reject modes that would normally
2861 receive greater alignment, even if unaligned accesses are
2862 acceptable. This has both advantages and disadvantages.
2863 Removing this check means that something like:
2864
2865 struct s { unsigned int x; unsigned int y; };
2866 int f (struct s *s) { return s->x == 0 && s->y == 0; }
2867
2868 can be implemented using a single load and compare on
2869 64-bit machines that have no alignment restrictions.
2870 For example, on powerpc64-linux-gnu, we would generate:
2871
2872 ld 3,0(3)
2873 cntlzd 3,3
2874 srdi 3,3,6
2875 blr
2876
2877 rather than:
2878
2879 lwz 9,0(3)
2880 cmpwi 7,9,0
2881 bne 7,.L3
2882 lwz 3,4(3)
2883 cntlzw 3,3
2884 srwi 3,3,5
2885 extsw 3,3
2886 blr
2887 .p2align 4,,15
2888 .L3:
2889 li 3,0
2890 blr
2891
2892 However, accessing more than one field can make life harder
2893 for the gimple optimizers. For example, gcc.dg/vect/bb-slp-5.c
2894 has a series of unsigned short copies followed by a series of
2895 unsigned short comparisons. With this check, both the copies
2896 and comparisons remain 16-bit accesses and FRE is able
2897 to eliminate the latter. Without the check, the comparisons
2898 can be done using 2 64-bit operations, which FRE isn't able
2899 to handle in the same way.
2900
2901 Either way, it would probably be worth disabling this check
2902 during expand. One particular example where removing the
2903 check would help is the get_best_mode call in store_bit_field.
2904 If we are given a memory bitregion of 128 bits that is aligned
2905 to a 64-bit boundary, and the bitfield we want to modify is
2906 in the second half of the bitregion, this check causes
2907 store_bitfield to turn the memory into a 64-bit reference
2908 to the _first_ half of the region. We later use
2909 adjust_bitfield_address to get a reference to the correct half,
2910 but doing so looks to adjust_bitfield_address as though we are
2911 moving past the end of the original object, so it drops the
2912 associated MEM_EXPR and MEM_OFFSET. Removing the check
2913 causes store_bit_field to keep a 128-bit memory reference,
2914 so that the final bitfield reference still has a MEM_EXPR
2915 and MEM_OFFSET. */
2916 && GET_MODE_ALIGNMENT (mode) <= align
2917 && GET_MODE_BITSIZE (mode) <= largest_mode_bitsize)
2918 {
2919 *best_mode = mode;
2920 found = true;
2921 if (iter.prefer_smaller_modes ())
2922 break;
2923 }
2924
2925 return found;
2926}
2927
2928/* Gets minimal and maximal values for MODE (signed or unsigned depending on
2929 SIGN). The returned constants are made to be usable in TARGET_MODE. */
2930
2931void
2932get_mode_bounds (scalar_int_mode mode, int sign,
2933 scalar_int_mode target_mode,
2934 rtx *mmin, rtx *mmax)
2935{
2936 unsigned size = GET_MODE_PRECISION (mode);
2937 unsigned HOST_WIDE_INT min_val, max_val;
2938
2939 gcc_assert (size <= HOST_BITS_PER_WIDE_INT);
2940
2941 /* Special case BImode, which has values 0 and STORE_FLAG_VALUE. */
2942 if (mode == BImode)
2943 {
2944 if (STORE_FLAG_VALUE < 0)
2945 {
2946 min_val = STORE_FLAG_VALUE;
2947 max_val = 0;
2948 }
2949 else
2950 {
2951 min_val = 0;
2952 max_val = STORE_FLAG_VALUE;
2953 }
2954 }
2955 else if (sign)
2956 {
2957 min_val = -(HOST_WIDE_INT_1U << (size - 1));
2958 max_val = (HOST_WIDE_INT_1U << (size - 1)) - 1;
2959 }
2960 else
2961 {
2962 min_val = 0;
2963 max_val = (HOST_WIDE_INT_1U << (size - 1) << 1) - 1;
2964 }
2965
2966 *mmin = gen_int_mode (min_val, target_mode);
2967 *mmax = gen_int_mode (max_val, target_mode);
2968}
2969
2970#include "gt-stor-layout.h"
2971