gcc/stor-layout.c

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