gcc/stor-layout.c

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