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