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, DECL_ALIGN (field));
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 #ifdef ROUND_TYPE_SIZE
1283   TYPE_SIZE (rli->t) = ROUND_TYPE_SIZE (rli->t, unpadded_size,
1284                                         TYPE_ALIGN (rli->t));
1285   TYPE_SIZE_UNIT (rli->t)
1286     = ROUND_TYPE_SIZE_UNIT (rli->t, unpadded_size_unit,
1287                             TYPE_ALIGN (rli->t) / BITS_PER_UNIT);
1288 #else
1289   TYPE_SIZE (rli->t) = round_up (unpadded_size, TYPE_ALIGN (rli->t));
1290   TYPE_SIZE_UNIT (rli->t) = round_up (unpadded_size_unit,
1291                                       TYPE_ALIGN (rli->t) / BITS_PER_UNIT);
1292 #endif
1293
1294   if (warn_padded && TREE_CONSTANT (unpadded_size)
1295       && simple_cst_equal (unpadded_size, TYPE_SIZE (rli->t)) == 0)
1296     warning ("padding struct size to alignment boundary");
1297
1298   if (warn_packed && TREE_CODE (rli->t) == RECORD_TYPE
1299       && TYPE_PACKED (rli->t) && ! rli->packed_maybe_necessary
1300       && TREE_CONSTANT (unpadded_size))
1301     {
1302       tree unpacked_size;
1303
1304 #ifdef ROUND_TYPE_ALIGN
1305       rli->unpacked_align
1306         = ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t), rli->unpacked_align);
1307 #else
1308       rli->unpacked_align = MAX (TYPE_ALIGN (rli->t), rli->unpacked_align);
1309 #endif
1310
1311 #ifdef ROUND_TYPE_SIZE
1312       unpacked_size = ROUND_TYPE_SIZE (rli->t, TYPE_SIZE (rli->t),
1313                                        rli->unpacked_align);
1314 #else
1315       unpacked_size = round_up (TYPE_SIZE (rli->t), rli->unpacked_align);
1316 #endif
1317
1318       if (simple_cst_equal (unpacked_size, TYPE_SIZE (rli->t)))
1319         {
1320           TYPE_PACKED (rli->t) = 0;
1321
1322           if (TYPE_NAME (rli->t))
1323             {
1324               const char *name;
1325
1326               if (TREE_CODE (TYPE_NAME (rli->t)) == IDENTIFIER_NODE)
1327                 name = IDENTIFIER_POINTER (TYPE_NAME (rli->t));
1328               else
1329                 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (rli->t)));
1330
1331               if (STRICT_ALIGNMENT)
1332                 warning ("packed attribute causes inefficient alignment for `%s'", name);
1333               else
1334                 warning ("packed attribute is unnecessary for `%s'", name);
1335             }
1336           else
1337             {
1338               if (STRICT_ALIGNMENT)
1339                 warning ("packed attribute causes inefficient alignment");
1340               else
1341                 warning ("packed attribute is unnecessary");
1342             }
1343         }
1344     }
1345 }
1346
1347 /* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE).  */
1348
1349 void
1350 compute_record_mode (type)
1351      tree type;
1352 {
1353   tree field;
1354   enum machine_mode mode = VOIDmode;
1355
1356   /* Most RECORD_TYPEs have BLKmode, so we start off assuming that.
1357      However, if possible, we use a mode that fits in a register
1358      instead, in order to allow for better optimization down the
1359      line.  */
1360   TYPE_MODE (type) = BLKmode;
1361
1362   if (! host_integerp (TYPE_SIZE (type), 1))
1363     return;
1364
1365   /* A record which has any BLKmode members must itself be
1366      BLKmode; it can't go in a register.  Unless the member is
1367      BLKmode only because it isn't aligned.  */
1368   for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1369     {
1370       unsigned HOST_WIDE_INT bitpos;
1371
1372       if (TREE_CODE (field) != FIELD_DECL)
1373         continue;
1374
1375       if (TREE_CODE (TREE_TYPE (field)) == ERROR_MARK
1376           || (TYPE_MODE (TREE_TYPE (field)) == BLKmode
1377               && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field)))
1378           || ! host_integerp (bit_position (field), 1)
1379           || DECL_SIZE (field) == 0
1380           || ! host_integerp (DECL_SIZE (field), 1))
1381         return;
1382
1383       bitpos = int_bit_position (field);
1384
1385       /* Must be BLKmode if any field crosses a word boundary,
1386          since extract_bit_field can't handle that in registers.  */
1387       if (bitpos / BITS_PER_WORD
1388           != ((tree_low_cst (DECL_SIZE (field), 1) + bitpos - 1)
1389               / BITS_PER_WORD)
1390           /* But there is no problem if the field is entire words.  */
1391           && tree_low_cst (DECL_SIZE (field), 1) % BITS_PER_WORD != 0)
1392         return;
1393
1394       /* If this field is the whole struct, remember its mode so
1395          that, say, we can put a double in a class into a DF
1396          register instead of forcing it to live in the stack.  */
1397       if (simple_cst_equal (TYPE_SIZE (type), DECL_SIZE (field)))
1398         mode = DECL_MODE (field);
1399
1400 #ifdef MEMBER_TYPE_FORCES_BLK
1401       /* With some targets, eg. c4x, it is sub-optimal
1402          to access an aligned BLKmode structure as a scalar.  */
1403
1404       if (MEMBER_TYPE_FORCES_BLK (field, mode))
1405         return;
1406 #endif /* MEMBER_TYPE_FORCES_BLK  */
1407     }
1408
1409   /* If we only have one real field; use its mode.  This only applies to
1410      RECORD_TYPE.  This does not apply to unions.  */
1411   if (TREE_CODE (type) == RECORD_TYPE && mode != VOIDmode)
1412     TYPE_MODE (type) = mode;
1413   else
1414     TYPE_MODE (type) = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1);
1415
1416   /* If structure's known alignment is less than what the scalar
1417      mode would need, and it matters, then stick with BLKmode.  */
1418   if (TYPE_MODE (type) != BLKmode
1419       && STRICT_ALIGNMENT
1420       && ! (TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT
1421             || TYPE_ALIGN (type) >= GET_MODE_ALIGNMENT (TYPE_MODE (type))))
1422     {
1423       /* If this is the only reason this type is BLKmode, then
1424          don't force containing types to be BLKmode.  */
1425       TYPE_NO_FORCE_BLK (type) = 1;
1426       TYPE_MODE (type) = BLKmode;
1427     }
1428 }
1429
1430 /* Compute TYPE_SIZE and TYPE_ALIGN for TYPE, once it has been laid
1431    out.  */
1432
1433 static void
1434 finalize_type_size (type)
1435      tree type;
1436 {
1437   /* Normally, use the alignment corresponding to the mode chosen.
1438      However, where strict alignment is not required, avoid
1439      over-aligning structures, since most compilers do not do this
1440      alignment.  */
1441
1442   if (TYPE_MODE (type) != BLKmode && TYPE_MODE (type) != VOIDmode
1443       && (STRICT_ALIGNMENT
1444           || (TREE_CODE (type) != RECORD_TYPE && TREE_CODE (type) != UNION_TYPE
1445               && TREE_CODE (type) != QUAL_UNION_TYPE
1446               && TREE_CODE (type) != ARRAY_TYPE)))
1447     {
1448       TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type));
1449       TYPE_USER_ALIGN (type) = 0;
1450     }
1451
1452   /* Do machine-dependent extra alignment.  */
1453 #ifdef ROUND_TYPE_ALIGN
1454   TYPE_ALIGN (type)
1455     = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (type), BITS_PER_UNIT);
1456 #endif
1457
1458   /* If we failed to find a simple way to calculate the unit size
1459      of the type, find it by division.  */
1460   if (TYPE_SIZE_UNIT (type) == 0 && TYPE_SIZE (type) != 0)
1461     /* TYPE_SIZE (type) is computed in bitsizetype.  After the division, the
1462        result will fit in sizetype.  We will get more efficient code using
1463        sizetype, so we force a conversion.  */
1464     TYPE_SIZE_UNIT (type)
1465       = convert (sizetype,
1466                  size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (type),
1467                              bitsize_unit_node));
1468
1469   if (TYPE_SIZE (type) != 0)
1470     {
1471 #ifdef ROUND_TYPE_SIZE
1472       TYPE_SIZE (type)
1473         = ROUND_TYPE_SIZE (type, TYPE_SIZE (type), TYPE_ALIGN (type));
1474       TYPE_SIZE_UNIT (type)
1475         = ROUND_TYPE_SIZE_UNIT (type, TYPE_SIZE_UNIT (type),
1476                                 TYPE_ALIGN (type) / BITS_PER_UNIT);
1477 #else
1478       TYPE_SIZE (type) = round_up (TYPE_SIZE (type), TYPE_ALIGN (type));
1479       TYPE_SIZE_UNIT (type)
1480         = round_up (TYPE_SIZE_UNIT (type), TYPE_ALIGN (type) / BITS_PER_UNIT);
1481 #endif
1482     }
1483
1484   /* Evaluate nonconstant sizes only once, either now or as soon as safe.  */
1485   if (TYPE_SIZE (type) != 0 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1486     TYPE_SIZE (type) = variable_size (TYPE_SIZE (type));
1487   if (TYPE_SIZE_UNIT (type) != 0
1488       && TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST)
1489     TYPE_SIZE_UNIT (type) = variable_size (TYPE_SIZE_UNIT (type));
1490
1491   /* Also layout any other variants of the type.  */
1492   if (TYPE_NEXT_VARIANT (type)
1493       || type != TYPE_MAIN_VARIANT (type))
1494     {
1495       tree variant;
1496       /* Record layout info of this variant.  */
1497       tree size = TYPE_SIZE (type);
1498       tree size_unit = TYPE_SIZE_UNIT (type);
1499       unsigned int align = TYPE_ALIGN (type);
1500       unsigned int user_align = TYPE_USER_ALIGN (type);
1501       enum machine_mode mode = TYPE_MODE (type);
1502
1503       /* Copy it into all variants.  */
1504       for (variant = TYPE_MAIN_VARIANT (type);
1505            variant != 0;
1506            variant = TYPE_NEXT_VARIANT (variant))
1507         {
1508           TYPE_SIZE (variant) = size;
1509           TYPE_SIZE_UNIT (variant) = size_unit;
1510           TYPE_ALIGN (variant) = align;
1511           TYPE_USER_ALIGN (variant) = user_align;
1512           TYPE_MODE (variant) = mode;
1513         }
1514     }
1515 }
1516
1517 /* Do all of the work required to layout the type indicated by RLI,
1518    once the fields have been laid out.  This function will call `free'
1519    for RLI, unless FREE_P is false.  Passing a value other than false
1520    for FREE_P is bad practice; this option only exists to support the
1521    G++ 3.2 ABI.  */
1522
1523 void
1524 finish_record_layout (rli, free_p)
1525      record_layout_info rli;
1526      int free_p;
1527 {
1528   /* Compute the final size.  */
1529   finalize_record_size (rli);
1530
1531   /* Compute the TYPE_MODE for the record.  */
1532   compute_record_mode (rli->t);
1533
1534   /* Perform any last tweaks to the TYPE_SIZE, etc.  */
1535   finalize_type_size (rli->t);
1536
1537   /* Lay out any static members.  This is done now because their type
1538      may use the record's type.  */
1539   while (rli->pending_statics)
1540     {
1541       layout_decl (TREE_VALUE (rli->pending_statics), 0);
1542       rli->pending_statics = TREE_CHAIN (rli->pending_statics);
1543     }
1544
1545   /* Clean up.  */
1546   if (free_p)
1547     free (rli);
1548 }
1549 \f
1550
1551 /* Finish processing a builtin RECORD_TYPE type TYPE.  It's name is
1552    NAME, its fields are chained in reverse on FIELDS.
1553
1554    If ALIGN_TYPE is non-null, it is given the same alignment as
1555    ALIGN_TYPE.  */
1556
1557 void
1558 finish_builtin_struct (type, name, fields, align_type)
1559      tree type;
1560      const char *name;
1561      tree fields;
1562      tree align_type;
1563 {
1564   tree tail, next;
1565
1566   for (tail = NULL_TREE; fields; tail = fields, fields = next)
1567     {
1568       DECL_FIELD_CONTEXT (fields) = type;
1569       next = TREE_CHAIN (fields);
1570       TREE_CHAIN (fields) = tail;
1571     }
1572   TYPE_FIELDS (type) = tail;
1573
1574   if (align_type)
1575     {
1576       TYPE_ALIGN (type) = TYPE_ALIGN (align_type);
1577       TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (align_type);
1578     }
1579
1580   layout_type (type);
1581 #if 0 /* not yet, should get fixed properly later */
1582   TYPE_NAME (type) = make_type_decl (get_identifier (name), type);
1583 #else
1584   TYPE_NAME (type) = build_decl (TYPE_DECL, get_identifier (name), type);
1585 #endif
1586   TYPE_STUB_DECL (type) = TYPE_NAME (type);
1587   layout_decl (TYPE_NAME (type), 0);
1588 }
1589
1590 /* Calculate the mode, size, and alignment for TYPE.
1591    For an array type, calculate the element separation as well.
1592    Record TYPE on the chain of permanent or temporary types
1593    so that dbxout will find out about it.
1594
1595    TYPE_SIZE of a type is nonzero if the type has been laid out already.
1596    layout_type does nothing on such a type.
1597
1598    If the type is incomplete, its TYPE_SIZE remains zero.  */
1599
1600 void
1601 layout_type (type)
1602      tree type;
1603 {
1604   if (type == 0)
1605     abort ();
1606
1607   /* Do nothing if type has been laid out before.  */
1608   if (TYPE_SIZE (type))
1609     return;
1610
1611   switch (TREE_CODE (type))
1612     {
1613     case LANG_TYPE:
1614       /* This kind of type is the responsibility
1615          of the language-specific code.  */
1616       abort ();
1617
1618     case BOOLEAN_TYPE:  /* Used for Java, Pascal, and Chill.  */
1619       if (TYPE_PRECISION (type) == 0)
1620         TYPE_PRECISION (type) = 1; /* default to one byte/boolean.  */
1621
1622       /* ... fall through ...  */
1623
1624     case INTEGER_TYPE:
1625     case ENUMERAL_TYPE:
1626     case CHAR_TYPE:
1627       if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
1628           && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0)
1629         TREE_UNSIGNED (type) = 1;
1630
1631       TYPE_MODE (type) = smallest_mode_for_size (TYPE_PRECISION (type),
1632                                                  MODE_INT);
1633       TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
1634       TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
1635       break;
1636
1637     case REAL_TYPE:
1638       TYPE_MODE (type) = mode_for_size (TYPE_PRECISION (type), MODE_FLOAT, 0);
1639       TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
1640       TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
1641       break;
1642
1643     case COMPLEX_TYPE:
1644       TREE_UNSIGNED (type) = TREE_UNSIGNED (TREE_TYPE (type));
1645       TYPE_MODE (type)
1646         = mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type)),
1647                          (TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE
1648                           ? MODE_COMPLEX_INT : MODE_COMPLEX_FLOAT),
1649                          0);
1650       TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
1651       TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
1652       break;
1653
1654     case VECTOR_TYPE:
1655       {
1656         tree subtype;
1657
1658         subtype = TREE_TYPE (type);
1659         TREE_UNSIGNED (type) = TREE_UNSIGNED (subtype);
1660         TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
1661         TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
1662       }
1663       break;
1664
1665     case VOID_TYPE:
1666       /* This is an incomplete type and so doesn't have a size.  */
1667       TYPE_ALIGN (type) = 1;
1668       TYPE_USER_ALIGN (type) = 0;
1669       TYPE_MODE (type) = VOIDmode;
1670       break;
1671
1672     case OFFSET_TYPE:
1673       TYPE_SIZE (type) = bitsize_int (POINTER_SIZE);
1674       TYPE_SIZE_UNIT (type) = size_int (POINTER_SIZE / BITS_PER_UNIT);
1675       /* A pointer might be MODE_PARTIAL_INT,
1676          but ptrdiff_t must be integral.  */
1677       TYPE_MODE (type) = mode_for_size (POINTER_SIZE, MODE_INT, 0);
1678       break;
1679
1680     case FUNCTION_TYPE:
1681     case METHOD_TYPE:
1682       TYPE_MODE (type) = mode_for_size (2 * POINTER_SIZE, MODE_INT, 0);
1683       TYPE_SIZE (type) = bitsize_int (2 * POINTER_SIZE);
1684       TYPE_SIZE_UNIT (type) = size_int ((2 * POINTER_SIZE) / BITS_PER_UNIT);
1685       break;
1686
1687     case POINTER_TYPE:
1688     case REFERENCE_TYPE:
1689       {
1690
1691         enum machine_mode mode = ((TREE_CODE (type) == REFERENCE_TYPE
1692                                    && reference_types_internal)
1693                                   ? Pmode : TYPE_MODE (type));
1694
1695         int nbits = GET_MODE_BITSIZE (mode);
1696
1697         TYPE_SIZE (type) = bitsize_int (nbits);
1698         TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (mode));
1699         TREE_UNSIGNED (type) = 1;
1700         TYPE_PRECISION (type) = nbits;
1701       }
1702       break;
1703
1704     case ARRAY_TYPE:
1705       {
1706         tree index = TYPE_DOMAIN (type);
1707         tree element = TREE_TYPE (type);
1708
1709         build_pointer_type (element);
1710
1711         /* We need to know both bounds in order to compute the size.  */
1712         if (index && TYPE_MAX_VALUE (index) && TYPE_MIN_VALUE (index)
1713             && TYPE_SIZE (element))
1714           {
1715             tree ub = TYPE_MAX_VALUE (index);
1716             tree lb = TYPE_MIN_VALUE (index);
1717             tree length;
1718             tree element_size;
1719
1720             /* The initial subtraction should happen in the original type so
1721                that (possible) negative values are handled appropriately.  */
1722             length = size_binop (PLUS_EXPR, size_one_node,
1723                                  convert (sizetype,
1724                                           fold (build (MINUS_EXPR,
1725                                                        TREE_TYPE (lb),
1726                                                        ub, lb))));
1727
1728             /* Special handling for arrays of bits (for Chill).  */
1729             element_size = TYPE_SIZE (element);
1730             if (TYPE_PACKED (type) && INTEGRAL_TYPE_P (element)
1731                 && (integer_zerop (TYPE_MAX_VALUE (element))
1732                     || integer_onep (TYPE_MAX_VALUE (element)))
1733                 && host_integerp (TYPE_MIN_VALUE (element), 1))
1734               {
1735                 HOST_WIDE_INT maxvalue
1736                   = tree_low_cst (TYPE_MAX_VALUE (element), 1);
1737                 HOST_WIDE_INT minvalue
1738                   = tree_low_cst (TYPE_MIN_VALUE (element), 1);
1739
1740                 if (maxvalue - minvalue == 1
1741                     && (maxvalue == 1 || maxvalue == 0))
1742                   element_size = integer_one_node;
1743               }
1744
1745             /* If neither bound is a constant and sizetype is signed, make
1746                sure the size is never negative.  We should really do this
1747                if *either* bound is non-constant, but this is the best
1748                compromise between C and Ada.  */
1749             if (! TREE_UNSIGNED (sizetype)
1750                 && TREE_CODE (TYPE_MIN_VALUE (index)) != INTEGER_CST
1751                 && TREE_CODE (TYPE_MAX_VALUE (index)) != INTEGER_CST)
1752               length = size_binop (MAX_EXPR, length, size_zero_node);
1753
1754             TYPE_SIZE (type) = size_binop (MULT_EXPR, element_size,
1755                                            convert (bitsizetype, length));
1756
1757             /* If we know the size of the element, calculate the total
1758                size directly, rather than do some division thing below.
1759                This optimization helps Fortran assumed-size arrays
1760                (where the size of the array is determined at runtime)
1761                substantially.
1762                Note that we can't do this in the case where the size of
1763                the elements is one bit since TYPE_SIZE_UNIT cannot be
1764                set correctly in that case.  */
1765             if (TYPE_SIZE_UNIT (element) != 0 && ! integer_onep (element_size))
1766               TYPE_SIZE_UNIT (type)
1767                 = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (element), length);
1768           }
1769
1770         /* Now round the alignment and size,
1771            using machine-dependent criteria if any.  */
1772
1773 #ifdef ROUND_TYPE_ALIGN
1774         TYPE_ALIGN (type)
1775           = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (element), BITS_PER_UNIT);
1776 #else
1777         TYPE_ALIGN (type) = MAX (TYPE_ALIGN (element), BITS_PER_UNIT);
1778 #endif
1779         TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (element);
1780
1781 #ifdef ROUND_TYPE_SIZE
1782         if (TYPE_SIZE (type) != 0)
1783           {
1784             tree tmp
1785               = ROUND_TYPE_SIZE (type, TYPE_SIZE (type), TYPE_ALIGN (type));
1786
1787             /* If the rounding changed the size of the type, remove any
1788                pre-calculated TYPE_SIZE_UNIT.  */
1789             if (simple_cst_equal (TYPE_SIZE (type), tmp) != 1)
1790               TYPE_SIZE_UNIT (type) = NULL;
1791
1792             TYPE_SIZE (type) = tmp;
1793           }
1794 #endif
1795
1796         TYPE_MODE (type) = BLKmode;
1797         if (TYPE_SIZE (type) != 0
1798 #ifdef MEMBER_TYPE_FORCES_BLK
1799             && ! MEMBER_TYPE_FORCES_BLK (type, VOIDmode)
1800 #endif
1801             /* BLKmode elements force BLKmode aggregate;
1802                else extract/store fields may lose.  */
1803             && (TYPE_MODE (TREE_TYPE (type)) != BLKmode
1804                 || TYPE_NO_FORCE_BLK (TREE_TYPE (type))))
1805           {
1806             /* One-element arrays get the component type's mode.  */
1807             if (simple_cst_equal (TYPE_SIZE (type),
1808                                   TYPE_SIZE (TREE_TYPE (type))))
1809               TYPE_MODE (type) = TYPE_MODE (TREE_TYPE (type));
1810             else
1811               TYPE_MODE (type)
1812                 = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1);
1813
1814             if (TYPE_MODE (type) != BLKmode
1815                 && STRICT_ALIGNMENT && TYPE_ALIGN (type) < BIGGEST_ALIGNMENT
1816                 && TYPE_ALIGN (type) < GET_MODE_ALIGNMENT (TYPE_MODE (type))
1817                 && TYPE_MODE (type) != BLKmode)
1818               {
1819                 TYPE_NO_FORCE_BLK (type) = 1;
1820                 TYPE_MODE (type) = BLKmode;
1821               }
1822           }
1823         break;
1824       }
1825
1826     case RECORD_TYPE:
1827     case UNION_TYPE:
1828     case QUAL_UNION_TYPE:
1829       {
1830         tree field;
1831         record_layout_info rli;
1832
1833         /* Initialize the layout information.  */
1834         rli = start_record_layout (type);
1835
1836         /* If this is a QUAL_UNION_TYPE, we want to process the fields
1837            in the reverse order in building the COND_EXPR that denotes
1838            its size.  We reverse them again later.  */
1839         if (TREE_CODE (type) == QUAL_UNION_TYPE)
1840           TYPE_FIELDS (type) = nreverse (TYPE_FIELDS (type));
1841
1842         /* Place all the fields.  */
1843         for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1844           place_field (rli, field);
1845
1846         if (TREE_CODE (type) == QUAL_UNION_TYPE)
1847           TYPE_FIELDS (type) = nreverse (TYPE_FIELDS (type));
1848
1849         if (lang_adjust_rli)
1850           (*lang_adjust_rli) (rli);
1851
1852         /* Finish laying out the record.  */
1853         finish_record_layout (rli, /*free_p=*/true);
1854       }
1855       break;
1856
1857     case SET_TYPE:  /* Used by Chill and Pascal.  */
1858       if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST
1859           || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST)
1860         abort ();
1861       else
1862         {
1863 #ifndef SET_WORD_SIZE
1864 #define SET_WORD_SIZE BITS_PER_WORD
1865 #endif
1866           unsigned int alignment
1867             = set_alignment ? set_alignment : SET_WORD_SIZE;
1868           HOST_WIDE_INT size_in_bits
1869             = (tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0)
1870                - tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0) + 1);
1871           HOST_WIDE_INT rounded_size
1872             = ((size_in_bits + alignment - 1) / alignment) * alignment;
1873
1874           if (rounded_size > (int) alignment)
1875             TYPE_MODE (type) = BLKmode;
1876           else
1877             TYPE_MODE (type) = mode_for_size (alignment, MODE_INT, 1);
1878
1879           TYPE_SIZE (type) = bitsize_int (rounded_size);
1880           TYPE_SIZE_UNIT (type) = size_int (rounded_size / BITS_PER_UNIT);
1881           TYPE_ALIGN (type) = alignment;
1882           TYPE_USER_ALIGN (type) = 0;
1883           TYPE_PRECISION (type) = size_in_bits;
1884         }
1885       break;
1886
1887     case FILE_TYPE:
1888       /* The size may vary in different languages, so the language front end
1889          should fill in the size.  */
1890       TYPE_ALIGN (type) = BIGGEST_ALIGNMENT;
1891       TYPE_USER_ALIGN (type) = 0;
1892       TYPE_MODE  (type) = BLKmode;
1893       break;
1894
1895     default:
1896       abort ();
1897     }
1898
1899   /* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE.  For
1900      records and unions, finish_record_layout already called this
1901      function.  */
1902   if (TREE_CODE (type) != RECORD_TYPE
1903       && TREE_CODE (type) != UNION_TYPE
1904       && TREE_CODE (type) != QUAL_UNION_TYPE)
1905     finalize_type_size (type);
1906
1907   /* If this type is created before sizetype has been permanently set,
1908      record it so set_sizetype can fix it up.  */
1909   if (! sizetype_set)
1910     early_type_list = tree_cons (NULL_TREE, type, early_type_list);
1911
1912   /* If an alias set has been set for this aggregate when it was incomplete,
1913      force it into alias set 0.
1914      This is too conservative, but we cannot call record_component_aliases
1915      here because some frontends still change the aggregates after
1916      layout_type.  */
1917   if (AGGREGATE_TYPE_P (type) && TYPE_ALIAS_SET_KNOWN_P (type))
1918     TYPE_ALIAS_SET (type) = 0;
1919 }
1920 \f
1921 /* Create and return a type for signed integers of PRECISION bits.  */
1922
1923 tree
1924 make_signed_type (precision)
1925      int precision;
1926 {
1927   tree type = make_node (INTEGER_TYPE);
1928
1929   TYPE_PRECISION (type) = precision;
1930
1931   fixup_signed_type (type);
1932   return type;
1933 }
1934
1935 /* Create and return a type for unsigned integers of PRECISION bits.  */
1936
1937 tree
1938 make_unsigned_type (precision)
1939      int precision;
1940 {
1941   tree type = make_node (INTEGER_TYPE);
1942
1943   TYPE_PRECISION (type) = precision;
1944
1945   fixup_unsigned_type (type);
1946   return type;
1947 }
1948 \f
1949 /* Initialize sizetype and bitsizetype to a reasonable and temporary
1950    value to enable integer types to be created.  */
1951
1952 void
1953 initialize_sizetypes ()
1954 {
1955   tree t = make_node (INTEGER_TYPE);
1956
1957   /* Set this so we do something reasonable for the build_int_2 calls
1958      below.  */
1959   integer_type_node = t;
1960
1961   TYPE_MODE (t) = SImode;
1962   TYPE_ALIGN (t) = GET_MODE_ALIGNMENT (SImode);
1963   TYPE_USER_ALIGN (t) = 0;
1964   TYPE_SIZE (t) = build_int_2 (GET_MODE_BITSIZE (SImode), 0);
1965   TYPE_SIZE_UNIT (t) = build_int_2 (GET_MODE_SIZE (SImode), 0);
1966   TREE_UNSIGNED (t) = 1;
1967   TYPE_PRECISION (t) = GET_MODE_BITSIZE (SImode);
1968   TYPE_MIN_VALUE (t) = build_int_2 (0, 0);
1969   TYPE_IS_SIZETYPE (t) = 1;
1970
1971   /* 1000 avoids problems with possible overflow and is certainly
1972      larger than any size value we'd want to be storing.  */
1973   TYPE_MAX_VALUE (t) = build_int_2 (1000, 0);
1974
1975   /* These two must be different nodes because of the caching done in
1976      size_int_wide.  */
1977   sizetype = t;
1978   bitsizetype = copy_node (t);
1979   integer_type_node = 0;
1980 }
1981
1982 /* Set sizetype to TYPE, and initialize *sizetype accordingly.
1983    Also update the type of any standard type's sizes made so far.  */
1984
1985 void
1986 set_sizetype (type)
1987      tree type;
1988 {
1989   int oprecision = TYPE_PRECISION (type);
1990   /* The *bitsizetype types use a precision that avoids overflows when
1991      calculating signed sizes / offsets in bits.  However, when
1992      cross-compiling from a 32 bit to a 64 bit host, we are limited to 64 bit
1993      precision.  */
1994   int precision = MIN (oprecision + BITS_PER_UNIT_LOG + 1,
1995                        2 * HOST_BITS_PER_WIDE_INT);
1996   unsigned int i;
1997   tree t;
1998
1999   if (sizetype_set)
2000     abort ();
2001
2002   /* Make copies of nodes since we'll be setting TYPE_IS_SIZETYPE.  */
2003   sizetype = copy_node (type);
2004   TYPE_DOMAIN (sizetype) = type;
2005   TYPE_IS_SIZETYPE (sizetype) = 1;
2006   bitsizetype = make_node (INTEGER_TYPE);
2007   TYPE_NAME (bitsizetype) = TYPE_NAME (type);
2008   TYPE_PRECISION (bitsizetype) = precision;
2009   TYPE_IS_SIZETYPE (bitsizetype) = 1;
2010
2011   if (TREE_UNSIGNED (type))
2012     fixup_unsigned_type (bitsizetype);
2013   else
2014     fixup_signed_type (bitsizetype);
2015
2016   layout_type (bitsizetype);
2017
2018   if (TREE_UNSIGNED (type))
2019     {
2020       usizetype = sizetype;
2021       ubitsizetype = bitsizetype;
2022       ssizetype = copy_node (make_signed_type (oprecision));
2023       sbitsizetype = copy_node (make_signed_type (precision));
2024     }
2025   else
2026     {
2027       ssizetype = sizetype;
2028       sbitsizetype = bitsizetype;
2029       usizetype = copy_node (make_unsigned_type (oprecision));
2030       ubitsizetype = copy_node (make_unsigned_type (precision));
2031     }
2032
2033   TYPE_NAME (bitsizetype) = get_identifier ("bit_size_type");
2034
2035   /* Show is a sizetype, is a main type, and has no pointers to it.  */
2036   for (i = 0; i < ARRAY_SIZE (sizetype_tab); i++)
2037     {
2038       TYPE_IS_SIZETYPE (sizetype_tab[i]) = 1;
2039       TYPE_MAIN_VARIANT (sizetype_tab[i]) = sizetype_tab[i];
2040       TYPE_NEXT_VARIANT (sizetype_tab[i]) = 0;
2041       TYPE_POINTER_TO (sizetype_tab[i]) = 0;
2042       TYPE_REFERENCE_TO (sizetype_tab[i]) = 0;
2043     }
2044
2045   /* Go down each of the types we already made and set the proper type
2046      for the sizes in them.  */
2047   for (t = early_type_list; t != 0; t = TREE_CHAIN (t))
2048     {
2049       if (TREE_CODE (TREE_VALUE (t)) != INTEGER_TYPE)
2050         abort ();
2051
2052       TREE_TYPE (TYPE_SIZE (TREE_VALUE (t))) = bitsizetype;
2053       TREE_TYPE (TYPE_SIZE_UNIT (TREE_VALUE (t))) = sizetype;
2054     }
2055
2056   early_type_list = 0;
2057   sizetype_set = 1;
2058 }
2059 \f
2060 /* Set the extreme values of TYPE based on its precision in bits,
2061    then lay it out.  Used when make_signed_type won't do
2062    because the tree code is not INTEGER_TYPE.
2063    E.g. for Pascal, when the -fsigned-char option is given.  */
2064
2065 void
2066 fixup_signed_type (type)
2067      tree type;
2068 {
2069   int precision = TYPE_PRECISION (type);
2070
2071   /* We can not represent properly constants greater then
2072      2 * HOST_BITS_PER_WIDE_INT, still we need the types
2073      as they are used by i386 vector extensions and friends.  */
2074   if (precision > HOST_BITS_PER_WIDE_INT * 2)
2075     precision = HOST_BITS_PER_WIDE_INT * 2;
2076
2077   TYPE_MIN_VALUE (type)
2078     = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
2079                     ? 0 : (HOST_WIDE_INT) (-1) << (precision - 1)),
2080                    (((HOST_WIDE_INT) (-1)
2081                      << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
2082                          ? precision - HOST_BITS_PER_WIDE_INT - 1
2083                          : 0))));
2084   TYPE_MAX_VALUE (type)
2085     = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
2086                     ? -1 : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1),
2087                    (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
2088                     ? (((HOST_WIDE_INT) 1
2089                         << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1
2090                     : 0));
2091
2092   TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
2093   TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
2094
2095   /* Lay out the type: set its alignment, size, etc.  */
2096   layout_type (type);
2097 }
2098
2099 /* Set the extreme values of TYPE based on its precision in bits,
2100    then lay it out.  This is used both in `make_unsigned_type'
2101    and for enumeral types.  */
2102
2103 void
2104 fixup_unsigned_type (type)
2105      tree type;
2106 {
2107   int precision = TYPE_PRECISION (type);
2108
2109   /* We can not represent properly constants greater then
2110      2 * HOST_BITS_PER_WIDE_INT, still we need the types
2111      as they are used by i386 vector extensions and friends.  */
2112   if (precision > HOST_BITS_PER_WIDE_INT * 2)
2113     precision = HOST_BITS_PER_WIDE_INT * 2;
2114
2115   TYPE_MIN_VALUE (type) = build_int_2 (0, 0);
2116   TYPE_MAX_VALUE (type)
2117     = build_int_2 (precision - HOST_BITS_PER_WIDE_INT >= 0
2118                    ? -1 : ((HOST_WIDE_INT) 1 << precision) - 1,
2119                    precision - HOST_BITS_PER_WIDE_INT > 0
2120                    ? ((unsigned HOST_WIDE_INT) ~0
2121                       >> (HOST_BITS_PER_WIDE_INT
2122                           - (precision - HOST_BITS_PER_WIDE_INT)))
2123                    : 0);
2124   TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
2125   TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
2126
2127   /* Lay out the type: set its alignment, size, etc.  */
2128   layout_type (type);
2129 }
2130 \f
2131 /* Find the best machine mode to use when referencing a bit field of length
2132    BITSIZE bits starting at BITPOS.
2133
2134    The underlying object is known to be aligned to a boundary of ALIGN bits.
2135    If LARGEST_MODE is not VOIDmode, it means that we should not use a mode
2136    larger than LARGEST_MODE (usually SImode).
2137
2138    If no mode meets all these conditions, we return VOIDmode.  Otherwise, if
2139    VOLATILEP is true or SLOW_BYTE_ACCESS is false, we return the smallest
2140    mode meeting these conditions.
2141
2142    Otherwise (VOLATILEP is false and SLOW_BYTE_ACCESS is true), we return
2143    the largest mode (but a mode no wider than UNITS_PER_WORD) that meets
2144    all the conditions.  */
2145
2146 enum machine_mode
2147 get_best_mode (bitsize, bitpos, align, largest_mode, volatilep)
2148      int bitsize, bitpos;
2149      unsigned int align;
2150      enum machine_mode largest_mode;
2151      int volatilep;
2152 {
2153   enum machine_mode mode;
2154   unsigned int unit = 0;
2155
2156   /* Find the narrowest integer mode that contains the bit field.  */
2157   for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
2158        mode = GET_MODE_WIDER_MODE (mode))
2159     {
2160       unit = GET_MODE_BITSIZE (mode);
2161       if ((bitpos % unit) + bitsize <= unit)
2162         break;
2163     }
2164
2165   if (mode == VOIDmode
2166       /* It is tempting to omit the following line
2167          if STRICT_ALIGNMENT is true.
2168          But that is incorrect, since if the bitfield uses part of 3 bytes
2169          and we use a 4-byte mode, we could get a spurious segv
2170          if the extra 4th byte is past the end of memory.
2171          (Though at least one Unix compiler ignores this problem:
2172          that on the Sequent 386 machine.  */
2173       || MIN (unit, BIGGEST_ALIGNMENT) > align
2174       || (largest_mode != VOIDmode && unit > GET_MODE_BITSIZE (largest_mode)))
2175     return VOIDmode;
2176
2177   if (SLOW_BYTE_ACCESS && ! volatilep)
2178     {
2179       enum machine_mode wide_mode = VOIDmode, tmode;
2180
2181       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT); tmode != VOIDmode;
2182            tmode = GET_MODE_WIDER_MODE (tmode))
2183         {
2184           unit = GET_MODE_BITSIZE (tmode);
2185           if (bitpos / unit == (bitpos + bitsize - 1) / unit
2186               && unit <= BITS_PER_WORD
2187               && unit <= MIN (align, BIGGEST_ALIGNMENT)
2188               && (largest_mode == VOIDmode
2189                   || unit <= GET_MODE_BITSIZE (largest_mode)))
2190             wide_mode = tmode;
2191         }
2192
2193       if (wide_mode != VOIDmode)
2194         return wide_mode;
2195     }
2196
2197   return mode;
2198 }
2199
2200 #include "gt-stor-layout.h"