gcc/stor-layout.c

   1 /* C-compiler utilities for types and variables storage layout
   2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20
  21 #include "config.h"
  22 #include <stdio.h>
  23
  24 #include "tree.h"
  25 #include "flags.h"
  26 #include "function.h"
  27
  28 #define CEIL(x,y) (((x) + (y) - 1) / (y))
  29
  30 /* Data type for the expressions representing sizes of data types.
  31    It is the first integer type laid out.
  32    In C, this is int.  */
  33
  34 tree sizetype;
  35
  36 /* An integer constant with value 0 whose type is sizetype.  */
  37
  38 tree size_zero_node;
  39
  40 /* An integer constant with value 1 whose type is sizetype.  */
  41
  42 tree size_one_node;
  43
  44 /* If nonzero, this is an upper limit on alignment of structure fields.
  45    The value is measured in bits.  */
  46 int maximum_field_alignment;
  47
  48 /* If non-zero, the alignment of a bitsting or (power-)set value, in bits.
  49    May be overridden by front-ends.  */
  50 int set_alignment = 0;
  51
  52 #define GET_MODE_ALIGNMENT(MODE)   \
  53   MIN (BIGGEST_ALIGNMENT,          \
  54        MAX (1, (GET_MODE_UNIT_SIZE (MODE) * BITS_PER_UNIT)))
  55
  56 static enum machine_mode smallest_mode_for_size  PROTO((unsigned int,
  57                                                         enum mode_class));
  58 static tree layout_record       PROTO((tree));
  59 static void layout_union        PROTO((tree));
  60 \f
  61 /* SAVE_EXPRs for sizes of types and decls, waiting to be expanded.  */
  62
  63 static tree pending_sizes;
  64
  65 /* Nonzero means cannot safely call expand_expr now,
  66    so put variable sizes onto `pending_sizes' instead.  */
  67
  68 int immediate_size_expand;
  69
  70 tree
  71 get_pending_sizes ()
  72 {
  73   tree chain = pending_sizes;
  74   tree t;
  75
  76   /* Put each SAVE_EXPR into the current function.  */
  77   for (t = chain; t; t = TREE_CHAIN (t))
  78     SAVE_EXPR_CONTEXT (TREE_VALUE (t)) = current_function_decl;
  79   pending_sizes = 0;
  80   return chain;
  81 }
  82
  83 /* Given a size SIZE that isn't constant, return a SAVE_EXPR
  84    to serve as the actual size-expression for a type or decl.  */
  85
  86 tree
  87 variable_size (size)
  88      tree size;
  89 {
  90   /* If the language-processor is to take responsibility for variable-sized
  91      items (e.g., languages which have elaboration procedures like Ada),
  92      just return SIZE unchanged.  Likewise for self-referential sizes.  */
  93   if (global_bindings_p () < 0 || contains_placeholder_p (size))
  94     return size;
  95
  96   size = save_expr (size);
  97
  98   if (global_bindings_p ())
  99     {
 100       if (TREE_CONSTANT (size))
 101         error ("type size can't be explicitly evaluated");
 102       else
 103         error ("variable-size type declared outside of any function");
 104
 105       return size_int (1);
 106     }
 107
 108   if (immediate_size_expand)
 109     /* NULL_RTX is not defined; neither is the rtx type.
 110        Also, we would like to pass const0_rtx here, but don't have it.  */
 111     expand_expr (size, expand_expr (integer_zero_node, NULL_PTR, VOIDmode, 0),
 112                  VOIDmode, 0);
 113   else
 114     pending_sizes = tree_cons (NULL_TREE, size, pending_sizes);
 115
 116   return size;
 117 }
 118 \f
 119 #ifndef MAX_FIXED_MODE_SIZE
 120 #define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (DImode)
 121 #endif
 122
 123 /* Return the machine mode to use for a nonscalar of SIZE bits.
 124    The mode must be in class CLASS, and have exactly that many bits.
 125    If LIMIT is nonzero, modes of wider than MAX_FIXED_MODE_SIZE will not
 126    be used.  */
 127
 128 enum machine_mode
 129 mode_for_size (size, class, limit)
 130      unsigned int size;
 131      enum mode_class class;
 132      int limit;
 133 {
 134   register enum machine_mode mode;
 135
 136   if (limit && size > MAX_FIXED_MODE_SIZE)
 137     return BLKmode;
 138
 139   /* Get the first mode which has this size, in the specified class.  */
 140   for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode;
 141        mode = GET_MODE_WIDER_MODE (mode))
 142     if (GET_MODE_BITSIZE (mode) == size)
 143       return mode;
 144
 145   return BLKmode;
 146 }
 147
 148 /* Similar, but never return BLKmode; return the narrowest mode that
 149    contains at least the requested number of bits.  */
 150
 151 static enum machine_mode
 152 smallest_mode_for_size (size, class)
 153      unsigned int size;
 154      enum mode_class class;
 155 {
 156   register enum machine_mode mode;
 157
 158   /* Get the first mode which has at least this size, in the
 159      specified class.  */
 160   for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode;
 161        mode = GET_MODE_WIDER_MODE (mode))
 162     if (GET_MODE_BITSIZE (mode) >= size)
 163       return mode;
 164
 165   abort ();
 166 }
 167
 168 /* Return the value of VALUE, rounded up to a multiple of DIVISOR.  */
 169
 170 tree
 171 round_up (value, divisor)
 172      tree value;
 173      int divisor;
 174 {
 175   return size_binop (MULT_EXPR,
 176                      size_binop (CEIL_DIV_EXPR, value, size_int (divisor)),
 177                      size_int (divisor));
 178 }
 179 \f
 180 /* Set the size, mode and alignment of a ..._DECL node.
 181    TYPE_DECL does need this for C++.
 182    Note that LABEL_DECL and CONST_DECL nodes do not need this,
 183    and FUNCTION_DECL nodes have them set up in a special (and simple) way.
 184    Don't call layout_decl for them.
 185
 186    KNOWN_ALIGN is the amount of alignment we can assume this
 187    decl has with no special effort.  It is relevant only for FIELD_DECLs
 188    and depends on the previous fields.
 189    All that matters about KNOWN_ALIGN is which powers of 2 divide it.
 190    If KNOWN_ALIGN is 0, it means, "as much alignment as you like":
 191    the record will be aligned to suit.  */
 192
 193 void
 194 layout_decl (decl, known_align)
 195      tree decl;
 196      unsigned known_align;
 197 {
 198   register tree type = TREE_TYPE (decl);
 199   register enum tree_code code = TREE_CODE (decl);
 200   int spec_size = DECL_FIELD_SIZE (decl);
 201
 202   if (code == CONST_DECL)
 203     return;
 204
 205   if (code != VAR_DECL && code != PARM_DECL && code != RESULT_DECL
 206       && code != FIELD_DECL && code != TYPE_DECL)
 207     abort ();
 208
 209   if (type == error_mark_node)
 210     {
 211       type = void_type_node;
 212       spec_size = 0;
 213     }
 214
 215   /* Usually the size and mode come from the data type without change.  */
 216
 217   DECL_MODE (decl) = TYPE_MODE (type);
 218   TREE_UNSIGNED (decl) = TREE_UNSIGNED (type);
 219   if (DECL_SIZE (decl) == 0)
 220     DECL_SIZE (decl) = TYPE_SIZE (type);
 221
 222   if (code == FIELD_DECL && DECL_BIT_FIELD (decl))
 223     {
 224       if (spec_size == 0 && DECL_NAME (decl) != 0)
 225         abort ();
 226
 227       /* Size is specified number of bits.  */
 228       DECL_SIZE (decl) = size_int (spec_size);
 229     }
 230   /* Force alignment required for the data type.
 231      But if the decl itself wants greater alignment, don't override that.
 232      Likewise, if the decl is packed, don't override it.  */
 233   else if (DECL_ALIGN (decl) == 0
 234            || (! DECL_PACKED (decl) &&  TYPE_ALIGN (type) > DECL_ALIGN (decl)))
 235     DECL_ALIGN (decl) = TYPE_ALIGN (type);
 236
 237   /* See if we can use an ordinary integer mode for a bit-field.  */
 238   /* Conditions are: a fixed size that is correct for another mode
 239      and occupying a complete byte or bytes on proper boundary.  */
 240   if (code == FIELD_DECL)
 241     {
 242       DECL_BIT_FIELD_TYPE (decl) = DECL_BIT_FIELD (decl) ? type : 0;
 243       if (maximum_field_alignment != 0)
 244         DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), maximum_field_alignment);
 245       else if (flag_pack_struct)
 246         DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), BITS_PER_UNIT);
 247     }
 248
 249   if (DECL_BIT_FIELD (decl)
 250       && TYPE_SIZE (type) != 0
 251       && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
 252     {
 253       register enum machine_mode xmode
 254         = mode_for_size (TREE_INT_CST_LOW (DECL_SIZE (decl)), MODE_INT, 1);
 255
 256       if (xmode != BLKmode
 257           && known_align % GET_MODE_ALIGNMENT (xmode) == 0)
 258         {
 259           DECL_ALIGN (decl) = MAX (GET_MODE_ALIGNMENT (xmode),
 260                                    DECL_ALIGN (decl));
 261           DECL_MODE (decl) = xmode;
 262           DECL_SIZE (decl) = size_int (GET_MODE_BITSIZE (xmode));
 263           /* This no longer needs to be accessed as a bit field.  */
 264           DECL_BIT_FIELD (decl) = 0;
 265         }
 266     }
 267
 268   /* Evaluate nonconstant size only once, either now or as soon as safe.  */
 269   if (DECL_SIZE (decl) != 0 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
 270     DECL_SIZE (decl) = variable_size (DECL_SIZE (decl));
 271 }
 272 \f
 273 /* Lay out a RECORD_TYPE type (a C struct).
 274    This means laying out the fields, determining their positions,
 275    and computing the overall size and required alignment of the record.
 276    Note that if you set the TYPE_ALIGN before calling this
 277    then the struct is aligned to at least that boundary.
 278
 279    If the type has basetypes, you must call layout_basetypes
 280    before calling this function.
 281
 282    The return value is a list of static members of the record.
 283    They still need to be laid out.  */
 284
 285 static tree
 286 layout_record (rec)
 287      tree rec;
 288 {
 289   register tree field;
 290 #ifdef STRUCTURE_SIZE_BOUNDARY
 291   unsigned record_align = MAX (STRUCTURE_SIZE_BOUNDARY, TYPE_ALIGN (rec));
 292 #else
 293   unsigned record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (rec));
 294 #endif
 295   /* These must be laid out *after* the record is.  */
 296   tree pending_statics = NULL_TREE;
 297   /* Record size so far is CONST_SIZE + VAR_SIZE bits,
 298      where CONST_SIZE is an integer
 299      and VAR_SIZE is a tree expression.
 300      If VAR_SIZE is null, the size is just CONST_SIZE.
 301      Naturally we try to avoid using VAR_SIZE.  */
 302   register int const_size = 0;
 303   register tree var_size = 0;
 304   /* Once we start using VAR_SIZE, this is the maximum alignment
 305      that we know VAR_SIZE has.  */
 306   register int var_align = BITS_PER_UNIT;
 307
 308
 309   for (field = TYPE_FIELDS (rec); field; field = TREE_CHAIN (field))
 310     {
 311       register int known_align = var_size ? var_align : const_size;
 312       register int desired_align;
 313
 314       /* If FIELD is static, then treat it like a separate variable,
 315          not really like a structure field.
 316          If it is a FUNCTION_DECL, it's a method.
 317          In both cases, all we do is lay out the decl,
 318          and we do it *after* the record is laid out.  */
 319
 320       if (TREE_STATIC (field))
 321         {
 322           pending_statics = tree_cons (NULL_TREE, field, pending_statics);
 323           continue;
 324         }
 325       /* Enumerators and enum types which are local to this class need not
 326          be laid out.  Likewise for initialized constant fields.  */
 327       if (TREE_CODE (field) != FIELD_DECL)
 328         continue;
 329
 330       /* Lay out the field so we know what alignment it needs.
 331          For a packed field, use the alignment as specified,
 332          disregarding what the type would want.  */
 333       if (DECL_PACKED (field))
 334         desired_align = DECL_ALIGN (field);
 335       layout_decl (field, known_align);
 336       if (! DECL_PACKED (field))
 337         desired_align = DECL_ALIGN (field);
 338       /* Some targets (i.e. VMS) limit struct field alignment
 339          to a lower boundary than alignment of variables.  */
 340 #ifdef BIGGEST_FIELD_ALIGNMENT
 341       desired_align = MIN (desired_align, BIGGEST_FIELD_ALIGNMENT);
 342 #endif
 343
 344       /* Record must have at least as much alignment as any field.
 345          Otherwise, the alignment of the field within the record
 346          is meaningless.  */
 347
 348 #ifndef PCC_BITFIELD_TYPE_MATTERS
 349       record_align = MAX (record_align, desired_align);
 350 #else
 351       if (PCC_BITFIELD_TYPE_MATTERS && TREE_TYPE (field) != error_mark_node
 352           && DECL_BIT_FIELD_TYPE (field)
 353           && ! integer_zerop (TYPE_SIZE (TREE_TYPE (field))))
 354         {
 355           /* For these machines, a zero-length field does not
 356              affect the alignment of the structure as a whole.
 357              It does, however, affect the alignment of the next field
 358              within the structure.  */
 359           if (! integer_zerop (DECL_SIZE (field)))
 360             record_align = MAX (record_align, desired_align);
 361           else if (! DECL_PACKED (field))
 362             desired_align = TYPE_ALIGN (TREE_TYPE (field));
 363           /* A named bit field of declared type `int'
 364              forces the entire structure to have `int' alignment.  */
 365           if (DECL_NAME (field) != 0)
 366             {
 367               int type_align = TYPE_ALIGN (TREE_TYPE (field));
 368               if (maximum_field_alignment != 0)
 369                 type_align = MIN (type_align, maximum_field_alignment);
 370               else if (flag_pack_struct)
 371                 type_align = MIN (type_align, BITS_PER_UNIT);
 372
 373               record_align = MAX (record_align, type_align);
 374             }
 375         }
 376       else
 377         record_align = MAX (record_align, desired_align);
 378 #endif
 379
 380       /* Does this field automatically have alignment it needs
 381          by virtue of the fields that precede it and the record's
 382          own alignment?  */
 383
 384       if (const_size % desired_align != 0
 385           || (var_align % desired_align != 0
 386               && var_size != 0))
 387         {
 388           /* No, we need to skip space before this field.
 389              Bump the cumulative size to multiple of field alignment.  */
 390
 391           if (var_size == 0
 392               || var_align % desired_align == 0)
 393             const_size
 394               = CEIL (const_size, desired_align) * desired_align;
 395           else
 396             {
 397               if (const_size > 0)
 398                 var_size = size_binop (PLUS_EXPR, var_size,
 399                                        size_int (const_size));
 400               const_size = 0;
 401               var_size = round_up (var_size, desired_align);
 402               var_align = MIN (var_align, desired_align);
 403             }
 404         }
 405
 406 #ifdef PCC_BITFIELD_TYPE_MATTERS
 407       if (PCC_BITFIELD_TYPE_MATTERS
 408           && TREE_CODE (field) == FIELD_DECL
 409           && TREE_TYPE (field) != error_mark_node
 410           && DECL_BIT_FIELD_TYPE (field)
 411           && !DECL_PACKED (field)
 412           /* If #pragma pack is in effect, turn off this feature.  */
 413           && maximum_field_alignment == 0
 414           && !flag_pack_struct
 415           && !integer_zerop (DECL_SIZE (field)))
 416         {
 417           int type_align = TYPE_ALIGN (TREE_TYPE (field));
 418           register tree dsize = DECL_SIZE (field);
 419           int field_size = TREE_INT_CST_LOW (dsize);
 420
 421           /* A bit field may not span the unit of alignment of its type.
 422              Advance to next boundary if necessary.  */
 423           /* ??? There is some uncertainty here as to what
 424              should be done if type_align is less than the width of the type.
 425              That can happen because the width exceeds BIGGEST_ALIGNMENT
 426              or because it exceeds maximum_field_alignment.  */
 427           if (const_size / type_align
 428               != (const_size + field_size - 1) / type_align)
 429             const_size = CEIL (const_size, type_align) * type_align;
 430         }
 431 #endif
 432
 433 /* No existing machine description uses this parameter.
 434    So I have made it in this aspect identical to PCC_BITFIELD_TYPE_MATTERS.  */
 435 #ifdef BITFIELD_NBYTES_LIMITED
 436       if (BITFIELD_NBYTES_LIMITED
 437           && TREE_CODE (field) == FIELD_DECL
 438           && TREE_TYPE (field) != error_mark_node
 439           && DECL_BIT_FIELD_TYPE (field)
 440           && !DECL_PACKED (field)
 441           && !integer_zerop (DECL_SIZE (field)))
 442         {
 443           int type_align = TYPE_ALIGN (TREE_TYPE (field));
 444           register tree dsize = DECL_SIZE (field);
 445           int field_size = TREE_INT_CST_LOW (dsize);
 446
 447           if (maximum_field_alignment != 0)
 448             type_align = MIN (type_align, maximum_field_alignment);
 449           else if (flag_pack_struct)
 450             type_align = MIN (type_align, BITS_PER_UNIT);
 451
 452           /* A bit field may not span the unit of alignment of its type.
 453              Advance to next boundary if necessary.  */
 454           if (const_size / type_align
 455               != (const_size + field_size - 1) / type_align)
 456             const_size = CEIL (const_size, type_align) * type_align;
 457         }
 458 #endif
 459
 460       /* Size so far becomes the position of this field.  */
 461
 462       if (var_size && const_size)
 463         DECL_FIELD_BITPOS (field)
 464           = size_binop (PLUS_EXPR, var_size, size_int (const_size));
 465       else if (var_size)
 466         DECL_FIELD_BITPOS (field) = var_size;
 467       else
 468         {
 469           DECL_FIELD_BITPOS (field) = size_int (const_size);
 470
 471           /* If this field ended up more aligned than we thought it
 472              would be (we approximate this by seeing if its position
 473              changed), lay out the field again; perhaps we can use an
 474              integral mode for it now.  */
 475           if (known_align != const_size)
 476             layout_decl (field, const_size);
 477         }
 478
 479       /* Now add size of this field to the size of the record.  */
 480
 481       {
 482         register tree dsize = DECL_SIZE (field);
 483
 484         /* This can happen when we have an invalid nested struct definition,
 485            such as struct j { struct j { int i; } }.  The error message is
 486            printed in finish_struct.  */
 487         if (dsize == 0)
 488           /* Do nothing.  */;
 489         else if (TREE_CODE (dsize) == INTEGER_CST
 490                  && TREE_INT_CST_HIGH (dsize) == 0
 491                  && TREE_INT_CST_LOW (dsize) + const_size > const_size)
 492           /* Use const_size if there's no overflow.  */
 493           const_size += TREE_INT_CST_LOW (dsize);
 494         else
 495           {
 496             if (var_size == 0)
 497               var_size = dsize;
 498             else
 499               var_size = size_binop (PLUS_EXPR, var_size, dsize);
 500           }
 501       }
 502     }
 503
 504   /* Work out the total size and alignment of the record
 505      as one expression and store in the record type.
 506      Round it up to a multiple of the record's alignment.  */
 507
 508   if (var_size == 0)
 509     {
 510       TYPE_SIZE (rec) = size_int (const_size);
 511     }
 512   else
 513     {
 514       if (const_size)
 515         var_size
 516           = size_binop (PLUS_EXPR, var_size, size_int (const_size));
 517       TYPE_SIZE (rec) = var_size;
 518     }
 519
 520   /* Determine the desired alignment.  */
 521 #ifdef ROUND_TYPE_ALIGN
 522   TYPE_ALIGN (rec) = ROUND_TYPE_ALIGN (rec, TYPE_ALIGN (rec), record_align);
 523 #else
 524   TYPE_ALIGN (rec) = MAX (TYPE_ALIGN (rec), record_align);
 525 #endif
 526
 527 #ifdef ROUND_TYPE_SIZE
 528   TYPE_SIZE (rec) = ROUND_TYPE_SIZE (rec, TYPE_SIZE (rec), TYPE_ALIGN (rec));
 529 #else
 530   /* Round the size up to be a multiple of the required alignment */
 531   TYPE_SIZE (rec) = round_up (TYPE_SIZE (rec), TYPE_ALIGN (rec));
 532 #endif
 533
 534   return pending_statics;
 535 }
 536 \f
 537 /* Lay out a UNION_TYPE or QUAL_UNION_TYPE type.
 538    Lay out all the fields, set their positions to zero,
 539    and compute the size and alignment of the union (maximum of any field).
 540    Note that if you set the TYPE_ALIGN before calling this
 541    then the union align is aligned to at least that boundary.  */
 542
 543 static void
 544 layout_union (rec)
 545      tree rec;
 546 {
 547   register tree field;
 548 #ifdef STRUCTURE_SIZE_BOUNDARY
 549   unsigned union_align = STRUCTURE_SIZE_BOUNDARY;
 550 #else
 551   unsigned union_align = BITS_PER_UNIT;
 552 #endif
 553
 554   /* The size of the union, based on the fields scanned so far,
 555      is max (CONST_SIZE, VAR_SIZE).
 556      VAR_SIZE may be null; then CONST_SIZE by itself is the size.  */
 557   register int const_size = 0;
 558   register tree var_size = 0;
 559
 560   /* If this is a QUAL_UNION_TYPE, we want to process the fields in
 561      the reverse order in building the COND_EXPR that denotes its
 562      size.  We reverse them again later.  */
 563   if (TREE_CODE (rec) == QUAL_UNION_TYPE)
 564     TYPE_FIELDS (rec) = nreverse (TYPE_FIELDS (rec));
 565
 566   for (field = TYPE_FIELDS (rec); field; field = TREE_CHAIN (field))
 567     {
 568       /* Enums which are local to this class need not be laid out.  */
 569       if (TREE_CODE (field) == CONST_DECL || TREE_CODE (field) == TYPE_DECL)
 570         continue;
 571
 572       layout_decl (field, 0);
 573       DECL_FIELD_BITPOS (field) = size_int (0);
 574
 575       /* Union must be at least as aligned as any field requires.  */
 576
 577       union_align = MAX (union_align, DECL_ALIGN (field));
 578
 579 #ifdef PCC_BITFIELD_TYPE_MATTERS
 580       /* On the m88000, a bit field of declare type `int'
 581          forces the entire union to have `int' alignment.  */
 582       if (PCC_BITFIELD_TYPE_MATTERS && DECL_BIT_FIELD_TYPE (field))
 583         union_align = MAX (union_align, TYPE_ALIGN (TREE_TYPE (field)));
 584 #endif
 585
 586       if (TREE_CODE (rec) == UNION_TYPE)
 587         {
 588           /* Set union_size to max (decl_size, union_size).
 589              There are more and less general ways to do this.
 590              Use only CONST_SIZE unless forced to use VAR_SIZE.  */
 591
 592           if (TREE_CODE (DECL_SIZE (field)) == INTEGER_CST)
 593             const_size
 594               = MAX (const_size, TREE_INT_CST_LOW (DECL_SIZE (field)));
 595           else if (var_size == 0)
 596             var_size = DECL_SIZE (field);
 597           else
 598             var_size = size_binop (MAX_EXPR, var_size, DECL_SIZE (field));
 599         }
 600       else if (TREE_CODE (rec) == QUAL_UNION_TYPE)
 601         var_size = fold (build (COND_EXPR, sizetype, DECL_QUALIFIER (field),
 602                                 DECL_SIZE (field),
 603                                 var_size ? var_size : integer_zero_node));
 604       }
 605
 606   if (TREE_CODE (rec) == QUAL_UNION_TYPE)
 607     TYPE_FIELDS (rec) = nreverse (TYPE_FIELDS (rec));
 608
 609   /* Determine the ultimate size of the union (in bytes).  */
 610   if (NULL == var_size)
 611     TYPE_SIZE (rec) = size_int (CEIL (const_size, BITS_PER_UNIT)
 612                                 * BITS_PER_UNIT);
 613   else if (const_size == 0)
 614     TYPE_SIZE (rec) = var_size;
 615   else
 616     TYPE_SIZE (rec) = size_binop (MAX_EXPR, var_size,
 617                                   round_up (size_int (const_size),
 618                                             BITS_PER_UNIT));
 619
 620   /* Determine the desired alignment.  */
 621 #ifdef ROUND_TYPE_ALIGN
 622   TYPE_ALIGN (rec) = ROUND_TYPE_ALIGN (rec, TYPE_ALIGN (rec), union_align);
 623 #else
 624   TYPE_ALIGN (rec) = MAX (TYPE_ALIGN (rec), union_align);
 625 #endif
 626
 627 #ifdef ROUND_TYPE_SIZE
 628   TYPE_SIZE (rec) = ROUND_TYPE_SIZE (rec, TYPE_SIZE (rec), TYPE_ALIGN (rec));
 629 #else
 630   /* Round the size up to be a multiple of the required alignment */
 631   TYPE_SIZE (rec) = round_up (TYPE_SIZE (rec), TYPE_ALIGN (rec));
 632 #endif
 633 }
 634 \f
 635 /* Calculate the mode, size, and alignment for TYPE.
 636    For an array type, calculate the element separation as well.
 637    Record TYPE on the chain of permanent or temporary types
 638    so that dbxout will find out about it.
 639
 640    TYPE_SIZE of a type is nonzero if the type has been laid out already.
 641    layout_type does nothing on such a type.
 642
 643    If the type is incomplete, its TYPE_SIZE remains zero.  */
 644
 645 void
 646 layout_type (type)
 647      tree type;
 648 {
 649   int old;
 650   tree pending_statics;
 651
 652   if (type == 0)
 653     abort ();
 654
 655   /* Do nothing if type has been laid out before.  */
 656   if (TYPE_SIZE (type))
 657     return;
 658
 659   /* Make sure all nodes we allocate are not momentary;
 660      they must last past the current statement.  */
 661   old = suspend_momentary ();
 662
 663   /* Put all our nodes into the same obstack as the type.  Also,
 664      make expressions saveable (this is a no-op for permanent types).  */
 665
 666   push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type));
 667   saveable_allocation ();
 668
 669   switch (TREE_CODE (type))
 670     {
 671     case LANG_TYPE:
 672       /* This kind of type is the responsibility
 673          of the languge-specific code.  */
 674       abort ();
 675
 676     case INTEGER_TYPE:
 677     case ENUMERAL_TYPE:
 678       if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
 679           && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0)
 680         TREE_UNSIGNED (type) = 1;
 681
 682       TYPE_MODE (type) = smallest_mode_for_size (TYPE_PRECISION (type),
 683                                                  MODE_INT);
 684       TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
 685       break;
 686
 687     case REAL_TYPE:
 688       TYPE_MODE (type) = mode_for_size (TYPE_PRECISION (type), MODE_FLOAT, 0);
 689       TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
 690       break;
 691
 692     case COMPLEX_TYPE:
 693       TREE_UNSIGNED (type) = TREE_UNSIGNED (TREE_TYPE (type));
 694       TYPE_MODE (type)
 695         = mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type)),
 696                          (TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE
 697                           ? MODE_COMPLEX_INT : MODE_COMPLEX_FLOAT),
 698                          0);
 699       TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
 700       break;
 701
 702     case VOID_TYPE:
 703       TYPE_SIZE (type) = size_zero_node;
 704       TYPE_ALIGN (type) = 1;
 705       TYPE_MODE (type) = VOIDmode;
 706       break;
 707
 708     case OFFSET_TYPE:
 709       TYPE_SIZE (type) = size_int (POINTER_SIZE);
 710       TYPE_MODE (type) = ptr_mode;
 711       break;
 712
 713     case FUNCTION_TYPE:
 714     case METHOD_TYPE:
 715       TYPE_MODE (type) = mode_for_size (2 * POINTER_SIZE, MODE_INT, 0);
 716       TYPE_SIZE (type) = size_int (2 * POINTER_SIZE);
 717       break;
 718
 719     case POINTER_TYPE:
 720     case REFERENCE_TYPE:
 721       TYPE_MODE (type) = ptr_mode;
 722       TYPE_SIZE (type) = size_int (POINTER_SIZE);
 723       TREE_UNSIGNED (type) = 1;
 724       TYPE_PRECISION (type) = POINTER_SIZE;
 725       break;
 726
 727     case ARRAY_TYPE:
 728       {
 729         register tree index = TYPE_DOMAIN (type);
 730         register tree element = TREE_TYPE (type);
 731
 732         build_pointer_type (element);
 733
 734         /* We need to know both bounds in order to compute the size.  */
 735         if (index && TYPE_MAX_VALUE (index) && TYPE_MIN_VALUE (index)
 736             && TYPE_SIZE (element))
 737           {
 738             tree length
 739               = size_binop (PLUS_EXPR, size_one_node,
 740                             size_binop (MINUS_EXPR, TYPE_MAX_VALUE (index),
 741                                         TYPE_MIN_VALUE (index)));
 742
 743             TYPE_SIZE (type) = size_binop (MULT_EXPR, length,
 744                                            TYPE_SIZE (element));
 745           }
 746
 747         /* Now round the alignment and size,
 748            using machine-dependent criteria if any.  */
 749
 750 #ifdef ROUND_TYPE_ALIGN
 751         TYPE_ALIGN (type)
 752           = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (element), BITS_PER_UNIT);
 753 #else
 754         TYPE_ALIGN (type) = MAX (TYPE_ALIGN (element), BITS_PER_UNIT);
 755 #endif
 756
 757 #ifdef ROUND_TYPE_SIZE
 758         if (TYPE_SIZE (type) != 0)
 759           TYPE_SIZE (type)
 760             = ROUND_TYPE_SIZE (type, TYPE_SIZE (type), TYPE_ALIGN (type));
 761 #endif
 762
 763         TYPE_MODE (type) = BLKmode;
 764         if (TYPE_SIZE (type) != 0
 765             && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
 766             /* BLKmode elements force BLKmode aggregate;
 767                else extract/store fields may lose.  */
 768             && (TYPE_MODE (TREE_TYPE (type)) != BLKmode
 769                 || TYPE_NO_FORCE_BLK (TREE_TYPE (type))))
 770           {
 771             TYPE_MODE (type)
 772               = mode_for_size (TREE_INT_CST_LOW (TYPE_SIZE (type)),
 773                                MODE_INT, 1);
 774
 775             if (STRICT_ALIGNMENT && TYPE_ALIGN (type) < BIGGEST_ALIGNMENT
 776                 && TYPE_ALIGN (type) < TREE_INT_CST_LOW (TYPE_SIZE (type))
 777                 && TYPE_MODE (type) != BLKmode)
 778               {
 779                 TYPE_NO_FORCE_BLK (type) = 1;
 780                 TYPE_MODE (type) = BLKmode;
 781               }
 782           }
 783         break;
 784       }
 785
 786     case RECORD_TYPE:
 787       pending_statics = layout_record (type);
 788       TYPE_MODE (type) = BLKmode;
 789       if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
 790         {
 791           tree field;
 792           /* A record which has any BLKmode members must itself be BLKmode;
 793              it can't go in a register.
 794              Unless the member is BLKmode only because it isn't aligned.  */
 795           for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
 796             {
 797               int bitpos;
 798
 799               if (TREE_CODE (field) != FIELD_DECL)
 800                 continue;
 801
 802               if (TYPE_MODE (TREE_TYPE (field)) == BLKmode
 803                   && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field)))
 804                 goto record_lose;
 805
 806               if (TREE_CODE (DECL_FIELD_BITPOS (field)) != INTEGER_CST)
 807                 goto record_lose;
 808
 809               bitpos = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field));
 810
 811               /* Must be BLKmode if any field crosses a word boundary,
 812                  since extract_bit_field can't handle that in registers.  */
 813               if (bitpos / BITS_PER_WORD
 814                   != ((TREE_INT_CST_LOW (DECL_SIZE (field)) + bitpos - 1)
 815                       / BITS_PER_WORD)
 816                   /* But there is no problem if the field is entire words.  */
 817                   && TREE_INT_CST_LOW (DECL_SIZE (field)) % BITS_PER_WORD == 0)
 818                 goto record_lose;
 819             }
 820
 821           TYPE_MODE (type)
 822             = mode_for_size (TREE_INT_CST_LOW (TYPE_SIZE (type)),
 823                              MODE_INT, 1);
 824
 825           /* If structure's known alignment is less than
 826              what the scalar mode would need, and it matters,
 827              then stick with BLKmode.  */
 828           if (STRICT_ALIGNMENT
 829               && ! (TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT
 830                     || (TYPE_ALIGN (type)
 831                         >= TREE_INT_CST_LOW (TYPE_SIZE (type)))))
 832             {
 833               if (TYPE_MODE (type) != BLKmode)
 834                 /* If this is the only reason this type is BLKmode,
 835                    then don't force containing types to be BLKmode.  */
 836                 TYPE_NO_FORCE_BLK (type) = 1;
 837               TYPE_MODE (type) = BLKmode;
 838             }
 839
 840         record_lose: ;
 841         }
 842
 843       /* Lay out any static members.  This is done now
 844          because their type may use the record's type.  */
 845       while (pending_statics)
 846         {
 847           layout_decl (TREE_VALUE (pending_statics), 0);
 848           pending_statics = TREE_CHAIN (pending_statics);
 849         }
 850       break;
 851
 852     case UNION_TYPE:
 853     case QUAL_UNION_TYPE:
 854       layout_union (type);
 855       TYPE_MODE (type) = BLKmode;
 856       if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
 857           /* If structure's known alignment is less than
 858              what the scalar mode would need, and it matters,
 859              then stick with BLKmode.  */
 860           && (! STRICT_ALIGNMENT
 861               || TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT
 862               || TYPE_ALIGN (type) >= TREE_INT_CST_LOW (TYPE_SIZE (type))))
 863         {
 864           tree field;
 865           /* A union which has any BLKmode members must itself be BLKmode;
 866              it can't go in a register.
 867              Unless the member is BLKmode only because it isn't aligned.  */
 868           for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
 869             {
 870               if (TREE_CODE (field) != FIELD_DECL)
 871                 continue;
 872
 873               if (TYPE_MODE (TREE_TYPE (field)) == BLKmode
 874                   && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field)))
 875                 goto union_lose;
 876             }
 877
 878           TYPE_MODE (type)
 879             = mode_for_size (TREE_INT_CST_LOW (TYPE_SIZE (type)),
 880                              MODE_INT, 1);
 881
 882         union_lose: ;
 883         }
 884       break;
 885
 886     /* Pascal and Chill types */
 887     case BOOLEAN_TYPE:           /* store one byte/boolean for now. */
 888       TYPE_MODE (type) = QImode;
 889       TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
 890       TYPE_PRECISION (type) = 1;
 891       TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type));
 892       if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
 893           && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0)
 894         TREE_UNSIGNED (type) = 1;
 895       break;
 896
 897     case CHAR_TYPE:
 898       TYPE_MODE (type) = QImode;
 899       TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
 900       TYPE_PRECISION (type) = GET_MODE_BITSIZE (TYPE_MODE (type));
 901       TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type));
 902       break;
 903
 904     case SET_TYPE:
 905       if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST
 906           || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST)
 907         abort();
 908       else
 909         {
 910 #ifndef SET_WORD_SIZE
 911 #define SET_WORD_SIZE BITS_PER_WORD
 912 #endif
 913           int alignment = set_alignment ? set_alignment : SET_WORD_SIZE;
 914           int size_in_bits =
 915             TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
 916               - TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) + 1;
 917           int rounded_size
 918             = ((size_in_bits + alignment - 1) / alignment) * alignment;
 919           if (rounded_size > alignment)
 920             TYPE_MODE (type) = BLKmode;
 921           else
 922             TYPE_MODE (type) = mode_for_size (alignment, MODE_INT, 1);
 923           TYPE_SIZE (type) = size_int (rounded_size);
 924           TYPE_ALIGN (type) = alignment;
 925           TYPE_PRECISION (type) = size_in_bits;
 926         }
 927       break;
 928
 929     case FILE_TYPE:
 930       /* The size may vary in different languages, so the language front end
 931          should fill in the size.  */
 932       TYPE_ALIGN (type) = BIGGEST_ALIGNMENT;
 933       TYPE_MODE  (type) = BLKmode;
 934       break;
 935
 936     default:
 937       abort ();
 938     } /* end switch */
 939
 940   /* Normally, use the alignment corresponding to the mode chosen.
 941      However, where strict alignment is not required, avoid
 942      over-aligning structures, since most compilers do not do this
 943      alignment.  */
 944
 945   if (TYPE_MODE (type) != BLKmode && TYPE_MODE (type) != VOIDmode
 946       && (STRICT_ALIGNMENT
 947           || (TREE_CODE (type) != RECORD_TYPE && TREE_CODE (type) != UNION_TYPE
 948               && TREE_CODE (type) != QUAL_UNION_TYPE
 949               && TREE_CODE (type) != ARRAY_TYPE)))
 950     TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type));
 951
 952   /* Evaluate nonconstant size only once, either now or as soon as safe.  */
 953   if (TYPE_SIZE (type) != 0 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
 954     TYPE_SIZE (type) = variable_size (TYPE_SIZE (type));
 955
 956   /* Also layout any other variants of the type.  */
 957   if (TYPE_NEXT_VARIANT (type)
 958       || type != TYPE_MAIN_VARIANT (type))
 959     {
 960       tree variant;
 961       /* Record layout info of this variant.  */
 962       tree size = TYPE_SIZE (type);
 963       int align = TYPE_ALIGN (type);
 964       enum machine_mode mode = TYPE_MODE (type);
 965
 966       /* Copy it into all variants.  */
 967       for (variant = TYPE_MAIN_VARIANT (type);
 968            variant;
 969            variant = TYPE_NEXT_VARIANT (variant))
 970         {
 971           TYPE_SIZE (variant) = size;
 972           TYPE_ALIGN (variant) = align;
 973           TYPE_MODE (variant) = mode;
 974         }
 975     }
 976
 977   pop_obstacks ();
 978   resume_momentary (old);
 979 }
 980 \f
 981 /* Create and return a type for signed integers of PRECISION bits.  */
 982
 983 tree
 984 make_signed_type (precision)
 985      int precision;
 986 {
 987   register tree type = make_node (INTEGER_TYPE);
 988
 989   TYPE_PRECISION (type) = precision;
 990
 991   /* Create the extreme values based on the number of bits.  */
 992
 993   TYPE_MIN_VALUE (type)
 994     = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
 995                     ? 0 : (HOST_WIDE_INT) (-1) << (precision - 1)),
 996                    (((HOST_WIDE_INT) (-1)
 997                      << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
 998                          ? precision - HOST_BITS_PER_WIDE_INT - 1
 999                          : 0))));
