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