OSDN Git Service

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