1000   TYPE_MAX_VALUE (type)
1001     = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
1002                     ? -1 : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1),
1003                    (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
1004                     ? (((HOST_WIDE_INT) 1
1005                         << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1
1006                     : 0));
1007
1008   /* Give this type's extreme values this type as their type.  */
1009
1010   TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
1011   TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
1012
1013   /* The first type made with this or `make_unsigned_type'
1014      is the type for size values.  */
1015
1016   if (sizetype == 0)
1017     {
1018       sizetype = type;
1019     }
1020
1021   /* Lay out the type: set its alignment, size, etc.  */
1022
1023   layout_type (type);
1024
1025   return type;
1026 }
1027
1028 /* Create and return a type for unsigned integers of PRECISION bits.  */
1029
1030 tree
1031 make_unsigned_type (precision)
1032      int precision;
1033 {
1034   register tree type = make_node (INTEGER_TYPE);
1035
1036   TYPE_PRECISION (type) = precision;
1037
1038   /* The first type made with this or `make_signed_type'
1039      is the type for size values.  */
1040
1041   if (sizetype == 0)
1042     {
1043       sizetype = type;
1044     }
1045
1046   fixup_unsigned_type (type);
1047   return type;
1048 }
1049
1050 /* Set the extreme values of TYPE based on its precision in bits,
1051    then lay it out.  Used when make_signed_type won't do
1052    because the tree code is not INTEGER_TYPE.
1053    E.g. for Pascal, when the -fsigned-char option is given.  */
1054
1055 void
1056 fixup_signed_type (type)
1057      tree type;
1058 {
1059   register int precision = TYPE_PRECISION (type);
1060
1061   TYPE_MIN_VALUE (type)
1062     = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
1063                     ? 0 : (HOST_WIDE_INT) (-1) << (precision - 1)),
1064                    (((HOST_WIDE_INT) (-1)
1065                      << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
1066                          ? precision - HOST_BITS_PER_WIDE_INT - 1
1067                          : 0))));
1068   TYPE_MAX_VALUE (type)
1069     = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
1070                     ? -1 : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1),
1071                    (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
1072                     ? (((HOST_WIDE_INT) 1
1073                         << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1
1074                     : 0));
1075
1076   TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
1077   TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
1078
1079   /* Lay out the type: set its alignment, size, etc.  */
1080
1081   layout_type (type);
1082 }
1083
1084 /* Set the extreme values of TYPE based on its precision in bits,
1085    then lay it out.  This is used both in `make_unsigned_type'
1086    and for enumeral types.  */
1087
1088 void
1089 fixup_unsigned_type (type)
1090      tree type;
1091 {
1092   register int precision = TYPE_PRECISION (type);
1093
1094   TYPE_MIN_VALUE (type) = build_int_2 (0, 0);
1095   TYPE_MAX_VALUE (type)
1096     = build_int_2 (precision - HOST_BITS_PER_WIDE_INT >= 0
1097                    ? -1 : ((HOST_WIDE_INT) 1 << precision) - 1,
1098                    precision - HOST_BITS_PER_WIDE_INT > 0
1099                    ? ((unsigned HOST_WIDE_INT) ~0
1100                       >> (HOST_BITS_PER_WIDE_INT
1101                           - (precision - HOST_BITS_PER_WIDE_INT)))
1102                    : 0);
1103   TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
1104   TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
1105
1106   /* Lay out the type: set its alignment, size, etc.  */
1107
1108   layout_type (type);
1109 }
1110 \f
1111 /* Find the best machine mode to use when referencing a bit field of length
1112    BITSIZE bits starting at BITPOS.
1113
1114    The underlying object is known to be aligned to a boundary of ALIGN bits.
1115    If LARGEST_MODE is not VOIDmode, it means that we should not use a mode
1116    larger than LARGEST_MODE (usually SImode).
1117
1118    If no mode meets all these conditions, we return VOIDmode.  Otherwise, if
1119    VOLATILEP is true or SLOW_BYTE_ACCESS is false, we return the smallest
1120    mode meeting these conditions.
1121
1122    Otherwise (VOLATILEP is false and SLOW_BYTE_ACCESS is true), we return
1123    the largest mode (but a mode no wider than UNITS_PER_WORD) that meets
1124    all the conditions.  */
1125
1126 enum machine_mode
1127 get_best_mode (bitsize, bitpos, align, largest_mode, volatilep)
1128      int bitsize, bitpos;
1129      int align;
1130      enum machine_mode largest_mode;
1131      int volatilep;
1132 {
1133   enum machine_mode mode;
1134   int unit;
1135
1136   /* Find the narrowest integer mode that contains the bit field.  */
1137   for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
1138        mode = GET_MODE_WIDER_MODE (mode))
1139     {
1140       unit = GET_MODE_BITSIZE (mode);
1141       if (bitpos / unit == (bitpos + bitsize - 1) / unit)
1142         break;
1143     }
1144
1145   if (mode == MAX_MACHINE_MODE
1146       /* It is tempting to omit the following line
1147          if STRICT_ALIGNMENT is true.
1148          But that is incorrect, since if the bitfield uses part of 3 bytes
1149          and we use a 4-byte mode, we could get a spurious segv
1150          if the extra 4th byte is past the end of memory.
1151          (Though at least one Unix compiler ignores this problem:
1152          that on the Sequent 386 machine.  */
1153       || MIN (unit, BIGGEST_ALIGNMENT) > align
1154       || (largest_mode != VOIDmode && unit > GET_MODE_BITSIZE (largest_mode)))
1155     return VOIDmode;
1156
1157   if (SLOW_BYTE_ACCESS && ! volatilep)
1158     {
1159       enum machine_mode wide_mode = VOIDmode, tmode;
1160
1161       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT); tmode != VOIDmode;
1162            tmode = GET_MODE_WIDER_MODE (tmode))
1163         {
1164           unit = GET_MODE_BITSIZE (tmode);
1165           if (bitpos / unit == (bitpos + bitsize - 1) / unit
1166               && unit <= BITS_PER_WORD
1167               && unit <= MIN (align, BIGGEST_ALIGNMENT)
1168               && (largest_mode == VOIDmode
1169                   || unit <= GET_MODE_BITSIZE (largest_mode)))
1170             wide_mode = tmode;
1171         }
1172
1173       if (wide_mode != VOIDmode)
1174         return wide_mode;
1175     }
1176
1177   return mode;
1178 }
1179 \f
1180 /* Save all variables describing the current status into the structure *P.
1181    This is used before starting a nested function.  */
1182
1183 void
1184 save_storage_status (p)
1185      struct function *p;
1186 {
1187 #if 0  /* Need not save, since always 0 and non0 (resp.) within a function.  */
1188   p->pending_sizes = pending_sizes;
1189   p->immediate_size_expand = immediate_size_expand;
1190 #endif /* 0 */
1191 }
1192
1193 /* Restore all variables describing the current status from the structure *P.
1194    This is used after a nested function.  */
1195
1196 void
1197 restore_storage_status (p)
1198      struct function *p;
1199 {
1200 #if 0
1201   pending_sizes = p->pending_sizes;
1202   immediate_size_expand = p->immediate_size_expand;
1203 #endif /* 0 */
1204 }