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