OSDN Git Service

Revert:
[pf3gnuchains/gcc-fork.git] / gcc / stor-layout.c
1 /* C-compiler utilities for types and variables storage layout
2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1996, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
4    Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
21
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "tree.h"
28 #include "rtl.h"
29 #include "tm_p.h"
30 #include "flags.h"
31 #include "function.h"
32 #include "expr.h"
33 #include "output.h"
34 #include "toplev.h"
35 #include "ggc.h"
36 #include "target.h"
37 #include "langhooks.h"
38 #include "regs.h"
39 #include "params.h"
40
41 /* Data type for the expressions representing sizes of data types.
42    It is the first integer type laid out.  */
43 tree sizetype_tab[(int) TYPE_KIND_LAST];
44
45 /* If nonzero, this is an upper limit on alignment of structure fields.
46    The value is measured in bits.  */
47 unsigned int maximum_field_alignment = TARGET_DEFAULT_PACK_STRUCT * BITS_PER_UNIT;
48 /* ... and its original value in bytes, specified via -fpack-struct=<value>.  */
49 unsigned int initial_max_fld_align = TARGET_DEFAULT_PACK_STRUCT;
50
51 /* Nonzero if all REFERENCE_TYPEs are internal and hence should be
52    allocated in Pmode, not ptr_mode.   Set only by internal_reference_types
53    called only by a front end.  */
54 static int reference_types_internal = 0;
55
56 static void finalize_record_size (record_layout_info);
57 static void finalize_type_size (tree);
58 static void place_union_field (record_layout_info, tree);
59 #if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED)
60 static int excess_unit_span (HOST_WIDE_INT, HOST_WIDE_INT, HOST_WIDE_INT,
61                              HOST_WIDE_INT, tree);
62 #endif
63 extern void debug_rli (record_layout_info);
64 \f
65 /* SAVE_EXPRs for sizes of types and decls, waiting to be expanded.  */
66
67 static GTY(()) tree pending_sizes;
68
69 /* Show that REFERENCE_TYPES are internal and should be Pmode.  Called only
70    by front end.  */
71
72 void
73 internal_reference_types (void)
74 {
75   reference_types_internal = 1;
76 }
77
78 /* Get a list of all the objects put on the pending sizes list.  */
79
80 tree
81 get_pending_sizes (void)
82 {
83   tree chain = pending_sizes;
84
85   pending_sizes = 0;
86   return chain;
87 }
88
89 /* Add EXPR to the pending sizes list.  */
90
91 void
92 put_pending_size (tree expr)
93 {
94   /* Strip any simple arithmetic from EXPR to see if it has an underlying
95      SAVE_EXPR.  */
96   expr = skip_simple_arithmetic (expr);
97
98   if (TREE_CODE (expr) == SAVE_EXPR)
99     pending_sizes = tree_cons (NULL_TREE, expr, pending_sizes);
100 }
101
102 /* Put a chain of objects into the pending sizes list, which must be
103    empty.  */
104
105 void
106 put_pending_sizes (tree chain)
107 {
108   gcc_assert (!pending_sizes);
109   pending_sizes = chain;
110 }
111
112 /* Given a size SIZE that may not be a constant, return a SAVE_EXPR
113    to serve as the actual size-expression for a type or decl.  */
114
115 tree
116 variable_size (tree size)
117 {
118   tree save;
119
120   /* If the language-processor is to take responsibility for variable-sized
121      items (e.g., languages which have elaboration procedures like Ada),
122      just return SIZE unchanged.  Likewise for self-referential sizes and
123      constant sizes.  */
124   if (TREE_CONSTANT (size)
125       || lang_hooks.decls.global_bindings_p () < 0
126       || CONTAINS_PLACEHOLDER_P (size))
127     return size;
128
129   size = save_expr (size);
130
131   /* If an array with a variable number of elements is declared, and
132      the elements require destruction, we will emit a cleanup for the
133      array.  That cleanup is run both on normal exit from the block
134      and in the exception-handler for the block.  Normally, when code
135      is used in both ordinary code and in an exception handler it is
136      `unsaved', i.e., all SAVE_EXPRs are recalculated.  However, we do
137      not wish to do that here; the array-size is the same in both
138      places.  */
139   save = skip_simple_arithmetic (size);
140
141   if (cfun && cfun->x_dont_save_pending_sizes_p)
142     /* The front-end doesn't want us to keep a list of the expressions
143        that determine sizes for variable size objects.  Trust it.  */
144     return size;
145
146   if (lang_hooks.decls.global_bindings_p ())
147     {
148       if (TREE_CONSTANT (size))
149         error ("type size can%'t be explicitly evaluated");
150       else
151         error ("variable-size type declared outside of any function");
152
153       return size_one_node;
154     }
155
156   put_pending_size (save);
157
158   return size;
159 }
160 \f
161 #ifndef MAX_FIXED_MODE_SIZE
162 #define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (DImode)
163 #endif
164
165 /* Return the machine mode to use for a nonscalar of SIZE bits.  The
166    mode must be in class CLASS, and have exactly that many value bits;
167    it may have padding as well.  If LIMIT is nonzero, modes of wider
168    than MAX_FIXED_MODE_SIZE will not be used.  */
169
170 enum machine_mode
171 mode_for_size (unsigned int size, enum mode_class class, int limit)
172 {
173   enum machine_mode mode;
174
175   if (limit && size > MAX_FIXED_MODE_SIZE)
176     return BLKmode;
177
178   /* Get the first mode which has this size, in the specified class.  */
179   for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode;
180        mode = GET_MODE_WIDER_MODE (mode))
181     if (GET_MODE_PRECISION (mode) == size)
182       return mode;
183
184   return BLKmode;
185 }
186
187 /* Similar, except passed a tree node.  */
188
189 enum machine_mode
190 mode_for_size_tree (const_tree size, enum mode_class class, int limit)
191 {
192   unsigned HOST_WIDE_INT uhwi;
193   unsigned int ui;
194
195   if (!host_integerp (size, 1))
196     return BLKmode;
197   uhwi = tree_low_cst (size, 1);
198   ui = uhwi;
199   if (uhwi != ui)
200     return BLKmode;
201   return mode_for_size (ui, class, limit);
202 }
203
204 /* Similar, but never return BLKmode; return the narrowest mode that
205    contains at least the requested number of value bits.  */
206
207 enum machine_mode
208 smallest_mode_for_size (unsigned int size, enum mode_class class)
209 {
210   enum machine_mode mode;
211
212   /* Get the first mode which has at least this size, in the
213      specified class.  */
214   for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode;
215        mode = GET_MODE_WIDER_MODE (mode))
216     if (GET_MODE_PRECISION (mode) >= size)
217       return mode;
218
219   gcc_unreachable ();
220 }
221
222 /* Find an integer mode of the exact same size, or BLKmode on failure.  */
223
224 enum machine_mode
225 int_mode_for_mode (enum machine_mode mode)
226 {
227   switch (GET_MODE_CLASS (mode))
228     {
229     case MODE_INT:
230     case MODE_PARTIAL_INT:
231       break;
232
233     case MODE_COMPLEX_INT:
234     case MODE_COMPLEX_FLOAT:
235     case MODE_FLOAT:
236     case MODE_DECIMAL_FLOAT:
237     case MODE_VECTOR_INT:
238     case MODE_VECTOR_FLOAT:
239     case MODE_FRACT:
240     case MODE_ACCUM:
241     case MODE_UFRACT:
242     case MODE_UACCUM:
243     case MODE_VECTOR_FRACT:
244     case MODE_VECTOR_ACCUM:
245     case MODE_VECTOR_UFRACT:
246     case MODE_VECTOR_UACCUM:
247       mode = mode_for_size (GET_MODE_BITSIZE (mode), MODE_INT, 0);
248       break;
249
250     case MODE_RANDOM:
251       if (mode == BLKmode)
252         break;
253
254       /* ... fall through ...  */
255
256     case MODE_CC:
257     default:
258       gcc_unreachable ();
259     }
260
261   return mode;
262 }
263
264 /* Return the alignment of MODE. This will be bounded by 1 and
265    BIGGEST_ALIGNMENT.  */
266
267 unsigned int
268 get_mode_alignment (enum machine_mode mode)
269 {
270   return MIN (BIGGEST_ALIGNMENT, MAX (1, mode_base_align[mode]*BITS_PER_UNIT));
271 }
272
273 \f
274 /* Subroutine of layout_decl: Force alignment required for the data type.
275    But if the decl itself wants greater alignment, don't override that.  */
276
277 static inline void
278 do_type_align (tree type, tree decl)
279 {
280   if (TYPE_ALIGN (type) > DECL_ALIGN (decl))
281     {
282       DECL_ALIGN (decl) = TYPE_ALIGN (type);
283       if (TREE_CODE (decl) == FIELD_DECL)
284         DECL_USER_ALIGN (decl) = TYPE_USER_ALIGN (type);
285     }
286 }
287
288 /* Set the size, mode and alignment of a ..._DECL node.
289    TYPE_DECL does need this for C++.
290    Note that LABEL_DECL and CONST_DECL nodes do not need this,
291    and FUNCTION_DECL nodes have them set up in a special (and simple) way.
292    Don't call layout_decl for them.
293
294    KNOWN_ALIGN is the amount of alignment we can assume this
295    decl has with no special effort.  It is relevant only for FIELD_DECLs
296    and depends on the previous fields.
297    All that matters about KNOWN_ALIGN is which powers of 2 divide it.
298    If KNOWN_ALIGN is 0, it means, "as much alignment as you like":
299    the record will be aligned to suit.  */
300
301 void
302 layout_decl (tree decl, unsigned int known_align)
303 {
304   tree type = TREE_TYPE (decl);
305   enum tree_code code = TREE_CODE (decl);
306   rtx rtl = NULL_RTX;
307
308   if (code == CONST_DECL)
309     return;
310
311   gcc_assert (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL
312               || code == TYPE_DECL ||code == FIELD_DECL);
313
314   rtl = DECL_RTL_IF_SET (decl);
315
316   if (type == error_mark_node)
317     type = void_type_node;
318
319   /* Usually the size and mode come from the data type without change,
320      however, the front-end may set the explicit width of the field, so its
321      size may not be the same as the size of its type.  This happens with
322      bitfields, of course (an `int' bitfield may be only 2 bits, say), but it
323      also happens with other fields.  For example, the C++ front-end creates
324      zero-sized fields corresponding to empty base classes, and depends on
325      layout_type setting DECL_FIELD_BITPOS correctly for the field.  Set the
326      size in bytes from the size in bits.  If we have already set the mode,
327      don't set it again since we can be called twice for FIELD_DECLs.  */
328
329   DECL_UNSIGNED (decl) = TYPE_UNSIGNED (type);
330   if (DECL_MODE (decl) == VOIDmode)
331     DECL_MODE (decl) = TYPE_MODE (type);
332
333   if (DECL_SIZE (decl) == 0)
334     {
335       DECL_SIZE (decl) = TYPE_SIZE (type);
336       DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (type);
337     }
338   else if (DECL_SIZE_UNIT (decl) == 0)
339     DECL_SIZE_UNIT (decl)
340       = fold_convert (sizetype, size_binop (CEIL_DIV_EXPR, DECL_SIZE (decl),
341                                             bitsize_unit_node));
342
343   if (code != FIELD_DECL)
344     /* For non-fields, update the alignment from the type.  */
345     do_type_align (type, decl);
346   else
347     /* For fields, it's a bit more complicated...  */
348     {
349       bool old_user_align = DECL_USER_ALIGN (decl);
350       bool zero_bitfield = false;
351       bool packed_p = DECL_PACKED (decl);
352       unsigned int mfa;
353
354       if (DECL_BIT_FIELD (decl))
355         {
356           DECL_BIT_FIELD_TYPE (decl) = type;
357
358           /* A zero-length bit-field affects the alignment of the next
359              field.  In essence such bit-fields are not influenced by
360              any packing due to #pragma pack or attribute packed.  */
361           if (integer_zerop (DECL_SIZE (decl))
362               && ! targetm.ms_bitfield_layout_p (DECL_FIELD_CONTEXT (decl)))
363             {
364               zero_bitfield = true;
365               packed_p = false;
366 #ifdef PCC_BITFIELD_TYPE_MATTERS
367               if (PCC_BITFIELD_TYPE_MATTERS)
368                 do_type_align (type, decl);
369               else
370 #endif
371                 {
372 #ifdef EMPTY_FIELD_BOUNDARY
373                   if (EMPTY_FIELD_BOUNDARY > DECL_ALIGN (decl))
374                     {
375                       DECL_ALIGN (decl) = EMPTY_FIELD_BOUNDARY;
376                       DECL_USER_ALIGN (decl) = 0;
377                     }
378 #endif
379                 }
380             }
381
382           /* See if we can use an ordinary integer mode for a bit-field.
383              Conditions are: a fixed size that is correct for another mode
384              and occupying a complete byte or bytes on proper boundary.  */
385           if (TYPE_SIZE (type) != 0
386               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
387               && GET_MODE_CLASS (TYPE_MODE (type)) == MODE_INT)
388             {
389               enum machine_mode xmode
390                 = mode_for_size_tree (DECL_SIZE (decl), MODE_INT, 1);
391               unsigned int xalign = GET_MODE_ALIGNMENT (xmode);
392
393               if (xmode != BLKmode
394                   && !(xalign > BITS_PER_UNIT && DECL_PACKED (decl))
395                   && (known_align == 0 || known_align >= xalign))
396                 {
397                   DECL_ALIGN (decl) = MAX (xalign, DECL_ALIGN (decl));
398                   DECL_MODE (decl) = xmode;
399                   DECL_BIT_FIELD (decl) = 0;
400                 }
401             }
402
403           /* Turn off DECL_BIT_FIELD if we won't need it set.  */
404           if (TYPE_MODE (type) == BLKmode && DECL_MODE (decl) == BLKmode
405               && known_align >= TYPE_ALIGN (type)
406               && DECL_ALIGN (decl) >= TYPE_ALIGN (type))
407             DECL_BIT_FIELD (decl) = 0;
408         }
409       else if (packed_p && DECL_USER_ALIGN (decl))
410         /* Don't touch DECL_ALIGN.  For other packed fields, go ahead and
411            round up; we'll reduce it again below.  We want packing to
412            supersede USER_ALIGN inherited from the type, but defer to
413            alignment explicitly specified on the field decl.  */;
414       else
415         do_type_align (type, decl);
416
417       /* If the field is packed and not explicitly aligned, give it the
418          minimum alignment.  Note that do_type_align may set
419          DECL_USER_ALIGN, so we need to check old_user_align instead.  */
420       if (packed_p
421           && !old_user_align)
422         DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), BITS_PER_UNIT);
423
424       if (! packed_p && ! DECL_USER_ALIGN (decl))
425         {
426           /* Some targets (i.e. i386, VMS) limit struct field alignment
427              to a lower boundary than alignment of variables unless
428              it was overridden by attribute aligned.  */
429 #ifdef BIGGEST_FIELD_ALIGNMENT
430           DECL_ALIGN (decl)
431             = MIN (DECL_ALIGN (decl), (unsigned) BIGGEST_FIELD_ALIGNMENT);
432 #endif
433 #ifdef ADJUST_FIELD_ALIGN
434           DECL_ALIGN (decl) = ADJUST_FIELD_ALIGN (decl, DECL_ALIGN (decl));
435 #endif
436         }
437
438       if (zero_bitfield)
439         mfa = initial_max_fld_align * BITS_PER_UNIT;
440       else
441         mfa = maximum_field_alignment;
442       /* Should this be controlled by DECL_USER_ALIGN, too?  */
443       if (mfa != 0)
444         DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), mfa);
445     }
446
447   /* Evaluate nonconstant size only once, either now or as soon as safe.  */
448   if (DECL_SIZE (decl) != 0 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
449     DECL_SIZE (decl) = variable_size (DECL_SIZE (decl));
450   if (DECL_SIZE_UNIT (decl) != 0
451       && TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST)
452     DECL_SIZE_UNIT (decl) = variable_size (DECL_SIZE_UNIT (decl));
453
454   /* If requested, warn about definitions of large data objects.  */
455   if (warn_larger_than
456       && (code == VAR_DECL || code == PARM_DECL)
457       && ! DECL_EXTERNAL (decl))
458     {
459       tree size = DECL_SIZE_UNIT (decl);
460
461       if (size != 0 && TREE_CODE (size) == INTEGER_CST
462           && compare_tree_int (size, larger_than_size) > 0)
463         {
464           int size_as_int = TREE_INT_CST_LOW (size);
465
466           if (compare_tree_int (size, size_as_int) == 0)
467             warning (OPT_Wlarger_than_eq, "size of %q+D is %d bytes", decl, size_as_int);
468           else
469             warning (OPT_Wlarger_than_eq, "size of %q+D is larger than %wd bytes",
470                      decl, larger_than_size);
471         }
472     }
473
474   /* If the RTL was already set, update its mode and mem attributes.  */
475   if (rtl)
476     {
477       PUT_MODE (rtl, DECL_MODE (decl));
478       SET_DECL_RTL (decl, 0);
479       set_mem_attributes (rtl, decl, 1);
480       SET_DECL_RTL (decl, rtl);
481     }
482 }
483
484 /* Given a VAR_DECL, PARM_DECL or RESULT_DECL, clears the results of
485    a previous call to layout_decl and calls it again.  */
486
487 void
488 relayout_decl (tree decl)
489 {
490   DECL_SIZE (decl) = DECL_SIZE_UNIT (decl) = 0;
491   DECL_MODE (decl) = VOIDmode;
492   if (!DECL_USER_ALIGN (decl))
493     DECL_ALIGN (decl) = 0;
494   SET_DECL_RTL (decl, 0);
495
496   layout_decl (decl, 0);
497 }
498 \f
499 /* Begin laying out type T, which may be a RECORD_TYPE, UNION_TYPE, or
500    QUAL_UNION_TYPE.  Return a pointer to a struct record_layout_info which
501    is to be passed to all other layout functions for this record.  It is the
502    responsibility of the caller to call `free' for the storage returned.
503    Note that garbage collection is not permitted until we finish laying
504    out the record.  */
505
506 record_layout_info
507 start_record_layout (tree t)
508 {
509   record_layout_info rli = xmalloc (sizeof (struct record_layout_info_s));
510
511   rli->t = t;
512
513   /* If the type has a minimum specified alignment (via an attribute
514      declaration, for example) use it -- otherwise, start with a
515      one-byte alignment.  */
516   rli->record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (t));
517   rli->unpacked_align = rli->record_align;
518   rli->offset_align = MAX (rli->record_align, BIGGEST_ALIGNMENT);
519
520 #ifdef STRUCTURE_SIZE_BOUNDARY
521   /* Packed structures don't need to have minimum size.  */
522   if (! TYPE_PACKED (t))
523     {
524       unsigned tmp;
525
526       /* #pragma pack overrides STRUCTURE_SIZE_BOUNDARY.  */
527       tmp = (unsigned) STRUCTURE_SIZE_BOUNDARY;
528       if (maximum_field_alignment != 0)
529         tmp = MIN (tmp, maximum_field_alignment);
530       rli->record_align = MAX (rli->record_align, tmp);
531     }
532 #endif
533
534   rli->offset = size_zero_node;
535   rli->bitpos = bitsize_zero_node;
536   rli->prev_field = 0;
537   rli->pending_statics = 0;
538   rli->packed_maybe_necessary = 0;
539   rli->remaining_in_alignment = 0;
540
541   return rli;
542 }
543
544 /* These four routines perform computations that convert between
545    the offset/bitpos forms and byte and bit offsets.  */
546
547 tree
548 bit_from_pos (tree offset, tree bitpos)
549 {
550   return size_binop (PLUS_EXPR, bitpos,
551                      size_binop (MULT_EXPR,
552                                  fold_convert (bitsizetype, offset),
553                                  bitsize_unit_node));
554 }
555
556 tree
557 byte_from_pos (tree offset, tree bitpos)
558 {
559   return size_binop (PLUS_EXPR, offset,
560                      fold_convert (sizetype,
561                                    size_binop (TRUNC_DIV_EXPR, bitpos,
562                                                bitsize_unit_node)));
563 }
564
565 void
566 pos_from_bit (tree *poffset, tree *pbitpos, unsigned int off_align,
567               tree pos)
568 {
569   *poffset = size_binop (MULT_EXPR,
570                          fold_convert (sizetype,
571                                        size_binop (FLOOR_DIV_EXPR, pos,
572                                                    bitsize_int (off_align))),
573                          size_int (off_align / BITS_PER_UNIT));
574   *pbitpos = size_binop (FLOOR_MOD_EXPR, pos, bitsize_int (off_align));
575 }
576
577 /* Given a pointer to bit and byte offsets and an offset alignment,
578    normalize the offsets so they are within the alignment.  */
579
580 void
581 normalize_offset (tree *poffset, tree *pbitpos, unsigned int off_align)
582 {
583   /* If the bit position is now larger than it should be, adjust it
584      downwards.  */
585   if (compare_tree_int (*pbitpos, off_align) >= 0)
586     {
587       tree extra_aligns = size_binop (FLOOR_DIV_EXPR, *pbitpos,
588                                       bitsize_int (off_align));
589
590       *poffset
591         = size_binop (PLUS_EXPR, *poffset,
592                       size_binop (MULT_EXPR,
593                                   fold_convert (sizetype, extra_aligns),
594                                   size_int (off_align / BITS_PER_UNIT)));
595
596       *pbitpos
597         = size_binop (FLOOR_MOD_EXPR, *pbitpos, bitsize_int (off_align));
598     }
599 }
600
601 /* Print debugging information about the information in RLI.  */
602
603 void
604 debug_rli (record_layout_info rli)
605 {
606   print_node_brief (stderr, "type", rli->t, 0);
607   print_node_brief (stderr, "\noffset", rli->offset, 0);
608   print_node_brief (stderr, " bitpos", rli->bitpos, 0);
609
610   fprintf (stderr, "\naligns: rec = %u, unpack = %u, off = %u\n",
611            rli->record_align, rli->unpacked_align,
612            rli->offset_align);
613
614   /* The ms_struct code is the only that uses this.  */
615   if (targetm.ms_bitfield_layout_p (rli->t))
616     fprintf (stderr, "remaining in alignment = %u\n", rli->remaining_in_alignment);
617
618   if (rli->packed_maybe_necessary)
619     fprintf (stderr, "packed may be necessary\n");
620
621   if (rli->pending_statics)
622     {
623       fprintf (stderr, "pending statics:\n");
624       debug_tree (rli->pending_statics);
625     }
626 }
627
628 /* Given an RLI with a possibly-incremented BITPOS, adjust OFFSET and
629    BITPOS if necessary to keep BITPOS below OFFSET_ALIGN.  */
630
631 void
632 normalize_rli (record_layout_info rli)
633 {
634   normalize_offset (&rli->offset, &rli->bitpos, rli->offset_align);
635 }
636
637 /* Returns the size in bytes allocated so far.  */
638
639 tree
640 rli_size_unit_so_far (record_layout_info rli)
641 {
642   return byte_from_pos (rli->offset, rli->bitpos);
643 }
644
645 /* Returns the size in bits allocated so far.  */
646
647 tree
648 rli_size_so_far (record_layout_info rli)
649 {
650   return bit_from_pos (rli->offset, rli->bitpos);
651 }
652
653 /* FIELD is about to be added to RLI->T.  The alignment (in bits) of
654    the next available location within the record is given by KNOWN_ALIGN.
655    Update the variable alignment fields in RLI, and return the alignment
656    to give the FIELD.  */
657
658 unsigned int
659 update_alignment_for_field (record_layout_info rli, tree field,
660                             unsigned int known_align)
661 {
662   /* The alignment required for FIELD.  */
663   unsigned int desired_align;
664   /* The type of this field.  */
665   tree type = TREE_TYPE (field);
666   /* True if the field was explicitly aligned by the user.  */
667   bool user_align;
668   bool is_bitfield;
669
670   /* Do not attempt to align an ERROR_MARK node */
671   if (TREE_CODE (type) == ERROR_MARK)
672     return 0;
673
674   /* Lay out the field so we know what alignment it needs.  */
675   layout_decl (field, known_align);
676   desired_align = DECL_ALIGN (field);
677   user_align = DECL_USER_ALIGN (field);
678
679   is_bitfield = (type != error_mark_node
680                  && DECL_BIT_FIELD_TYPE (field)
681                  && ! integer_zerop (TYPE_SIZE (type)));
682
683   /* Record must have at least as much alignment as any field.
684      Otherwise, the alignment of the field within the record is
685      meaningless.  */
686   if (targetm.ms_bitfield_layout_p (rli->t))
687     {
688       /* Here, the alignment of the underlying type of a bitfield can
689          affect the alignment of a record; even a zero-sized field
690          can do this.  The alignment should be to the alignment of
691          the type, except that for zero-size bitfields this only
692          applies if there was an immediately prior, nonzero-size
693          bitfield.  (That's the way it is, experimentally.) */
694       if ((!is_bitfield && !DECL_PACKED (field))
695           || (!integer_zerop (DECL_SIZE (field))
696               ? !DECL_PACKED (field)
697               : (rli->prev_field
698                  && DECL_BIT_FIELD_TYPE (rli->prev_field)
699                  && ! integer_zerop (DECL_SIZE (rli->prev_field)))))
700         {
701           unsigned int type_align = TYPE_ALIGN (type);
702           type_align = MAX (type_align, desired_align);
703           if (maximum_field_alignment != 0)
704             type_align = MIN (type_align, maximum_field_alignment);
705           rli->record_align = MAX (rli->record_align, type_align);
706           rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type));
707         }
708     }
709 #ifdef PCC_BITFIELD_TYPE_MATTERS
710   else if (is_bitfield && PCC_BITFIELD_TYPE_MATTERS)
711     {
712       /* Named bit-fields cause the entire structure to have the
713          alignment implied by their type.  Some targets also apply the same
714          rules to unnamed bitfields.  */
715       if (DECL_NAME (field) != 0
716           || targetm.align_anon_bitfield ())
717         {
718           unsigned int type_align = TYPE_ALIGN (type);
719
720 #ifdef ADJUST_FIELD_ALIGN
721           if (! TYPE_USER_ALIGN (type))
722             type_align = ADJUST_FIELD_ALIGN (field, type_align);
723 #endif
724
725           /* Targets might chose to handle unnamed and hence possibly
726              zero-width bitfield.  Those are not influenced by #pragmas
727              or packed attributes.  */
728           if (integer_zerop (DECL_SIZE (field)))
729             {
730               if (initial_max_fld_align)
731                 type_align = MIN (type_align,
732                                   initial_max_fld_align * BITS_PER_UNIT);
733             }
734           else if (maximum_field_alignment != 0)
735             type_align = MIN (type_align, maximum_field_alignment);
736           else if (DECL_PACKED (field))
737             type_align = MIN (type_align, BITS_PER_UNIT);
738
739           /* The alignment of the record is increased to the maximum
740              of the current alignment, the alignment indicated on the
741              field (i.e., the alignment specified by an __aligned__
742              attribute), and the alignment indicated by the type of
743              the field.  */
744           rli->record_align = MAX (rli->record_align, desired_align);
745           rli->record_align = MAX (rli->record_align, type_align);
746
747           if (warn_packed)
748             rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type));
749           user_align |= TYPE_USER_ALIGN (type);
750         }
751     }
752 #endif
753   else
754     {
755       rli->record_align = MAX (rli->record_align, desired_align);
756       rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type));
757     }
758
759   TYPE_USER_ALIGN (rli->t) |= user_align;
760
761   return desired_align;
762 }
763
764 /* Called from place_field to handle unions.  */
765
766 static void
767 place_union_field (record_layout_info rli, tree field)
768 {
769   update_alignment_for_field (rli, field, /*known_align=*/0);
770
771   DECL_FIELD_OFFSET (field) = size_zero_node;
772   DECL_FIELD_BIT_OFFSET (field) = bitsize_zero_node;
773   SET_DECL_OFFSET_ALIGN (field, BIGGEST_ALIGNMENT);
774
775   /* If this is an ERROR_MARK return *after* having set the
776      field at the start of the union. This helps when parsing
777      invalid fields. */
778   if (TREE_CODE (TREE_TYPE (field)) == ERROR_MARK)
779     return;
780
781   /* We assume the union's size will be a multiple of a byte so we don't
782      bother with BITPOS.  */
783   if (TREE_CODE (rli->t) == UNION_TYPE)
784     rli->offset = size_binop (MAX_EXPR, rli->offset, DECL_SIZE_UNIT (field));
785   else if (TREE_CODE (rli->t) == QUAL_UNION_TYPE)
786     rli->offset = fold_build3 (COND_EXPR, sizetype,
787                                DECL_QUALIFIER (field),
788                                DECL_SIZE_UNIT (field), rli->offset);
789 }
790
791 #if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED)
792 /* A bitfield of SIZE with a required access alignment of ALIGN is allocated
793    at BYTE_OFFSET / BIT_OFFSET.  Return nonzero if the field would span more
794    units of alignment than the underlying TYPE.  */
795 static int
796 excess_unit_span (HOST_WIDE_INT byte_offset, HOST_WIDE_INT bit_offset,
797                   HOST_WIDE_INT size, HOST_WIDE_INT align, tree type)
798 {
799   /* Note that the calculation of OFFSET might overflow; we calculate it so
800      that we still get the right result as long as ALIGN is a power of two.  */
801   unsigned HOST_WIDE_INT offset = byte_offset * BITS_PER_UNIT + bit_offset;
802
803   offset = offset % align;
804   return ((offset + size + align - 1) / align
805           > ((unsigned HOST_WIDE_INT) tree_low_cst (TYPE_SIZE (type), 1)
806              / align));
807 }
808 #endif
809
810 /* RLI contains information about the layout of a RECORD_TYPE.  FIELD
811    is a FIELD_DECL to be added after those fields already present in
812    T.  (FIELD is not actually added to the TYPE_FIELDS list here;
813    callers that desire that behavior must manually perform that step.)  */
814
815 void
816 place_field (record_layout_info rli, tree field)
817 {
818   /* The alignment required for FIELD.  */
819   unsigned int desired_align;
820   /* The alignment FIELD would have if we just dropped it into the
821      record as it presently stands.  */
822   unsigned int known_align;
823   unsigned int actual_align;
824   /* The type of this field.  */
825   tree type = TREE_TYPE (field);
826
827   gcc_assert (TREE_CODE (field) != ERROR_MARK);
828
829   /* If FIELD is static, then treat it like a separate variable, not
830      really like a structure field.  If it is a FUNCTION_DECL, it's a
831      method.  In both cases, all we do is lay out the decl, and we do
832      it *after* the record is laid out.  */
833   if (TREE_CODE (field) == VAR_DECL)
834     {
835       rli->pending_statics = tree_cons (NULL_TREE, field,
836                                         rli->pending_statics);
837       return;
838     }
839
840   /* Enumerators and enum types which are local to this class need not
841      be laid out.  Likewise for initialized constant fields.  */
842   else if (TREE_CODE (field) != FIELD_DECL)
843     return;
844
845   /* Unions are laid out very differently than records, so split
846      that code off to another function.  */
847   else if (TREE_CODE (rli->t) != RECORD_TYPE)
848     {
849       place_union_field (rli, field);
850       return;
851     }
852
853   else if (TREE_CODE (type) == ERROR_MARK)
854     {
855       /* Place this field at the current allocation position, so we
856          maintain monotonicity.  */
857       DECL_FIELD_OFFSET (field) = rli->offset;
858       DECL_FIELD_BIT_OFFSET (field) = rli->bitpos;
859       SET_DECL_OFFSET_ALIGN (field, rli->offset_align);
860       return;
861     }
862
863   /* Work out the known alignment so far.  Note that A & (-A) is the
864      value of the least-significant bit in A that is one.  */
865   if (! integer_zerop (rli->bitpos))
866     known_align = (tree_low_cst (rli->bitpos, 1)
867                    & - tree_low_cst (rli->bitpos, 1));
868   else if (integer_zerop (rli->offset))
869     known_align = 0;
870   else if (host_integerp (rli->offset, 1))
871     known_align = (BITS_PER_UNIT
872                    * (tree_low_cst (rli->offset, 1)
873                       & - tree_low_cst (rli->offset, 1)));
874   else
875     known_align = rli->offset_align;
876
877   desired_align = update_alignment_for_field (rli, field, known_align);
878   if (known_align == 0)
879     known_align = MAX (BIGGEST_ALIGNMENT, rli->record_align);
880
881   if (warn_packed && DECL_PACKED (field))
882     {
883       if (known_align >= TYPE_ALIGN (type))
884         {
885           if (TYPE_ALIGN (type) > desired_align)
886             {
887               if (STRICT_ALIGNMENT)
888                 warning (OPT_Wattributes, "packed attribute causes "
889                          "inefficient alignment for %q+D", field);
890               else
891                 warning (OPT_Wattributes, "packed attribute is "
892                          "unnecessary for %q+D", field);
893             }
894         }
895       else
896         rli->packed_maybe_necessary = 1;
897     }
898
899   /* Does this field automatically have alignment it needs by virtue
900      of the fields that precede it and the record's own alignment?
901      We already align ms_struct fields, so don't re-align them.  */
902   if (known_align < desired_align
903       && !targetm.ms_bitfield_layout_p (rli->t))
904     {
905       /* No, we need to skip space before this field.
906          Bump the cumulative size to multiple of field alignment.  */
907
908       warning (OPT_Wpadded, "padding struct to align %q+D", field);
909
910       /* If the alignment is still within offset_align, just align
911          the bit position.  */
912       if (desired_align < rli->offset_align)
913         rli->bitpos = round_up (rli->bitpos, desired_align);
914       else
915         {
916           /* First adjust OFFSET by the partial bits, then align.  */
917           rli->offset
918             = size_binop (PLUS_EXPR, rli->offset,
919                           fold_convert (sizetype,
920                                         size_binop (CEIL_DIV_EXPR, rli->bitpos,
921                                                     bitsize_unit_node)));
922           rli->bitpos = bitsize_zero_node;
923
924           rli->offset = round_up (rli->offset, desired_align / BITS_PER_UNIT);
925         }
926
927       if (! TREE_CONSTANT (rli->offset))
928         rli->offset_align = desired_align;
929
930     }
931
932   /* Handle compatibility with PCC.  Note that if the record has any
933      variable-sized fields, we need not worry about compatibility.  */
934 #ifdef PCC_BITFIELD_TYPE_MATTERS
935   if (PCC_BITFIELD_TYPE_MATTERS
936       && ! targetm.ms_bitfield_layout_p (rli->t)
937       && TREE_CODE (field) == FIELD_DECL
938       && type != error_mark_node
939       && DECL_BIT_FIELD (field)
940       && ! DECL_PACKED (field)
941       && maximum_field_alignment == 0
942       && ! integer_zerop (DECL_SIZE (field))
943       && host_integerp (DECL_SIZE (field), 1)
944       && host_integerp (rli->offset, 1)
945       && host_integerp (TYPE_SIZE (type), 1))
946     {
947       unsigned int type_align = TYPE_ALIGN (type);
948       tree dsize = DECL_SIZE (field);
949       HOST_WIDE_INT field_size = tree_low_cst (dsize, 1);
950       HOST_WIDE_INT offset = tree_low_cst (rli->offset, 0);
951       HOST_WIDE_INT bit_offset = tree_low_cst (rli->bitpos, 0);
952
953 #ifdef ADJUST_FIELD_ALIGN
954       if (! TYPE_USER_ALIGN (type))
955         type_align = ADJUST_FIELD_ALIGN (field, type_align);
956 #endif
957
958       /* A bit field may not span more units of alignment of its type
959          than its type itself.  Advance to next boundary if necessary.  */
960       if (excess_unit_span (offset, bit_offset, field_size, type_align, type))
961         rli->bitpos = round_up (rli->bitpos, type_align);
962
963       TYPE_USER_ALIGN (rli->t) |= TYPE_USER_ALIGN (type);
964     }
965 #endif
966
967 #ifdef BITFIELD_NBYTES_LIMITED
968   if (BITFIELD_NBYTES_LIMITED
969       && ! targetm.ms_bitfield_layout_p (rli->t)
970       && TREE_CODE (field) == FIELD_DECL
971       && type != error_mark_node
972       && DECL_BIT_FIELD_TYPE (field)
973       && ! DECL_PACKED (field)
974       && ! integer_zerop (DECL_SIZE (field))
975       && host_integerp (DECL_SIZE (field), 1)
976       && host_integerp (rli->offset, 1)
977       && host_integerp (TYPE_SIZE (type), 1))
978     {
979       unsigned int type_align = TYPE_ALIGN (type);
980       tree dsize = DECL_SIZE (field);
981       HOST_WIDE_INT field_size = tree_low_cst (dsize, 1);
982       HOST_WIDE_INT offset = tree_low_cst (rli->offset, 0);
983       HOST_WIDE_INT bit_offset = tree_low_cst (rli->bitpos, 0);
984
985 #ifdef ADJUST_FIELD_ALIGN
986       if (! TYPE_USER_ALIGN (type))
987         type_align = ADJUST_FIELD_ALIGN (field, type_align);
988 #endif
989
990       if (maximum_field_alignment != 0)
991         type_align = MIN (type_align, maximum_field_alignment);
992       /* ??? This test is opposite the test in the containing if
993          statement, so this code is unreachable currently.  */
994       else if (DECL_PACKED (field))
995         type_align = MIN (type_align, BITS_PER_UNIT);
996
997       /* A bit field may not span the unit of alignment of its type.
998          Advance to next boundary if necessary.  */
999       if (excess_unit_span (offset, bit_offset, field_size, type_align, type))
1000         rli->bitpos = round_up (rli->bitpos, type_align);
1001
1002       TYPE_USER_ALIGN (rli->t) |= TYPE_USER_ALIGN (type);
1003     }
1004 #endif
1005
1006   /* See the docs for TARGET_MS_BITFIELD_LAYOUT_P for details.
1007      A subtlety:
1008         When a bit field is inserted into a packed record, the whole
1009         size of the underlying type is used by one or more same-size
1010         adjacent bitfields.  (That is, if its long:3, 32 bits is
1011         used in the record, and any additional adjacent long bitfields are
1012         packed into the same chunk of 32 bits. However, if the size
1013         changes, a new field of that size is allocated.)  In an unpacked
1014         record, this is the same as using alignment, but not equivalent
1015         when packing.
1016
1017      Note: for compatibility, we use the type size, not the type alignment
1018      to determine alignment, since that matches the documentation */
1019
1020   if (targetm.ms_bitfield_layout_p (rli->t))
1021     {
1022       tree prev_saved = rli->prev_field;
1023       tree prev_type = prev_saved ? DECL_BIT_FIELD_TYPE (prev_saved) : NULL;
1024
1025       /* This is a bitfield if it exists.  */
1026       if (rli->prev_field)
1027         {
1028           /* If both are bitfields, nonzero, and the same size, this is
1029              the middle of a run.  Zero declared size fields are special
1030              and handled as "end of run". (Note: it's nonzero declared
1031              size, but equal type sizes!) (Since we know that both
1032              the current and previous fields are bitfields by the
1033              time we check it, DECL_SIZE must be present for both.) */
1034           if (DECL_BIT_FIELD_TYPE (field)
1035               && !integer_zerop (DECL_SIZE (field))
1036               && !integer_zerop (DECL_SIZE (rli->prev_field))
1037               && host_integerp (DECL_SIZE (rli->prev_field), 0)
1038               && host_integerp (TYPE_SIZE (type), 0)
1039               && simple_cst_equal (TYPE_SIZE (type), TYPE_SIZE (prev_type)))
1040             {
1041               /* We're in the middle of a run of equal type size fields; make
1042                  sure we realign if we run out of bits.  (Not decl size,
1043                  type size!) */
1044               HOST_WIDE_INT bitsize = tree_low_cst (DECL_SIZE (field), 1);
1045
1046               if (rli->remaining_in_alignment < bitsize)
1047                 {
1048                   HOST_WIDE_INT typesize = tree_low_cst (TYPE_SIZE (type), 1);
1049
1050                   /* out of bits; bump up to next 'word'.  */
1051                   rli->bitpos
1052                     = size_binop (PLUS_EXPR, rli->bitpos,
1053                                   bitsize_int (rli->remaining_in_alignment));
1054                   rli->prev_field = field;
1055                   if (typesize < bitsize)
1056                     rli->remaining_in_alignment = 0;
1057                   else
1058                     rli->remaining_in_alignment = typesize - bitsize;
1059                 }
1060               else
1061                 rli->remaining_in_alignment -= bitsize;
1062             }
1063           else
1064             {
1065               /* End of a run: if leaving a run of bitfields of the same type
1066                  size, we have to "use up" the rest of the bits of the type
1067                  size.
1068
1069                  Compute the new position as the sum of the size for the prior
1070                  type and where we first started working on that type.
1071                  Note: since the beginning of the field was aligned then
1072                  of course the end will be too.  No round needed.  */
1073
1074               if (!integer_zerop (DECL_SIZE (rli->prev_field)))
1075                 {
1076                   rli->bitpos
1077                     = size_binop (PLUS_EXPR, rli->bitpos,
1078                                   bitsize_int (rli->remaining_in_alignment));
1079                 }
1080               else
1081                 /* We "use up" size zero fields; the code below should behave
1082                    as if the prior field was not a bitfield.  */
1083                 prev_saved = NULL;
1084
1085               /* Cause a new bitfield to be captured, either this time (if
1086                  currently a bitfield) or next time we see one.  */
1087               if (!DECL_BIT_FIELD_TYPE(field)
1088                   || integer_zerop (DECL_SIZE (field)))
1089                 rli->prev_field = NULL;
1090             }
1091
1092           normalize_rli (rli);
1093         }
1094
1095       /* If we're starting a new run of same size type bitfields
1096          (or a run of non-bitfields), set up the "first of the run"
1097          fields.
1098
1099          That is, if the current field is not a bitfield, or if there
1100          was a prior bitfield the type sizes differ, or if there wasn't
1101          a prior bitfield the size of the current field is nonzero.
1102
1103          Note: we must be sure to test ONLY the type size if there was
1104          a prior bitfield and ONLY for the current field being zero if
1105          there wasn't.  */
1106
1107       if (!DECL_BIT_FIELD_TYPE (field)
1108           || (prev_saved != NULL
1109               ? !simple_cst_equal (TYPE_SIZE (type), TYPE_SIZE (prev_type))
1110               : !integer_zerop (DECL_SIZE (field)) ))
1111         {
1112           /* Never smaller than a byte for compatibility.  */
1113           unsigned int type_align = BITS_PER_UNIT;
1114
1115           /* (When not a bitfield), we could be seeing a flex array (with
1116              no DECL_SIZE).  Since we won't be using remaining_in_alignment
1117              until we see a bitfield (and come by here again) we just skip
1118              calculating it.  */
1119           if (DECL_SIZE (field) != NULL
1120               && host_integerp (TYPE_SIZE (TREE_TYPE (field)), 0)
1121               && host_integerp (DECL_SIZE (field), 0))
1122             {
1123               HOST_WIDE_INT bitsize = tree_low_cst (DECL_SIZE (field), 1);
1124               HOST_WIDE_INT typesize
1125                 = tree_low_cst (TYPE_SIZE (TREE_TYPE (field)), 1);
1126
1127               if (typesize < bitsize)
1128                 rli->remaining_in_alignment = 0;
1129               else
1130                 rli->remaining_in_alignment = typesize - bitsize;
1131             }
1132
1133           /* Now align (conventionally) for the new type.  */
1134           type_align = TYPE_ALIGN (TREE_TYPE (field));
1135
1136           if (maximum_field_alignment != 0)
1137             type_align = MIN (type_align, maximum_field_alignment);
1138
1139           rli->bitpos = round_up (rli->bitpos, type_align);
1140
1141           /* If we really aligned, don't allow subsequent bitfields
1142              to undo that.  */
1143           rli->prev_field = NULL;
1144         }
1145     }
1146
1147   /* Offset so far becomes the position of this field after normalizing.  */
1148   normalize_rli (rli);
1149   DECL_FIELD_OFFSET (field) = rli->offset;
1150   DECL_FIELD_BIT_OFFSET (field) = rli->bitpos;
1151   SET_DECL_OFFSET_ALIGN (field, rli->offset_align);
1152
1153   /* If this field ended up more aligned than we thought it would be (we
1154      approximate this by seeing if its position changed), lay out the field
1155      again; perhaps we can use an integral mode for it now.  */
1156   if (! integer_zerop (DECL_FIELD_BIT_OFFSET (field)))
1157     actual_align = (tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1158                     & - tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1));
1159   else if (integer_zerop (DECL_FIELD_OFFSET (field)))
1160     actual_align = MAX (BIGGEST_ALIGNMENT, rli->record_align);
1161   else if (host_integerp (DECL_FIELD_OFFSET (field), 1))
1162     actual_align = (BITS_PER_UNIT
1163                    * (tree_low_cst (DECL_FIELD_OFFSET (field), 1)
1164                       & - tree_low_cst (DECL_FIELD_OFFSET (field), 1)));
1165   else
1166     actual_align = DECL_OFFSET_ALIGN (field);
1167   /* ACTUAL_ALIGN is still the actual alignment *within the record* .
1168      store / extract bit field operations will check the alignment of the
1169      record against the mode of bit fields.  */
1170
1171   if (known_align != actual_align)
1172     layout_decl (field, actual_align);
1173
1174   if (rli->prev_field == NULL && DECL_BIT_FIELD_TYPE (field))
1175     rli->prev_field = field;
1176
1177   /* Now add size of this field to the size of the record.  If the size is
1178      not constant, treat the field as being a multiple of bytes and just
1179      adjust the offset, resetting the bit position.  Otherwise, apportion the
1180      size amongst the bit position and offset.  First handle the case of an
1181      unspecified size, which can happen when we have an invalid nested struct
1182      definition, such as struct j { struct j { int i; } }.  The error message
1183      is printed in finish_struct.  */
1184   if (DECL_SIZE (field) == 0)
1185     /* Do nothing.  */;
1186   else if (TREE_CODE (DECL_SIZE (field)) != INTEGER_CST
1187            || TREE_OVERFLOW (DECL_SIZE (field)))
1188     {
1189       rli->offset
1190         = size_binop (PLUS_EXPR, rli->offset,
1191                       fold_convert (sizetype,
1192                                     size_binop (CEIL_DIV_EXPR, rli->bitpos,
1193                                                 bitsize_unit_node)));
1194       rli->offset
1195         = size_binop (PLUS_EXPR, rli->offset, DECL_SIZE_UNIT (field));
1196       rli->bitpos = bitsize_zero_node;
1197       rli->offset_align = MIN (rli->offset_align, desired_align);
1198     }
1199   else if (targetm.ms_bitfield_layout_p (rli->t))
1200     {
1201       rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, DECL_SIZE (field));
1202
1203       /* If we ended a bitfield before the full length of the type then
1204          pad the struct out to the full length of the last type.  */
1205       if ((TREE_CHAIN (field) == NULL
1206            || TREE_CODE (TREE_CHAIN (field)) != FIELD_DECL)
1207           && DECL_BIT_FIELD_TYPE (field)
1208           && !integer_zerop (DECL_SIZE (field)))
1209         rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos,
1210                                   bitsize_int (rli->remaining_in_alignment));
1211
1212       normalize_rli (rli);
1213     }
1214   else
1215     {
1216       rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, DECL_SIZE (field));
1217       normalize_rli (rli);
1218     }
1219 }
1220
1221 /* Assuming that all the fields have been laid out, this function uses
1222    RLI to compute the final TYPE_SIZE, TYPE_ALIGN, etc. for the type
1223    indicated by RLI.  */
1224
1225 static void
1226 finalize_record_size (record_layout_info rli)
1227 {
1228   tree unpadded_size, unpadded_size_unit;
1229
1230   /* Now we want just byte and bit offsets, so set the offset alignment
1231      to be a byte and then normalize.  */
1232   rli->offset_align = BITS_PER_UNIT;
1233   normalize_rli (rli);
1234
1235   /* Determine the desired alignment.  */
1236 #ifdef ROUND_TYPE_ALIGN
1237   TYPE_ALIGN (rli->t) = ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t),
1238                                           rli->record_align);
1239 #else
1240   TYPE_ALIGN (rli->t) = MAX (TYPE_ALIGN (rli->t), rli->record_align);
1241 #endif
1242
1243   /* Compute the size so far.  Be sure to allow for extra bits in the
1244      size in bytes.  We have guaranteed above that it will be no more
1245      than a single byte.  */
1246   unpadded_size = rli_size_so_far (rli);
1247   unpadded_size_unit = rli_size_unit_so_far (rli);
1248   if (! integer_zerop (rli->bitpos))
1249     unpadded_size_unit
1250       = size_binop (PLUS_EXPR, unpadded_size_unit, size_one_node);
1251
1252   /* Round the size up to be a multiple of the required alignment.  */
1253   TYPE_SIZE (rli->t) = round_up (unpadded_size, TYPE_ALIGN (rli->t));
1254   TYPE_SIZE_UNIT (rli->t)
1255     = round_up (unpadded_size_unit, TYPE_ALIGN_UNIT (rli->t));
1256
1257   if (TREE_CONSTANT (unpadded_size)
1258       && simple_cst_equal (unpadded_size, TYPE_SIZE (rli->t)) == 0)
1259     warning (OPT_Wpadded, "padding struct size to alignment boundary");
1260
1261   if (warn_packed && TREE_CODE (rli->t) == RECORD_TYPE
1262       && TYPE_PACKED (rli->t) && ! rli->packed_maybe_necessary
1263       && TREE_CONSTANT (unpadded_size))
1264     {
1265       tree unpacked_size;
1266
1267 #ifdef ROUND_TYPE_ALIGN
1268       rli->unpacked_align
1269         = ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t), rli->unpacked_align);
1270 #else
1271       rli->unpacked_align = MAX (TYPE_ALIGN (rli->t), rli->unpacked_align);
1272 #endif
1273
1274       unpacked_size = round_up (TYPE_SIZE (rli->t), rli->unpacked_align);
1275       if (simple_cst_equal (unpacked_size, TYPE_SIZE (rli->t)))
1276         {
1277           TYPE_PACKED (rli->t) = 0;
1278
1279           if (TYPE_NAME (rli->t))
1280             {
1281               const char *name;
1282
1283               if (TREE_CODE (TYPE_NAME (rli->t)) == IDENTIFIER_NODE)
1284                 name = IDENTIFIER_POINTER (TYPE_NAME (rli->t));
1285               else
1286                 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (rli->t)));
1287
1288               if (STRICT_ALIGNMENT)
1289                 warning (OPT_Wpacked, "packed attribute causes inefficient "
1290                          "alignment for %qs", name);
1291               else
1292                 warning (OPT_Wpacked,
1293                          "packed attribute is unnecessary for %qs", name);
1294             }
1295           else
1296             {
1297               if (STRICT_ALIGNMENT)
1298                 warning (OPT_Wpacked,
1299                          "packed attribute causes inefficient alignment");
1300               else
1301                 warning (OPT_Wpacked, "packed attribute is unnecessary");
1302             }
1303         }
1304     }
1305 }
1306
1307 /* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE).  */
1308
1309 void
1310 compute_record_mode (tree type)
1311 {
1312   tree field;
1313   enum machine_mode mode = VOIDmode;
1314
1315   /* Most RECORD_TYPEs have BLKmode, so we start off assuming that.
1316      However, if possible, we use a mode that fits in a register
1317      instead, in order to allow for better optimization down the
1318      line.  */
1319   TYPE_MODE (type) = BLKmode;
1320
1321   if (! host_integerp (TYPE_SIZE (type), 1))
1322     return;
1323
1324   /* A record which has any BLKmode members must itself be
1325      BLKmode; it can't go in a register.  Unless the member is
1326      BLKmode only because it isn't aligned.  */
1327   for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1328     {
1329       if (TREE_CODE (field) != FIELD_DECL)
1330         continue;
1331
1332       if (TREE_CODE (TREE_TYPE (field)) == ERROR_MARK
1333           || (TYPE_MODE (TREE_TYPE (field)) == BLKmode
1334               && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field))
1335               && !(TYPE_SIZE (TREE_TYPE (field)) != 0
1336                    && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))))
1337           || ! host_integerp (bit_position (field), 1)
1338           || DECL_SIZE (field) == 0
1339           || ! host_integerp (DECL_SIZE (field), 1))
1340         return;
1341
1342       /* If this field is the whole struct, remember its mode so
1343          that, say, we can put a double in a class into a DF
1344          register instead of forcing it to live in the stack.  */
1345       if (simple_cst_equal (TYPE_SIZE (type), DECL_SIZE (field)))
1346         mode = DECL_MODE (field);
1347
1348 #ifdef MEMBER_TYPE_FORCES_BLK
1349       /* With some targets, eg. c4x, it is sub-optimal
1350          to access an aligned BLKmode structure as a scalar.  */
1351
1352       if (MEMBER_TYPE_FORCES_BLK (field, mode))
1353         return;
1354 #endif /* MEMBER_TYPE_FORCES_BLK  */
1355     }
1356
1357   /* If we only have one real field; use its mode if that mode's size
1358      matches the type's size.  This only applies to RECORD_TYPE.  This
1359      does not apply to unions.  */
1360   if (TREE_CODE (type) == RECORD_TYPE && mode != VOIDmode
1361       && host_integerp (TYPE_SIZE (type), 1)
1362       && GET_MODE_BITSIZE (mode) == TREE_INT_CST_LOW (TYPE_SIZE (type)))
1363     TYPE_MODE (type) = mode;
1364   else
1365     TYPE_MODE (type) = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1);
1366
1367   /* If structure's known alignment is less than what the scalar
1368      mode would need, and it matters, then stick with BLKmode.  */
1369   if (TYPE_MODE (type) != BLKmode
1370       && STRICT_ALIGNMENT
1371       && ! (TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT
1372             || TYPE_ALIGN (type) >= GET_MODE_ALIGNMENT (TYPE_MODE (type))))
1373     {
1374       /* If this is the only reason this type is BLKmode, then
1375          don't force containing types to be BLKmode.  */
1376       TYPE_NO_FORCE_BLK (type) = 1;
1377       TYPE_MODE (type) = BLKmode;
1378     }
1379 }
1380
1381 /* Compute TYPE_SIZE and TYPE_ALIGN for TYPE, once it has been laid
1382    out.  */
1383
1384 static void
1385 finalize_type_size (tree type)
1386 {
1387   /* Normally, use the alignment corresponding to the mode chosen.
1388      However, where strict alignment is not required, avoid
1389      over-aligning structures, since most compilers do not do this
1390      alignment.  */
1391
1392   if (TYPE_MODE (type) != BLKmode && TYPE_MODE (type) != VOIDmode
1393       && (STRICT_ALIGNMENT
1394           || (TREE_CODE (type) != RECORD_TYPE && TREE_CODE (type) != UNION_TYPE
1395               && TREE_CODE (type) != QUAL_UNION_TYPE
1396               && TREE_CODE (type) != ARRAY_TYPE)))
1397     {
1398       unsigned mode_align = GET_MODE_ALIGNMENT (TYPE_MODE (type));
1399
1400       /* Don't override a larger alignment requirement coming from a user
1401          alignment of one of the fields.  */
1402       if (mode_align >= TYPE_ALIGN (type))
1403         {
1404           TYPE_ALIGN (type) = mode_align;
1405           TYPE_USER_ALIGN (type) = 0;
1406         }
1407     }
1408
1409   /* Do machine-dependent extra alignment.  */
1410 #ifdef ROUND_TYPE_ALIGN
1411   TYPE_ALIGN (type)
1412     = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (type), BITS_PER_UNIT);
1413 #endif
1414
1415   /* If we failed to find a simple way to calculate the unit size
1416      of the type, find it by division.  */
1417   if (TYPE_SIZE_UNIT (type) == 0 && TYPE_SIZE (type) != 0)
1418     /* TYPE_SIZE (type) is computed in bitsizetype.  After the division, the
1419        result will fit in sizetype.  We will get more efficient code using
1420        sizetype, so we force a conversion.  */
1421     TYPE_SIZE_UNIT (type)
1422       = fold_convert (sizetype,
1423                       size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (type),
1424                                   bitsize_unit_node));
1425
1426   if (TYPE_SIZE (type) != 0)
1427     {
1428       TYPE_SIZE (type) = round_up (TYPE_SIZE (type), TYPE_ALIGN (type));
1429       TYPE_SIZE_UNIT (type) = round_up (TYPE_SIZE_UNIT (type),
1430                                         TYPE_ALIGN_UNIT (type));
1431     }
1432
1433   /* Evaluate nonconstant sizes only once, either now or as soon as safe.  */
1434   if (TYPE_SIZE (type) != 0 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1435     TYPE_SIZE (type) = variable_size (TYPE_SIZE (type));
1436   if (TYPE_SIZE_UNIT (type) != 0
1437       && TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST)
1438     TYPE_SIZE_UNIT (type) = variable_size (TYPE_SIZE_UNIT (type));
1439
1440   /* Also layout any other variants of the type.  */
1441   if (TYPE_NEXT_VARIANT (type)
1442       || type != TYPE_MAIN_VARIANT (type))
1443     {
1444       tree variant;
1445       /* Record layout info of this variant.  */
1446       tree size = TYPE_SIZE (type);
1447       tree size_unit = TYPE_SIZE_UNIT (type);
1448       unsigned int align = TYPE_ALIGN (type);
1449       unsigned int user_align = TYPE_USER_ALIGN (type);
1450       enum machine_mode mode = TYPE_MODE (type);
1451
1452       /* Copy it into all variants.  */
1453       for (variant = TYPE_MAIN_VARIANT (type);
1454            variant != 0;
1455            variant = TYPE_NEXT_VARIANT (variant))
1456         {
1457           TYPE_SIZE (variant) = size;
1458           TYPE_SIZE_UNIT (variant) = size_unit;
1459           TYPE_ALIGN (variant) = align;
1460           TYPE_USER_ALIGN (variant) = user_align;
1461           TYPE_MODE (variant) = mode;
1462         }
1463     }
1464 }
1465
1466 /* Do all of the work required to layout the type indicated by RLI,
1467    once the fields have been laid out.  This function will call `free'
1468    for RLI, unless FREE_P is false.  Passing a value other than false
1469    for FREE_P is bad practice; this option only exists to support the
1470    G++ 3.2 ABI.  */
1471
1472 void
1473 finish_record_layout (record_layout_info rli, int free_p)
1474 {
1475   tree variant;
1476
1477   /* Compute the final size.  */
1478   finalize_record_size (rli);
1479
1480   /* Compute the TYPE_MODE for the record.  */
1481   compute_record_mode (rli->t);
1482
1483   /* Perform any last tweaks to the TYPE_SIZE, etc.  */
1484   finalize_type_size (rli->t);
1485
1486   /* Propagate TYPE_PACKED to variants.  With C++ templates,
1487      handle_packed_attribute is too early to do this.  */
1488   for (variant = TYPE_NEXT_VARIANT (rli->t); variant;
1489        variant = TYPE_NEXT_VARIANT (variant))
1490     TYPE_PACKED (variant) = TYPE_PACKED (rli->t);
1491
1492   /* Lay out any static members.  This is done now because their type
1493      may use the record's type.  */
1494   while (rli->pending_statics)
1495     {
1496       layout_decl (TREE_VALUE (rli->pending_statics), 0);
1497       rli->pending_statics = TREE_CHAIN (rli->pending_statics);
1498     }
1499
1500   /* Clean up.  */
1501   if (free_p)
1502     free (rli);
1503 }
1504 \f
1505
1506 /* Finish processing a builtin RECORD_TYPE type TYPE.  It's name is
1507    NAME, its fields are chained in reverse on FIELDS.
1508
1509    If ALIGN_TYPE is non-null, it is given the same alignment as
1510    ALIGN_TYPE.  */
1511
1512 void
1513 finish_builtin_struct (tree type, const char *name, tree fields,
1514                        tree align_type)
1515 {
1516   tree tail, next;
1517
1518   for (tail = NULL_TREE; fields; tail = fields, fields = next)
1519     {
1520       DECL_FIELD_CONTEXT (fields) = type;
1521       next = TREE_CHAIN (fields);
1522       TREE_CHAIN (fields) = tail;
1523     }
1524   TYPE_FIELDS (type) = tail;
1525
1526   if (align_type)
1527     {
1528       TYPE_ALIGN (type) = TYPE_ALIGN (align_type);
1529       TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (align_type);
1530     }
1531
1532   layout_type (type);
1533 #if 0 /* not yet, should get fixed properly later */
1534   TYPE_NAME (type) = make_type_decl (get_identifier (name), type);
1535 #else
1536   TYPE_NAME (type) = build_decl (TYPE_DECL, get_identifier (name), type);
1537 #endif
1538   TYPE_STUB_DECL (type) = TYPE_NAME (type);
1539   layout_decl (TYPE_NAME (type), 0);
1540 }
1541
1542 /* Calculate the mode, size, and alignment for TYPE.
1543    For an array type, calculate the element separation as well.
1544    Record TYPE on the chain of permanent or temporary types
1545    so that dbxout will find out about it.
1546
1547    TYPE_SIZE of a type is nonzero if the type has been laid out already.
1548    layout_type does nothing on such a type.
1549
1550    If the type is incomplete, its TYPE_SIZE remains zero.  */
1551
1552 void
1553 layout_type (tree type)
1554 {
1555   gcc_assert (type);
1556
1557   if (type == error_mark_node)
1558     return;
1559
1560   /* Do nothing if type has been laid out before.  */
1561   if (TYPE_SIZE (type))
1562     return;
1563
1564   switch (TREE_CODE (type))
1565     {
1566     case LANG_TYPE:
1567       /* This kind of type is the responsibility
1568          of the language-specific code.  */
1569       gcc_unreachable ();
1570
1571     case BOOLEAN_TYPE:  /* Used for Java, Pascal, and Chill.  */
1572       if (TYPE_PRECISION (type) == 0)
1573         TYPE_PRECISION (type) = 1; /* default to one byte/boolean.  */
1574
1575       /* ... fall through ...  */
1576
1577     case INTEGER_TYPE:
1578     case ENUMERAL_TYPE:
1579       if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
1580           && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0)
1581         TYPE_UNSIGNED (type) = 1;
1582
1583       TYPE_MODE (type) = smallest_mode_for_size (TYPE_PRECISION (type),
1584                                                  MODE_INT);
1585       TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
1586       TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
1587       break;
1588
1589     case REAL_TYPE:
1590       TYPE_MODE (type) = mode_for_size (TYPE_PRECISION (type), MODE_FLOAT, 0);
1591       TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
1592       TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
1593       break;
1594
1595    case FIXED_POINT_TYPE:
1596      /* TYPE_MODE (type) has been set already.  */
1597      TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
1598      TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
1599      break;
1600
1601     case COMPLEX_TYPE:
1602       TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TREE_TYPE (type));
1603       TYPE_MODE (type)
1604         = mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type)),
1605                          (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE
1606                           ? MODE_COMPLEX_FLOAT : MODE_COMPLEX_INT),
1607                          0);
1608       TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
1609       TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
1610       break;
1611
1612     case VECTOR_TYPE:
1613       {
1614         int nunits = TYPE_VECTOR_SUBPARTS (type);
1615         tree innertype = TREE_TYPE (type);
1616
1617         gcc_assert (!(nunits & (nunits - 1)));
1618
1619         /* Find an appropriate mode for the vector type.  */
1620         if (TYPE_MODE (type) == VOIDmode)
1621           {
1622             enum machine_mode innermode = TYPE_MODE (innertype);
1623             enum machine_mode mode;
1624
1625             /* First, look for a supported vector type.  */
1626             if (SCALAR_FLOAT_MODE_P (innermode))
1627               mode = MIN_MODE_VECTOR_FLOAT;
1628             else if (SCALAR_FRACT_MODE_P (innermode))
1629               mode = MIN_MODE_VECTOR_FRACT;
1630             else if (SCALAR_UFRACT_MODE_P (innermode))
1631               mode = MIN_MODE_VECTOR_UFRACT;
1632             else if (SCALAR_ACCUM_MODE_P (innermode))
1633               mode = MIN_MODE_VECTOR_ACCUM;
1634             else if (SCALAR_UACCUM_MODE_P (innermode))
1635               mode = MIN_MODE_VECTOR_UACCUM;
1636             else
1637               mode = MIN_MODE_VECTOR_INT;
1638
1639             for (; mode != VOIDmode ; mode = GET_MODE_WIDER_MODE (mode))
1640               if (GET_MODE_NUNITS (mode) == nunits
1641                   && GET_MODE_INNER (mode) == innermode
1642                   && targetm.vector_mode_supported_p (mode))
1643                 break;
1644
1645             /* For integers, try mapping it to a same-sized scalar mode.  */
1646             if (mode == VOIDmode
1647                 && GET_MODE_CLASS (innermode) == MODE_INT)
1648               mode = mode_for_size (nunits * GET_MODE_BITSIZE (innermode),
1649                                     MODE_INT, 0);
1650
1651             if (mode == VOIDmode || !have_regs_of_mode[mode])
1652               TYPE_MODE (type) = BLKmode;
1653             else
1654               TYPE_MODE (type) = mode;
1655           }
1656
1657         TYPE_SATURATING (type) = TYPE_SATURATING (TREE_TYPE (type));
1658         TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TREE_TYPE (type));
1659         TYPE_SIZE_UNIT (type) = int_const_binop (MULT_EXPR,
1660                                                  TYPE_SIZE_UNIT (innertype),
1661                                                  size_int (nunits), 0);
1662         TYPE_SIZE (type) = int_const_binop (MULT_EXPR, TYPE_SIZE (innertype),
1663                                             bitsize_int (nunits), 0);
1664
1665         /* Always naturally align vectors.  This prevents ABI changes
1666            depending on whether or not native vector modes are supported.  */
1667         TYPE_ALIGN (type) = tree_low_cst (TYPE_SIZE (type), 0);
1668         break;
1669       }
1670
1671     case VOID_TYPE:
1672       /* This is an incomplete type and so doesn't have a size.  */
1673       TYPE_ALIGN (type) = 1;
1674       TYPE_USER_ALIGN (type) = 0;
1675       TYPE_MODE (type) = VOIDmode;
1676       break;
1677
1678     case OFFSET_TYPE:
1679       TYPE_SIZE (type) = bitsize_int (POINTER_SIZE);
1680       TYPE_SIZE_UNIT (type) = size_int (POINTER_SIZE / BITS_PER_UNIT);
1681       /* A pointer might be MODE_PARTIAL_INT,
1682          but ptrdiff_t must be integral.  */
1683       TYPE_MODE (type) = mode_for_size (POINTER_SIZE, MODE_INT, 0);
1684       break;
1685
1686     case FUNCTION_TYPE:
1687     case METHOD_TYPE:
1688       /* It's hard to see what the mode and size of a function ought to
1689          be, but we do know the alignment is FUNCTION_BOUNDARY, so
1690          make it consistent with that.  */
1691       TYPE_MODE (type) = mode_for_size (FUNCTION_BOUNDARY, MODE_INT, 0);
1692       TYPE_SIZE (type) = bitsize_int (FUNCTION_BOUNDARY);
1693       TYPE_SIZE_UNIT (type) = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1694       break;
1695
1696     case POINTER_TYPE:
1697     case REFERENCE_TYPE:
1698       {
1699
1700         enum machine_mode mode = ((TREE_CODE (type) == REFERENCE_TYPE
1701                                    && reference_types_internal)
1702                                   ? Pmode : TYPE_MODE (type));
1703
1704         int nbits = GET_MODE_BITSIZE (mode);
1705
1706         TYPE_SIZE (type) = bitsize_int (nbits);
1707         TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (mode));
1708         TYPE_UNSIGNED (type) = 1;
1709         TYPE_PRECISION (type) = nbits;
1710       }
1711       break;
1712
1713     case ARRAY_TYPE:
1714       {
1715         tree index = TYPE_DOMAIN (type);
1716         tree element = TREE_TYPE (type);
1717
1718         build_pointer_type (element);
1719
1720         /* We need to know both bounds in order to compute the size.  */
1721         if (index && TYPE_MAX_VALUE (index) && TYPE_MIN_VALUE (index)
1722             && TYPE_SIZE (element))
1723           {
1724             tree ub = TYPE_MAX_VALUE (index);
1725             tree lb = TYPE_MIN_VALUE (index);
1726             tree length;
1727             tree element_size;
1728
1729             /* The initial subtraction should happen in the original type so
1730                that (possible) negative values are handled appropriately.  */
1731             length = size_binop (PLUS_EXPR, size_one_node,
1732                                  fold_convert (sizetype,
1733                                                fold_build2 (MINUS_EXPR,
1734                                                             TREE_TYPE (lb),
1735                                                             ub, lb)));
1736
1737             /* Special handling for arrays of bits (for Chill).  */
1738             element_size = TYPE_SIZE (element);
1739             if (TYPE_PACKED (type) && INTEGRAL_TYPE_P (element)
1740                 && (integer_zerop (TYPE_MAX_VALUE (element))
1741                     || integer_onep (TYPE_MAX_VALUE (element)))
1742                 && host_integerp (TYPE_MIN_VALUE (element), 1))
1743               {
1744                 HOST_WIDE_INT maxvalue
1745                   = tree_low_cst (TYPE_MAX_VALUE (element), 1);
1746                 HOST_WIDE_INT minvalue
1747                   = tree_low_cst (TYPE_MIN_VALUE (element), 1);
1748
1749                 if (maxvalue - minvalue == 1
1750                     && (maxvalue == 1 || maxvalue == 0))
1751                   element_size = integer_one_node;
1752               }
1753
1754             /* If neither bound is a constant and sizetype is signed, make
1755                sure the size is never negative.  We should really do this
1756                if *either* bound is non-constant, but this is the best
1757                compromise between C and Ada.  */
1758             if (!TYPE_UNSIGNED (sizetype)
1759                 && TREE_CODE (TYPE_MIN_VALUE (index)) != INTEGER_CST
1760                 && TREE_CODE (TYPE_MAX_VALUE (index)) != INTEGER_CST)
1761               length = size_binop (MAX_EXPR, length, size_zero_node);
1762
1763             TYPE_SIZE (type) = size_binop (MULT_EXPR, element_size,
1764                                            fold_convert (bitsizetype,
1765                                                          length));
1766
1767             /* If we know the size of the element, calculate the total
1768                size directly, rather than do some division thing below.
1769                This optimization helps Fortran assumed-size arrays
1770                (where the size of the array is determined at runtime)
1771                substantially.
1772                Note that we can't do this in the case where the size of
1773                the elements is one bit since TYPE_SIZE_UNIT cannot be
1774                set correctly in that case.  */
1775             if (TYPE_SIZE_UNIT (element) != 0 && ! integer_onep (element_size))
1776               TYPE_SIZE_UNIT (type)
1777                 = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (element), length);
1778           }
1779
1780         /* Now round the alignment and size,
1781            using machine-dependent criteria if any.  */
1782
1783 #ifdef ROUND_TYPE_ALIGN
1784         TYPE_ALIGN (type)
1785           = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (element), BITS_PER_UNIT);
1786 #else
1787         TYPE_ALIGN (type) = MAX (TYPE_ALIGN (element), BITS_PER_UNIT);
1788 #endif
1789         if (!TYPE_SIZE (element))
1790           /* We don't know the size of the underlying element type, so
1791              our alignment calculations will be wrong, forcing us to
1792              fall back on structural equality. */
1793           SET_TYPE_STRUCTURAL_EQUALITY (type);
1794         TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (element);
1795         TYPE_MODE (type) = BLKmode;
1796         if (TYPE_SIZE (type) != 0
1797 #ifdef MEMBER_TYPE_FORCES_BLK
1798             && ! MEMBER_TYPE_FORCES_BLK (type, VOIDmode)
1799 #endif
1800             /* BLKmode elements force BLKmode aggregate;
1801                else extract/store fields may lose.  */
1802             && (TYPE_MODE (TREE_TYPE (type)) != BLKmode
1803                 || TYPE_NO_FORCE_BLK (TREE_TYPE (type))))
1804           {
1805             /* One-element arrays get the component type's mode.  */
1806             if (simple_cst_equal (TYPE_SIZE (type),
1807                                   TYPE_SIZE (TREE_TYPE (type))))
1808               TYPE_MODE (type) = TYPE_MODE (TREE_TYPE (type));
1809             else
1810               TYPE_MODE (type)
1811                 = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1);
1812
1813             if (TYPE_MODE (type) != BLKmode
1814                 && STRICT_ALIGNMENT && TYPE_ALIGN (type) < BIGGEST_ALIGNMENT
1815                 && TYPE_ALIGN (type) < GET_MODE_ALIGNMENT (TYPE_MODE (type)))
1816               {
1817                 TYPE_NO_FORCE_BLK (type) = 1;
1818                 TYPE_MODE (type) = BLKmode;
1819               }
1820           }
1821         /* When the element size is constant, check that it is at least as
1822            large as the element alignment.  */
1823         if (TYPE_SIZE_UNIT (element)
1824             && TREE_CODE (TYPE_SIZE_UNIT (element)) == INTEGER_CST
1825             /* If TYPE_SIZE_UNIT overflowed, then it is certainly larger than
1826                TYPE_ALIGN_UNIT.  */
1827             && !TREE_OVERFLOW (TYPE_SIZE_UNIT (element))
1828             && !integer_zerop (TYPE_SIZE_UNIT (element))
1829             && compare_tree_int (TYPE_SIZE_UNIT (element),
1830                                  TYPE_ALIGN_UNIT (element)) < 0)
1831           error ("alignment of array elements is greater than element size");
1832         break;
1833       }
1834
1835     case RECORD_TYPE:
1836     case UNION_TYPE:
1837     case QUAL_UNION_TYPE:
1838       {
1839         tree field;
1840         record_layout_info rli;
1841
1842         /* Initialize the layout information.  */
1843         rli = start_record_layout (type);
1844
1845         /* If this is a QUAL_UNION_TYPE, we want to process the fields
1846            in the reverse order in building the COND_EXPR that denotes
1847            its size.  We reverse them again later.  */
1848         if (TREE_CODE (type) == QUAL_UNION_TYPE)
1849           TYPE_FIELDS (type) = nreverse (TYPE_FIELDS (type));
1850
1851         /* Place all the fields.  */
1852         for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1853           place_field (rli, field);
1854
1855         if (TREE_CODE (type) == QUAL_UNION_TYPE)
1856           TYPE_FIELDS (type) = nreverse (TYPE_FIELDS (type));
1857
1858         /* Finish laying out the record.  */
1859         finish_record_layout (rli, /*free_p=*/true);
1860       }
1861       break;
1862
1863     default:
1864       gcc_unreachable ();
1865     }
1866
1867   /* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE.  For
1868      records and unions, finish_record_layout already called this
1869      function.  */
1870   if (TREE_CODE (type) != RECORD_TYPE
1871       && TREE_CODE (type) != UNION_TYPE
1872       && TREE_CODE (type) != QUAL_UNION_TYPE)
1873     finalize_type_size (type);
1874
1875   /* We should never see alias sets on incomplete aggregates.  And we
1876      should not call layout_type on not incomplete aggregates.  */
1877   if (AGGREGATE_TYPE_P (type))
1878     gcc_assert (!TYPE_ALIAS_SET_KNOWN_P (type));
1879 }
1880 \f
1881 /* Create and return a type for signed integers of PRECISION bits.  */
1882
1883 tree
1884 make_signed_type (int precision)
1885 {
1886   tree type = make_node (INTEGER_TYPE);
1887
1888   TYPE_PRECISION (type) = precision;
1889
1890   fixup_signed_type (type);
1891   return type;
1892 }
1893
1894 /* Create and return a type for unsigned integers of PRECISION bits.  */
1895
1896 tree
1897 make_unsigned_type (int precision)
1898 {
1899   tree type = make_node (INTEGER_TYPE);
1900
1901   TYPE_PRECISION (type) = precision;
1902
1903   fixup_unsigned_type (type);
1904   return type;
1905 }
1906 \f
1907 /* Create and return a type for fract of PRECISION bits, UNSIGNEDP,
1908    and SATP.  */
1909
1910 tree
1911 make_fract_type (int precision, int unsignedp, int satp)
1912 {
1913   tree type = make_node (FIXED_POINT_TYPE);
1914
1915   TYPE_PRECISION (type) = precision;
1916
1917   if (satp)
1918     TYPE_SATURATING (type) = 1;
1919
1920   /* Lay out the type: set its alignment, size, etc.  */
1921   if (unsignedp)
1922     {
1923       TYPE_UNSIGNED (type) = 1;
1924       TYPE_MODE (type) = mode_for_size (precision, MODE_UFRACT, 0);
1925     }
1926   else
1927     TYPE_MODE (type) = mode_for_size (precision, MODE_FRACT, 0);
1928   layout_type (type);
1929
1930   return type;
1931 }
1932
1933 /* Create and return a type for accum of PRECISION bits, UNSIGNEDP,
1934    and SATP.  */
1935
1936 tree
1937 make_accum_type (int precision, int unsignedp, int satp)
1938 {
1939   tree type = make_node (FIXED_POINT_TYPE);
1940
1941   TYPE_PRECISION (type) = precision;
1942
1943   if (satp)
1944     TYPE_SATURATING (type) = 1;
1945
1946   /* Lay out the type: set its alignment, size, etc.  */
1947   if (unsignedp)
1948     {
1949       TYPE_UNSIGNED (type) = 1;
1950       TYPE_MODE (type) = mode_for_size (precision, MODE_UACCUM, 0);
1951     }
1952   else
1953     TYPE_MODE (type) = mode_for_size (precision, MODE_ACCUM, 0);
1954   layout_type (type);
1955
1956   return type;
1957 }
1958
1959 /* Initialize sizetype and bitsizetype to a reasonable and temporary
1960    value to enable integer types to be created.  */
1961
1962 void
1963 initialize_sizetypes (bool signed_p)
1964 {
1965   tree t = make_node (INTEGER_TYPE);
1966   int precision = GET_MODE_BITSIZE (SImode);
1967
1968   TYPE_MODE (t) = SImode;
1969   TYPE_ALIGN (t) = GET_MODE_ALIGNMENT (SImode);
1970   TYPE_USER_ALIGN (t) = 0;
1971   TYPE_IS_SIZETYPE (t) = 1;
1972   TYPE_UNSIGNED (t) = !signed_p;
1973   TYPE_SIZE (t) = build_int_cst (t, precision);
1974   TYPE_SIZE_UNIT (t) = build_int_cst (t, GET_MODE_SIZE (SImode));
1975   TYPE_PRECISION (t) = precision;
1976
1977   /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE.  */
1978   set_min_and_max_values_for_integral_type (t, precision, !signed_p);
1979
1980   sizetype = t;
1981   bitsizetype = build_distinct_type_copy (t);
1982 }
1983
1984 /* Make sizetype a version of TYPE, and initialize *sizetype
1985    accordingly.  We do this by overwriting the stub sizetype and
1986    bitsizetype nodes created by initialize_sizetypes.  This makes sure
1987    that (a) anything stubby about them no longer exists, (b) any
1988    INTEGER_CSTs created with such a type, remain valid.  */
1989
1990 void
1991 set_sizetype (tree type)
1992 {
1993   int oprecision = TYPE_PRECISION (type);
1994   /* The *bitsizetype types use a precision that avoids overflows when
1995      calculating signed sizes / offsets in bits.  However, when
1996      cross-compiling from a 32 bit to a 64 bit host, we are limited to 64 bit
1997      precision.  */
1998   int precision = MIN (MIN (oprecision + BITS_PER_UNIT_LOG + 1,
1999                             MAX_FIXED_MODE_SIZE),
2000                        2 * HOST_BITS_PER_WIDE_INT);
2001   tree t;
2002
2003   gcc_assert (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (sizetype));
2004
2005   t = build_distinct_type_copy (type);
2006   /* We do want to use sizetype's cache, as we will be replacing that
2007      type.  */
2008   TYPE_CACHED_VALUES (t) = TYPE_CACHED_VALUES (sizetype);
2009   TYPE_CACHED_VALUES_P (t) = TYPE_CACHED_VALUES_P (sizetype);
2010   TREE_TYPE (TYPE_CACHED_VALUES (t)) = type;
2011   TYPE_UID (t) = TYPE_UID (sizetype);
2012   TYPE_IS_SIZETYPE (t) = 1;
2013
2014   /* Replace our original stub sizetype.  */
2015   memcpy (sizetype, t, tree_size (sizetype));
2016   TYPE_MAIN_VARIANT (sizetype) = sizetype;
2017
2018   t = make_node (INTEGER_TYPE);
2019   TYPE_NAME (t) = get_identifier ("bit_size_type");
2020   /* We do want to use bitsizetype's cache, as we will be replacing that
2021      type.  */
2022   TYPE_CACHED_VALUES (t) = TYPE_CACHED_VALUES (bitsizetype);
2023   TYPE_CACHED_VALUES_P (t) = TYPE_CACHED_VALUES_P (bitsizetype);
2024   TYPE_PRECISION (t) = precision;
2025   TYPE_UID (t) = TYPE_UID (bitsizetype);
2026   TYPE_IS_SIZETYPE (t) = 1;
2027
2028   /* Replace our original stub bitsizetype.  */
2029   memcpy (bitsizetype, t, tree_size (bitsizetype));
2030   TYPE_MAIN_VARIANT (bitsizetype) = bitsizetype;
2031
2032   if (TYPE_UNSIGNED (type))
2033     {
2034       fixup_unsigned_type (bitsizetype);
2035       ssizetype = build_distinct_type_copy (make_signed_type (oprecision));
2036       TYPE_IS_SIZETYPE (ssizetype) = 1;
2037       sbitsizetype = build_distinct_type_copy (make_signed_type (precision));
2038       TYPE_IS_SIZETYPE (sbitsizetype) = 1;
2039     }
2040   else
2041     {
2042       fixup_signed_type (bitsizetype);
2043       ssizetype = sizetype;
2044       sbitsizetype = bitsizetype;
2045     }
2046
2047   /* If SIZETYPE is unsigned, we need to fix TYPE_MAX_VALUE so that
2048      it is sign extended in a way consistent with force_fit_type.  */
2049   if (TYPE_UNSIGNED (type))
2050     {
2051       tree orig_max, new_max;
2052
2053       orig_max = TYPE_MAX_VALUE (sizetype);
2054
2055       /* Build a new node with the same values, but a different type.
2056          Sign extend it to ensure consistency.  */
2057       new_max = build_int_cst_wide_type (sizetype,
2058                                          TREE_INT_CST_LOW (orig_max),
2059                                          TREE_INT_CST_HIGH (orig_max));
2060       TYPE_MAX_VALUE (sizetype) = new_max;
2061     }
2062 }
2063 \f
2064 /* TYPE is an integral type, i.e., an INTEGRAL_TYPE, ENUMERAL_TYPE
2065    or BOOLEAN_TYPE.  Set TYPE_MIN_VALUE and TYPE_MAX_VALUE
2066    for TYPE, based on the PRECISION and whether or not the TYPE
2067    IS_UNSIGNED.  PRECISION need not correspond to a width supported
2068    natively by the hardware; for example, on a machine with 8-bit,
2069    16-bit, and 32-bit register modes, PRECISION might be 7, 23, or
2070    61.  */
2071
2072 void
2073 set_min_and_max_values_for_integral_type (tree type,
2074                                           int precision,
2075                                           bool is_unsigned)
2076 {
2077   tree min_value;
2078   tree max_value;
2079
2080   if (is_unsigned)
2081     {
2082       min_value = build_int_cst (type, 0);
2083       max_value
2084         = build_int_cst_wide (type, precision - HOST_BITS_PER_WIDE_INT >= 0
2085                               ? -1
2086                               : ((HOST_WIDE_INT) 1 << precision) - 1,
2087                               precision - HOST_BITS_PER_WIDE_INT > 0
2088                               ? ((unsigned HOST_WIDE_INT) ~0
2089                                  >> (HOST_BITS_PER_WIDE_INT
2090                                      - (precision - HOST_BITS_PER_WIDE_INT)))
2091                               : 0);
2092     }
2093   else
2094     {
2095       min_value
2096         = build_int_cst_wide (type,
2097                               (precision - HOST_BITS_PER_WIDE_INT > 0
2098                                ? 0
2099                                : (HOST_WIDE_INT) (-1) << (precision - 1)),
2100                               (((HOST_WIDE_INT) (-1)
2101                                 << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
2102                                     ? precision - HOST_BITS_PER_WIDE_INT - 1
2103                                     : 0))));
2104       max_value
2105         = build_int_cst_wide (type,
2106                               (precision - HOST_BITS_PER_WIDE_INT > 0
2107                                ? -1
2108                                : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1),
2109                               (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
2110                                ? (((HOST_WIDE_INT) 1
2111                                    << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1
2112                                : 0));
2113     }
2114
2115   TYPE_MIN_VALUE (type) = min_value;
2116   TYPE_MAX_VALUE (type) = max_value;
2117 }
2118
2119 /* Set the extreme values of TYPE based on its precision in bits,
2120    then lay it out.  Used when make_signed_type won't do
2121    because the tree code is not INTEGER_TYPE.
2122    E.g. for Pascal, when the -fsigned-char option is given.  */
2123
2124 void
2125 fixup_signed_type (tree type)
2126 {
2127   int precision = TYPE_PRECISION (type);
2128
2129   /* We can not represent properly constants greater then
2130      2 * HOST_BITS_PER_WIDE_INT, still we need the types
2131      as they are used by i386 vector extensions and friends.  */
2132   if (precision > HOST_BITS_PER_WIDE_INT * 2)
2133     precision = HOST_BITS_PER_WIDE_INT * 2;
2134
2135   set_min_and_max_values_for_integral_type (type, precision,
2136                                             /*is_unsigned=*/false);
2137
2138   /* Lay out the type: set its alignment, size, etc.  */
2139   layout_type (type);
2140 }
2141
2142 /* Set the extreme values of TYPE based on its precision in bits,
2143    then lay it out.  This is used both in `make_unsigned_type'
2144    and for enumeral types.  */
2145
2146 void
2147 fixup_unsigned_type (tree type)
2148 {
2149   int precision = TYPE_PRECISION (type);
2150
2151   /* We can not represent properly constants greater then
2152      2 * HOST_BITS_PER_WIDE_INT, still we need the types
2153      as they are used by i386 vector extensions and friends.  */
2154   if (precision > HOST_BITS_PER_WIDE_INT * 2)
2155     precision = HOST_BITS_PER_WIDE_INT * 2;
2156
2157   TYPE_UNSIGNED (type) = 1;
2158
2159   set_min_and_max_values_for_integral_type (type, precision,
2160                                             /*is_unsigned=*/true);
2161
2162   /* Lay out the type: set its alignment, size, etc.  */
2163   layout_type (type);
2164 }
2165 \f
2166 /* Find the best machine mode to use when referencing a bit field of length
2167    BITSIZE bits starting at BITPOS.
2168
2169    The underlying object is known to be aligned to a boundary of ALIGN bits.
2170    If LARGEST_MODE is not VOIDmode, it means that we should not use a mode
2171    larger than LARGEST_MODE (usually SImode).
2172
2173    If no mode meets all these conditions, we return VOIDmode.
2174
2175    If VOLATILEP is false and SLOW_BYTE_ACCESS is false, we return the
2176    smallest mode meeting these conditions.
2177
2178    If VOLATILEP is false and SLOW_BYTE_ACCESS is true, we return the
2179    largest mode (but a mode no wider than UNITS_PER_WORD) that meets
2180    all the conditions.
2181
2182    If VOLATILEP is true the narrow_volatile_bitfields target hook is used to
2183    decide which of the above modes should be used.  */
2184
2185 enum machine_mode
2186 get_best_mode (int bitsize, int bitpos, unsigned int align,
2187                enum machine_mode largest_mode, int volatilep)
2188 {
2189   enum machine_mode mode;
2190   unsigned int unit = 0;
2191
2192   /* Find the narrowest integer mode that contains the bit field.  */
2193   for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
2194        mode = GET_MODE_WIDER_MODE (mode))
2195     {
2196       unit = GET_MODE_BITSIZE (mode);
2197       if ((bitpos % unit) + bitsize <= unit)
2198         break;
2199     }
2200
2201   if (mode == VOIDmode
2202       /* It is tempting to omit the following line
2203          if STRICT_ALIGNMENT is true.
2204          But that is incorrect, since if the bitfield uses part of 3 bytes
2205          and we use a 4-byte mode, we could get a spurious segv
2206          if the extra 4th byte is past the end of memory.
2207          (Though at least one Unix compiler ignores this problem:
2208          that on the Sequent 386 machine.  */
2209       || MIN (unit, BIGGEST_ALIGNMENT) > align
2210       || (largest_mode != VOIDmode && unit > GET_MODE_BITSIZE (largest_mode)))
2211     return VOIDmode;
2212
2213   if ((SLOW_BYTE_ACCESS && ! volatilep)
2214       || (volatilep && !targetm.narrow_volatile_bitfield ()))
2215     {
2216       enum machine_mode wide_mode = VOIDmode, tmode;
2217
2218       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT); tmode != VOIDmode;
2219            tmode = GET_MODE_WIDER_MODE (tmode))
2220         {
2221           unit = GET_MODE_BITSIZE (tmode);
2222           if (bitpos / unit == (bitpos + bitsize - 1) / unit
2223               && unit <= BITS_PER_WORD
2224               && unit <= MIN (align, BIGGEST_ALIGNMENT)
2225               && (largest_mode == VOIDmode
2226                   || unit <= GET_MODE_BITSIZE (largest_mode)))
2227             wide_mode = tmode;
2228         }
2229
2230       if (wide_mode != VOIDmode)
2231         return wide_mode;
2232     }
2233
2234   return mode;
2235 }
2236
2237 /* Gets minimal and maximal values for MODE (signed or unsigned depending on
2238    SIGN).  The returned constants are made to be usable in TARGET_MODE.  */
2239
2240 void
2241 get_mode_bounds (enum machine_mode mode, int sign,
2242                  enum machine_mode target_mode,
2243                  rtx *mmin, rtx *mmax)
2244 {
2245   unsigned size = GET_MODE_BITSIZE (mode);
2246   unsigned HOST_WIDE_INT min_val, max_val;
2247
2248   gcc_assert (size <= HOST_BITS_PER_WIDE_INT);
2249
2250   if (sign)
2251     {
2252       min_val = -((unsigned HOST_WIDE_INT) 1 << (size - 1));
2253       max_val = ((unsigned HOST_WIDE_INT) 1 << (size - 1)) - 1;
2254     }
2255   else
2256     {
2257       min_val = 0;
2258       max_val = ((unsigned HOST_WIDE_INT) 1 << (size - 1) << 1) - 1;
2259     }
2260
2261   *mmin = gen_int_mode (min_val, target_mode);
2262   *mmax = gen_int_mode (max_val, target_mode);
2263 }
2264
2265 #include "gt-stor-layout.h"