OSDN Git Service

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