OSDN Git Service

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