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