gcc/stor-layout.c

   1 /* C-compiler utilities for types and variables storage layout
   2    Copyright (C) 1987, 88, 92-97, 1998 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 "system.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_tab[2], sbitsizetype, ubitsizetype;
  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 (DECL_PACKED (field))
 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                                        bitsize_int (const_size, 0L));
 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           /* ??? This test is opposite the test in the containing if
 468              statement, so this code is unreachable currently.  */
 469           else if (DECL_PACKED (field))
 470             type_align = MIN (type_align, BITS_PER_UNIT);
 471
 472           /* A bit field may not span the unit of alignment of its type.
 473              Advance to next boundary if necessary.  */
 474           /* ??? This code should match the code above for the
 475              PCC_BITFIELD_TYPE_MATTERS case.  */
 476           if (const_size / type_align
 477               != (const_size + field_size - 1) / type_align)
 478             const_size = CEIL (const_size, type_align) * type_align;
 479         }
 480 #endif
 481
 482       /* Size so far becomes the position of this field.  */
 483
 484       if (var_size && const_size)
 485         DECL_FIELD_BITPOS (field)
 486           = size_binop (PLUS_EXPR, var_size, bitsize_int (const_size, 0L));
 487       else if (var_size)
 488         DECL_FIELD_BITPOS (field) = var_size;
 489       else
 490         {
 491           DECL_FIELD_BITPOS (field) = size_int (const_size);
 492
 493           /* If this field ended up more aligned than we thought it
 494              would be (we approximate this by seeing if its position
 495              changed), lay out the field again; perhaps we can use an
 496              integral mode for it now.  */
 497           if (known_align != const_size)
 498             layout_decl (field, const_size);
 499         }
 500
 501       /* Now add size of this field to the size of the record.  */
 502
 503       {
 504         register tree dsize = DECL_SIZE (field);
 505
 506         /* This can happen when we have an invalid nested struct definition,
 507            such as struct j { struct j { int i; } }.  The error message is
 508            printed in finish_struct.  */
 509         if (dsize == 0)
 510           /* Do nothing.  */;
 511         else if (TREE_CODE (dsize) == INTEGER_CST
 512                  && ! TREE_CONSTANT_OVERFLOW (dsize)
 513                  && TREE_INT_CST_HIGH (dsize) == 0
 514                  && TREE_INT_CST_LOW (dsize) + const_size >= const_size)
 515           /* Use const_size if there's no overflow.  */
 516           const_size += TREE_INT_CST_LOW (dsize);
 517         else
 518           {
 519             if (var_size == 0)
 520               var_size = dsize;
 521             else
 522               var_size = size_binop (PLUS_EXPR, var_size, dsize);
 523           }
 524       }
 525     }
 526
 527   /* Work out the total size and alignment of the record
 528      as one expression and store in the record type.
 529      Round it up to a multiple of the record's alignment.  */
 530
 531   if (var_size == 0)
 532     {
 533       TYPE_SIZE (rec) = size_int (const_size);
 534     }
 535   else
 536     {
 537       if (const_size)
 538         var_size
 539           = size_binop (PLUS_EXPR, var_size, bitsize_int (const_size, 0L));
 540       TYPE_SIZE (rec) = var_size;
 541     }
 542
 543   /* Determine the desired alignment.  */
 544 #ifdef ROUND_TYPE_ALIGN
 545   TYPE_ALIGN (rec) = ROUND_TYPE_ALIGN (rec, TYPE_ALIGN (rec), record_align);
 546 #else
 547   TYPE_ALIGN (rec) = MAX (TYPE_ALIGN (rec), record_align);
 548 #endif
 549
 550 #ifdef ROUND_TYPE_SIZE
 551   TYPE_SIZE (rec) = ROUND_TYPE_SIZE (rec, TYPE_SIZE (rec), TYPE_ALIGN (rec));
 552 #else
 553   /* Round the size up to be a multiple of the required alignment */
 554   TYPE_SIZE (rec) = round_up (TYPE_SIZE (rec), TYPE_ALIGN (rec));
 555 #endif
 556
 557   return pending_statics;
 558 }
 559 \f
 560 /* Lay out a UNION_TYPE or QUAL_UNION_TYPE type.
 561    Lay out all the fields, set their positions to zero,
 562    and compute the size and alignment of the union (maximum of any field).
 563    Note that if you set the TYPE_ALIGN before calling this
 564    then the union align is aligned to at least that boundary.  */
 565
 566 static void
 567 layout_union (rec)
 568      tree rec;
 569 {
 570   register tree field;
 571   unsigned union_align = BITS_PER_UNIT;
 572
 573   /* The size of the union, based on the fields scanned so far,
 574      is max (CONST_SIZE, VAR_SIZE).
 575      VAR_SIZE may be null; then CONST_SIZE by itself is the size.  */
 576   register int const_size = 0;
 577   register tree var_size = 0;
 578
 579 #ifdef STRUCTURE_SIZE_BOUNDARY
 580   /* Packed structures don't need to have minimum size.  */
 581   if (! TYPE_PACKED (rec))
 582     union_align = STRUCTURE_SIZE_BOUNDARY;
 583 #endif
 584
 585   /* If this is a QUAL_UNION_TYPE, we want to process the fields in
 586      the reverse order in building the COND_EXPR that denotes its
 587      size.  We reverse them again later.  */
 588   if (TREE_CODE (rec) == QUAL_UNION_TYPE)
 589     TYPE_FIELDS (rec) = nreverse (TYPE_FIELDS (rec));
 590
 591   for (field = TYPE_FIELDS (rec); field; field = TREE_CHAIN (field))
 592     {
 593       /* Enums which are local to this class need not be laid out.  */
 594       if (TREE_CODE (field) == CONST_DECL || TREE_CODE (field) == TYPE_DECL)
 595         continue;
 596
 597       layout_decl (field, 0);
 598       DECL_FIELD_BITPOS (field) = bitsize_int (0L, 0L);
 599
 600       /* Union must be at least as aligned as any field requires.  */
 601
 602       union_align = MAX (union_align, DECL_ALIGN (field));
 603
 604 #ifdef PCC_BITFIELD_TYPE_MATTERS
 605       /* On the m88000, a bit field of declare type `int'
 606          forces the entire union to have `int' alignment.  */
 607       if (PCC_BITFIELD_TYPE_MATTERS && DECL_BIT_FIELD_TYPE (field))
 608         union_align = MAX (union_align, TYPE_ALIGN (TREE_TYPE (field)));
 609 #endif
 610
 611       if (TREE_CODE (rec) == UNION_TYPE)
 612         {
 613           /* Set union_size to max (decl_size, union_size).
 614              There are more and less general ways to do this.
 615              Use only CONST_SIZE unless forced to use VAR_SIZE.  */
 616
 617           if (TREE_CODE (DECL_SIZE (field)) == INTEGER_CST)
 618             const_size
 619               = MAX (const_size, TREE_INT_CST_LOW (DECL_SIZE (field)));
 620           else if (var_size == 0)
 621             var_size = DECL_SIZE (field);
 622           else
 623             var_size = size_binop (MAX_EXPR, var_size, DECL_SIZE (field));
 624         }
 625       else if (TREE_CODE (rec) == QUAL_UNION_TYPE)
 626         var_size = fold (build (COND_EXPR, sizetype, DECL_QUALIFIER (field),
 627                                 DECL_SIZE (field),
 628                                 var_size ? var_size : bitsize_int (0L, 0L)));
 629       }
 630
 631   if (TREE_CODE (rec) == QUAL_UNION_TYPE)
 632     TYPE_FIELDS (rec) = nreverse (TYPE_FIELDS (rec));
 633
 634   /* Determine the ultimate size of the union (in bytes).  */
 635   if (NULL == var_size)
 636     TYPE_SIZE (rec) = bitsize_int (CEIL (const_size, BITS_PER_UNIT)
 637                                    * BITS_PER_UNIT, 0L);
 638   else if (const_size == 0)
 639     TYPE_SIZE (rec) = var_size;
 640   else
 641     TYPE_SIZE (rec) = size_binop (MAX_EXPR, var_size,
 642                                   round_up (bitsize_int (const_size, 0L),
 643                                             BITS_PER_UNIT));
 644
 645   /* Determine the desired alignment.  */
 646 #ifdef ROUND_TYPE_ALIGN
 647   TYPE_ALIGN (rec) = ROUND_TYPE_ALIGN (rec, TYPE_ALIGN (rec), union_align);
 648 #else
 649   TYPE_ALIGN (rec) = MAX (TYPE_ALIGN (rec), union_align);
 650 #endif
 651
 652 #ifdef ROUND_TYPE_SIZE
 653   TYPE_SIZE (rec) = ROUND_TYPE_SIZE (rec, TYPE_SIZE (rec), TYPE_ALIGN (rec));
 654 #else
 655   /* Round the size up to be a multiple of the required alignment */
 656   TYPE_SIZE (rec) = round_up (TYPE_SIZE (rec), TYPE_ALIGN (rec));
 657 #endif
 658 }
 659 \f
 660 /* Calculate the mode, size, and alignment for TYPE.
 661    For an array type, calculate the element separation as well.
 662    Record TYPE on the chain of permanent or temporary types
 663    so that dbxout will find out about it.
 664
 665    TYPE_SIZE of a type is nonzero if the type has been laid out already.
 666    layout_type does nothing on such a type.
 667
 668    If the type is incomplete, its TYPE_SIZE remains zero.  */
 669
 670 void
 671 layout_type (type)
 672      tree type;
 673 {
 674   int old;
 675   tree pending_statics;
 676
 677   if (type == 0)
 678     abort ();
 679
 680   /* Do nothing if type has been laid out before.  */
 681   if (TYPE_SIZE (type))
 682     return;
 683
 684   /* Make sure all nodes we allocate are not momentary;
 685      they must last past the current statement.  */
 686   old = suspend_momentary ();
 687
 688   /* Put all our nodes into the same obstack as the type.  Also,
 689      make expressions saveable (this is a no-op for permanent types).  */
 690
 691   push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type));
 692   saveable_allocation ();
 693
 694   switch (TREE_CODE (type))
 695     {
 696     case LANG_TYPE:
 697       /* This kind of type is the responsibility
 698          of the language-specific code.  */
 699       abort ();
 700
 701     case BOOLEAN_TYPE:  /* Used for Java, Pascal, and Chill. */
 702       if (TYPE_PRECISION (type) == 0)
 703         TYPE_PRECISION (type) = 1; /* default to one byte/boolean. */
 704       /* ... fall through ... */
 705
 706     case INTEGER_TYPE:
 707     case ENUMERAL_TYPE:
 708     case CHAR_TYPE:
 709       if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
 710           && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0)
 711         TREE_UNSIGNED (type) = 1;
 712
 713       TYPE_MODE (type) = smallest_mode_for_size (TYPE_PRECISION (type),
 714                                                  MODE_INT);
 715       TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)), 0L);
 716       break;
 717
 718     case REAL_TYPE:
 719       TYPE_MODE (type) = mode_for_size (TYPE_PRECISION (type), MODE_FLOAT, 0);
 720       TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)), 0L);
 721       break;
 722
 723     case COMPLEX_TYPE:
 724       TREE_UNSIGNED (type) = TREE_UNSIGNED (TREE_TYPE (type));
 725       TYPE_MODE (type)
 726         = mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type)),
 727                          (TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE
 728                           ? MODE_COMPLEX_INT : MODE_COMPLEX_FLOAT),
 729                          0);
 730       TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)), 0L);
 731       break;
 732
 733     case VOID_TYPE:
 734       TYPE_SIZE (type) = size_zero_node;
 735       TYPE_ALIGN (type) = 1;
 736       TYPE_MODE (type) = VOIDmode;
 737       break;
 738
 739     case OFFSET_TYPE:
 740       TYPE_SIZE (type) = bitsize_int (POINTER_SIZE, 0L);
 741       TYPE_MODE (type) = ptr_mode;
 742       break;
 743
 744     case FUNCTION_TYPE:
 745     case METHOD_TYPE:
 746       TYPE_MODE (type) = mode_for_size (2 * POINTER_SIZE, MODE_INT, 0);
 747       TYPE_SIZE (type) = size_int (2 * POINTER_SIZE);
 748       break;
 749
 750     case POINTER_TYPE:
 751     case REFERENCE_TYPE:
 752       TYPE_MODE (type) = ptr_mode;
 753       TYPE_SIZE (type) = bitsize_int (POINTER_SIZE, 0L);
 754       TREE_UNSIGNED (type) = 1;
 755       TYPE_PRECISION (type) = POINTER_SIZE;
 756       break;
 757
 758     case ARRAY_TYPE:
 759       {
 760         register tree index = TYPE_DOMAIN (type);
 761         register tree element = TREE_TYPE (type);
 762
 763         build_pointer_type (element);
 764
 765         /* We need to know both bounds in order to compute the size.  */
 766         if (index && TYPE_MAX_VALUE (index) && TYPE_MIN_VALUE (index)
 767             && TYPE_SIZE (element))
 768           {
 769             tree ub = TYPE_MAX_VALUE (index);
 770             tree lb = TYPE_MIN_VALUE (index);
 771             tree length;
 772
 773             /* If UB is max (lb - 1, x), remove the MAX_EXPR since the
 774                test for negative below covers it.  */
 775             if (TREE_CODE (ub) == MAX_EXPR
 776                 && TREE_CODE (TREE_OPERAND (ub, 0)) == MINUS_EXPR
 777                 && integer_onep (TREE_OPERAND (TREE_OPERAND (ub, 0), 1))
 778                 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (ub, 0), 0),
 779                                     lb, 0))
 780               ub = TREE_OPERAND (ub, 1);
 781             else if (TREE_CODE (ub) == MAX_EXPR
 782                      && TREE_CODE (TREE_OPERAND (ub, 1)) == MINUS_EXPR
 783                      && integer_onep (TREE_OPERAND (TREE_OPERAND (ub, 1), 1))
 784                      && operand_equal_p (TREE_OPERAND (TREE_OPERAND (ub, 1),
 785                                                        0),
 786                                          lb, 0))
 787               ub = TREE_OPERAND (ub, 0);
 788
 789             /* The initial subtraction should happen in the original type so
 790                that (possible) negative values are handled appropriately.  */
 791             length = size_binop (PLUS_EXPR, size_one_node,
 792                                  fold (build (MINUS_EXPR, TREE_TYPE (lb),
 793                                               ub, lb)));
 794
 795             /* If neither bound is a constant and sizetype is signed, make
 796                sure the size is never negative.  We should really do this
 797                if *either* bound is non-constant, but this is the best
 798                compromise between C and Ada.  */
 799             if (! TREE_UNSIGNED (sizetype)
 800                 && TREE_CODE (TYPE_MIN_VALUE (index)) != INTEGER_CST
 801                 && TREE_CODE (TYPE_MAX_VALUE (index)) != INTEGER_CST)
 802               length = size_binop (MAX_EXPR, length, size_zero_node);
 803
 804             TYPE_SIZE (type) = size_binop (MULT_EXPR, TYPE_SIZE (element),
 805                                            length);
 806           }
 807
 808         /* Now round the alignment and size,
 809            using machine-dependent criteria if any.  */
 810
 811 #ifdef ROUND_TYPE_ALIGN
 812         TYPE_ALIGN (type)
 813           = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (element), BITS_PER_UNIT);
 814 #else
 815         TYPE_ALIGN (type) = MAX (TYPE_ALIGN (element), BITS_PER_UNIT);
 816 #endif
 817
 818 #ifdef ROUND_TYPE_SIZE
 819         if (TYPE_SIZE (type) != 0)
 820           TYPE_SIZE (type)
 821             = ROUND_TYPE_SIZE (type, TYPE_SIZE (type), TYPE_ALIGN (type));
 822 #endif
 823
 824         TYPE_MODE (type) = BLKmode;
 825         if (TYPE_SIZE (type) != 0
 826             && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
 827             /* BLKmode elements force BLKmode aggregate;
 828                else extract/store fields may lose.  */
 829             && (TYPE_MODE (TREE_TYPE (type)) != BLKmode
 830                 || TYPE_NO_FORCE_BLK (TREE_TYPE (type))))
 831           {
 832             TYPE_MODE (type)
 833               = mode_for_size (TREE_INT_CST_LOW (TYPE_SIZE (type)),
 834                                MODE_INT, 1);
 835
 836             if (STRICT_ALIGNMENT && TYPE_ALIGN (type) < BIGGEST_ALIGNMENT
 837                 && TYPE_ALIGN (type) < TREE_INT_CST_LOW (TYPE_SIZE (type))
 838                 && TYPE_MODE (type) != BLKmode)
 839               {
 840                 TYPE_NO_FORCE_BLK (type) = 1;
 841                 TYPE_MODE (type) = BLKmode;
 842               }
 843           }
 844         break;
 845       }
 846
 847     case RECORD_TYPE:
 848       pending_statics = layout_record (type);
 849       TYPE_MODE (type) = BLKmode;
 850       if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
 851         {
 852           tree field;
 853           enum machine_mode mode = VOIDmode;
 854
 855           /* A record which has any BLKmode members must itself be BLKmode;
 856              it can't go in a register.
 857              Unless the member is BLKmode only because it isn't aligned.  */
 858           for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
 859             {
 860               int bitpos;
 861
 862               if (TREE_CODE (field) != FIELD_DECL)
 863                 continue;
 864
 865               if (TYPE_MODE (TREE_TYPE (field)) == BLKmode
 866                   && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field)))
 867                 goto record_lose;
 868
 869               if (TREE_CODE (DECL_FIELD_BITPOS (field)) != INTEGER_CST)
 870                 goto record_lose;
 871
 872               bitpos = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field));
 873
 874               /* Must be BLKmode if any field crosses a word boundary,
 875                  since extract_bit_field can't handle that in registers.  */
 876               if (bitpos / BITS_PER_WORD
 877                   != ((TREE_INT_CST_LOW (DECL_SIZE (field)) + bitpos - 1)
 878                       / BITS_PER_WORD)
 879                   /* But there is no problem if the field is entire words.  */
 880                   && TREE_INT_CST_LOW (DECL_SIZE (field)) % BITS_PER_WORD != 0)
 881                 goto record_lose;
 882
 883               /* If this field is the whole struct, remember its mode so
 884                  that, say, we can put a double in a class into a DF
 885                  register instead of forcing it to live in the stack.  */
 886               if (simple_cst_equal (TYPE_SIZE (type), DECL_SIZE (field)))
 887                 mode = DECL_MODE (field);
 888             }
 889
 890           if (mode != VOIDmode)
 891             /* We only have one real field; use its mode.  */
 892             TYPE_MODE (type) = mode;
 893           else
 894             TYPE_MODE (type)
 895               = mode_for_size (TREE_INT_CST_LOW (TYPE_SIZE (type)),
 896                                MODE_INT, 1);
 897
 898           /* If structure's known alignment is less than
 899              what the scalar mode would need, and it matters,
 900              then stick with BLKmode.  */
 901           if (STRICT_ALIGNMENT
 902               && ! (TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT
 903                     || (TYPE_ALIGN (type)
 904                         >= TREE_INT_CST_LOW (TYPE_SIZE (type)))))
 905             {
 906               if (TYPE_MODE (type) != BLKmode)
 907                 /* If this is the only reason this type is BLKmode,
 908                    then don't force containing types to be BLKmode.  */
 909                 TYPE_NO_FORCE_BLK (type) = 1;
 910               TYPE_MODE (type) = BLKmode;
 911             }
 912
 913         record_lose: ;
 914         }
 915
 916       /* Lay out any static members.  This is done now
 917          because their type may use the record's type.  */
 918       while (pending_statics)
 919         {
 920           layout_decl (TREE_VALUE (pending_statics), 0);
 921           pending_statics = TREE_CHAIN (pending_statics);
 922         }
 923       break;
 924
 925     case UNION_TYPE:
 926     case QUAL_UNION_TYPE:
 927       layout_union (type);
 928       TYPE_MODE (type) = BLKmode;
 929       if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
 930           /* If structure's known alignment is less than
 931              what the scalar mode would need, and it matters,
 932              then stick with BLKmode.  */
 933           && (! STRICT_ALIGNMENT
 934               || TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT
 935               || TYPE_ALIGN (type) >= TREE_INT_CST_LOW (TYPE_SIZE (type))))
 936         {
 937           tree field;
 938           /* A union which has any BLKmode members must itself be BLKmode;
 939              it can't go in a register.
 940              Unless the member is BLKmode only because it isn't aligned.  */
 941           for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
 942             {
 943               if (TREE_CODE (field) != FIELD_DECL)
 944                 continue;
 945
 946               if (TYPE_MODE (TREE_TYPE (field)) == BLKmode
 947                   && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field)))
 948                 goto union_lose;
 949             }
 950
 951           TYPE_MODE (type)
 952             = mode_for_size (TREE_INT_CST_LOW (TYPE_SIZE (type)),
 953                              MODE_INT, 1);
 954
 955         union_lose: ;
 956         }
 957       break;
 958
 959     case SET_TYPE:  /* Used by Chill and Pascal. */
 960       if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST
 961           || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST)
 962         abort();
 963       else
 964         {
 965 #ifndef SET_WORD_SIZE
 966 #define SET_WORD_SIZE BITS_PER_WORD
 967 #endif
 968           int alignment = set_alignment ? set_alignment : SET_WORD_SIZE;
 969           int size_in_bits
 970             = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
 971                - TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) + 1);
 972           int rounded_size
 973             = ((size_in_bits + alignment - 1) / alignment) * alignment;
 974           if (rounded_size > alignment)
 975             TYPE_MODE (type) = BLKmode;
 976           else
 977             TYPE_MODE (type) = mode_for_size (alignment, MODE_INT, 1);
 978           TYPE_SIZE (type) = bitsize_int (rounded_size, 0L);
 979           TYPE_ALIGN (type) = alignment;
 980           TYPE_PRECISION (type) = size_in_bits;
 981         }
 982       break;
 983
 984     case FILE_TYPE:
 985       /* The size may vary in different languages, so the language front end
 986          should fill in the size.  */
 987       TYPE_ALIGN (type) = BIGGEST_ALIGNMENT;
 988       TYPE_MODE  (type) = BLKmode;
 989       break;
 990
 991     default:
 992       abort ();
 993     } /* end switch */
 994
 995   /* Normally, use the alignment corresponding to the mode chosen.
 996      However, where strict alignment is not required, avoid
 997      over-aligning structures, since most compilers do not do this
 998      alignment.  */
 999
