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 #ifdef STRUCTURE_SIZE_BOUNDARY
 310   unsigned record_align = MAX (STRUCTURE_SIZE_BOUNDARY, TYPE_ALIGN (rec));
 311 #else
 312   unsigned record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (rec));
 313 #endif
 314   /* These must be laid out *after* the record is.  */
 315   tree pending_statics = NULL_TREE;
 316   /* Record size so far is CONST_SIZE + VAR_SIZE bits,
 317      where CONST_SIZE is an integer
 318      and VAR_SIZE is a tree expression.
 319      If VAR_SIZE is null, the size is just CONST_SIZE.
 320      Naturally we try to avoid using VAR_SIZE.  */
 321  register HOST_WIDE_INT const_size = 0;
 322   register tree var_size = 0;
 323   /* Once we start using VAR_SIZE, this is the maximum alignment
 324      that we know VAR_SIZE has.  */
 325   register int var_align = BITS_PER_UNIT;
 326
 327
 328   for (field = TYPE_FIELDS (rec); field; field = TREE_CHAIN (field))
 329     {
 330       register int known_align = var_size ? var_align : const_size;
 331       register int desired_align;
 332
 333       /* If FIELD is static, then treat it like a separate variable,
 334          not really like a structure field.
 335          If it is a FUNCTION_DECL, it's a method.
 336          In both cases, all we do is lay out the decl,
 337          and we do it *after* the record is laid out.  */
 338
 339       if (TREE_CODE (field) == VAR_DECL)
 340         {
 341           pending_statics = tree_cons (NULL_TREE, field, pending_statics);
 342           continue;
 343         }
 344       /* Enumerators and enum types which are local to this class need not
 345          be laid out.  Likewise for initialized constant fields.  */
 346       if (TREE_CODE (field) != FIELD_DECL)
 347         continue;
 348
 349       /* Lay out the field so we know what alignment it needs.
 350          For a packed field, use the alignment as specified,
 351          disregarding what the type would want.  */
 352       if (DECL_PACKED (field))
 353         desired_align = DECL_ALIGN (field);
 354       layout_decl (field, known_align);
 355       if (! DECL_PACKED (field))
 356         desired_align = DECL_ALIGN (field);
 357       /* Some targets (i.e. VMS) limit struct field alignment
 358          to a lower boundary than alignment of variables.  */
 359 #ifdef BIGGEST_FIELD_ALIGNMENT
 360       desired_align = MIN (desired_align, BIGGEST_FIELD_ALIGNMENT);
 361 #endif
 362 #ifdef ADJUST_FIELD_ALIGN
 363       desired_align = ADJUST_FIELD_ALIGN (field, desired_align);
 364 #endif
 365
 366       /* Record must have at least as much alignment as any field.
 367          Otherwise, the alignment of the field within the record
 368          is meaningless.  */
 369
 370 #ifndef PCC_BITFIELD_TYPE_MATTERS
 371       record_align = MAX (record_align, desired_align);
 372 #else
 373       if (PCC_BITFIELD_TYPE_MATTERS && TREE_TYPE (field) != error_mark_node
 374           && DECL_BIT_FIELD_TYPE (field)
 375           && ! integer_zerop (TYPE_SIZE (TREE_TYPE (field))))
 376         {
 377           /* For these machines, a zero-length field does not
 378              affect the alignment of the structure as a whole.
 379              It does, however, affect the alignment of the next field
 380              within the structure.  */
 381           if (! integer_zerop (DECL_SIZE (field)))
 382             record_align = MAX (record_align, desired_align);
 383           else if (! DECL_PACKED (field))
 384             desired_align = TYPE_ALIGN (TREE_TYPE (field));
 385           /* A named bit field of declared type `int'
 386              forces the entire structure to have `int' alignment.  */
 387           if (DECL_NAME (field) != 0)
 388             {
 389               int type_align = TYPE_ALIGN (TREE_TYPE (field));
 390               if (maximum_field_alignment != 0)
 391                 type_align = MIN (type_align, maximum_field_alignment);
 392               else if (TYPE_PACKED (rec))
 393                 type_align = MIN (type_align, BITS_PER_UNIT);
 394
 395               record_align = MAX (record_align, type_align);
 396             }
 397         }
 398       else
 399         record_align = MAX (record_align, desired_align);
 400 #endif
 401
 402       /* Does this field automatically have alignment it needs
 403          by virtue of the fields that precede it and the record's
 404          own alignment?  */
 405
 406       if (const_size % desired_align != 0
 407           || (var_align % desired_align != 0
 408               && var_size != 0))
 409         {
 410           /* No, we need to skip space before this field.
 411              Bump the cumulative size to multiple of field alignment.  */
 412
 413           if (var_size == 0
 414               || var_align % desired_align == 0)
 415             const_size
 416               = CEIL (const_size, desired_align) * desired_align;
 417           else
 418             {
 419               if (const_size > 0)
 420                 var_size = size_binop (PLUS_EXPR, var_size,
 421                                        size_int (const_size));
 422               const_size = 0;
 423               var_size = round_up (var_size, desired_align);
 424               var_align = MIN (var_align, desired_align);
 425             }
 426         }
 427
 428 #ifdef PCC_BITFIELD_TYPE_MATTERS
 429       if (PCC_BITFIELD_TYPE_MATTERS
 430           && TREE_CODE (field) == FIELD_DECL
 431           && TREE_TYPE (field) != error_mark_node
 432           && DECL_BIT_FIELD_TYPE (field)
 433           && !DECL_PACKED (field)
 434           && maximum_field_alignment == 0
 435           && !integer_zerop (DECL_SIZE (field)))
 436         {
 437           int type_align = TYPE_ALIGN (TREE_TYPE (field));
 438           register tree dsize = DECL_SIZE (field);
 439           int field_size = TREE_INT_CST_LOW (dsize);
 440
 441           /* A bit field may not span more units of alignment of its type
 442              than its type itself.  Advance to next boundary if necessary.  */
 443           if (((const_size + field_size) / type_align - const_size / type_align)
 444               > TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (field))) / type_align)
 445             const_size = CEIL (const_size, type_align) * type_align;
 446         }
 447 #endif
 448
 449 /* No existing machine description uses this parameter.
 450    So I have made it in this aspect identical to PCC_BITFIELD_TYPE_MATTERS.  */
 451 #ifdef BITFIELD_NBYTES_LIMITED
 452       if (BITFIELD_NBYTES_LIMITED
 453           && TREE_CODE (field) == FIELD_DECL
 454           && TREE_TYPE (field) != error_mark_node
 455           && DECL_BIT_FIELD_TYPE (field)
 456           && !DECL_PACKED (field)
 457           && !integer_zerop (DECL_SIZE (field)))
 458         {
 459           int type_align = TYPE_ALIGN (TREE_TYPE (field));
 460           register tree dsize = DECL_SIZE (field);
 461           int field_size = TREE_INT_CST_LOW (dsize);
 462
 463           if (maximum_field_alignment != 0)
 464             type_align = MIN (type_align, maximum_field_alignment);
 465           else if (TYPE_PACKED (rec))
 466             type_align = MIN (type_align, BITS_PER_UNIT);
 467
 468           /* A bit field may not span the unit of alignment of its type.
 469              Advance to next boundary if necessary.  */
 470           if (const_size / type_align
 471               != (const_size + field_size - 1) / type_align)
 472             const_size = CEIL (const_size, type_align) * type_align;
 473         }
 474 #endif
 475
 476       /* Size so far becomes the position of this field.  */
 477
 478       if (var_size && const_size)
 479         DECL_FIELD_BITPOS (field)
 480           = size_binop (PLUS_EXPR, var_size, size_int (const_size));
 481       else if (var_size)
 482         DECL_FIELD_BITPOS (field) = var_size;
 483       else
 484         {
 485           DECL_FIELD_BITPOS (field) = size_int (const_size);
 486
 487           /* If this field ended up more aligned than we thought it
 488              would be (we approximate this by seeing if its position
 489              changed), lay out the field again; perhaps we can use an
 490              integral mode for it now.  */
 491           if (known_align != const_size)
 492             layout_decl (field, const_size);
 493         }
 494
 495       /* Now add size of this field to the size of the record.  */
 496
 497       {
 498         register tree dsize = DECL_SIZE (field);
 499
 500         /* This can happen when we have an invalid nested struct definition,
 501            such as struct j { struct j { int i; } }.  The error message is
 502            printed in finish_struct.  */
 503         if (dsize == 0)
 504           /* Do nothing.  */;
 505         else if (TREE_CODE (dsize) == INTEGER_CST
 506                  && ! TREE_CONSTANT_OVERFLOW (dsize)
 507                  && TREE_INT_CST_HIGH (dsize) == 0
 508                  && TREE_INT_CST_LOW (dsize) + const_size >= const_size)
 509           /* Use const_size if there's no overflow.  */
 510           const_size += TREE_INT_CST_LOW (dsize);
 511         else
 512           {
 513             if (var_size == 0)
 514               var_size = dsize;
 515             else
 516               var_size = size_binop (PLUS_EXPR, var_size, dsize);
 517           }
 518       }
 519     }
 520
 521   /* Work out the total size and alignment of the record
 522      as one expression and store in the record type.
 523      Round it up to a multiple of the record's alignment.  */
 524
 525   if (var_size == 0)
 526     {
 527       TYPE_SIZE (rec) = size_int (const_size);
 528     }
 529   else
 530     {
 531       if (const_size)
 532         var_size
 533           = size_binop (PLUS_EXPR, var_size, size_int (const_size));
 534       TYPE_SIZE (rec) = var_size;
 535     }
 536
 537   /* Determine the desired alignment.  */
 538 #ifdef ROUND_TYPE_ALIGN
 539   TYPE_ALIGN (rec) = ROUND_TYPE_ALIGN (rec, TYPE_ALIGN (rec), record_align);
 540 #else
 541   TYPE_ALIGN (rec) = MAX (TYPE_ALIGN (rec), record_align);
 542 #endif
 543
 544 #ifdef ROUND_TYPE_SIZE
 545   TYPE_SIZE (rec) = ROUND_TYPE_SIZE (rec, TYPE_SIZE (rec), TYPE_ALIGN (rec));
 546 #else
 547   /* Round the size up to be a multiple of the required alignment */
 548   TYPE_SIZE (rec) = round_up (TYPE_SIZE (rec), TYPE_ALIGN (rec));
 549 #endif
 550
 551   return pending_statics;
 552 }
 553 \f
 554 /* Lay out a UNION_TYPE or QUAL_UNION_TYPE type.
 555    Lay out all the fields, set their positions to zero,
 556    and compute the size and alignment of the union (maximum of any field).
 557    Note that if you set the TYPE_ALIGN before calling this
 558    then the union align is aligned to at least that boundary.  */
 559
 560 static void
 561 layout_union (rec)
 562      tree rec;
 563 {
 564   register tree field;
 565 #ifdef STRUCTURE_SIZE_BOUNDARY
 566   unsigned union_align = STRUCTURE_SIZE_BOUNDARY;
 567 #else
 568   unsigned union_align = BITS_PER_UNIT;
 569 #endif
 570
 571   /* The size of the union, based on the fields scanned so far,
 572      is max (CONST_SIZE, VAR_SIZE).
 573      VAR_SIZE may be null; then CONST_SIZE by itself is the size.  */
 574   register int const_size = 0;
 575   register tree var_size = 0;
 576
 577   /* If this is a QUAL_UNION_TYPE, we want to process the fields in
 578      the reverse order in building the COND_EXPR that denotes its
 579      size.  We reverse them again later.  */
 580   if (TREE_CODE (rec) == QUAL_UNION_TYPE)
 581     TYPE_FIELDS (rec) = nreverse (TYPE_FIELDS (rec));
 582
 583   for (field = TYPE_FIELDS (rec); field; field = TREE_CHAIN (field))
 584     {
 585       /* Enums which are local to this class need not be laid out.  */
 586       if (TREE_CODE (field) == CONST_DECL || TREE_CODE (field) == TYPE_DECL)
 587         continue;
 588
 589       layout_decl (field, 0);
 590       DECL_FIELD_BITPOS (field) = size_int (0);
 591
 592       /* Union must be at least as aligned as any field requires.  */
 593
 594       union_align = MAX (union_align, DECL_ALIGN (field));
 595
 596 #ifdef PCC_BITFIELD_TYPE_MATTERS
 597       /* On the m88000, a bit field of declare type `int'
 598          forces the entire union to have `int' alignment.  */
 599       if (PCC_BITFIELD_TYPE_MATTERS && DECL_BIT_FIELD_TYPE (field))
 600         union_align = MAX (union_align, TYPE_ALIGN (TREE_TYPE (field)));
 601 #endif
 602
 603       if (TREE_CODE (rec) == UNION_TYPE)
 604         {
 605           /* Set union_size to max (decl_size, union_size).
 606              There are more and less general ways to do this.
 607              Use only CONST_SIZE unless forced to use VAR_SIZE.  */
 608
 609           if (TREE_CODE (DECL_SIZE (field)) == INTEGER_CST)
 610             const_size
 611               = MAX (const_size, TREE_INT_CST_LOW (DECL_SIZE (field)));
 612           else if (var_size == 0)
 613             var_size = DECL_SIZE (field);
 614           else
 615             var_size = size_binop (MAX_EXPR, var_size, DECL_SIZE (field));
 616         }
 617       else if (TREE_CODE (rec) == QUAL_UNION_TYPE)
 618         var_size = fold (build (COND_EXPR, sizetype, DECL_QUALIFIER (field),
 619                                 DECL_SIZE (field),
 620                                 var_size ? var_size : integer_zero_node));
 621       }
 622
 623   if (TREE_CODE (rec) == QUAL_UNION_TYPE)
 624     TYPE_FIELDS (rec) = nreverse (TYPE_FIELDS (rec));
 625
 626   /* Determine the ultimate size of the union (in bytes).  */
 627   if (NULL == var_size)
 628     TYPE_SIZE (rec) = size_int (CEIL (const_size, BITS_PER_UNIT)
 629                                 * BITS_PER_UNIT);
 630   else if (const_size == 0)
 631     TYPE_SIZE (rec) = var_size;
 632   else
 633     TYPE_SIZE (rec) = size_binop (MAX_EXPR, var_size,
 634                                   round_up (size_int (const_size),
 635                                             BITS_PER_UNIT));
 636
 637   /* Determine the desired alignment.  */
 638 #ifdef ROUND_TYPE_ALIGN
 639   TYPE_ALIGN (rec) = ROUND_TYPE_ALIGN (rec, TYPE_ALIGN (rec), union_align);
 640 #else
 641   TYPE_ALIGN (rec) = MAX (TYPE_ALIGN (rec), union_align);
 642 #endif
 643
 644 #ifdef ROUND_TYPE_SIZE
 645   TYPE_SIZE (rec) = ROUND_TYPE_SIZE (rec, TYPE_SIZE (rec), TYPE_ALIGN (rec));
 646 #else
 647   /* Round the size up to be a multiple of the required alignment */
 648   TYPE_SIZE (rec) = round_up (TYPE_SIZE (rec), TYPE_ALIGN (rec));
 649 #endif
 650 }
 651 \f
 652 /* Calculate the mode, size, and alignment for TYPE.
 653    For an array type, calculate the element separation as well.
 654    Record TYPE on the chain of permanent or temporary types
 655    so that dbxout will find out about it.
 656
 657    TYPE_SIZE of a type is nonzero if the type has been laid out already.
 658    layout_type does nothing on such a type.
 659
 660    If the type is incomplete, its TYPE_SIZE remains zero.  */
 661
 662 void
 663 layout_type (type)
 664      tree type;
 665 {
 666   int old;
 667   tree pending_statics;
 668
 669   if (type == 0)
 670     abort ();
 671
 672   /* Do nothing if type has been laid out before.  */
 673   if (TYPE_SIZE (type))
 674     return;
 675
 676   /* Make sure all nodes we allocate are not momentary;
 677      they must last past the current statement.  */
 678   old = suspend_momentary ();
 679
 680   /* Put all our nodes into the same obstack as the type.  Also,
 681      make expressions saveable (this is a no-op for permanent types).  */
 682
 683   push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type));
 684   saveable_allocation ();
 685
 686   switch (TREE_CODE (type))
 687     {
 688     case LANG_TYPE:
 689       /* This kind of type is the responsibility
 690          of the language-specific code.  */
 691       abort ();
 692
 693     case INTEGER_TYPE:
 694     case ENUMERAL_TYPE:
 695     case CHAR_TYPE:
 696       if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
 697           && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0)
 698         TREE_UNSIGNED (type) = 1;
 699
 700       TYPE_MODE (type) = smallest_mode_for_size (TYPE_PRECISION (type),
 701                                                  MODE_INT);
 702       TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
 703       break;
 704
 705     case REAL_TYPE:
 706       TYPE_MODE (type) = mode_for_size (TYPE_PRECISION (type), MODE_FLOAT, 0);
 707       TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
 708       break;
 709
 710     case COMPLEX_TYPE:
 711       TREE_UNSIGNED (type) = TREE_UNSIGNED (TREE_TYPE (type));
 712       TYPE_MODE (type)
 713         = mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type)),
 714                          (TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE
 715                           ? MODE_COMPLEX_INT : MODE_COMPLEX_FLOAT),
 716                          0);
 717       TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
 718       break;
 719
 720     case VOID_TYPE:
 721       TYPE_SIZE (type) = size_zero_node;
 722       TYPE_ALIGN (type) = 1;
 723       TYPE_MODE (type) = VOIDmode;
 724       break;
 725
 726     case OFFSET_TYPE:
 727       TYPE_SIZE (type) = size_int (POINTER_SIZE);
 728       TYPE_MODE (type) = ptr_mode;
 729       break;
 730
 731     case FUNCTION_TYPE:
 732     case METHOD_TYPE:
 733       TYPE_MODE (type) = mode_for_size (2 * POINTER_SIZE, MODE_INT, 0);
 734       TYPE_SIZE (type) = size_int (2 * POINTER_SIZE);
 735       break;
 736
 737     case POINTER_TYPE:
 738     case REFERENCE_TYPE:
 739       TYPE_MODE (type) = ptr_mode;
 740       TYPE_SIZE (type) = size_int (POINTER_SIZE);
 741       TREE_UNSIGNED (type) = 1;
 742       TYPE_PRECISION (type) = POINTER_SIZE;
 743       break;
 744
 745     case ARRAY_TYPE:
 746       {
 747         register tree index = TYPE_DOMAIN (type);
 748         register tree element = TREE_TYPE (type);
 749
 750         build_pointer_type (element);
 751
 752         /* We need to know both bounds in order to compute the size.  */
 753         if (index && TYPE_MAX_VALUE (index) && TYPE_MIN_VALUE (index)
 754             && TYPE_SIZE (element))
 755           {
 756             tree ub = TYPE_MAX_VALUE (index);
 757             tree lb = TYPE_MIN_VALUE (index);
 758             tree length;
 759
 760             /* If UB is max (lb - 1, x), remove the MAX_EXPR since the
 761                test for negative below covers it.  */
 762             if (TREE_CODE (ub) == MAX_EXPR
 763                 && TREE_CODE (TREE_OPERAND (ub, 0)) == MINUS_EXPR
 764                 && integer_onep (TREE_OPERAND (TREE_OPERAND (ub, 0), 1))
 765                 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (ub, 0), 0),
 766                                     lb, 0))
 767               ub = TREE_OPERAND (ub, 1);
 768             else if (TREE_CODE (ub) == MAX_EXPR
 769                      && TREE_CODE (TREE_OPERAND (ub, 1)) == MINUS_EXPR
 770                      && integer_onep (TREE_OPERAND (TREE_OPERAND (ub, 1), 1))
 771                      && operand_equal_p (TREE_OPERAND (TREE_OPERAND (ub, 1),
 772                                                        0),
 773                                          lb, 0))
 774               ub = TREE_OPERAND (ub, 0);
 775
 776             length = size_binop (PLUS_EXPR, size_one_node,
 777                                  size_binop (MINUS_EXPR, ub, lb));
 778
 779             /* If neither bound is a constant and sizetype is signed, make
 780                sure the size is never negative.  We should really do this
 781                if *either* bound is non-constant, but this is the best
 782                compromise between C and Ada.  */
 783             if (! TREE_UNSIGNED (sizetype)
 784                 && TREE_CODE (TYPE_MIN_VALUE (index)) != INTEGER_CST
 785                 && TREE_CODE (TYPE_MAX_VALUE (index)) != INTEGER_CST)
 786               length = size_binop (MAX_EXPR, length, size_zero_node);
 787
 788             TYPE_SIZE (type) = size_binop (MULT_EXPR, length,
 789                                            TYPE_SIZE (element));
 790           }
 791
 792         /* Now round the alignment and size,
 793            using machine-dependent criteria if any.  */
 794
 795 #ifdef ROUND_TYPE_ALIGN
 796         TYPE_ALIGN (type)
 797           = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (element), BITS_PER_UNIT);
 798 #else
 799         TYPE_ALIGN (type) = MAX (TYPE_ALIGN (element), BITS_PER_UNIT);
 800 #endif
 801
 802 #ifdef ROUND_TYPE_SIZE
 803         if (TYPE_SIZE (type) != 0)
 804           TYPE_SIZE (type)
 805             = ROUND_TYPE_SIZE (type, TYPE_SIZE (type), TYPE_ALIGN (type));
 806 #endif
 807
 808         TYPE_MODE (type) = BLKmode;
 809         if (TYPE_SIZE (type) != 0
 810             && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
 811             /* BLKmode elements force BLKmode aggregate;
 812                else extract/store fields may lose.  */
 813             && (TYPE_MODE (TREE_TYPE (type)) != BLKmode
 814                 || TYPE_NO_FORCE_BLK (TREE_TYPE (type))))
 815           {
 816             TYPE_MODE (type)
 817               = mode_for_size (TREE_INT_CST_LOW (TYPE_SIZE (type)),
 818                                MODE_INT, 1);
 819
 820             if (STRICT_ALIGNMENT && TYPE_ALIGN (type) < BIGGEST_ALIGNMENT
 821                 && TYPE_ALIGN (type) < TREE_INT_CST_LOW (TYPE_SIZE (type))
 822                 && TYPE_MODE (type) != BLKmode)
 823               {
 824                 TYPE_NO_FORCE_BLK (type) = 1;
 825                 TYPE_MODE (type) = BLKmode;
 826               }
 827           }
 828         break;
 829       }
 830
 831     case RECORD_TYPE:
 832       pending_statics = layout_record (type);
 833       TYPE_MODE (type) = BLKmode;
 834       if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
 835         {
 836           tree field;
 837           /* A record which has any BLKmode members must itself be BLKmode;
 838              it can't go in a register.
 839              Unless the member is BLKmode only because it isn't aligned.  */
 840           for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
 841             {
 842               int bitpos;
 843
 844               if (TREE_CODE (field) != FIELD_DECL)
 845                 continue;
 846
 847               if (TYPE_MODE (TREE_TYPE (field)) == BLKmode
 848                   && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field)))
 849                 goto record_lose;
 850
 851               if (TREE_CODE (DECL_FIELD_BITPOS (field)) != INTEGER_CST)
 852                 goto record_lose;
 853
 854               bitpos = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field));
 855
 856               /* Must be BLKmode if any field crosses a word boundary,
 857                  since extract_bit_field can't handle that in registers.  */
 858               if (bitpos / BITS_PER_WORD
 859                   != ((TREE_INT_CST_LOW (DECL_SIZE (field)) + bitpos - 1)
 860                       / BITS_PER_WORD)
 861                   /* But there is no problem if the field is entire words.  */
 862                   && TREE_INT_CST_LOW (DECL_SIZE (field)) % BITS_PER_WORD == 0)
 863                 goto record_lose;
 864             }
 865
 866           TYPE_MODE (type)
 867             = mode_for_size (TREE_INT_CST_LOW (TYPE_SIZE (type)),
 868                              MODE_INT, 1);
 869
 870           /* If structure's known alignment is less than
 871              what the scalar mode would need, and it matters,
 872              then stick with BLKmode.  */
 873           if (STRICT_ALIGNMENT
 874               && ! (TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT
 875                     || (TYPE_ALIGN (type)
 876                         >= TREE_INT_CST_LOW (TYPE_SIZE (type)))))
 877             {
 878               if (TYPE_MODE (type) != BLKmode)
 879                 /* If this is the only reason this type is BLKmode,
 880                    then don't force containing types to be BLKmode.  */
 881                 TYPE_NO_FORCE_BLK (type) = 1;
 882               TYPE_MODE (type) = BLKmode;
 883             }
 884
 885         record_lose: ;
 886         }
 887
 888       /* Lay out any static members.  This is done now
 889          because their type may use the record's type.  */
 890       while (pending_statics)
 891         {
 892           layout_decl (TREE_VALUE (pending_statics), 0);
 893           pending_statics = TREE_CHAIN (pending_statics);
 894         }
 895       break;
 896
 897     case UNION_TYPE:
 898     case QUAL_UNION_TYPE:
 899       layout_union (type);
 900       TYPE_MODE (type) = BLKmode;
 901       if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
 902           /* If structure's known alignment is less than
 903              what the scalar mode would need, and it matters,
 904              then stick with BLKmode.  */
 905           && (! STRICT_ALIGNMENT
 906               || TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT
 907               || TYPE_ALIGN (type) >= TREE_INT_CST_LOW (TYPE_SIZE (type))))
 908         {
 909           tree field;
 910           /* A union which has any BLKmode members must itself be BLKmode;
 911              it can't go in a register.
 912              Unless the member is BLKmode only because it isn't aligned.  */
 913           for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
 914             {
 915               if (TREE_CODE (field) != FIELD_DECL)
 916                 continue;
 917
 918               if (TYPE_MODE (TREE_TYPE (field)) == BLKmode
 919                   && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field)))
 920                 goto union_lose;
 921             }
 922
 923           TYPE_MODE (type)
 924             = mode_for_size (TREE_INT_CST_LOW (TYPE_SIZE (type)),
 925                              MODE_INT, 1);
 926
 927         union_lose: ;
 928         }
 929       break;
 930
 931     /* Pascal and Chill types */
 932     case BOOLEAN_TYPE:           /* store one byte/boolean for now.  */
 933       TYPE_MODE (type) = QImode;
 934       TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
 935       TYPE_PRECISION (type) = 1;
 936       TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type));
 937       if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
 938           && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0)
 939         TREE_UNSIGNED (type) = 1;
 940       break;
 941
 942     case SET_TYPE:
 943       if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST
 944           || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST)
 945         abort();
 946       else
 947         {
 948 #ifndef SET_WORD_SIZE
 949 #define SET_WORD_SIZE BITS_PER_WORD
 950 #endif
 951           int alignment = set_alignment ? set_alignment : SET_WORD_SIZE;
 952           int size_in_bits =
 953             TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
 954               - TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) + 1;
 955           int rounded_size
 956             = ((size_in_bits + alignment - 1) / alignment) * alignment;
 957           if (rounded_size > alignment)
 958             TYPE_MODE (type) = BLKmode;
 959           else
 960             TYPE_MODE (type) = mode_for_size (alignment, MODE_INT, 1);
 961           TYPE_SIZE (type) = size_int (rounded_size);
 962           TYPE_ALIGN (type) = alignment;
 963           TYPE_PRECISION (type) = size_in_bits;
 964         }
 965       break;
 966
 967     case FILE_TYPE:
 968       /* The size may vary in different languages, so the language front end
 969          should fill in the size.  */
 970       TYPE_ALIGN (type) = BIGGEST_ALIGNMENT;
 971       TYPE_MODE  (type) = BLKmode;
 972       break;
 973
 974     default:
 975       abort ();
 976     } /* end switch */
 977
 978   /* Normally, use the alignment corresponding to the mode chosen.
 979      However, where strict alignment is not required, avoid
 980      over-aligning structures, since most compilers do not do this
 981      alignment.  */
 982
 983   if (TYPE_MODE (type) != BLKmode && TYPE_MODE (type) != VOIDmode
 984       && (STRICT_ALIGNMENT
 985           || (TREE_CODE (type) != RECORD_TYPE && TREE_CODE (type) != UNION_TYPE
 986               && TREE_CODE (type) != QUAL_UNION_TYPE
 987               && TREE_CODE (type) != ARRAY_TYPE)))
 988     TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type));
 989
 990   /* Evaluate nonconstant size only once, either now or as soon as safe.  */
 991   if (TYPE_SIZE (type) != 0 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
 992     TYPE_SIZE (type) = variable_size (TYPE_SIZE (type));
 993
 994   /* Also layout any other variants of the type.  */
 995   if (TYPE_NEXT_VARIANT (type)
 996       || type != TYPE_MAIN_VARIANT (type))
 997     {
 998       tree variant;
 999       /* Record layout info of this variant.  */
1000       tree size = TYPE_SIZE (type);
1001       int align = TYPE_ALIGN (type);
1002       enum machine_mode mode = TYPE_MODE (type);
1003
1004       /* Copy it into all variants.  */
1005       for (variant = TYPE_MAIN_VARIANT (type);
1006            variant;
1007            variant = TYPE_NEXT_VARIANT (variant))
1008         {
1009           TYPE_SIZE (variant) = size;
1010           TYPE_ALIGN (variant) = align;
1011           TYPE_MODE (variant) = mode;
1012         }
1013     }
1014
1015   pop_obstacks ();
1016   resume_momentary (old);
1017 }
1018 \f
1019 /* Create and return a type for signed integers of PRECISION bits.  */
1020
1021 tree
1022 make_signed_type (precision)
1023      int precision;
1024 {
1025   register tree type = make_node (INTEGER_TYPE);
1026
1027   TYPE_PRECISION (type) = precision;
1028
1029   /* Create the extreme values based on the number of bits.  */
1030
1031   TYPE_MIN_VALUE (type)
1032     = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
1033                     ? 0 : (HOST_WIDE_INT) (-1) << (precision - 1)),
1034                    (((HOST_WIDE_INT) (-1)
1035                      << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
1036                          ? precision - HOST_BITS_PER_WIDE_INT - 1
1037                          : 0))));
1038   TYPE_MAX_VALUE (type)
1039     = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
1040                     ? -1 : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1),
1041                    (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
1042                     ? (((HOST_WIDE_INT) 1
1043                         << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1
1044                     : 0));
1045
1046   /* Give this type's extreme values this type as their type.  */
1047
1048   TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
1049   TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
1050
1051   /* The first type made with this or `make_unsigned_type'
1052      is the type for size values.  */
1053
1054   if (sizetype == 0)
1055     {
1056       sizetype = type;
1057     }
1058
1059   /* Lay out the type: set its alignment, size, etc.  */
1060
1061   layout_type (type);
1062
1063   return type;
1064 }
1065
1066 /* Create and return a type for unsigned integers of PRECISION bits.  */
1067
1068 tree
1069 make_unsigned_type (precision)
1070      int precision;
1071 {
1072   register tree type = make_node (INTEGER_TYPE);
1073
1074   TYPE_PRECISION (type) = precision;
1075
1076   /* The first type made with this or `make_signed_type'
1077      is the type for size values.  */
1078
1079   if (sizetype == 0)
1080     {
1081       sizetype = type;
1082     }
1083
1084   fixup_unsigned_type (type);
1085   return type;
1086 }
1087
1088 /* Set the extreme values of TYPE based on its precision in bits,
1089    then lay it out.  Used when make_signed_type won't do
1090    because the tree code is not INTEGER_TYPE.
1091    E.g. for Pascal, when the -fsigned-char option is given.  */
1092
1093 void
1094 fixup_signed_type (type)
1095      tree type;
1096 {
1097   register int precision = TYPE_PRECISION (type);
1098
1099   TYPE_MIN_VALUE (type)
1100     = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
1101                     ? 0 : (HOST_WIDE_INT) (-1) << (precision - 1)),
1102                    (((HOST_WIDE_INT) (-1)
1103                      << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
1104                          ? precision - HOST_BITS_PER_WIDE_INT - 1
1105                          : 0))));
1106   TYPE_MAX_VALUE (type)
1107     = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
1108                     ? -1 : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1),
1109                    (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
1110                     ? (((HOST_WIDE_INT) 1
1111                         << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1
1112                     : 0));
1113
1114   TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
1115   TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
1116
1117   /* Lay out the type: set its alignment, size, etc.  */
1118
1119   layout_type (type);
1120 }
1121
1122 /* Set the extreme values of TYPE based on its precision in bits,
1123    then lay it out.  This is used both in `make_unsigned_type'
1124    and for enumeral types.  */
1125
1126 void
1127 fixup_unsigned_type (type)
1128      tree type;
1129 {
1130   register int precision = TYPE_PRECISION (type);
1131
1132   TYPE_MIN_VALUE (type) = build_int_2 (0, 0);
1133   TYPE_MAX_VALUE (type)
1134     = build_int_2 (precision - HOST_BITS_PER_WIDE_INT >= 0
1135                    ? -1 : ((HOST_WIDE_INT) 1 << precision) - 1,
1136                    precision - HOST_BITS_PER_WIDE_INT > 0
1137                    ? ((unsigned HOST_WIDE_INT) ~0
1138                       >> (HOST_BITS_PER_WIDE_INT
1139                           - (precision - HOST_BITS_PER_WIDE_INT)))
1140                    : 0);
1141   TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
1142   TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
1143
1144   /* Lay out the type: set its alignment, size, etc.  */
1145
1146   layout_type (type);
1147 }
1148 \f
1149 /* Find the best machine mode to use when referencing a bit field of length
1150    BITSIZE bits starting at BITPOS.
1151
1152    The underlying object is known to be aligned to a boundary of ALIGN bits.
1153    If LARGEST_MODE is not VOIDmode, it means that we should not use a mode
1154    larger than LARGEST_MODE (usually SImode).
1155
1156    If no mode meets all these conditions, we return VOIDmode.  Otherwise, if
1157    VOLATILEP is true or SLOW_BYTE_ACCESS is false, we return the smallest
1158    mode meeting these conditions.
1159
1160    Otherwise (VOLATILEP is false and SLOW_BYTE_ACCESS is true), we return
1161    the largest mode (but a mode no wider than UNITS_PER_WORD) that meets
1162    all the conditions.  */
1163
1164 enum machine_mode
1165 get_best_mode (bitsize, bitpos, align, largest_mode, volatilep)
1166      int bitsize, bitpos;
1167      int align;
1168      enum machine_mode largest_mode;
1169      int volatilep;
1170 {
1171   enum machine_mode mode;
1172   int unit;
1173
1174   /* Find the narrowest integer mode that contains the bit field.  */
1175   for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
1176        mode = GET_MODE_WIDER_MODE (mode))
1177     {
1178       unit = GET_MODE_BITSIZE (mode);
1179       if (bitpos / unit == (bitpos + bitsize - 1) / unit)
1180         break;
1181     }
1182
1183   if (mode == MAX_MACHINE_MODE
1184       /* It is tempting to omit the following line
1185          if STRICT_ALIGNMENT is true.
1186          But that is incorrect, since if the bitfield uses part of 3 bytes
1187          and we use a 4-byte mode, we could get a spurious segv
1188          if the extra 4th byte is past the end of memory.
1189          (Though at least one Unix compiler ignores this problem:
1190          that on the Sequent 386 machine.  */
1191       || MIN (unit, BIGGEST_ALIGNMENT) > align
1192       || (largest_mode != VOIDmode && unit > GET_MODE_BITSIZE (largest_mode)))
1193     return VOIDmode;
1194
1195   if (SLOW_BYTE_ACCESS && ! volatilep)
1196     {
1197       enum machine_mode wide_mode = VOIDmode, tmode;
1198
1199       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT); tmode != VOIDmode;
1200            tmode = GET_MODE_WIDER_MODE (tmode))
1201         {
1202           unit = GET_MODE_BITSIZE (tmode);
1203           if (bitpos / unit == (bitpos + bitsize - 1) / unit
1204               && unit <= BITS_PER_WORD
1205               && unit <= MIN (align, BIGGEST_ALIGNMENT)
1206               && (largest_mode == VOIDmode
1207                   || unit <= GET_MODE_BITSIZE (largest_mode)))
1208             wide_mode = tmode;
1209         }
1210
1211       if (wide_mode != VOIDmode)
1212         return wide_mode;
1213     }
1214
1215   return mode;
1216 }
1217 \f
1218 /* Save all variables describing the current status into the structure *P.
1219    This is used before starting a nested function.  */
1220
1221 void
1222 save_storage_status (p)
1223      struct function *p;
1224 {
1225 #if 0  /* Need not save, since always 0 and non0 (resp.) within a function.  */
1226   p->pending_sizes = pending_sizes;
1227   p->immediate_size_expand = immediate_size_expand;
1228 #endif /* 0 */
1229 }
1230
1231 /* Restore all variables describing the current status from the structure *P.
1232    This is used after a nested function.  */
1233
1234 void
1235 restore_storage_status (p)
1236      struct function *p;
1237 {
1238 #if 0
1239   pending_sizes = p->pending_sizes;
1240   immediate_size_expand = p->immediate_size_expand;
1241 #endif /* 0 */
1242 }