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
 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                   && rli->remaining_in_alignment)
1075                 {
1076                   rli->bitpos
1077                     = size_binop (PLUS_EXPR, rli->bitpos,
1078                                   bitsize_int (rli->remaining_in_alignment));
1079                 }
1080               else
1081                 /* We "use up" size zero fields; the code below should behave
1082                    as if the prior field was not a bitfield.  */
1083                 prev_saved = NULL;
1084
1085               /* Cause a new bitfield to be captured, either this time (if
1086                  currently a bitfield) or next time we see one.  */
1087               if (!DECL_BIT_FIELD_TYPE(field)
1088                  || integer_zerop (DECL_SIZE (field)))
1089                 rli->prev_field = NULL;
1090             }
1091
1092           normalize_rli (rli);
1093         }
1094
1095       /* If we're starting a new run of same size type bitfields
1096          (or a run of non-bitfields), set up the "first of the run"
1097          fields.
1098
1099          That is, if the current field is not a bitfield, or if there
1100          was a prior bitfield the type sizes differ, or if there wasn't
1101          a prior bitfield the size of the current field is nonzero.
1102
1103          Note: we must be sure to test ONLY the type size if there was
1104          a prior bitfield and ONLY for the current field being zero if
1105          there wasn't.  */
1106
1107       if (!DECL_BIT_FIELD_TYPE (field)
1108           || ( prev_saved != NULL
1109                ? !simple_cst_equal (TYPE_SIZE (type),
1110                                     TYPE_SIZE (TREE_TYPE (prev_saved)))
1111               : !integer_zerop (DECL_SIZE (field)) ))
1112         {
1113           /* Never smaller than a byte for compatibility.  */
1114           unsigned int type_align = BITS_PER_UNIT;
1115
1116           /* (When not a bitfield), we could be seeing a flex array (with
1117              no DECL_SIZE).  Since we won't be using remaining_in_alignment
1118              until we see a bitfield (and come by here again) we just skip
1119              calculating it.  */
1120           if (DECL_SIZE (field) != NULL
1121               && host_integerp (TYPE_SIZE (TREE_TYPE (field)), 0)
1122               && host_integerp (DECL_SIZE (field), 0))
1123             rli->remaining_in_alignment
1124               = tree_low_cst (TYPE_SIZE (TREE_TYPE(field)), 1)
1125                 - tree_low_cst (DECL_SIZE (field), 1);
1126
1127           /* Now align (conventionally) for the new type.  */
1128           type_align = TYPE_ALIGN (TREE_TYPE (field));
1129
1130           if (maximum_field_alignment != 0)
1131             type_align = MIN (type_align, maximum_field_alignment);
1132
1133           rli->bitpos = round_up (rli->bitpos, type_align);
1134
1135           /* If we really aligned, don't allow subsequent bitfields
1136              to undo that.  */
1137           rli->prev_field = NULL;
1138         }
1139     }
1140
1141   /* Offset so far becomes the position of this field after normalizing.  */
1142   normalize_rli (rli);
1143   DECL_FIELD_OFFSET (field) = rli->offset;
1144   DECL_FIELD_BIT_OFFSET (field) = rli->bitpos;
1145   SET_DECL_OFFSET_ALIGN (field, rli->offset_align);
1146
1147   /* If this field ended up more aligned than we thought it would be (we
1148      approximate this by seeing if its position changed), lay out the field
1149      again; perhaps we can use an integral mode for it now.  */
1150   if (! integer_zerop (DECL_FIELD_BIT_OFFSET (field)))
1151     actual_align = (tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1152                     & - tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1));
1153   else if (integer_zerop (DECL_FIELD_OFFSET (field)))
1154     actual_align = MAX (BIGGEST_ALIGNMENT, rli->record_align);
1155   else if (host_integerp (DECL_FIELD_OFFSET (field), 1))
1156     actual_align = (BITS_PER_UNIT
1157                    * (tree_low_cst (DECL_FIELD_OFFSET (field), 1)
1158                       & - tree_low_cst (DECL_FIELD_OFFSET (field), 1)));
1159   else
1160     actual_align = DECL_OFFSET_ALIGN (field);
1161   /* ACTUAL_ALIGN is still the actual alignment *within the record* .
1162      store / extract bit field operations will check the alignment of the
1163      record against the mode of bit fields.  */
1164
1165   if (known_align != actual_align)
1166     layout_decl (field, actual_align);
1167
1168   if (rli->prev_field == NULL && DECL_BIT_FIELD_TYPE (field))
1169     rli->prev_field = field;
1170
1171   /* Now add size of this field to the size of the record.  If the size is
1172      not constant, treat the field as being a multiple of bytes and just
1173      adjust the offset, resetting the bit position.  Otherwise, apportion the
1174      size amongst the bit position and offset.  First handle the case of an
1175      unspecified size, which can happen when we have an invalid nested struct
1176      definition, such as struct j { struct j { int i; } }.  The error message
1177      is printed in finish_struct.  */
1178   if (DECL_SIZE (field) == 0)
1179     /* Do nothing.  */;
1180   else if (TREE_CODE (DECL_SIZE (field)) != INTEGER_CST
1181            || TREE_CONSTANT_OVERFLOW (DECL_SIZE (field)))
1182     {
1183       rli->offset
1184         = size_binop (PLUS_EXPR, rli->offset,
1185                       fold_convert (sizetype,
1186                                     size_binop (CEIL_DIV_EXPR, rli->bitpos,
1187                                                 bitsize_unit_node)));
1188       rli->offset
1189         = size_binop (PLUS_EXPR, rli->offset, DECL_SIZE_UNIT (field));
1190       rli->bitpos = bitsize_zero_node;
1191       rli->offset_align = MIN (rli->offset_align, desired_align);
1192     }
1193   else if (targetm.ms_bitfield_layout_p (rli->t))
1194     {
1195       rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, DECL_SIZE (field));
1196
1197       /* If we ended a bitfield before the full length of the type then
1198          pad the struct out to the full length of the last type.  */
1199       if ((TREE_CHAIN (field) == NULL
1200            || TREE_CODE (TREE_CHAIN (field)) != FIELD_DECL)
1201           && DECL_BIT_FIELD_TYPE (field)
1202           && !integer_zerop (DECL_SIZE (field)))
1203         rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos,
1204                                   bitsize_int (rli->remaining_in_alignment));
1205
1206       normalize_rli (rli);
1207     }
1208   else
1209     {
1210       rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, DECL_SIZE (field));
1211       normalize_rli (rli);
1212     }
1213 }
1214
1215 /* Assuming that all the fields have been laid out, this function uses
1216    RLI to compute the final TYPE_SIZE, TYPE_ALIGN, etc. for the type
1217    indicated by RLI.  */
1218
1219 static void
1220 finalize_record_size (record_layout_info rli)
1221 {
1222   tree unpadded_size, unpadded_size_unit;
1223
1224   /* Now we want just byte and bit offsets, so set the offset alignment
1225      to be a byte and then normalize.  */
1226   rli->offset_align = BITS_PER_UNIT;
1227   normalize_rli (rli);
1228
1229   /* Determine the desired alignment.  */
1230 #ifdef ROUND_TYPE_ALIGN
1231   TYPE_ALIGN (rli->t) = ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t),
1232                                           rli->record_align);
1233 #else
1234   TYPE_ALIGN (rli->t) = MAX (TYPE_ALIGN (rli->t), rli->record_align);
1235 #endif
1236
1237   /* Compute the size so far.  Be sure to allow for extra bits in the
1238      size in bytes.  We have guaranteed above that it will be no more
1239      than a single byte.  */
1240   unpadded_size = rli_size_so_far (rli);
1241   unpadded_size_unit = rli_size_unit_so_far (rli);
1242   if (! integer_zerop (rli->bitpos))
1243     unpadded_size_unit
1244       = size_binop (PLUS_EXPR, unpadded_size_unit, size_one_node);
1245
1246   /* Round the size up to be a multiple of the required alignment.  */
1247   TYPE_SIZE (rli->t) = round_up (unpadded_size, TYPE_ALIGN (rli->t));
1248   TYPE_SIZE_UNIT (rli->t)
1249     = round_up (unpadded_size_unit, TYPE_ALIGN_UNIT (rli->t));
1250
1251   if (TREE_CONSTANT (unpadded_size)
1252       && simple_cst_equal (unpadded_size, TYPE_SIZE (rli->t)) == 0)
1253     warning (OPT_Wpadded, "padding struct size to alignment boundary");
1254
1255   if (warn_packed && TREE_CODE (rli->t) == RECORD_TYPE
1256       && TYPE_PACKED (rli->t) && ! rli->packed_maybe_necessary
1257       && TREE_CONSTANT (unpadded_size))
1258     {
1259       tree unpacked_size;
1260
1261 #ifdef ROUND_TYPE_ALIGN
1262       rli->unpacked_align
1263         = ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t), rli->unpacked_align);
1264 #else
1265       rli->unpacked_align = MAX (TYPE_ALIGN (rli->t), rli->unpacked_align);
1266 #endif
1267
1268       unpacked_size = round_up (TYPE_SIZE (rli->t), rli->unpacked_align);
1269       if (simple_cst_equal (unpacked_size, TYPE_SIZE (rli->t)))
1270         {
1271           TYPE_PACKED (rli->t) = 0;
1272
1273           if (TYPE_NAME (rli->t))
1274             {
1275               const char *name;
1276
1277               if (TREE_CODE (TYPE_NAME (rli->t)) == IDENTIFIER_NODE)
1278                 name = IDENTIFIER_POINTER (TYPE_NAME (rli->t));
1279               else
1280                 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (rli->t)));
1281
1282               if (STRICT_ALIGNMENT)
1283                 warning (OPT_Wpacked, "packed attribute causes inefficient "
1284                          "alignment for %qs", name);
1285               else
1286                 warning (OPT_Wpacked,
1287                          "packed attribute is unnecessary for %qs", name);
1288             }
1289           else
1290             {
1291               if (STRICT_ALIGNMENT)
1292                 warning (OPT_Wpacked,
1293                          "packed attribute causes inefficient alignment");
1294               else
1295                 warning (OPT_Wpacked, "packed attribute is unnecessary");
1296             }
1297         }
1298     }
1299 }
1300
1301 /* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE).  */
1302
1303 void
1304 compute_record_mode (tree type)
1305 {
1306   tree field;
1307   enum machine_mode mode = VOIDmode;
1308
1309   /* Most RECORD_TYPEs have BLKmode, so we start off assuming that.
1310      However, if possible, we use a mode that fits in a register
1311      instead, in order to allow for better optimization down the
1312      line.  */
1313   TYPE_MODE (type) = BLKmode;
1314
1315   if (! host_integerp (TYPE_SIZE (type), 1))
1316     return;
1317
1318   /* A record which has any BLKmode members must itself be
1319      BLKmode; it can't go in a register.  Unless the member is
1320      BLKmode only because it isn't aligned.  */
1321   for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1322     {
1323       if (TREE_CODE (field) != FIELD_DECL)
1324         continue;
1325
1326       if (TREE_CODE (TREE_TYPE (field)) == ERROR_MARK
1327           || (TYPE_MODE (TREE_TYPE (field)) == BLKmode
1328               && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field))
1329               && !(TYPE_SIZE (TREE_TYPE (field)) != 0
1330                    && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))))
1331           || ! host_integerp (bit_position (field), 1)
1332           || DECL_SIZE (field) == 0
1333           || ! host_integerp (DECL_SIZE (field), 1))
1334         return;
1335
1336       /* If this field is the whole struct, remember its mode so
1337          that, say, we can put a double in a class into a DF
1338          register instead of forcing it to live in the stack.  */
1339       if (simple_cst_equal (TYPE_SIZE (type), DECL_SIZE (field)))
1340         mode = DECL_MODE (field);
1341
1342 #ifdef MEMBER_TYPE_FORCES_BLK
1343       /* With some targets, eg. c4x, it is sub-optimal
1344          to access an aligned BLKmode structure as a scalar.  */
1345
1346       if (MEMBER_TYPE_FORCES_BLK (field, mode))
1347         return;
1348 #endif /* MEMBER_TYPE_FORCES_BLK  */
1349     }
1350
1351   /* If we only have one real field; use its mode if that mode's size
1352      matches the type's size.  This only applies to RECORD_TYPE.  This
1353      does not apply to unions.  */
1354   if (TREE_CODE (type) == RECORD_TYPE && mode != VOIDmode
1355       && host_integerp (TYPE_SIZE (type), 1)
1356       && GET_MODE_BITSIZE (mode) == TREE_INT_CST_LOW (TYPE_SIZE (type)))
1357     TYPE_MODE (type) = mode;
1358   else
1359     TYPE_MODE (type) = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1);
1360
1361   /* If structure's known alignment is less than what the scalar
1362      mode would need, and it matters, then stick with BLKmode.  */
1363   if (TYPE_MODE (type) != BLKmode
1364       && STRICT_ALIGNMENT
1365       && ! (TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT
1366             || TYPE_ALIGN (type) >= GET_MODE_ALIGNMENT (TYPE_MODE (type))))
1367     {
1368       /* If this is the only reason this type is BLKmode, then
1369          don't force containing types to be BLKmode.  */
1370       TYPE_NO_FORCE_BLK (type) = 1;
1371       TYPE_MODE (type) = BLKmode;
1372     }
1373 }
1374
1375 /* Compute TYPE_SIZE and TYPE_ALIGN for TYPE, once it has been laid
1376    out.  */
1377
1378 static void
1379 finalize_type_size (tree type)
1380 {
1381   /* Normally, use the alignment corresponding to the mode chosen.
1382      However, where strict alignment is not required, avoid
1383      over-aligning structures, since most compilers do not do this
1384      alignment.  */
1385
1386   if (TYPE_MODE (type) != BLKmode && TYPE_MODE (type) != VOIDmode
1387       && (STRICT_ALIGNMENT
1388           || (TREE_CODE (type) != RECORD_TYPE && TREE_CODE (type) != UNION_TYPE
1389               && TREE_CODE (type) != QUAL_UNION_TYPE
1390               && TREE_CODE (type) != ARRAY_TYPE)))
1391     {
1392       unsigned mode_align = GET_MODE_ALIGNMENT (TYPE_MODE (type));
1393
1394       /* Don't override a larger alignment requirement coming from a user
1395          alignment of one of the fields.  */
1396       if (mode_align >= TYPE_ALIGN (type))
1397         {
1398           TYPE_ALIGN (type) = mode_align;
1399           TYPE_USER_ALIGN (type) = 0;
1400         }
1401     }
1402
1403   /* Do machine-dependent extra alignment.  */
1404 #ifdef ROUND_TYPE_ALIGN
1405   TYPE_ALIGN (type)
1406     = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (type), BITS_PER_UNIT);
1407 #endif
1408
1409   /* If we failed to find a simple way to calculate the unit size
1410      of the type, find it by division.  */
1411   if (TYPE_SIZE_UNIT (type) == 0 && TYPE_SIZE (type) != 0)
1412     /* TYPE_SIZE (type) is computed in bitsizetype.  After the division, the
1413        result will fit in sizetype.  We will get more efficient code using
1414        sizetype, so we force a conversion.  */
1415     TYPE_SIZE_UNIT (type)
1416       = fold_convert (sizetype,
1417                       size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (type),
1418                                   bitsize_unit_node));
1419
1420   if (TYPE_SIZE (type) != 0)
1421     {
1422       TYPE_SIZE (type) = round_up (TYPE_SIZE (type), TYPE_ALIGN (type));
1423       TYPE_SIZE_UNIT (type) = round_up (TYPE_SIZE_UNIT (type),
1424                                         TYPE_ALIGN_UNIT (type));
1425     }
1426
1427   /* Evaluate nonconstant sizes only once, either now or as soon as safe.  */
1428   if (TYPE_SIZE (type) != 0 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1429     TYPE_SIZE (type) = variable_size (TYPE_SIZE (type));
1430   if (TYPE_SIZE_UNIT (type) != 0
1431       && TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST)
1432     TYPE_SIZE_UNIT (type) = variable_size (TYPE_SIZE_UNIT (type));
1433
1434   /* Also layout any other variants of the type.  */
1435   if (TYPE_NEXT_VARIANT (type)
1436       || type != TYPE_MAIN_VARIANT (type))
1437     {
1438       tree variant;
1439       /* Record layout info of this variant.  */
1440       tree size = TYPE_SIZE (type);
1441       tree size_unit = TYPE_SIZE_UNIT (type);
1442       unsigned int align = TYPE_ALIGN (type);
1443       unsigned int user_align = TYPE_USER_ALIGN (type);
1444       enum machine_mode mode = TYPE_MODE (type);
1445
1446       /* Copy it into all variants.  */
1447       for (variant = TYPE_MAIN_VARIANT (type);
1448            variant != 0;
1449            variant = TYPE_NEXT_VARIANT (variant))
1450         {
1451           TYPE_SIZE (variant) = size;
1452           TYPE_SIZE_UNIT (variant) = size_unit;
1453           TYPE_ALIGN (variant) = align;
1454           TYPE_USER_ALIGN (variant) = user_align;
1455           TYPE_MODE (variant) = mode;
1456         }
1457     }
1458 }
1459
1460 /* Do all of the work required to layout the type indicated by RLI,
1461    once the fields have been laid out.  This function will call `free'
1462    for RLI, unless FREE_P is false.  Passing a value other than false
1463    for FREE_P is bad practice; this option only exists to support the
1464    G++ 3.2 ABI.  */
1465
1466 void
1467 finish_record_layout (record_layout_info rli, int free_p)
1468 {
1469   /* Compute the final size.  */
1470   finalize_record_size (rli);
1471
1472   /* Compute the TYPE_MODE for the record.  */
1473   compute_record_mode (rli->t);
1474
1475   /* Perform any last tweaks to the TYPE_SIZE, etc.  */
1476   finalize_type_size (rli->t);
1477
1478   /* Lay out any static members.  This is done now because their type
1479      may use the record's type.  */
1480   while (rli->pending_statics)
1481     {
1482       layout_decl (TREE_VALUE (rli->pending_statics), 0);
1483       rli->pending_statics = TREE_CHAIN (rli->pending_statics);
1484     }
1485
1486   /* Clean up.  */
1487   if (free_p)
1488     free (rli);
1489 }
1490 \f
1491
1492 /* Finish processing a builtin RECORD_TYPE type TYPE.  It's name is
1493    NAME, its fields are chained in reverse on FIELDS.
1494
1495    If ALIGN_TYPE is non-null, it is given the same alignment as
1496    ALIGN_TYPE.  */
1497
1498 void
1499 finish_builtin_struct (tree type, const char *name, tree fields,
1500                        tree align_type)
1501 {
1502   tree tail, next;
1503
1504   for (tail = NULL_TREE; fields; tail = fields, fields = next)
1505     {
1506       DECL_FIELD_CONTEXT (fields) = type;
1507       next = TREE_CHAIN (fields);
1508       TREE_CHAIN (fields) = tail;
1509     }
1510   TYPE_FIELDS (type) = tail;
1511
1512   if (align_type)
1513     {
1514       TYPE_ALIGN (type) = TYPE_ALIGN (align_type);
1515       TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (align_type);
1516     }
1517
1518   layout_type (type);
1519 #if 0 /* not yet, should get fixed properly later */
1520   TYPE_NAME (type) = make_type_decl (get_identifier (name), type);
1521 #else
1522   TYPE_NAME (type) = build_decl (TYPE_DECL, get_identifier (name), type);
1523 #endif
1524   TYPE_STUB_DECL (type) = TYPE_NAME (type);
1525   layout_decl (TYPE_NAME (type), 0);
1526 }
1527
1528 /* Calculate the mode, size, and alignment for TYPE.
1529    For an array type, calculate the element separation as well.
1530    Record TYPE on the chain of permanent or temporary types
1531    so that dbxout will find out about it.
1532
1533    TYPE_SIZE of a type is nonzero if the type has been laid out already.
1534    layout_type does nothing on such a type.
1535
1536    If the type is incomplete, its TYPE_SIZE remains zero.  */
1537
1538 void
1539 layout_type (tree type)
1540 {
1541   gcc_assert (type);
1542
1543   if (type == error_mark_node)
1544     return;
1545
1546   /* Do nothing if type has been laid out before.  */
1547   if (TYPE_SIZE (type))
1548     return;
1549
1550   switch (TREE_CODE (type))
1551     {
1552     case LANG_TYPE:
1553       /* This kind of type is the responsibility
1554          of the language-specific code.  */
1555       gcc_unreachable ();
1556
1557     case BOOLEAN_TYPE:  /* Used for Java, Pascal, and Chill.  */
1558       if (TYPE_PRECISION (type) == 0)
1559         TYPE_PRECISION (type) = 1; /* default to one byte/boolean.  */
1560
1561       /* ... fall through ...  */
1562
1563     case INTEGER_TYPE:
1564     case ENUMERAL_TYPE:
1565       if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
1566           && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0)
1567         TYPE_UNSIGNED (type) = 1;
1568
1569       TYPE_MODE (type) = smallest_mode_for_size (TYPE_PRECISION (type),
1570                                                  MODE_INT);
1571       TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
1572       TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
1573       break;
1574
1575     case REAL_TYPE:
1576       TYPE_MODE (type) = mode_for_size (TYPE_PRECISION (type), MODE_FLOAT, 0);
1577       TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
1578       TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
1579       break;
1580
1581     case COMPLEX_TYPE:
1582       TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TREE_TYPE (type));
1583       TYPE_MODE (type)
1584         = mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type)),
1585                          (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE
1586                           ? MODE_COMPLEX_FLOAT : MODE_COMPLEX_INT),
1587                          0);
1588       TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
1589       TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
1590       break;
1591
1592     case VECTOR_TYPE:
1593       {
1594         int nunits = TYPE_VECTOR_SUBPARTS (type);
1595         tree nunits_tree = build_int_cst (NULL_TREE, nunits);
1596         tree innertype = TREE_TYPE (type);
1597
1598         gcc_assert (!(nunits & (nunits - 1)));
1599
1600         /* Find an appropriate mode for the vector type.  */
1601         if (TYPE_MODE (type) == VOIDmode)
1602           {
1603             enum machine_mode innermode = TYPE_MODE (innertype);
1604             enum machine_mode mode;
1605
1606             /* First, look for a supported vector type.  */
1607             if (SCALAR_FLOAT_MODE_P (innermode))
1608               mode = MIN_MODE_VECTOR_FLOAT;
1609             else
1610               mode = MIN_MODE_VECTOR_INT;
1611
1612             for (; mode != VOIDmode ; mode = GET_MODE_WIDER_MODE (mode))
1613               if (GET_MODE_NUNITS (mode) == nunits
1614                   && GET_MODE_INNER (mode) == innermode
1615                   && targetm.vector_mode_supported_p (mode))
1616                 break;
1617
1618             /* For integers, try mapping it to a same-sized scalar mode.  */
1619             if (mode == VOIDmode
1620                 && GET_MODE_CLASS (innermode) == MODE_INT)
1621               mode = mode_for_size (nunits * GET_MODE_BITSIZE (innermode),
1622                                     MODE_INT, 0);
1623
1624             if (mode == VOIDmode || !have_regs_of_mode[mode])
1625               TYPE_MODE (type) = BLKmode;
1626             else
1627               TYPE_MODE (type) = mode;
1628           }
1629
1630         TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TREE_TYPE (type));
1631         TYPE_SIZE_UNIT (type) = int_const_binop (MULT_EXPR,
1632                                                  TYPE_SIZE_UNIT (innertype),
1633                                                  nunits_tree, 0);
1634         TYPE_SIZE (type) = int_const_binop (MULT_EXPR, TYPE_SIZE (innertype),
1635                                             nunits_tree, 0);
1636
1637         /* Always naturally align vectors.  This prevents ABI changes
1638            depending on whether or not native vector modes are supported.  */
1639         TYPE_ALIGN (type) = tree_low_cst (TYPE_SIZE (type), 0);
1640         break;
1641       }
1642
1643     case VOID_TYPE:
1644       /* This is an incomplete type and so doesn't have a size.  */
1645       TYPE_ALIGN (type) = 1;
1646       TYPE_USER_ALIGN (type) = 0;
1647       TYPE_MODE (type) = VOIDmode;
1648       break;
1649
1650     case OFFSET_TYPE:
1651       TYPE_SIZE (type) = bitsize_int (POINTER_SIZE);
1652       TYPE_SIZE_UNIT (type) = size_int (POINTER_SIZE / BITS_PER_UNIT);
1653       /* A pointer might be MODE_PARTIAL_INT,
1654          but ptrdiff_t must be integral.  */
1655       TYPE_MODE (type) = mode_for_size (POINTER_SIZE, MODE_INT, 0);
1656       break;
1657
1658     case FUNCTION_TYPE:
1659     case METHOD_TYPE:
1660       /* It's hard to see what the mode and size of a function ought to
1661          be, but we do know the alignment is FUNCTION_BOUNDARY, so
1662          make it consistent with that.  */
1663       TYPE_MODE (type) = mode_for_size (FUNCTION_BOUNDARY, MODE_INT, 0);
1664       TYPE_SIZE (type) = bitsize_int (FUNCTION_BOUNDARY);
1665       TYPE_SIZE_UNIT (type) = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1666       break;
1667
1668     case POINTER_TYPE:
1669     case REFERENCE_TYPE:
1670       {
1671
1672         enum machine_mode mode = ((TREE_CODE (type) == REFERENCE_TYPE
1673                                    && reference_types_internal)
1674                                   ? Pmode : TYPE_MODE (type));
1675
1676         int nbits = GET_MODE_BITSIZE (mode);
1677
1678         TYPE_SIZE (type) = bitsize_int (nbits);
1679         TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (mode));
1680         TYPE_UNSIGNED (type) = 1;
1681         TYPE_PRECISION (type) = nbits;
1682       }
1683       break;
1684
1685     case ARRAY_TYPE:
1686       {
1687         tree index = TYPE_DOMAIN (type);
1688         tree element = TREE_TYPE (type);
1689
1690         build_pointer_type (element);
1691
1692         /* We need to know both bounds in order to compute the size.  */
1693         if (index && TYPE_MAX_VALUE (index) && TYPE_MIN_VALUE (index)
1694             && TYPE_SIZE (element))
1695           {
1696             tree ub = TYPE_MAX_VALUE (index);
1697             tree lb = TYPE_MIN_VALUE (index);
1698             tree length;
1699             tree element_size;
1700
1701             /* The initial subtraction should happen in the original type so
1702                that (possible) negative values are handled appropriately.  */
1703             length = size_binop (PLUS_EXPR, size_one_node,
1704                                  fold_convert (sizetype,
1705                                                fold_build2 (MINUS_EXPR,
1706                                                             TREE_TYPE (lb),
1707                                                             ub, lb)));
1708
1709             /* Special handling for arrays of bits (for Chill).  */
1710             element_size = TYPE_SIZE (element);
1711             if (TYPE_PACKED (type) && INTEGRAL_TYPE_P (element)
1712                 && (integer_zerop (TYPE_MAX_VALUE (element))
1713                     || integer_onep (TYPE_MAX_VALUE (element)))
1714                 && host_integerp (TYPE_MIN_VALUE (element), 1))
1715               {
1716                 HOST_WIDE_INT maxvalue
1717                   = tree_low_cst (TYPE_MAX_VALUE (element), 1);
1718                 HOST_WIDE_INT minvalue
1719                   = tree_low_cst (TYPE_MIN_VALUE (element), 1);
1720
1721                 if (maxvalue - minvalue == 1
1722                     && (maxvalue == 1 || maxvalue == 0))
1723                   element_size = integer_one_node;
1724               }
1725
1726             /* If neither bound is a constant and sizetype is signed, make
1727                sure the size is never negative.  We should really do this
1728                if *either* bound is non-constant, but this is the best
1729                compromise between C and Ada.  */
1730             if (!TYPE_UNSIGNED (sizetype)
1731                 && TREE_CODE (TYPE_MIN_VALUE (index)) != INTEGER_CST
1732                 && TREE_CODE (TYPE_MAX_VALUE (index)) != INTEGER_CST)
1733               length = size_binop (MAX_EXPR, length, size_zero_node);
1734
1735             TYPE_SIZE (type) = size_binop (MULT_EXPR, element_size,
1736                                            fold_convert (bitsizetype,
1737                                                          length));
1738
1739             /* If we know the size of the element, calculate the total
1740                size directly, rather than do some division thing below.
1741                This optimization helps Fortran assumed-size arrays
1742                (where the size of the array is determined at runtime)
1743                substantially.
1744                Note that we can't do this in the case where the size of
1745                the elements is one bit since TYPE_SIZE_UNIT cannot be
1746                set correctly in that case.  */
1747             if (TYPE_SIZE_UNIT (element) != 0 && ! integer_onep (element_size))
1748               TYPE_SIZE_UNIT (type)
1749                 = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (element), length);
1750           }
1751
1752         /* Now round the alignment and size,
1753            using machine-dependent criteria if any.  */
1754
1755 #ifdef ROUND_TYPE_ALIGN
1756         TYPE_ALIGN (type)
1757           = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (element), BITS_PER_UNIT);
1758 #else
1759         TYPE_ALIGN (type) = MAX (TYPE_ALIGN (element), BITS_PER_UNIT);
1760 #endif
1761         TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (element);
1762         TYPE_MODE (type) = BLKmode;
1763         if (TYPE_SIZE (type) != 0
1764 #ifdef MEMBER_TYPE_FORCES_BLK
1765             && ! MEMBER_TYPE_FORCES_BLK (type, VOIDmode)
1766 #endif
1767             /* BLKmode elements force BLKmode aggregate;
1768                else extract/store fields may lose.  */
1769             && (TYPE_MODE (TREE_TYPE (type)) != BLKmode
1770                 || TYPE_NO_FORCE_BLK (TREE_TYPE (type))))
1771           {
1772             /* One-element arrays get the component type's mode.  */
1773             if (simple_cst_equal (TYPE_SIZE (type),
1774                                   TYPE_SIZE (TREE_TYPE (type))))
1775               TYPE_MODE (type) = TYPE_MODE (TREE_TYPE (type));
1776             else
1777               TYPE_MODE (type)
1778                 = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1);
1779
1780             if (TYPE_MODE (type) != BLKmode
1781                 && STRICT_ALIGNMENT && TYPE_ALIGN (type) < BIGGEST_ALIGNMENT
1782                 && TYPE_ALIGN (type) < GET_MODE_ALIGNMENT (TYPE_MODE (type))
1783                 && TYPE_MODE (type) != BLKmode)
1784               {
1785                 TYPE_NO_FORCE_BLK (type) = 1;
1786                 TYPE_MODE (type) = BLKmode;
1787               }
1788           }
1789         /* When the element size is constant, check that it is at least as
1790            large as the element alignment.  */
1791         if (TYPE_SIZE_UNIT (element)
1792             && TREE_CODE (TYPE_SIZE_UNIT (element)) == INTEGER_CST
1793             /* If TYPE_SIZE_UNIT overflowed, then it is certainly larger than
1794                TYPE_ALIGN_UNIT.  */
1795             && !TREE_CONSTANT_OVERFLOW (TYPE_SIZE_UNIT (element))
1796             && !integer_zerop (TYPE_SIZE_UNIT (element))
1797             && compare_tree_int (TYPE_SIZE_UNIT (element),
1798                                  TYPE_ALIGN_UNIT (element)) < 0)
1799           error ("alignment of array elements is greater than element size");
1800         break;
1801       }
1802
1803     case RECORD_TYPE:
1804     case UNION_TYPE:
1805     case QUAL_UNION_TYPE:
1806       {
1807         tree field;
1808         record_layout_info rli;
1809
1810         /* Initialize the layout information.  */
1811         rli = start_record_layout (type);
1812
1813         /* If this is a QUAL_UNION_TYPE, we want to process the fields
1814            in the reverse order in building the COND_EXPR that denotes
1815            its size.  We reverse them again later.  */
1816         if (TREE_CODE (type) == QUAL_UNION_TYPE)
1817           TYPE_FIELDS (type) = nreverse (TYPE_FIELDS (type));
1818
1819         /* Place all the fields.  */
1820         for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1821           place_field (rli, field);
1822
1823         if (TREE_CODE (type) == QUAL_UNION_TYPE)
1824           TYPE_FIELDS (type) = nreverse (TYPE_FIELDS (type));
1825
1826         if (lang_adjust_rli)
1827           (*lang_adjust_rli) (rli);
1828
1829         /* Finish laying out the record.  */
1830         finish_record_layout (rli, /*free_p=*/true);
1831       }
1832       break;
1833
1834     default:
1835       gcc_unreachable ();
1836     }
1837
1838   /* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE.  For
1839      records and unions, finish_record_layout already called this
1840      function.  */
1841   if (TREE_CODE (type) != RECORD_TYPE
1842       && TREE_CODE (type) != UNION_TYPE
1843       && TREE_CODE (type) != QUAL_UNION_TYPE)
1844     finalize_type_size (type);
1845
1846   /* If an alias set has been set for this aggregate when it was incomplete,
1847      force it into alias set 0.
1848      This is too conservative, but we cannot call record_component_aliases
1849      here because some frontends still change the aggregates after
1850      layout_type.  */
1851   if (AGGREGATE_TYPE_P (type) && TYPE_ALIAS_SET_KNOWN_P (type))
1852     TYPE_ALIAS_SET (type) = 0;
1853 }
1854 \f
1855 /* Create and return a type for signed integers of PRECISION bits.  */
1856
1857 tree
1858 make_signed_type (int precision)
1859 {
1860   tree type = make_node (INTEGER_TYPE);
1861
1862   TYPE_PRECISION (type) = precision;
1863
1864   fixup_signed_type (type);
1865   return type;
1866 }
1867
1868 /* Create and return a type for unsigned integers of PRECISION bits.  */
1869
1870 tree
1871 make_unsigned_type (int precision)
1872 {
1873   tree type = make_node (INTEGER_TYPE);
1874
1875   TYPE_PRECISION (type) = precision;
1876
1877   fixup_unsigned_type (type);
1878   return type;
1879 }
1880 \f
1881 /* Initialize sizetype and bitsizetype to a reasonable and temporary
1882    value to enable integer types to be created.  */
1883
1884 void
1885 initialize_sizetypes (bool signed_p)
1886 {
1887   tree t = make_node (INTEGER_TYPE);
1888   int precision = GET_MODE_BITSIZE (SImode);
1889
1890   TYPE_MODE (t) = SImode;
1891   TYPE_ALIGN (t) = GET_MODE_ALIGNMENT (SImode);
1892   TYPE_USER_ALIGN (t) = 0;
1893   TYPE_IS_SIZETYPE (t) = 1;
1894   TYPE_UNSIGNED (t) = !signed_p;
1895   TYPE_SIZE (t) = build_int_cst (t, precision);
1896   TYPE_SIZE_UNIT (t) = build_int_cst (t, GET_MODE_SIZE (SImode));
1897   TYPE_PRECISION (t) = precision;
1898
1899   /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE.  */
1900   set_min_and_max_values_for_integral_type (t, precision, !signed_p);
1901
1902   sizetype = t;
1903   bitsizetype = build_distinct_type_copy (t);
1904 }
1905
1906 /* Make sizetype a version of TYPE, and initialize *sizetype
1907    accordingly.  We do this by overwriting the stub sizetype and
1908    bitsizetype nodes created by initialize_sizetypes.  This makes sure
1909    that (a) anything stubby about them no longer exists, (b) any
1910    INTEGER_CSTs created with such a type, remain valid.  */
1911
1912 void
1913 set_sizetype (tree type)
1914 {
1915   int oprecision = TYPE_PRECISION (type);
1916   /* The *bitsizetype types use a precision that avoids overflows when
1917      calculating signed sizes / offsets in bits.  However, when
1918      cross-compiling from a 32 bit to a 64 bit host, we are limited to 64 bit
1919      precision.  */
1920   int precision = MIN (oprecision + BITS_PER_UNIT_LOG + 1,
1921                        2 * HOST_BITS_PER_WIDE_INT);
1922   tree t;
1923
1924   gcc_assert (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (sizetype));
1925
1926   t = build_distinct_type_copy (type);
1927   /* We do want to use sizetype's cache, as we will be replacing that
1928      type.  */
1929   TYPE_CACHED_VALUES (t) = TYPE_CACHED_VALUES (sizetype);
1930   TYPE_CACHED_VALUES_P (t) = TYPE_CACHED_VALUES_P (sizetype);
1931   TREE_TYPE (TYPE_CACHED_VALUES (t)) = type;
1932   TYPE_UID (t) = TYPE_UID (sizetype);
1933   TYPE_IS_SIZETYPE (t) = 1;
1934
1935   /* Replace our original stub sizetype.  */
1936   memcpy (sizetype, t, tree_size (sizetype));
1937   TYPE_MAIN_VARIANT (sizetype) = sizetype;
1938
1939   t = make_node (INTEGER_TYPE);
1940   TYPE_NAME (t) = get_identifier ("bit_size_type");
1941   /* We do want to use bitsizetype's cache, as we will be replacing that
1942      type.  */
1943   TYPE_CACHED_VALUES (t) = TYPE_CACHED_VALUES (bitsizetype);
1944   TYPE_CACHED_VALUES_P (t) = TYPE_CACHED_VALUES_P (bitsizetype);
1945   TYPE_PRECISION (t) = precision;
1946   TYPE_UID (t) = TYPE_UID (bitsizetype);
1947   TYPE_IS_SIZETYPE (t) = 1;
1948
1949   /* Replace our original stub bitsizetype.  */
1950   memcpy (bitsizetype, t, tree_size (bitsizetype));
1951   TYPE_MAIN_VARIANT (bitsizetype) = bitsizetype;
1952
1953   if (TYPE_UNSIGNED (type))
1954     {
1955       fixup_unsigned_type (bitsizetype);
1956       ssizetype = build_distinct_type_copy (make_signed_type (oprecision));
1957       TYPE_IS_SIZETYPE (ssizetype) = 1;
1958       sbitsizetype = build_distinct_type_copy (make_signed_type (precision));
1959       TYPE_IS_SIZETYPE (sbitsizetype) = 1;
1960     }
1961   else
1962     {
1963       fixup_signed_type (bitsizetype);
1964       ssizetype = sizetype;
1965       sbitsizetype = bitsizetype;
1966     }
1967
1968   /* If SIZETYPE is unsigned, we need to fix TYPE_MAX_VALUE so that
1969      it is sign extended in a way consistent with force_fit_type.  */
1970   if (TYPE_UNSIGNED (type))
1971     {
1972       tree orig_max, new_max;
1973
1974       orig_max = TYPE_MAX_VALUE (sizetype);
1975
1976       /* Build a new node with the same values, but a different type.  */
1977       new_max = build_int_cst_wide (sizetype,
1978                                     TREE_INT_CST_LOW (orig_max),
1979                                     TREE_INT_CST_HIGH (orig_max));
1980
1981       /* Now sign extend it using force_fit_type to ensure
1982          consistency.  */
1983       new_max = force_fit_type (new_max, 0, 0, 0);
1984       TYPE_MAX_VALUE (sizetype) = new_max;
1985     }
1986 }
1987 \f
1988 /* TYPE is an integral type, i.e., an INTEGRAL_TYPE, ENUMERAL_TYPE
1989    or BOOLEAN_TYPE.  Set TYPE_MIN_VALUE and TYPE_MAX_VALUE
1990    for TYPE, based on the PRECISION and whether or not the TYPE
1991    IS_UNSIGNED.  PRECISION need not correspond to a width supported
1992    natively by the hardware; for example, on a machine with 8-bit,
1993    16-bit, and 32-bit register modes, PRECISION might be 7, 23, or
1994    61.  */
1995
1996 void
1997 set_min_and_max_values_for_integral_type (tree type,
1998                                           int precision,
1999                                           bool is_unsigned)
2000 {
2001   tree min_value;
2002   tree max_value;
2003
2004   if (is_unsigned)
2005     {
2006       min_value = build_int_cst (type, 0);
2007       max_value
2008         = build_int_cst_wide (type, precision - HOST_BITS_PER_WIDE_INT >= 0
2009                               ? -1
2010                               : ((HOST_WIDE_INT) 1 << precision) - 1,
2011                               precision - HOST_BITS_PER_WIDE_INT > 0
2012                               ? ((unsigned HOST_WIDE_INT) ~0
2013                                  >> (HOST_BITS_PER_WIDE_INT
2014                                      - (precision - HOST_BITS_PER_WIDE_INT)))
2015                               : 0);
2016     }
2017   else
2018     {
2019       min_value
2020         = build_int_cst_wide (type,
2021                               (precision - HOST_BITS_PER_WIDE_INT > 0
2022                                ? 0
2023                                : (HOST_WIDE_INT) (-1) << (precision - 1)),
2024                               (((HOST_WIDE_INT) (-1)
2025                                 << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
2026                                     ? precision - HOST_BITS_PER_WIDE_INT - 1
2027                                     : 0))));
2028       max_value
2029         = build_int_cst_wide (type,
2030                               (precision - HOST_BITS_PER_WIDE_INT > 0
2031                                ? -1
2032                                : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1),
2033                               (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
2034                                ? (((HOST_WIDE_INT) 1
2035                                    << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1
2036                                : 0));
2037     }
2038
2039   TYPE_MIN_VALUE (type) = min_value;
2040   TYPE_MAX_VALUE (type) = max_value;
2041 }
2042
2043 /* Set the extreme values of TYPE based on its precision in bits,
2044    then lay it out.  Used when make_signed_type won't do
2045    because the tree code is not INTEGER_TYPE.
2046    E.g. for Pascal, when the -fsigned-char option is given.  */
2047
2048 void
2049 fixup_signed_type (tree type)
2050 {
2051   int precision = TYPE_PRECISION (type);
2052
2053   /* We can not represent properly constants greater then
2054      2 * HOST_BITS_PER_WIDE_INT, still we need the types
2055      as they are used by i386 vector extensions and friends.  */
2056   if (precision > HOST_BITS_PER_WIDE_INT * 2)
2057     precision = HOST_BITS_PER_WIDE_INT * 2;
2058
2059   set_min_and_max_values_for_integral_type (type, precision,
2060                                             /*is_unsigned=*/false);
2061
2062   /* Lay out the type: set its alignment, size, etc.  */
2063   layout_type (type);
2064 }
2065
2066 /* Set the extreme values of TYPE based on its precision in bits,
2067    then lay it out.  This is used both in `make_unsigned_type'
2068    and for enumeral types.  */
2069
2070 void
2071 fixup_unsigned_type (tree type)
2072 {
2073   int precision = TYPE_PRECISION (type);
2074
2075   /* We can not represent properly constants greater then
2076      2 * HOST_BITS_PER_WIDE_INT, still we need the types
2077      as they are used by i386 vector extensions and friends.  */
2078   if (precision > HOST_BITS_PER_WIDE_INT * 2)
2079     precision = HOST_BITS_PER_WIDE_INT * 2;
2080
2081   TYPE_UNSIGNED (type) = 1;
2082
2083   set_min_and_max_values_for_integral_type (type, precision,
2084                                             /*is_unsigned=*/true);
2085
2086   /* Lay out the type: set its alignment, size, etc.  */
2087   layout_type (type);
2088 }
2089 \f
2090 /* Find the best machine mode to use when referencing a bit field of length
2091    BITSIZE bits starting at BITPOS.
2092
2093    The underlying object is known to be aligned to a boundary of ALIGN bits.
2094    If LARGEST_MODE is not VOIDmode, it means that we should not use a mode
2095    larger than LARGEST_MODE (usually SImode).
2096
2097    If no mode meets all these conditions, we return VOIDmode.
2098
2099    If VOLATILEP is false and SLOW_BYTE_ACCESS is false, we return the
2100    smallest mode meeting these conditions.
2101
2102    If VOLATILEP is false and SLOW_BYTE_ACCESS is true, we return the
2103    largest mode (but a mode no wider than UNITS_PER_WORD) that meets
2104    all the conditions.
2105
2106    If VOLATILEP is true the narrow_volatile_bitfields target hook is used to
2107    decide which of the above modes should be used.  */
2108
2109 enum machine_mode
2110 get_best_mode (int bitsize, int bitpos, unsigned int align,
2111                enum machine_mode largest_mode, int volatilep)
2112 {
2113   enum machine_mode mode;
2114   unsigned int unit = 0;
2115
2116   /* Find the narrowest integer mode that contains the bit field.  */
2117   for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
2118        mode = GET_MODE_WIDER_MODE (mode))
2119     {
2120       unit = GET_MODE_BITSIZE (mode);
2121       if ((bitpos % unit) + bitsize <= unit)
2122         break;
2123     }
2124
2125   if (mode == VOIDmode
2126       /* It is tempting to omit the following line
2127          if STRICT_ALIGNMENT is true.
2128          But that is incorrect, since if the bitfield uses part of 3 bytes
2129          and we use a 4-byte mode, we could get a spurious segv
2130          if the extra 4th byte is past the end of memory.
2131          (Though at least one Unix compiler ignores this problem:
2132          that on the Sequent 386 machine.  */
2133       || MIN (unit, BIGGEST_ALIGNMENT) > align
2134       || (largest_mode != VOIDmode && unit > GET_MODE_BITSIZE (largest_mode)))
2135     return VOIDmode;
2136
2137   if ((SLOW_BYTE_ACCESS && ! volatilep)
2138       || (volatilep && !targetm.narrow_volatile_bitfield()))
2139     {
2140       enum machine_mode wide_mode = VOIDmode, tmode;
2141
2142       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT); tmode != VOIDmode;
2143            tmode = GET_MODE_WIDER_MODE (tmode))
2144         {
2145           unit = GET_MODE_BITSIZE (tmode);
2146           if (bitpos / unit == (bitpos + bitsize - 1) / unit
2147               && unit <= BITS_PER_WORD
2148               && unit <= MIN (align, BIGGEST_ALIGNMENT)
2149               && (largest_mode == VOIDmode
2150                   || unit <= GET_MODE_BITSIZE (largest_mode)))
2151             wide_mode = tmode;
2152         }
2153
2154       if (wide_mode != VOIDmode)
2155         return wide_mode;
2156     }
2157
2158   return mode;
2159 }
2160
2161 /* Gets minimal and maximal values for MODE (signed or unsigned depending on
2162    SIGN).  The returned constants are made to be usable in TARGET_MODE.  */
2163
2164 void
2165 get_mode_bounds (enum machine_mode mode, int sign,
2166                  enum machine_mode target_mode,
2167                  rtx *mmin, rtx *mmax)
2168 {
2169   unsigned size = GET_MODE_BITSIZE (mode);
2170   unsigned HOST_WIDE_INT min_val, max_val;
2171
2172   gcc_assert (size <= HOST_BITS_PER_WIDE_INT);
2173
2174   if (sign)
2175     {
2176       min_val = -((unsigned HOST_WIDE_INT) 1 << (size - 1));
2177       max_val = ((unsigned HOST_WIDE_INT) 1 << (size - 1)) - 1;
2178     }
2179   else
2180     {
2181       min_val = 0;
2182       max_val = ((unsigned HOST_WIDE_INT) 1 << (size - 1) << 1) - 1;
2183     }
2184
2185   *mmin = gen_int_mode (min_val, target_mode);
2186   *mmax = gen_int_mode (max_val, target_mode);
2187 }
2188
2189 #include "gt-stor-layout.h"