1000   if (TYPE_MODE (type) != BLKmode && TYPE_MODE (type) != VOIDmode
1001       && (STRICT_ALIGNMENT
1002           || (TREE_CODE (type) != RECORD_TYPE && TREE_CODE (type) != UNION_TYPE
1003               && TREE_CODE (type) != QUAL_UNION_TYPE
1004               && TREE_CODE (type) != ARRAY_TYPE)))
1005     TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type));
1006
1007   /* Evaluate nonconstant size only once, either now or as soon as safe.  */
1008   if (TYPE_SIZE (type) != 0 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1009     TYPE_SIZE (type) = variable_size (TYPE_SIZE (type));
1010
1011   /* Also layout any other variants of the type.  */
1012   if (TYPE_NEXT_VARIANT (type)
1013       || type != TYPE_MAIN_VARIANT (type))
1014     {
1015       tree variant;
1016       /* Record layout info of this variant.  */
1017       tree size = TYPE_SIZE (type);
1018       int align = TYPE_ALIGN (type);
1019       enum machine_mode mode = TYPE_MODE (type);
1020
1021       /* Copy it into all variants.  */
1022       for (variant = TYPE_MAIN_VARIANT (type);
1023            variant;
1024            variant = TYPE_NEXT_VARIANT (variant))
1025         {
1026           TYPE_SIZE (variant) = size;
1027           TYPE_ALIGN (variant) = align;
1028           TYPE_MODE (variant) = mode;
1029         }
1030     }
1031
1032   pop_obstacks ();
1033   resume_momentary (old);
1034 }
1035 \f
1036 /* Create and return a type for signed integers of PRECISION bits.  */
1037
1038 tree
1039 make_signed_type (precision)
1040      int precision;
1041 {
1042   register tree type = make_node (INTEGER_TYPE);
1043
1044   TYPE_PRECISION (type) = precision;
1045
1046   /* Create the extreme values based on the number of bits.  */
1047
1048   TYPE_MIN_VALUE (type)
1049     = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
1050                     ? 0 : (HOST_WIDE_INT) (-1) << (precision - 1)),
1051                    (((HOST_WIDE_INT) (-1)
1052                      << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
1053                          ? precision - HOST_BITS_PER_WIDE_INT - 1
1054                          : 0))));
1055   TYPE_MAX_VALUE (type)
1056     = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
1057                     ? -1 : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1),
1058                    (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
1059                     ? (((HOST_WIDE_INT) 1
1060                         << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1
1061                     : 0));
1062
1063   /* Give this type's extreme values this type as their type.  */
1064
1065   TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
1066   TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
1067
1068   /* The first type made with this or `make_unsigned_type'
1069      is the type for size values.  */
1070
1071   if (sizetype == 0)
1072     set_sizetype (type);
1073
1074   /* Lay out the type: set its alignment, size, etc.  */
1075
1076   layout_type (type);
1077
1078   return type;
1079 }
1080
1081 /* Create and return a type for unsigned integers of PRECISION bits.  */
1082
1083 tree
1084 make_unsigned_type (precision)
1085      int precision;
1086 {
1087   register tree type = make_node (INTEGER_TYPE);
1088
1089   TYPE_PRECISION (type) = precision;
1090
1091   /* The first type made with this or `make_signed_type'
1092      is the type for size values.  */
1093
1094   if (sizetype == 0)
1095     {
1096       TREE_UNSIGNED (type) = 1;
1097       set_sizetype (type);
1098     }
1099
1100   fixup_unsigned_type (type);
1101   return type;
1102 }
1103
1104 /* Set sizetype to TYPE, and initialize *bitsizetype accordingly.
1105    Also update the type of any standard type's sizes made so far.  */
1106
1107 void
1108 set_sizetype (type)
1109      tree type;
1110 {
1111   int precision = TYPE_PRECISION (type);
1112
1113   sizetype = type;
1114
1115   /* The *bitsizetype types use a precision that avoids overflows when
1116      calculating signed sizes / offsets in bits.
1117
1118      We are allocating bitsizetype once and change it in place when
1119      we decide later that we want to change it.  This way, we avoid the
1120      hassle of changing all the TYPE_SIZE (TREE_TYPE (sometype))
1121      individually in each front end.  */
1122   if (! bitsizetype)
1123     bitsizetype = make_node (INTEGER_TYPE);
1124
1125   precision += BITS_PER_UNIT_LOG + 1;
1126   /* However, when cross-compiling from a 32 bit to a 64 bit host,
1127      we are limited to 64 bit precision.  */
1128   if (precision > 2 * HOST_BITS_PER_WIDE_INT)
1129     precision = 2 * HOST_BITS_PER_WIDE_INT;
1130   TYPE_PRECISION (bitsizetype) = precision;
1131   (TREE_UNSIGNED (type) ? fixup_unsigned_type : fixup_signed_type)
1132     (bitsizetype);
1133   layout_type (bitsizetype);
1134
1135   sbitsizetype = make_signed_type (precision);
1136   ubitsizetype = make_unsigned_type (precision);
1137 }
1138
1139 /* Set the extreme values of TYPE based on its precision in bits,
1140    then lay it out.  Used when make_signed_type won't do
1141    because the tree code is not INTEGER_TYPE.
1142    E.g. for Pascal, when the -fsigned-char option is given.  */
1143
1144 void
1145 fixup_signed_type (type)
1146      tree type;
1147 {
1148   register int precision = TYPE_PRECISION (type);
1149
1150   TYPE_MIN_VALUE (type)
1151     = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
1152                     ? 0 : (HOST_WIDE_INT) (-1) << (precision - 1)),
1153                    (((HOST_WIDE_INT) (-1)
1154                      << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
1155                          ? precision - HOST_BITS_PER_WIDE_INT - 1
1156                          : 0))));
1157   TYPE_MAX_VALUE (type)
1158     = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
1159                     ? -1 : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1),
1160                    (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
1161                     ? (((HOST_WIDE_INT) 1
1162                         << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1
1163                     : 0));
1164
1165   TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
1166   TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
1167
1168   /* Lay out the type: set its alignment, size, etc.  */
1169
1170   layout_type (type);
1171 }
1172
1173 /* Set the extreme values of TYPE based on its precision in bits,
1174    then lay it out.  This is used both in `make_unsigned_type'
1175    and for enumeral types.  */
1176
1177 void
1178 fixup_unsigned_type (type)
1179      tree type;
1180 {
1181   register int precision = TYPE_PRECISION (type);
1182
1183   TYPE_MIN_VALUE (type) = build_int_2 (0, 0);
1184   TYPE_MAX_VALUE (type)
1185     = build_int_2 (precision - HOST_BITS_PER_WIDE_INT >= 0
1186                    ? -1 : ((HOST_WIDE_INT) 1 << precision) - 1,
1187                    precision - HOST_BITS_PER_WIDE_INT > 0
1188                    ? ((unsigned HOST_WIDE_INT) ~0
1189                       >> (HOST_BITS_PER_WIDE_INT
1190                           - (precision - HOST_BITS_PER_WIDE_INT)))
1191                    : 0);
1192   TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
1193   TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
1194
1195   /* Lay out the type: set its alignment, size, etc.  */
1196
1197   layout_type (type);
1198 }
1199 \f
1200 /* Find the best machine mode to use when referencing a bit field of length
1201    BITSIZE bits starting at BITPOS.
1202
1203    The underlying object is known to be aligned to a boundary of ALIGN bits.
1204    If LARGEST_MODE is not VOIDmode, it means that we should not use a mode
1205    larger than LARGEST_MODE (usually SImode).
1206
1207    If no mode meets all these conditions, we return VOIDmode.  Otherwise, if
1208    VOLATILEP is true or SLOW_BYTE_ACCESS is false, we return the smallest
1209    mode meeting these conditions.
1210
1211    Otherwise (VOLATILEP is false and SLOW_BYTE_ACCESS is true), we return
1212    the largest mode (but a mode no wider than UNITS_PER_WORD) that meets
1213    all the conditions.  */
1214
1215 enum machine_mode
1216 get_best_mode (bitsize, bitpos, align, largest_mode, volatilep)
1217      int bitsize, bitpos;
1218      int align;
1219      enum machine_mode largest_mode;
1220      int volatilep;
1221 {
1222   enum machine_mode mode;
1223   int unit;
1224
1225   /* Find the narrowest integer mode that contains the bit field.  */
1226   for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
1227        mode = GET_MODE_WIDER_MODE (mode))
1228     {
1229       unit = GET_MODE_BITSIZE (mode);
1230       if ((bitpos % unit) + bitsize <= unit)
1231         break;
1232     }
1233
1234   if (mode == MAX_MACHINE_MODE
1235       /* It is tempting to omit the following line
1236          if STRICT_ALIGNMENT is true.
1237          But that is incorrect, since if the bitfield uses part of 3 bytes
1238          and we use a 4-byte mode, we could get a spurious segv
1239          if the extra 4th byte is past the end of memory.
1240          (Though at least one Unix compiler ignores this problem:
1241          that on the Sequent 386 machine.  */
1242       || MIN (unit, BIGGEST_ALIGNMENT) > align
1243       || (largest_mode != VOIDmode && unit > GET_MODE_BITSIZE (largest_mode)))
1244     return VOIDmode;
1245
1246   if (SLOW_BYTE_ACCESS && ! volatilep)
1247     {
1248       enum machine_mode wide_mode = VOIDmode, tmode;
1249
1250       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT); tmode != VOIDmode;
1251            tmode = GET_MODE_WIDER_MODE (tmode))
1252         {
1253           unit = GET_MODE_BITSIZE (tmode);
1254           if (bitpos / unit == (bitpos + bitsize - 1) / unit
1255               && unit <= BITS_PER_WORD
1256               && unit <= MIN (align, BIGGEST_ALIGNMENT)
1257               && (largest_mode == VOIDmode
1258                   || unit <= GET_MODE_BITSIZE (largest_mode)))
1259             wide_mode = tmode;
1260         }
1261
1262       if (wide_mode != VOIDmode)
1263         return wide_mode;
1264     }
1265
1266   return mode;
1267 }
1268 \f
1269 /* Save all variables describing the current status into the structure *P.
1270    This is used before starting a nested function.  */
1271
1272 void
1273 save_storage_status (p)
1274      struct function *p;
1275 {
1276 #if 0  /* Need not save, since always 0 and non0 (resp.) within a function.  */
1277   p->pending_sizes = pending_sizes;
1278   p->immediate_size_expand = immediate_size_expand;
1279 #endif /* 0 */
1280 }
1281
1282 /* Restore all variables describing the current status from the structure *P.
1283    This is used after a nested function.  */
1284
1285 void
1286 restore_storage_status (p)
1287      struct function *p;
1288 {
1289 #if 0
1290   pending_sizes = p->pending_sizes;
1291   immediate_size_expand = p->immediate_size_expand;
1292 #endif /* 0 */
1293 }