gcc/stor-layout.c

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