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