gcc/stor-layout.c

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