OSDN Git Service

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