gcc/stor-layout.c

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