gcc/stor-layout.c

   1 /* C-compiler utilities for types and variables storage layout
   2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1996, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tm.h"
  27 #include "tree.h"
  28 #include "rtl.h"
  29 #include "tm_p.h"
  30 #include "flags.h"
  31 #include "function.h"
  32 #include "expr.h"
  33 #include "output.h"
  34 #include "toplev.h"
  35 #include "ggc.h"
  36 #include "target.h"
  37 #include "langhooks.h"
  38 #include "regs.h"
  39 #include "params.h"
  40 #include "cgraph.h"
  41 #include "tree-inline.h"
  42 #include "tree-dump.h"
  43 #include "gimple.h"
  44
  45 /* Data type for the expressions representing sizes of data types.
  46    It is the first integer type laid out.  */
  47 tree sizetype_tab[(int) TYPE_KIND_LAST];
  48
  49 /* If nonzero, this is an upper limit on alignment of structure fields.
  50    The value is measured in bits.  */
  51 unsigned int maximum_field_alignment = TARGET_DEFAULT_PACK_STRUCT * BITS_PER_UNIT;
  52 /* ... and its original value in bytes, specified via -fpack-struct=<value>.  */
  53 unsigned int initial_max_fld_align = TARGET_DEFAULT_PACK_STRUCT;
  54
  55 /* Nonzero if all REFERENCE_TYPEs are internal and hence should be
  56    allocated in Pmode, not ptr_mode.   Set only by internal_reference_types
  57    called only by a front end.  */
  58 static int reference_types_internal = 0;
  59
  60 static tree self_referential_size (tree);
  61 static void finalize_record_size (record_layout_info);
  62 static void finalize_type_size (tree);
  63 static void place_union_field (record_layout_info, tree);
  64 #if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED)
  65 static int excess_unit_span (HOST_WIDE_INT, HOST_WIDE_INT, HOST_WIDE_INT,
  66                              HOST_WIDE_INT, tree);
  67 #endif
  68 extern void debug_rli (record_layout_info);
  69 \f
  70 /* SAVE_EXPRs for sizes of types and decls, waiting to be expanded.  */
  71
  72 static GTY(()) tree pending_sizes;
  73
  74 /* Show that REFERENCE_TYPES are internal and should be Pmode.  Called only
  75    by front end.  */
  76
  77 void
  78 internal_reference_types (void)
  79 {
  80   reference_types_internal = 1;
  81 }
  82
  83 /* Get a list of all the objects put on the pending sizes list.  */
  84
  85 tree
  86 get_pending_sizes (void)
  87 {
  88   tree chain = pending_sizes;
  89
  90   pending_sizes = 0;
  91   return chain;
  92 }
  93
  94 /* Add EXPR to the pending sizes list.  */
  95
  96 void
  97 put_pending_size (tree expr)
  98 {
  99   /* Strip any simple arithmetic from EXPR to see if it has an underlying
 100      SAVE_EXPR.  */
 101   expr = skip_simple_arithmetic (expr);
 102
 103   if (TREE_CODE (expr) == SAVE_EXPR)
 104     pending_sizes = tree_cons (NULL_TREE, expr, pending_sizes);
 105 }
 106
 107 /* Put a chain of objects into the pending sizes list, which must be
 108    empty.  */
 109
 110 void
 111 put_pending_sizes (tree chain)
 112 {
 113   gcc_assert (!pending_sizes);
 114   pending_sizes = chain;
 115 }
 116
 117 /* Given a size SIZE that may not be a constant, return a SAVE_EXPR
 118    to serve as the actual size-expression for a type or decl.  */
 119
 120 tree
 121 variable_size (tree size)
 122 {
 123   tree save;
 124
 125   /* Obviously.  */
 126   if (TREE_CONSTANT (size))
 127     return size;
 128
 129   /* If the size is self-referential, we can't make a SAVE_EXPR (see
 130      save_expr for the rationale).  But we can do something else.  */
 131   if (CONTAINS_PLACEHOLDER_P (size))
 132     return self_referential_size (size);
 133
 134   /* If the language-processor is to take responsibility for variable-sized
 135      items (e.g., languages which have elaboration procedures like Ada),
 136      just return SIZE unchanged.  */
 137   if (lang_hooks.decls.global_bindings_p () < 0)
 138     return size;
 139
 140   size = save_expr (size);
 141
 142   /* If an array with a variable number of elements is declared, and
 143      the elements require destruction, we will emit a cleanup for the
 144      array.  That cleanup is run both on normal exit from the block
 145      and in the exception-handler for the block.  Normally, when code
 146      is used in both ordinary code and in an exception handler it is
 147      `unsaved', i.e., all SAVE_EXPRs are recalculated.  However, we do
 148      not wish to do that here; the array-size is the same in both
 149      places.  */
 150   save = skip_simple_arithmetic (size);
 151
 152   if (cfun && cfun->dont_save_pending_sizes_p)
 153     /* The front-end doesn't want us to keep a list of the expressions
 154        that determine sizes for variable size objects.  Trust it.  */
 155     return size;
 156
 157   if (lang_hooks.decls.global_bindings_p ())
 158     {
 159       if (TREE_CONSTANT (size))
 160         error ("type size can%'t be explicitly evaluated");
 161       else
 162         error ("variable-size type declared outside of any function");
 163
 164       return size_one_node;
 165     }
 166
 167   put_pending_size (save);
 168
 169   return size;
 170 }
 171
 172 /* An array of functions used for self-referential size computation.  */
 173 static GTY(()) VEC (tree, gc) *size_functions;
 174
 175 /* Similar to copy_tree_r but do not copy component references involving
 176    PLACEHOLDER_EXPRs.  These nodes are spotted in find_placeholder_in_expr
 177    and substituted in substitute_in_expr.  */
 178
 179 static tree
 180 copy_self_referential_tree_r (tree *tp, int *walk_subtrees, void *data)
 181 {
 182   enum tree_code code = TREE_CODE (*tp);
 183
 184   /* Stop at types, decls, constants like copy_tree_r.  */
 185   if (TREE_CODE_CLASS (code) == tcc_type
 186       || TREE_CODE_CLASS (code) == tcc_declaration
 187       || TREE_CODE_CLASS (code) == tcc_constant)
 188     {
 189       *walk_subtrees = 0;
 190       return NULL_TREE;
 191     }
 192
 193   /* This is the pattern built in ada/make_aligning_type.  */
 194   else if (code == ADDR_EXPR
 195            && TREE_CODE (TREE_OPERAND (*tp, 0)) == PLACEHOLDER_EXPR)
 196     {
 197       *walk_subtrees = 0;
 198       return NULL_TREE;
 199     }
 200
 201   /* Default case: the component reference.  */
 202   else if (code == COMPONENT_REF)
 203     {
 204       tree inner;
 205       for (inner = TREE_OPERAND (*tp, 0);
 206            REFERENCE_CLASS_P (inner);
 207            inner = TREE_OPERAND (inner, 0))
 208         ;
 209
 210       if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
 211         {
 212           *walk_subtrees = 0;
 213           return NULL_TREE;
 214         }
 215     }
 216
 217   /* We're not supposed to have them in self-referential size trees
 218      because we wouldn't properly control when they are evaluated.
 219      However, not creating superfluous SAVE_EXPRs requires accurate
 220      tracking of readonly-ness all the way down to here, which we
 221      cannot always guarantee in practice.  So punt in this case.  */
 222   else if (code == SAVE_EXPR)
 223     return error_mark_node;
 224
 225   return copy_tree_r (tp, walk_subtrees, data);
 226 }
 227
 228 /* Given a SIZE expression that is self-referential, return an equivalent
 229    expression to serve as the actual size expression for a type.  */
 230
 231 static tree
 232 self_referential_size (tree size)
 233 {
 234   static unsigned HOST_WIDE_INT fnno = 0;
 235   VEC (tree, heap) *self_refs = NULL;
 236   tree param_type_list = NULL, param_decl_list = NULL, arg_list = NULL;
 237   tree t, ref, return_type, fntype, fnname, fndecl;
 238   unsigned int i;
 239   char buf[128];
 240
 241   /* Do not factor out simple operations.  */
 242   t = skip_simple_arithmetic (size);
 243   if (TREE_CODE (t) == CALL_EXPR)
 244     return size;
 245
 246   /* Collect the list of self-references in the expression.  */
 247   find_placeholder_in_expr (size, &self_refs);
 248   gcc_assert (VEC_length (tree, self_refs) > 0);
 249
 250   /* Obtain a private copy of the expression.  */
 251   t = size;
 252   if (walk_tree (&t, copy_self_referential_tree_r, NULL, NULL) != NULL_TREE)
 253     return size;
 254   size = t;
 255
 256   /* Build the parameter and argument lists in parallel; also
 257      substitute the former for the latter in the expression.  */
 258   for (i = 0; VEC_iterate (tree, self_refs, i, ref); i++)
 259     {
 260       tree subst, param_name, param_type, param_decl;
 261
 262       if (DECL_P (ref))
 263         {
 264           /* We shouldn't have true variables here.  */
 265           gcc_assert (TREE_READONLY (ref));
 266           subst = ref;
 267         }
 268       /* This is the pattern built in ada/make_aligning_type.  */
 269       else if (TREE_CODE (ref) == ADDR_EXPR)
 270         subst = ref;
 271       /* Default case: the component reference.  */
 272       else
 273         subst = TREE_OPERAND (ref, 1);
 274
 275       sprintf (buf, "p%d", i);
 276       param_name = get_identifier (buf);
 277       param_type = TREE_TYPE (ref);
 278       param_decl
 279         = build_decl (input_location, PARM_DECL, param_name, param_type);
 280       if (targetm.calls.promote_prototypes (NULL_TREE)
 281           && INTEGRAL_TYPE_P (param_type)
 282           && TYPE_PRECISION (param_type) < TYPE_PRECISION (integer_type_node))
 283         DECL_ARG_TYPE (param_decl) = integer_type_node;
 284       else
 285         DECL_ARG_TYPE (param_decl) = param_type;
 286       DECL_ARTIFICIAL (param_decl) = 1;
 287       TREE_READONLY (param_decl) = 1;
 288
 289       size = substitute_in_expr (size, subst, param_decl);
 290
 291       param_type_list = tree_cons (NULL_TREE, param_type, param_type_list);
 292       param_decl_list = chainon (param_decl, param_decl_list);
 293       arg_list = tree_cons (NULL_TREE, ref, arg_list);
 294     }
 295
 296   VEC_free (tree, heap, self_refs);
 297
 298   /* Append 'void' to indicate that the number of parameters is fixed.  */
 299   param_type_list = tree_cons (NULL_TREE, void_type_node, param_type_list);
 300
 301   /* The 3 lists have been created in reverse order.  */
 302   param_type_list = nreverse (param_type_list);
 303   param_decl_list = nreverse (param_decl_list);
 304   arg_list = nreverse (arg_list);
 305
 306   /* Build the function type.  */
 307   return_type = TREE_TYPE (size);
 308   fntype = build_function_type (return_type, param_type_list);
 309
 310   /* Build the function declaration.  */
 311   sprintf (buf, "SZ"HOST_WIDE_INT_PRINT_UNSIGNED, fnno++);
 312   fnname = get_file_function_name (buf);
 313   fndecl = build_decl (input_location, FUNCTION_DECL, fnname, fntype);
 314   for (t = param_decl_list; t; t = TREE_CHAIN (t))
 315     DECL_CONTEXT (t) = fndecl;
 316   DECL_ARGUMENTS (fndecl) = param_decl_list;
 317   DECL_RESULT (fndecl)
 318     = build_decl (input_location, RESULT_DECL, 0, return_type);
 319   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
 320
 321   /* The function has been created by the compiler and we don't
 322      want to emit debug info for it.  */
 323   DECL_ARTIFICIAL (fndecl) = 1;
 324   DECL_IGNORED_P (fndecl) = 1;
 325
 326   /* It is supposed to be "const" and never throw.  */
 327   TREE_READONLY (fndecl) = 1;
 328   TREE_NOTHROW (fndecl) = 1;
 329
 330   /* We want it to be inlined when this is deemed profitable, as
 331      well as discarded if every call has been integrated.  */
 332   DECL_DECLARED_INLINE_P (fndecl) = 1;
 333
 334   /* It is made up of a unique return statement.  */
 335   DECL_INITIAL (fndecl) = make_node (BLOCK);
 336   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
 337   t = build2 (MODIFY_EXPR, return_type, DECL_RESULT (fndecl), size);
 338   DECL_SAVED_TREE (fndecl) = build1 (RETURN_EXPR, void_type_node, t);
 339   TREE_STATIC (fndecl) = 1;
 340
 341   /* Put it onto the list of size functions.  */
 342   VEC_safe_push (tree, gc, size_functions, fndecl);
 343
 344   /* Replace the original expression with a call to the size function.  */
 345   return build_function_call_expr (fndecl, arg_list);
 346 }
 347
 348 /* Take, queue and compile all the size functions.  It is essential that
 349    the size functions be gimplified at the very end of the compilation
 350    in order to guarantee transparent handling of self-referential sizes.
 351    Otherwise the GENERIC inliner would not be able to inline them back
 352    at each of their call sites, thus creating artificial non-constant
 353    size expressions which would trigger nasty problems later on.  */
 354
 355 void
 356 finalize_size_functions (void)
 357 {
 358   unsigned int i;
 359   tree fndecl;
 360
 361   for (i = 0; VEC_iterate(tree, size_functions, i, fndecl); i++)
 362     {
 363       dump_function (TDI_original, fndecl);
 364       gimplify_function_tree (fndecl);
 365       dump_function (TDI_generic, fndecl);
 366       cgraph_finalize_function (fndecl, false);
 367     }
 368
 369   VEC_free (tree, gc, size_functions);
 370 }
 371 \f
 372 #ifndef MAX_FIXED_MODE_SIZE
 373 #define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (DImode)
 374 #endif
 375
 376 /* Return the machine mode to use for a nonscalar of SIZE bits.  The
 377    mode must be in class MCLASS, and have exactly that many value bits;
 378    it may have padding as well.  If LIMIT is nonzero, modes of wider
 379    than MAX_FIXED_MODE_SIZE will not be used.  */
 380
 381 enum machine_mode
 382 mode_for_size (unsigned int size, enum mode_class mclass, int limit)
 383 {
 384   enum machine_mode mode;
 385
 386   if (limit && size > MAX_FIXED_MODE_SIZE)
 387     return BLKmode;
 388
 389   /* Get the first mode which has this size, in the specified class.  */
 390   for (mode = GET_CLASS_NARROWEST_MODE (mclass); mode != VOIDmode;
 391        mode = GET_MODE_WIDER_MODE (mode))
 392     if (GET_MODE_PRECISION (mode) == size)
 393       return mode;
 394
 395   return BLKmode;
 396 }
 397
 398 /* Similar, except passed a tree node.  */
 399
 400 enum machine_mode
 401 mode_for_size_tree (const_tree size, enum mode_class mclass, int limit)
 402 {
 403   unsigned HOST_WIDE_INT uhwi;
 404   unsigned int ui;
 405
 406   if (!host_integerp (size, 1))
 407     return BLKmode;
 408   uhwi = tree_low_cst (size, 1);
 409   ui = uhwi;
 410   if (uhwi != ui)
 411     return BLKmode;
 412   return mode_for_size (ui, mclass, limit);
 413 }
 414
 415 /* Similar, but never return BLKmode; return the narrowest mode that
 416    contains at least the requested number of value bits.  */
 417
 418 enum machine_mode
 419 smallest_mode_for_size (unsigned int size, enum mode_class mclass)
 420 {
 421   enum machine_mode mode;
 422
 423   /* Get the first mode which has at least this size, in the
 424      specified class.  */
 425   for (mode = GET_CLASS_NARROWEST_MODE (mclass); mode != VOIDmode;
 426        mode = GET_MODE_WIDER_MODE (mode))
 427     if (GET_MODE_PRECISION (mode) >= size)
 428       return mode;
 429
 430   gcc_unreachable ();
 431 }
 432
 433 /* Find an integer mode of the exact same size, or BLKmode on failure.  */
 434
 435 enum machine_mode
 436 int_mode_for_mode (enum machine_mode mode)
 437 {
 438   switch (GET_MODE_CLASS (mode))
 439     {
 440     case MODE_INT:
 441     case MODE_PARTIAL_INT:
 442       break;
 443
 444     case MODE_COMPLEX_INT:
 445     case MODE_COMPLEX_FLOAT:
 446     case MODE_FLOAT:
 447     case MODE_DECIMAL_FLOAT:
 448     case MODE_VECTOR_INT:
 449     case MODE_VECTOR_FLOAT:
 450     case MODE_FRACT:
 451     case MODE_ACCUM:
 452     case MODE_UFRACT:
 453     case MODE_UACCUM:
 454     case MODE_VECTOR_FRACT:
 455     case MODE_VECTOR_ACCUM:
 456     case MODE_VECTOR_UFRACT:
 457     case MODE_VECTOR_UACCUM:
 458       mode = mode_for_size (GET_MODE_BITSIZE (mode), MODE_INT, 0);
 459       break;
 460
 461     case MODE_RANDOM:
 462       if (mode == BLKmode)
 463         break;
 464
 465       /* ... fall through ...  */
 466
 467     case MODE_CC:
 468     default:
 469       gcc_unreachable ();
 470     }
 471
 472   return mode;
 473 }
 474
 475 /* Return the alignment of MODE. This will be bounded by 1 and
 476    BIGGEST_ALIGNMENT.  */
 477
 478 unsigned int
 479 get_mode_alignment (enum machine_mode mode)
 480 {
 481   return MIN (BIGGEST_ALIGNMENT, MAX (1, mode_base_align[mode]*BITS_PER_UNIT));
 482 }
 483
 484 \f
 485 /* Subroutine of layout_decl: Force alignment required for the data type.
 486    But if the decl itself wants greater alignment, don't override that.  */
 487
 488 static inline void
 489 do_type_align (tree type, tree decl)
 490 {
 491   if (TYPE_ALIGN (type) > DECL_ALIGN (decl))
 492     {
 493       DECL_ALIGN (decl) = TYPE_ALIGN (type);
 494       if (TREE_CODE (decl) == FIELD_DECL)
 495         DECL_USER_ALIGN (decl) = TYPE_USER_ALIGN (type);
 496     }
 497 }
 498
 499 /* Set the size, mode and alignment of a ..._DECL node.
 500    TYPE_DECL does need this for C++.
 501    Note that LABEL_DECL and CONST_DECL nodes do not need this,
 502    and FUNCTION_DECL nodes have them set up in a special (and simple) way.
 503    Don't call layout_decl for them.
 504
 505    KNOWN_ALIGN is the amount of alignment we can assume this
 506    decl has with no special effort.  It is relevant only for FIELD_DECLs
 507    and depends on the previous fields.
 508    All that matters about KNOWN_ALIGN is which powers of 2 divide it.
 509    If KNOWN_ALIGN is 0, it means, "as much alignment as you like":
 510    the record will be aligned to suit.  */
 511
 512 void
 513 layout_decl (tree decl, unsigned int known_align)
 514 {
 515   tree type = TREE_TYPE (decl);
 516   enum tree_code code = TREE_CODE (decl);
 517   rtx rtl = NULL_RTX;
 518
 519   if (code == CONST_DECL)
 520     return;
 521
 522   gcc_assert (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL
 523               || code == TYPE_DECL ||code == FIELD_DECL);
 524
 525   rtl = DECL_RTL_IF_SET (decl);
 526
 527   if (type == error_mark_node)
 528     type = void_type_node;
 529
 530   /* Usually the size and mode come from the data type without change,
 531      however, the front-end may set the explicit width of the field, so its
 532      size may not be the same as the size of its type.  This happens with
 533      bitfields, of course (an `int' bitfield may be only 2 bits, say), but it
 534      also happens with other fields.  For example, the C++ front-end creates
 535      zero-sized fields corresponding to empty base classes, and depends on
 536      layout_type setting DECL_FIELD_BITPOS correctly for the field.  Set the
 537      size in bytes from the size in bits.  If we have already set the mode,
 538      don't set it again since we can be called twice for FIELD_DECLs.  */
 539
 540   DECL_UNSIGNED (decl) = TYPE_UNSIGNED (type);
 541   if (DECL_MODE (decl) == VOIDmode)
 542     DECL_MODE (decl) = TYPE_MODE (type);
 543
 544   if (DECL_SIZE (decl) == 0)
 545     {
 546       DECL_SIZE (decl) = TYPE_SIZE (type);
 547       DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (type);
 548     }
 549   else if (DECL_SIZE_UNIT (decl) == 0)
 550     DECL_SIZE_UNIT (decl)
 551       = fold_convert (sizetype, size_binop (CEIL_DIV_EXPR, DECL_SIZE (decl),
 552                                             bitsize_unit_node));
 553
 554   if (code != FIELD_DECL)
 555     /* For non-fields, update the alignment from the type.  */
 556     do_type_align (type, decl);
 557   else
 558     /* For fields, it's a bit more complicated...  */
 559     {
 560       bool old_user_align = DECL_USER_ALIGN (decl);
 561       bool zero_bitfield = false;
 562       bool packed_p = DECL_PACKED (decl);
 563       unsigned int mfa;
 564
 565       if (DECL_BIT_FIELD (decl))
 566         {
 567           DECL_BIT_FIELD_TYPE (decl) = type;
 568
 569           /* A zero-length bit-field affects the alignment of the next
 570              field.  In essence such bit-fields are not influenced by
 571              any packing due to #pragma pack or attribute packed.  */
 572           if (integer_zerop (DECL_SIZE (decl))
 573               && ! targetm.ms_bitfield_layout_p (DECL_FIELD_CONTEXT (decl)))
 574             {
 575               zero_bitfield = true;
 576               packed_p = false;
 577 #ifdef PCC_BITFIELD_TYPE_MATTERS
 578               if (PCC_BITFIELD_TYPE_MATTERS)
 579                 do_type_align (type, decl);
 580               else
 581 #endif
 582                 {
 583 #ifdef EMPTY_FIELD_BOUNDARY
 584                   if (EMPTY_FIELD_BOUNDARY > DECL_ALIGN (decl))
 585                     {
 586                       DECL_ALIGN (decl) = EMPTY_FIELD_BOUNDARY;
 587                       DECL_USER_ALIGN (decl) = 0;
 588                     }
 589 #endif
 590                 }
 591             }
 592
 593           /* See if we can use an ordinary integer mode for a bit-field.
 594              Conditions are: a fixed size that is correct for another mode
 595              and occupying a complete byte or bytes on proper boundary.  */
 596           if (TYPE_SIZE (type) != 0
 597               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
 598               && GET_MODE_CLASS (TYPE_MODE (type)) == MODE_INT)
 599             {
 600               enum machine_mode xmode
 601                 = mode_for_size_tree (DECL_SIZE (decl), MODE_INT, 1);
 602               unsigned int xalign = GET_MODE_ALIGNMENT (xmode);
 603
 604               if (xmode != BLKmode
 605                   && !(xalign > BITS_PER_UNIT && DECL_PACKED (decl))
 606                   && (known_align == 0 || known_align >= xalign))
 607                 {
 608                   DECL_ALIGN (decl) = MAX (xalign, DECL_ALIGN (decl));
 609                   DECL_MODE (decl) = xmode;
 610                   DECL_BIT_FIELD (decl) = 0;
 611                 }
 612             }
 613
 614           /* Turn off DECL_BIT_FIELD if we won't need it set.  */
 615           if (TYPE_MODE (type) == BLKmode && DECL_MODE (decl) == BLKmode
 616               && known_align >= TYPE_ALIGN (type)
 617               && DECL_ALIGN (decl) >= TYPE_ALIGN (type))
 618             DECL_BIT_FIELD (decl) = 0;
 619         }
 620       else if (packed_p && DECL_USER_ALIGN (decl))
 621         /* Don't touch DECL_ALIGN.  For other packed fields, go ahead and
 622            round up; we'll reduce it again below.  We want packing to
 623            supersede USER_ALIGN inherited from the type, but defer to
 624            alignment explicitly specified on the field decl.  */;
 625       else
 626         do_type_align (type, decl);
 627
 628       /* If the field is packed and not explicitly aligned, give it the
 629          minimum alignment.  Note that do_type_align may set
 630          DECL_USER_ALIGN, so we need to check old_user_align instead.  */
 631       if (packed_p
 632           && !old_user_align)
 633         DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), BITS_PER_UNIT);
 634
 635       if (! packed_p && ! DECL_USER_ALIGN (decl))
 636         {
 637           /* Some targets (i.e. i386, VMS) limit struct field alignment
 638              to a lower boundary than alignment of variables unless
 639              it was overridden by attribute aligned.  */
 640 #ifdef BIGGEST_FIELD_ALIGNMENT
 641           DECL_ALIGN (decl)
 642             = MIN (DECL_ALIGN (decl), (unsigned) BIGGEST_FIELD_ALIGNMENT);
 643 #endif
 644 #ifdef ADJUST_FIELD_ALIGN
 645           DECL_ALIGN (decl) = ADJUST_FIELD_ALIGN (decl, DECL_ALIGN (decl));
 646 #endif
 647         }
 648
 649       if (zero_bitfield)
 650         mfa = initial_max_fld_align * BITS_PER_UNIT;
 651       else
 652         mfa = maximum_field_alignment;
 653       /* Should this be controlled by DECL_USER_ALIGN, too?  */
 654       if (mfa != 0)
 655         DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), mfa);
 656     }
 657
 658   /* Evaluate nonconstant size only once, either now or as soon as safe.  */
 659   if (DECL_SIZE (decl) != 0 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
 660     DECL_SIZE (decl) = variable_size (DECL_SIZE (decl));
 661   if (DECL_SIZE_UNIT (decl) != 0
 662       && TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST)
 663     DECL_SIZE_UNIT (decl) = variable_size (DECL_SIZE_UNIT (decl));
 664
 665   /* If requested, warn about definitions of large data objects.  */
 666   if (warn_larger_than
 667       && (code == VAR_DECL || code == PARM_DECL)
 668       && ! DECL_EXTERNAL (decl))
 669     {
 670       tree size = DECL_SIZE_UNIT (decl);
 671
 672       if (size != 0 && TREE_CODE (size) == INTEGER_CST
 673           && compare_tree_int (size, larger_than_size) > 0)
 674         {
 675           int size_as_int = TREE_INT_CST_LOW (size);
 676
 677           if (compare_tree_int (size, size_as_int) == 0)
 678             warning (OPT_Wlarger_than_eq, "size of %q+D is %d bytes", decl, size_as_int);
 679           else
 680             warning (OPT_Wlarger_than_eq, "size of %q+D is larger than %wd bytes",
 681                      decl, larger_than_size);
 682         }
 683     }
 684
 685   /* If the RTL was already set, update its mode and mem attributes.  */
 686   if (rtl)
 687     {
 688       PUT_MODE (rtl, DECL_MODE (decl));
 689       SET_DECL_RTL (decl, 0);
 690       set_mem_attributes (rtl, decl, 1);
 691       SET_DECL_RTL (decl, rtl);
 692     }
 693 }
 694
 695 /* Given a VAR_DECL, PARM_DECL or RESULT_DECL, clears the results of
 696    a previous call to layout_decl and calls it again.  */
 697
 698 void
 699 relayout_decl (tree decl)
 700 {
 701   DECL_SIZE (decl) = DECL_SIZE_UNIT (decl) = 0;
 702   DECL_MODE (decl) = VOIDmode;
 703   if (!DECL_USER_ALIGN (decl))
 704     DECL_ALIGN (decl) = 0;
 705   SET_DECL_RTL (decl, 0);
 706
 707   layout_decl (decl, 0);
 708 }
 709 \f
 710 /* Begin laying out type T, which may be a RECORD_TYPE, UNION_TYPE, or
 711    QUAL_UNION_TYPE.  Return a pointer to a struct record_layout_info which
 712    is to be passed to all other layout functions for this record.  It is the
 713    responsibility of the caller to call `free' for the storage returned.
 714    Note that garbage collection is not permitted until we finish laying
 715    out the record.  */
 716
 717 record_layout_info
 718 start_record_layout (tree t)
 719 {
 720   record_layout_info rli = XNEW (struct record_layout_info_s);
 721
 722   rli->t = t;
 723
 724   /* If the type has a minimum specified alignment (via an attribute
 725      declaration, for example) use it -- otherwise, start with a
 726      one-byte alignment.  */
 727   rli->record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (t));
 728   rli->unpacked_align = rli->record_align;
 729   rli->offset_align = MAX (rli->record_align, BIGGEST_ALIGNMENT);
 730
 731 #ifdef STRUCTURE_SIZE_BOUNDARY
 732   /* Packed structures don't need to have minimum size.  */
 733   if (! TYPE_PACKED (t))
 734     {
 735       unsigned tmp;
 736
 737       /* #pragma pack overrides STRUCTURE_SIZE_BOUNDARY.  */
 738       tmp = (unsigned) STRUCTURE_SIZE_BOUNDARY;
 739       if (maximum_field_alignment != 0)
 740         tmp = MIN (tmp, maximum_field_alignment);
 741       rli->record_align = MAX (rli->record_align, tmp);
 742     }
 743 #endif
 744
 745   rli->offset = size_zero_node;
 746   rli->bitpos = bitsize_zero_node;
 747   rli->prev_field = 0;
 748   rli->pending_statics = 0;
 749   rli->packed_maybe_necessary = 0;
 750   rli->remaining_in_alignment = 0;
 751
 752   return rli;
 753 }
 754
 755 /* These four routines perform computations that convert between
 756    the offset/bitpos forms and byte and bit offsets.  */
 757
 758 tree
 759 bit_from_pos (tree offset, tree bitpos)
 760 {
 761   return size_binop (PLUS_EXPR, bitpos,
 762                      size_binop (MULT_EXPR,
 763                                  fold_convert (bitsizetype, offset),
 764                                  bitsize_unit_node));
 765 }
 766
 767 tree
 768 byte_from_pos (tree offset, tree bitpos)
 769 {
 770   return size_binop (PLUS_EXPR, offset,
 771                      fold_convert (sizetype,
 772                                    size_binop (TRUNC_DIV_EXPR, bitpos,
 773                                                bitsize_unit_node)));
 774 }
 775
 776 void
 777 pos_from_bit (tree *poffset, tree *pbitpos, unsigned int off_align,
 778               tree pos)
 779 {
 780   *poffset = size_binop (MULT_EXPR,
 781                          fold_convert (sizetype,
 782                                        size_binop (FLOOR_DIV_EXPR, pos,
 783                                                    bitsize_int (off_align))),
 784                          size_int (off_align / BITS_PER_UNIT));
 785   *pbitpos = size_binop (FLOOR_MOD_EXPR, pos, bitsize_int (off_align));
 786 }
 787
 788 /* Given a pointer to bit and byte offsets and an offset alignment,
 789    normalize the offsets so they are within the alignment.  */
 790
 791 void
 792 normalize_offset (tree *poffset, tree *pbitpos, unsigned int off_align)
 793 {
 794   /* If the bit position is now larger than it should be, adjust it
 795      downwards.  */
 796   if (compare_tree_int (*pbitpos, off_align) >= 0)
 797     {
 798       tree extra_aligns = size_binop (FLOOR_DIV_EXPR, *pbitpos,
 799                                       bitsize_int (off_align));
 800
 801       *poffset
 802         = size_binop (PLUS_EXPR, *poffset,
 803                       size_binop (MULT_EXPR,
 804                                   fold_convert (sizetype, extra_aligns),
 805                                   size_int (off_align / BITS_PER_UNIT)));
 806
 807       *pbitpos
 808         = size_binop (FLOOR_MOD_EXPR, *pbitpos, bitsize_int (off_align));
 809     }
 810 }
 811
 812 /* Print debugging information about the information in RLI.  */
 813
 814 void
 815 debug_rli (record_layout_info rli)
 816 {
 817   print_node_brief (stderr, "type", rli->t, 0);
 818   print_node_brief (stderr, "\noffset", rli->offset, 0);
 819   print_node_brief (stderr, " bitpos", rli->bitpos, 0);
 820
 821   fprintf (stderr, "\naligns: rec = %u, unpack = %u, off = %u\n",
 822            rli->record_align, rli->unpacked_align,
 823            rli->offset_align);
 824
 825   /* The ms_struct code is the only that uses this.  */
 826   if (targetm.ms_bitfield_layout_p (rli->t))
 827     fprintf (stderr, "remaining in alignment = %u\n", rli->remaining_in_alignment);
 828
 829   if (rli->packed_maybe_necessary)
 830     fprintf (stderr, "packed may be necessary\n");
 831
 832   if (rli->pending_statics)
 833     {
 834       fprintf (stderr, "pending statics:\n");
 835       debug_tree (rli->pending_statics);
 836     }
 837 }
 838
 839 /* Given an RLI with a possibly-incremented BITPOS, adjust OFFSET and
 840    BITPOS if necessary to keep BITPOS below OFFSET_ALIGN.  */
 841
 842 void
 843 normalize_rli (record_layout_info rli)
 844 {
 845   normalize_offset (&rli->offset, &rli->bitpos, rli->offset_align);
 846 }
 847
 848 /* Returns the size in bytes allocated so far.  */
 849
 850 tree
 851 rli_size_unit_so_far (record_layout_info rli)
 852 {
 853   return byte_from_pos (rli->offset, rli->bitpos);
 854 }
 855
 856 /* Returns the size in bits allocated so far.  */
 857
 858 tree
 859 rli_size_so_far (record_layout_info rli)
 860 {
 861   return bit_from_pos (rli->offset, rli->bitpos);
 862 }
 863
 864 /* FIELD is about to be added to RLI->T.  The alignment (in bits) of
 865    the next available location within the record is given by KNOWN_ALIGN.
 866    Update the variable alignment fields in RLI, and return the alignment
 867    to give the FIELD.  */
 868
 869 unsigned int
 870 update_alignment_for_field (record_layout_info rli, tree field,
 871                             unsigned int known_align)
 872 {
 873   /* The alignment required for FIELD.  */
 874   unsigned int desired_align;
 875   /* The type of this field.  */
 876   tree type = TREE_TYPE (field);
 877   /* True if the field was explicitly aligned by the user.  */
 878   bool user_align;
 879   bool is_bitfield;
 880
 881   /* Do not attempt to align an ERROR_MARK node */
 882   if (TREE_CODE (type) == ERROR_MARK)
 883     return 0;
 884
 885   /* Lay out the field so we know what alignment it needs.  */
 886   layout_decl (field, known_align);
 887   desired_align = DECL_ALIGN (field);
 888   user_align = DECL_USER_ALIGN (field);
 889
 890   is_bitfield = (type != error_mark_node
 891                  && DECL_BIT_FIELD_TYPE (field)
 892                  && ! integer_zerop (TYPE_SIZE (type)));
 893
 894   /* Record must have at least as much alignment as any field.
 895      Otherwise, the alignment of the field within the record is
 896      meaningless.  */
 897   if (targetm.ms_bitfield_layout_p (rli->t))
 898     {
 899       /* Here, the alignment of the underlying type of a bitfield can
 900          affect the alignment of a record; even a zero-sized field
 901          can do this.  The alignment should be to the alignment of
 902          the type, except that for zero-size bitfields this only
 903          applies if there was an immediately prior, nonzero-size
 904          bitfield.  (That's the way it is, experimentally.) */
 905       if ((!is_bitfield && !DECL_PACKED (field))
 906           || (!integer_zerop (DECL_SIZE (field))
 907               ? !DECL_PACKED (field)
 908               : (rli->prev_field
 909                  && DECL_BIT_FIELD_TYPE (rli->prev_field)
 910                  && ! integer_zerop (DECL_SIZE (rli->prev_field)))))
 911         {
 912           unsigned int type_align = TYPE_ALIGN (type);
 913           type_align = MAX (type_align, desired_align);
 914           if (maximum_field_alignment != 0)
 915             type_align = MIN (type_align, maximum_field_alignment);
 916           rli->record_align = MAX (rli->record_align, type_align);
 917           rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type));
 918         }
 919     }
 920 #ifdef PCC_BITFIELD_TYPE_MATTERS
 921   else if (is_bitfield && PCC_BITFIELD_TYPE_MATTERS)
 922     {
 923       /* Named bit-fields cause the entire structure to have the
 924          alignment implied by their type.  Some targets also apply the same
 925          rules to unnamed bitfields.  */
 926       if (DECL_NAME (field) != 0
 927           || targetm.align_anon_bitfield ())
 928         {
 929           unsigned int type_align = TYPE_ALIGN (type);
 930
 931 #ifdef ADJUST_FIELD_ALIGN
 932           if (! TYPE_USER_ALIGN (type))
 933             type_align = ADJUST_FIELD_ALIGN (field, type_align);
 934 #endif
 935
 936           /* Targets might chose to handle unnamed and hence possibly
 937              zero-width bitfield.  Those are not influenced by #pragmas
 938              or packed attributes.  */
 939           if (integer_zerop (DECL_SIZE (field)))
 940             {
 941               if (initial_max_fld_align)
 942                 type_align = MIN (type_align,
 943                                   initial_max_fld_align * BITS_PER_UNIT);
 944             }
 945           else if (maximum_field_alignment != 0)
 946             type_align = MIN (type_align, maximum_field_alignment);
 947           else if (DECL_PACKED (field))
 948             type_align = MIN (type_align, BITS_PER_UNIT);
 949
 950           /* The alignment of the record is increased to the maximum
 951              of the current alignment, the alignment indicated on the
 952              field (i.e., the alignment specified by an __aligned__
 953              attribute), and the alignment indicated by the type of
 954              the field.  */
 955           rli->record_align = MAX (rli->record_align, desired_align);
 956           rli->record_align = MAX (rli->record_align, type_align);
 957
 958           if (warn_packed)
 959             rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type));
 960           user_align |= TYPE_USER_ALIGN (type);
 961         }
 962     }
 963 #endif
 964   else
 965     {
 966       rli->record_align = MAX (rli->record_align, desired_align);
 967       rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type));
 968     }
 969
 970   TYPE_USER_ALIGN (rli->t) |= user_align;
 971
 972   return desired_align;
 973 }
 974
 975 /* Called from place_field to handle unions.  */
 976
 977 static void
 978 place_union_field (record_layout_info rli, tree field)
 979 {
 980   update_alignment_for_field (rli, field, /*known_align=*/0);
 981
 982   DECL_FIELD_OFFSET (field) = size_zero_node;
 983   DECL_FIELD_BIT_OFFSET (field) = bitsize_zero_node;
 984   SET_DECL_OFFSET_ALIGN (field, BIGGEST_ALIGNMENT);
 985
 986   /* If this is an ERROR_MARK return *after* having set the
 987      field at the start of the union. This helps when parsing
 988      invalid fields. */
 989   if (TREE_CODE (TREE_TYPE (field)) == ERROR_MARK)
 990     return;
 991
 992   /* We assume the union's size will be a multiple of a byte so we don't
 993      bother with BITPOS.  */
 994   if (TREE_CODE (rli->t) == UNION_TYPE)
 995     rli->offset = size_binop (MAX_EXPR, rli->offset, DECL_SIZE_UNIT (field));
 996   else if (TREE_CODE (rli->t) == QUAL_UNION_TYPE)
 997     rli->offset = fold_build3 (COND_EXPR, sizetype,
 998                                DECL_QUALIFIER (field),
 999                                DECL_SIZE_UNIT (field), rli->offset);
1000 }
1001
1002 #if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED)
1003 /* A bitfield of SIZE with a required access alignment of ALIGN is allocated
1004    at BYTE_OFFSET / BIT_OFFSET.  Return nonzero if the field would span more
1005    units of alignment than the underlying TYPE.  */
1006 static int
1007 excess_unit_span (HOST_WIDE_INT byte_offset, HOST_WIDE_INT bit_offset,
1008                   HOST_WIDE_INT size, HOST_WIDE_INT align, tree type)
1009 {
1010   /* Note that the calculation of OFFSET might overflow; we calculate it so
1011      that we still get the right result as long as ALIGN is a power of two.  */
1012   unsigned HOST_WIDE_INT offset = byte_offset * BITS_PER_UNIT + bit_offset;
1013
1014   offset = offset % align;
1015   return ((offset + size + align - 1) / align
1016           > ((unsigned HOST_WIDE_INT) tree_low_cst (TYPE_SIZE (type), 1)
1017              / align));
1018 }
1019 #endif
1020
1021 /* RLI contains information about the layout of a RECORD_TYPE.  FIELD
1022    is a FIELD_DECL to be added after those fields already present in
1023    T.  (FIELD is not actually added to the TYPE_FIELDS list here;
1024    callers that desire that behavior must manually perform that step.)  */
1025
1026 void
1027 place_field (record_layout_info rli, tree field)
1028 {
1029   /* The alignment required for FIELD.  */
1030   unsigned int desired_align;
1031   /* The alignment FIELD would have if we just dropped it into the
1032      record as it presently stands.  */
1033   unsigned int known_align;
1034   unsigned int actual_align;
1035   /* The type of this field.  */
1036   tree type = TREE_TYPE (field);
1037
1038   gcc_assert (TREE_CODE (field) != ERROR_MARK);
1039
1040   /* If FIELD is static, then treat it like a separate variable, not
1041      really like a structure field.  If it is a FUNCTION_DECL, it's a
1042      method.  In both cases, all we do is lay out the decl, and we do
1043      it *after* the record is laid out.  */
1044   if (TREE_CODE (field) == VAR_DECL)
1045     {
1046       rli->pending_statics = tree_cons (NULL_TREE, field,
1047                                         rli->pending_statics);
1048       return;
1049     }
1050
1051   /* Enumerators and enum types which are local to this class need not
1052      be laid out.  Likewise for initialized constant fields.  */
1053   else if (TREE_CODE (field) != FIELD_DECL)
1054     return;
1055
1056   /* Unions are laid out very differently than records, so split
1057      that code off to another function.  */
1058   else if (TREE_CODE (rli->t) != RECORD_TYPE)
1059     {
1060       place_union_field (rli, field);
1061       return;
1062     }
1063
1064   else if (TREE_CODE (type) == ERROR_MARK)
1065     {
1066       /* Place this field at the current allocation position, so we
1067          maintain monotonicity.  */
1068       DECL_FIELD_OFFSET (field) = rli->offset;
1069       DECL_FIELD_BIT_OFFSET (field) = rli->bitpos;
1070       SET_DECL_OFFSET_ALIGN (field, rli->offset_align);
1071       return;
1072     }
1073
1074   /* Work out the known alignment so far.  Note that A & (-A) is the
1075      value of the least-significant bit in A that is one.  */
1076   if (! integer_zerop (rli->bitpos))
1077     known_align = (tree_low_cst (rli->bitpos, 1)
1078                    & - tree_low_cst (rli->bitpos, 1));
1079   else if (integer_zerop (rli->offset))
1080     known_align = 0;
1081   else if (host_integerp (rli->offset, 1))
1082     known_align = (BITS_PER_UNIT
1083                    * (tree_low_cst (rli->offset, 1)
1084                       & - tree_low_cst (rli->offset, 1)));
1085   else
1086     known_align = rli->offset_align;
1087
1088   desired_align = update_alignment_for_field (rli, field, known_align);
1089   if (known_align == 0)
1090     known_align = MAX (BIGGEST_ALIGNMENT, rli->record_align);
1091
1092   if (warn_packed && DECL_PACKED (field))
1093     {
1094       if (known_align >= TYPE_ALIGN (type))
1095         {
1096           if (TYPE_ALIGN (type) > desired_align)
1097             {
1098               if (STRICT_ALIGNMENT)
1099                 warning (OPT_Wattributes, "packed attribute causes "
1100                          "inefficient alignment for %q+D", field);
1101               else
1102                 warning (OPT_Wattributes, "packed attribute is "
1103                          "unnecessary for %q+D", field);
1104             }
1105         }
1106       else
1107         rli->packed_maybe_necessary = 1;
1108     }
1109
1110   /* Does this field automatically have alignment it needs by virtue
1111      of the fields that precede it and the record's own alignment?
1112      We already align ms_struct fields, so don't re-align them.  */
1113   if (known_align < desired_align
1114       && !targetm.ms_bitfield_layout_p (rli->t))
1115     {
1116       /* No, we need to skip space before this field.
1117          Bump the cumulative size to multiple of field alignment.  */
1118
1119       warning (OPT_Wpadded, "padding struct to align %q+D", field);
1120
1121       /* If the alignment is still within offset_align, just align
1122          the bit position.  */
1123       if (desired_align < rli->offset_align)
1124         rli->bitpos = round_up (rli->bitpos, desired_align);
1125       else
1126         {
1127           /* First adjust OFFSET by the partial bits, then align.  */
1128           rli->offset
1129             = size_binop (PLUS_EXPR, rli->offset,
1130                           fold_convert (sizetype,
1131                                         size_binop (CEIL_DIV_EXPR, rli->bitpos,
1132                                                     bitsize_unit_node)));
1133           rli->bitpos = bitsize_zero_node;
1134
1135           rli->offset = round_up (rli->offset, desired_align / BITS_PER_UNIT);
1136         }
1137
1138       if (! TREE_CONSTANT (rli->offset))
1139         rli->offset_align = desired_align;
1140
1141     }
1142
1143   /* Handle compatibility with PCC.  Note that if the record has any
1144      variable-sized fields, we need not worry about compatibility.  */
1145 #ifdef PCC_BITFIELD_TYPE_MATTERS
1146   if (PCC_BITFIELD_TYPE_MATTERS
1147       && ! targetm.ms_bitfield_layout_p (rli->t)
1148       && TREE_CODE (field) == FIELD_DECL
1149       && type != error_mark_node
1150       && DECL_BIT_FIELD (field)
1151       && (! DECL_PACKED (field)
1152           /* Enter for these packed fields only to issue a warning.  */
1153           || TYPE_ALIGN (type) <= BITS_PER_UNIT)
1154       && maximum_field_alignment == 0
1155       && ! integer_zerop (DECL_SIZE (field))
1156       && host_integerp (DECL_SIZE (field), 1)
1157       && host_integerp (rli->offset, 1)
1158       && host_integerp (TYPE_SIZE (type), 1))
1159     {
1160       unsigned int type_align = TYPE_ALIGN (type);
1161       tree dsize = DECL_SIZE (field);
1162       HOST_WIDE_INT field_size = tree_low_cst (dsize, 1);
1163       HOST_WIDE_INT offset = tree_low_cst (rli->offset, 0);
1164       HOST_WIDE_INT bit_offset = tree_low_cst (rli->bitpos, 0);
1165
1166 #ifdef ADJUST_FIELD_ALIGN
1167       if (! TYPE_USER_ALIGN (type))
1168         type_align = ADJUST_FIELD_ALIGN (field, type_align);
1169 #endif
1170
1171       /* A bit field may not span more units of alignment of its type
1172          than its type itself.  Advance to next boundary if necessary.  */
1173       if (excess_unit_span (offset, bit_offset, field_size, type_align, type))
1174         {
1175           if (DECL_PACKED (field))
1176             {
1177               if (warn_packed_bitfield_compat == 1)
1178                 inform
1179                   (input_location,
1180                    "Offset of packed bit-field %qD has changed in GCC 4.4",
1181                    field);
1182             }
1183           else
1184             rli->bitpos = round_up (rli->bitpos, type_align);
1185         }
1186
1187       if (! DECL_PACKED (field))
1188         TYPE_USER_ALIGN (rli->t) |= TYPE_USER_ALIGN (type);
1189     }
1190 #endif
1191
1192 #ifdef BITFIELD_NBYTES_LIMITED
1193   if (BITFIELD_NBYTES_LIMITED
1194       && ! targetm.ms_bitfield_layout_p (rli->t)
1195       && TREE_CODE (field) == FIELD_DECL
1196       && type != error_mark_node
1197       && DECL_BIT_FIELD_TYPE (field)
1198       && ! DECL_PACKED (field)
1199       && ! integer_zerop (DECL_SIZE (field))
1200       && host_integerp (DECL_SIZE (field), 1)
1201       && host_integerp (rli->offset, 1)
1202       && host_integerp (TYPE_SIZE (type), 1))
1203     {
1204       unsigned int type_align = TYPE_ALIGN (type);
1205       tree dsize = DECL_SIZE (field);
1206       HOST_WIDE_INT field_size = tree_low_cst (dsize, 1);
1207       HOST_WIDE_INT offset = tree_low_cst (rli->offset, 0);
1208       HOST_WIDE_INT bit_offset = tree_low_cst (rli->bitpos, 0);
1209
1210 #ifdef ADJUST_FIELD_ALIGN
1211       if (! TYPE_USER_ALIGN (type))
1212         type_align = ADJUST_FIELD_ALIGN (field, type_align);
1213 #endif
1214
1215       if (maximum_field_alignment != 0)
1216         type_align = MIN (type_align, maximum_field_alignment);
1217       /* ??? This test is opposite the test in the containing if
1218          statement, so this code is unreachable currently.  */
1219       else if (DECL_PACKED (field))
1220         type_align = MIN (type_align, BITS_PER_UNIT);
1221
1222       /* A bit field may not span the unit of alignment of its type.
1223          Advance to next boundary if necessary.  */
1224       if (excess_unit_span (offset, bit_offset, field_size, type_align, type))
1225         rli->bitpos = round_up (rli->bitpos, type_align);
1226
1227       TYPE_USER_ALIGN (rli->t) |= TYPE_USER_ALIGN (type);
1228     }
1229 #endif
1230
1231   /* See the docs for TARGET_MS_BITFIELD_LAYOUT_P for details.
1232      A subtlety:
1233         When a bit field is inserted into a packed record, the whole
1234         size of the underlying type is used by one or more same-size
1235         adjacent bitfields.  (That is, if its long:3, 32 bits is
1236         used in the record, and any additional adjacent long bitfields are
1237         packed into the same chunk of 32 bits. However, if the size
1238         changes, a new field of that size is allocated.)  In an unpacked
1239         record, this is the same as using alignment, but not equivalent
1240         when packing.
1241
1242      Note: for compatibility, we use the type size, not the type alignment
1243      to determine alignment, since that matches the documentation */
1244
1245   if (targetm.ms_bitfield_layout_p (rli->t))
1246     {
1247       tree prev_saved = rli->prev_field;
1248       tree prev_type = prev_saved ? DECL_BIT_FIELD_TYPE (prev_saved) : NULL;
1249
1250       /* This is a bitfield if it exists.  */
1251       if (rli->prev_field)
1252         {
1253           /* If both are bitfields, nonzero, and the same size, this is
1254              the middle of a run.  Zero declared size fields are special
1255              and handled as "end of run". (Note: it's nonzero declared
1256              size, but equal type sizes!) (Since we know that both
1257              the current and previous fields are bitfields by the
1258              time we check it, DECL_SIZE must be present for both.) */
1259           if (DECL_BIT_FIELD_TYPE (field)
1260               && !integer_zerop (DECL_SIZE (field))
1261               && !integer_zerop (DECL_SIZE (rli->prev_field))
1262               && host_integerp (DECL_SIZE (rli->prev_field), 0)
1263               && host_integerp (TYPE_SIZE (type), 0)
1264               && simple_cst_equal (TYPE_SIZE (type), TYPE_SIZE (prev_type)))
1265             {
1266               /* We're in the middle of a run of equal type size fields; make
1267                  sure we realign if we run out of bits.  (Not decl size,
1268                  type size!) */
1269               HOST_WIDE_INT bitsize = tree_low_cst (DECL_SIZE (field), 1);
1270
1271               if (rli->remaining_in_alignment < bitsize)
1272                 {
1273                   HOST_WIDE_INT typesize = tree_low_cst (TYPE_SIZE (type), 1);
1274
1275                   /* out of bits; bump up to next 'word'.  */
1276                   rli->bitpos
1277                     = size_binop (PLUS_EXPR, rli->bitpos,
1278                                   bitsize_int (rli->remaining_in_alignment));
1279                   rli->prev_field = field;
1280                   if (typesize < bitsize)
1281                     rli->remaining_in_alignment = 0;
1282                   else
1283                     rli->remaining_in_alignment = typesize - bitsize;
1284                 }
1285               else
1286                 rli->remaining_in_alignment -= bitsize;
1287             }
1288           else
1289             {
1290               /* End of a run: if leaving a run of bitfields of the same type
1291                  size, we have to "use up" the rest of the bits of the type
1292                  size.
1293
1294                  Compute the new position as the sum of the size for the prior
1295                  type and where we first started working on that type.
1296                  Note: since the beginning of the field was aligned then
1297                  of course the end will be too.  No round needed.  */
1298
1299               if (!integer_zerop (DECL_SIZE (rli->prev_field)))
1300                 {
1301                   rli->bitpos
1302                     = size_binop (PLUS_EXPR, rli->bitpos,
1303                                   bitsize_int (rli->remaining_in_alignment));
1304                 }
1305               else
1306                 /* We "use up" size zero fields; the code below should behave
1307                    as if the prior field was not a bitfield.  */
1308                 prev_saved = NULL;
1309
1310               /* Cause a new bitfield to be captured, either this time (if
1311                  currently a bitfield) or next time we see one.  */
1312               if (!DECL_BIT_FIELD_TYPE(field)
1313                   || integer_zerop (DECL_SIZE (field)))
1314                 rli->prev_field = NULL;
1315             }
1316
1317           normalize_rli (rli);
1318         }
1319
1320       /* If we're starting a new run of same size type bitfields
1321          (or a run of non-bitfields), set up the "first of the run"
1322          fields.
1323
1324          That is, if the current field is not a bitfield, or if there
1325          was a prior bitfield the type sizes differ, or if there wasn't
1326          a prior bitfield the size of the current field is nonzero.
1327
1328          Note: we must be sure to test ONLY the type size if there was
1329          a prior bitfield and ONLY for the current field being zero if
1330          there wasn't.  */
1331
1332       if (!DECL_BIT_FIELD_TYPE (field)
1333           || (prev_saved != NULL
1334               ? !simple_cst_equal (TYPE_SIZE (type), TYPE_SIZE (prev_type))
1335               : !integer_zerop (DECL_SIZE (field)) ))
1336         {
1337           /* Never smaller than a byte for compatibility.  */
1338           unsigned int type_align = BITS_PER_UNIT;
1339
1340           /* (When not a bitfield), we could be seeing a flex array (with
1341              no DECL_SIZE).  Since we won't be using remaining_in_alignment
1342              until we see a bitfield (and come by here again) we just skip
1343              calculating it.  */
1344           if (DECL_SIZE (field) != NULL
1345               && host_integerp (TYPE_SIZE (TREE_TYPE (field)), 0)
1346               && host_integerp (DECL_SIZE (field), 0))
1347             {
1348               HOST_WIDE_INT bitsize = tree_low_cst (DECL_SIZE (field), 1);
1349               HOST_WIDE_INT typesize
1350                 = tree_low_cst (TYPE_SIZE (TREE_TYPE (field)), 1);
1351
1352               if (typesize < bitsize)
1353                 rli->remaining_in_alignment = 0;
1354               else
1355                 rli->remaining_in_alignment = typesize - bitsize;
1356             }
1357
1358           /* Now align (conventionally) for the new type.  */
1359           type_align = TYPE_ALIGN (TREE_TYPE (field));
1360
1361           if (maximum_field_alignment != 0)
1362             type_align = MIN (type_align, maximum_field_alignment);
1363
1364           rli->bitpos = round_up (rli->bitpos, type_align);
1365
1366           /* If we really aligned, don't allow subsequent bitfields
1367              to undo that.  */
1368           rli->prev_field = NULL;
1369         }
1370     }
1371
1372   /* Offset so far becomes the position of this field after normalizing.  */
1373   normalize_rli (rli);
1374   DECL_FIELD_OFFSET (field) = rli->offset;
1375   DECL_FIELD_BIT_OFFSET (field) = rli->bitpos;
1376   SET_DECL_OFFSET_ALIGN (field, rli->offset_align);
1377
1378   /* If this field ended up more aligned than we thought it would be (we
1379      approximate this by seeing if its position changed), lay out the field
1380      again; perhaps we can use an integral mode for it now.  */
1381   if (! integer_zerop (DECL_FIELD_BIT_OFFSET (field)))
1382     actual_align = (tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1383                     & - tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1));
1384   else if (integer_zerop (DECL_FIELD_OFFSET (field)))
1385     actual_align = MAX (BIGGEST_ALIGNMENT, rli->record_align);
1386   else if (host_integerp (DECL_FIELD_OFFSET (field), 1))
1387     actual_align = (BITS_PER_UNIT
1388                    * (tree_low_cst (DECL_FIELD_OFFSET (field), 1)
1389                       & - tree_low_cst (DECL_FIELD_OFFSET (field), 1)));
1390   else
1391     actual_align = DECL_OFFSET_ALIGN (field);
1392   /* ACTUAL_ALIGN is still the actual alignment *within the record* .
1393      store / extract bit field operations will check the alignment of the
1394      record against the mode of bit fields.  */
1395
1396   if (known_align != actual_align)
1397     layout_decl (field, actual_align);
1398
1399   if (rli->prev_field == NULL && DECL_BIT_FIELD_TYPE (field))
1400     rli->prev_field = field;
1401
1402   /* Now add size of this field to the size of the record.  If the size is
1403      not constant, treat the field as being a multiple of bytes and just
1404      adjust the offset, resetting the bit position.  Otherwise, apportion the
1405      size amongst the bit position and offset.  First handle the case of an
1406      unspecified size, which can happen when we have an invalid nested struct
1407      definition, such as struct j { struct j { int i; } }.  The error message
1408      is printed in finish_struct.  */
1409   if (DECL_SIZE (field) == 0)
1410     /* Do nothing.  */;
1411   else if (TREE_CODE (DECL_SIZE (field)) != INTEGER_CST
1412            || TREE_OVERFLOW (DECL_SIZE (field)))
1413     {
1414       rli->offset
1415         = size_binop (PLUS_EXPR, rli->offset,
1416                       fold_convert (sizetype,
1417                                     size_binop (CEIL_DIV_EXPR, rli->bitpos,
1418                                                 bitsize_unit_node)));
1419       rli->offset
1420         = size_binop (PLUS_EXPR, rli->offset, DECL_SIZE_UNIT (field));
1421       rli->bitpos = bitsize_zero_node;
1422       rli->offset_align = MIN (rli->offset_align, desired_align);
1423     }
1424   else if (targetm.ms_bitfield_layout_p (rli->t))
1425     {
1426       rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, DECL_SIZE (field));
1427
1428       /* If we ended a bitfield before the full length of the type then
1429          pad the struct out to the full length of the last type.  */
1430       if ((TREE_CHAIN (field) == NULL
1431            || TREE_CODE (TREE_CHAIN (field)) != FIELD_DECL)
1432           && DECL_BIT_FIELD_TYPE (field)
1433           && !integer_zerop (DECL_SIZE (field)))
1434         rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos,
1435                                   bitsize_int (rli->remaining_in_alignment));
1436
1437       normalize_rli (rli);
1438     }
1439   else
1440     {
1441       rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, DECL_SIZE (field));
1442       normalize_rli (rli);
1443     }
1444 }
1445
1446 /* Assuming that all the fields have been laid out, this function uses
1447    RLI to compute the final TYPE_SIZE, TYPE_ALIGN, etc. for the type
1448    indicated by RLI.  */
1449
1450 static void
1451 finalize_record_size (record_layout_info rli)
1452 {
1453   tree unpadded_size, unpadded_size_unit;
1454
1455   /* Now we want just byte and bit offsets, so set the offset alignment
1456      to be a byte and then normalize.  */
1457   rli->offset_align = BITS_PER_UNIT;
1458   normalize_rli (rli);
1459
1460   /* Determine the desired alignment.  */
1461 #ifdef ROUND_TYPE_ALIGN
1462   TYPE_ALIGN (rli->t) = ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t),
1463                                           rli->record_align);
1464 #else
1465   TYPE_ALIGN (rli->t) = MAX (TYPE_ALIGN (rli->t), rli->record_align);
1466 #endif
1467
1468   /* Compute the size so far.  Be sure to allow for extra bits in the
1469      size in bytes.  We have guaranteed above that it will be no more
1470      than a single byte.  */
1471   unpadded_size = rli_size_so_far (rli);
1472   unpadded_size_unit = rli_size_unit_so_far (rli);
1473   if (! integer_zerop (rli->bitpos))
1474     unpadded_size_unit
1475       = size_binop (PLUS_EXPR, unpadded_size_unit, size_one_node);
1476
1477   /* Round the size up to be a multiple of the required alignment.  */
1478   TYPE_SIZE (rli->t) = round_up (unpadded_size, TYPE_ALIGN (rli->t));
1479   TYPE_SIZE_UNIT (rli->t)
1480     = round_up (unpadded_size_unit, TYPE_ALIGN_UNIT (rli->t));
1481
1482   if (TREE_CONSTANT (unpadded_size)
1483       && simple_cst_equal (unpadded_size, TYPE_SIZE (rli->t)) == 0)
1484     warning (OPT_Wpadded, "padding struct size to alignment boundary");
1485
1486   if (warn_packed && TREE_CODE (rli->t) == RECORD_TYPE
1487       && TYPE_PACKED (rli->t) && ! rli->packed_maybe_necessary
1488       && TREE_CONSTANT (unpadded_size))
1489     {
1490       tree unpacked_size;
1491
1492 #ifdef ROUND_TYPE_ALIGN
1493       rli->unpacked_align
1494         = ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t), rli->unpacked_align);
1495 #else
1496       rli->unpacked_align = MAX (TYPE_ALIGN (rli->t), rli->unpacked_align);
1497 #endif
1498
1499       unpacked_size = round_up (TYPE_SIZE (rli->t), rli->unpacked_align);
1500       if (simple_cst_equal (unpacked_size, TYPE_SIZE (rli->t)))
1501         {
1502           TYPE_PACKED (rli->t) = 0;
1503
1504           if (TYPE_NAME (rli->t))
1505             {
1506               tree name;
1507
1508               if (TREE_CODE (TYPE_NAME (rli->t)) == IDENTIFIER_NODE)
1509                 name = TYPE_NAME (rli->t);
1510               else
1511                 name = DECL_NAME (TYPE_NAME (rli->t));
1512
1513               if (STRICT_ALIGNMENT)
1514                 warning (OPT_Wpacked, "packed attribute causes inefficient "
1515                          "alignment for %qE", name);
1516               else
1517                 warning (OPT_Wpacked,
1518                          "packed attribute is unnecessary for %qE", name);
1519             }
1520           else
1521             {
1522               if (STRICT_ALIGNMENT)
1523                 warning (OPT_Wpacked,
1524                          "packed attribute causes inefficient alignment");
1525               else
1526                 warning (OPT_Wpacked, "packed attribute is unnecessary");
1527             }
1528         }
1529     }
1530 }
1531
1532 /* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE).  */
1533
1534 void
1535 compute_record_mode (tree type)
1536 {
1537   tree field;
1538   enum machine_mode mode = VOIDmode;
1539
1540   /* Most RECORD_TYPEs have BLKmode, so we start off assuming that.
1541      However, if possible, we use a mode that fits in a register
1542      instead, in order to allow for better optimization down the
1543      line.  */
1544   SET_TYPE_MODE (type, BLKmode);
1545
1546   if (! host_integerp (TYPE_SIZE (type), 1))
1547     return;
1548
1549   /* A record which has any BLKmode members must itself be
1550      BLKmode; it can't go in a register.  Unless the member is
1551      BLKmode only because it isn't aligned.  */
1552   for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1553     {
1554       if (TREE_CODE (field) != FIELD_DECL)
1555         continue;
1556
1557       if (TREE_CODE (TREE_TYPE (field)) == ERROR_MARK
1558           || (TYPE_MODE (TREE_TYPE (field)) == BLKmode
1559               && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field))
1560               && !(TYPE_SIZE (TREE_TYPE (field)) != 0
1561                    && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))))
1562           || ! host_integerp (bit_position (field), 1)
1563           || DECL_SIZE (field) == 0
1564           || ! host_integerp (DECL_SIZE (field), 1))
1565         return;
1566
1567       /* If this field is the whole struct, remember its mode so
1568          that, say, we can put a double in a class into a DF
1569          register instead of forcing it to live in the stack.  */
1570       if (simple_cst_equal (TYPE_SIZE (type), DECL_SIZE (field)))
1571         mode = DECL_MODE (field);
1572
1573 #ifdef MEMBER_TYPE_FORCES_BLK
1574       /* With some targets, eg. c4x, it is sub-optimal
1575          to access an aligned BLKmode structure as a scalar.  */
1576
1577       if (MEMBER_TYPE_FORCES_BLK (field, mode))
1578         return;
1579 #endif /* MEMBER_TYPE_FORCES_BLK  */
1580     }
1581
1582   /* If we only have one real field; use its mode if that mode's size
1583      matches the type's size.  This only applies to RECORD_TYPE.  This
1584      does not apply to unions.  */
1585   if (TREE_CODE (type) == RECORD_TYPE && mode != VOIDmode
1586       && host_integerp (TYPE_SIZE (type), 1)
1587       && GET_MODE_BITSIZE (mode) == TREE_INT_CST_LOW (TYPE_SIZE (type)))
1588     SET_TYPE_MODE (type, mode);
1589   else
1590     SET_TYPE_MODE (type, mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1));
1591
1592   /* If structure's known alignment is less than what the scalar
1593      mode would need, and it matters, then stick with BLKmode.  */
1594   if (TYPE_MODE (type) != BLKmode
1595       && STRICT_ALIGNMENT
1596       && ! (TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT
1597             || TYPE_ALIGN (type) >= GET_MODE_ALIGNMENT (TYPE_MODE (type))))
1598     {
1599       /* If this is the only reason this type is BLKmode, then
1600          don't force containing types to be BLKmode.  */
1601       TYPE_NO_FORCE_BLK (type) = 1;
1602       SET_TYPE_MODE (type, BLKmode);
1603     }
1604 }
1605
1606 /* Compute TYPE_SIZE and TYPE_ALIGN for TYPE, once it has been laid
1607    out.  */
1608
1609 static void
1610 finalize_type_size (tree type)
1611 {
1612   /* Normally, use the alignment corresponding to the mode chosen.
1613      However, where strict alignment is not required, avoid
1614      over-aligning structures, since most compilers do not do this
1615      alignment.  */
1616
1617   if (TYPE_MODE (type) != BLKmode && TYPE_MODE (type) != VOIDmode
1618       && (STRICT_ALIGNMENT
1619           || (TREE_CODE (type) != RECORD_TYPE && TREE_CODE (type) != UNION_TYPE
1620               && TREE_CODE (type) != QUAL_UNION_TYPE
1621               && TREE_CODE (type) != ARRAY_TYPE)))
1622     {
1623       unsigned mode_align = GET_MODE_ALIGNMENT (TYPE_MODE (type));
1624
1625       /* Don't override a larger alignment requirement coming from a user
1626          alignment of one of the fields.  */
1627       if (mode_align >= TYPE_ALIGN (type))
1628         {
1629           TYPE_ALIGN (type) = mode_align;
1630           TYPE_USER_ALIGN (type) = 0;
1631         }
1632     }
1633
1634   /* Do machine-dependent extra alignment.  */
1635 #ifdef ROUND_TYPE_ALIGN
1636   TYPE_ALIGN (type)
1637     = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (type), BITS_PER_UNIT);
1638 #endif
1639
1640   /* If we failed to find a simple way to calculate the unit size
1641      of the type, find it by division.  */
1642   if (TYPE_SIZE_UNIT (type) == 0 && TYPE_SIZE (type) != 0)
1643     /* TYPE_SIZE (type) is computed in bitsizetype.  After the division, the
1644        result will fit in sizetype.  We will get more efficient code using
1645        sizetype, so we force a conversion.  */
1646     TYPE_SIZE_UNIT (type)
1647       = fold_convert (sizetype,
1648                       size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (type),
1649                                   bitsize_unit_node));
1650
1651   if (TYPE_SIZE (type) != 0)
1652     {
1653       TYPE_SIZE (type) = round_up (TYPE_SIZE (type), TYPE_ALIGN (type));
1654       TYPE_SIZE_UNIT (type) = round_up (TYPE_SIZE_UNIT (type),
1655                                         TYPE_ALIGN_UNIT (type));
1656     }
1657
1658   /* Evaluate nonconstant sizes only once, either now or as soon as safe.  */
1659   if (TYPE_SIZE (type) != 0 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1660     TYPE_SIZE (type) = variable_size (TYPE_SIZE (type));
1661   if (TYPE_SIZE_UNIT (type) != 0
1662       && TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST)
1663     TYPE_SIZE_UNIT (type) = variable_size (TYPE_SIZE_UNIT (type));
1664
1665   /* Also layout any other variants of the type.  */
1666   if (TYPE_NEXT_VARIANT (type)
1667       || type != TYPE_MAIN_VARIANT (type))
1668     {
1669       tree variant;
1670       /* Record layout info of this variant.  */
1671       tree size = TYPE_SIZE (type);
1672       tree size_unit = TYPE_SIZE_UNIT (type);
1673       unsigned int align = TYPE_ALIGN (type);
1674       unsigned int user_align = TYPE_USER_ALIGN (type);
1675       enum machine_mode mode = TYPE_MODE (type);
1676
1677       /* Copy it into all variants.  */
1678       for (variant = TYPE_MAIN_VARIANT (type);
1679            variant != 0;
1680            variant = TYPE_NEXT_VARIANT (variant))
1681         {
1682           TYPE_SIZE (variant) = size;
1683           TYPE_SIZE_UNIT (variant) = size_unit;
1684           TYPE_ALIGN (variant) = align;
1685           TYPE_USER_ALIGN (variant) = user_align;
1686           SET_TYPE_MODE (variant, mode);
1687         }
1688     }
1689 }
1690
1691 /* Do all of the work required to layout the type indicated by RLI,
1692    once the fields have been laid out.  This function will call `free'
1693    for RLI, unless FREE_P is false.  Passing a value other than false
1694    for FREE_P is bad practice; this option only exists to support the
1695    G++ 3.2 ABI.  */
1696
1697 void
1698 finish_record_layout (record_layout_info rli, int free_p)
1699 {
1700   tree variant;
1701
1702   /* Compute the final size.  */
1703   finalize_record_size (rli);
1704
1705   /* Compute the TYPE_MODE for the record.  */
1706   compute_record_mode (rli->t);
1707
1708   /* Perform any last tweaks to the TYPE_SIZE, etc.  */
1709   finalize_type_size (rli->t);
1710
1711   /* Propagate TYPE_PACKED to variants.  With C++ templates,
1712      handle_packed_attribute is too early to do this.  */
1713   for (variant = TYPE_NEXT_VARIANT (rli->t); variant;
1714        variant = TYPE_NEXT_VARIANT (variant))
1715     TYPE_PACKED (variant) = TYPE_PACKED (rli->t);
1716
1717   /* Lay out any static members.  This is done now because their type
1718      may use the record's type.  */
1719   while (rli->pending_statics)
1720     {
1721       layout_decl (TREE_VALUE (rli->pending_statics), 0);
1722       rli->pending_statics = TREE_CHAIN (rli->pending_statics);
1723     }
1724
1725   /* Clean up.  */
1726   if (free_p)
1727     free (rli);
1728 }
1729 \f
1730
1731 /* Finish processing a builtin RECORD_TYPE type TYPE.  It's name is
1732    NAME, its fields are chained in reverse on FIELDS.
1733
1734    If ALIGN_TYPE is non-null, it is given the same alignment as
1735    ALIGN_TYPE.  */
1736
1737 void
1738 finish_builtin_struct (tree type, const char *name, tree fields,
1739                        tree align_type)
1740 {
1741   tree tail, next;
1742
1743   for (tail = NULL_TREE; fields; tail = fields, fields = next)
1744     {
1745       DECL_FIELD_CONTEXT (fields) = type;
1746       next = TREE_CHAIN (fields);
1747       TREE_CHAIN (fields) = tail;
1748     }
1749   TYPE_FIELDS (type) = tail;
1750
1751   if (align_type)
1752     {
1753       TYPE_ALIGN (type) = TYPE_ALIGN (align_type);
1754       TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (align_type);
1755     }
1756
1757   layout_type (type);
1758 #if 0 /* not yet, should get fixed properly later */
1759   TYPE_NAME (type) = make_type_decl (get_identifier (name), type);
1760 #else
1761   TYPE_NAME (type) = build_decl (BUILTINS_LOCATION,
1762                                  TYPE_DECL, get_identifier (name), type);
1763 #endif
1764   TYPE_STUB_DECL (type) = TYPE_NAME (type);
1765   layout_decl (TYPE_NAME (type), 0);
1766 }
1767
1768 /* Calculate the mode, size, and alignment for TYPE.
1769    For an array type, calculate the element separation as well.
1770    Record TYPE on the chain of permanent or temporary types
1771    so that dbxout will find out about it.
1772
1773    TYPE_SIZE of a type is nonzero if the type has been laid out already.
1774    layout_type does nothing on such a type.
1775
1776    If the type is incomplete, its TYPE_SIZE remains zero.  */
1777
1778 void
1779 layout_type (tree type)
1780 {
1781   gcc_assert (type);
1782
1783   if (type == error_mark_node)
1784     return;
1785
1786   /* Do nothing if type has been laid out before.  */
1787   if (TYPE_SIZE (type))
1788     return;
1789
1790   switch (TREE_CODE (type))
1791     {
1792     case LANG_TYPE:
1793       /* This kind of type is the responsibility
1794          of the language-specific code.  */
1795       gcc_unreachable ();
1796
1797     case BOOLEAN_TYPE:  /* Used for Java, Pascal, and Chill.  */
1798       if (TYPE_PRECISION (type) == 0)
1799         TYPE_PRECISION (type) = 1; /* default to one byte/boolean.  */
1800
1801       /* ... fall through ...  */
1802
1803     case INTEGER_TYPE:
1804     case ENUMERAL_TYPE:
1805       if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
1806           && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0)
1807         TYPE_UNSIGNED (type) = 1;
1808
1809       SET_TYPE_MODE (type,
1810                      smallest_mode_for_size (TYPE_PRECISION (type), MODE_INT));
1811       TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
1812       TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
1813       break;
1814
1815     case REAL_TYPE:
1816       SET_TYPE_MODE (type,
1817                      mode_for_size (TYPE_PRECISION (type), MODE_FLOAT, 0));
1818       TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
1819       TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
1820       break;
1821
1822    case FIXED_POINT_TYPE:
1823      /* TYPE_MODE (type) has been set already.  */
1824      TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
1825      TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
1826      break;
1827
1828     case COMPLEX_TYPE:
1829       TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TREE_TYPE (type));
1830       SET_TYPE_MODE (type,
1831                      mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type)),
1832                                     (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE
1833                                      ? MODE_COMPLEX_FLOAT : MODE_COMPLEX_INT),
1834                                      0));
1835       TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
1836       TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
1837       break;
1838
1839     case VECTOR_TYPE:
1840       {
1841         int nunits = TYPE_VECTOR_SUBPARTS (type);
1842         tree innertype = TREE_TYPE (type);
1843
1844         gcc_assert (!(nunits & (nunits - 1)));
1845
1846         /* Find an appropriate mode for the vector type.  */
1847         if (TYPE_MODE (type) == VOIDmode)
1848           {
1849             enum machine_mode innermode = TYPE_MODE (innertype);
1850             enum machine_mode mode;
1851
1852             /* First, look for a supported vector type.  */
1853             if (SCALAR_FLOAT_MODE_P (innermode))
1854               mode = MIN_MODE_VECTOR_FLOAT;
1855             else if (SCALAR_FRACT_MODE_P (innermode))
1856               mode = MIN_MODE_VECTOR_FRACT;
1857             else if (SCALAR_UFRACT_MODE_P (innermode))
1858               mode = MIN_MODE_VECTOR_UFRACT;
1859             else if (SCALAR_ACCUM_MODE_P (innermode))
1860               mode = MIN_MODE_VECTOR_ACCUM;
1861             else if (SCALAR_UACCUM_MODE_P (innermode))
1862               mode = MIN_MODE_VECTOR_UACCUM;
1863             else
1864               mode = MIN_MODE_VECTOR_INT;
1865
1866             /* Do not check vector_mode_supported_p here.  We'll do that
1867                later in vector_type_mode.  */
1868             for (; mode != VOIDmode ; mode = GET_MODE_WIDER_MODE (mode))
1869               if (GET_MODE_NUNITS (mode) == nunits
1870                   && GET_MODE_INNER (mode) == innermode)
1871                 break;
1872
1873             /* For integers, try mapping it to a same-sized scalar mode.  */
1874             if (mode == VOIDmode
1875                 && GET_MODE_CLASS (innermode) == MODE_INT)
1876               mode = mode_for_size (nunits * GET_MODE_BITSIZE (innermode),
1877                                     MODE_INT, 0);
1878
1879             if (mode == VOIDmode ||
1880                 (GET_MODE_CLASS (mode) == MODE_INT
1881                  && !have_regs_of_mode[mode]))
1882               SET_TYPE_MODE (type, BLKmode);
1883             else
1884               SET_TYPE_MODE (type, mode);
1885           }
1886
1887         TYPE_SATURATING (type) = TYPE_SATURATING (TREE_TYPE (type));
1888         TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TREE_TYPE (type));
1889         TYPE_SIZE_UNIT (type) = int_const_binop (MULT_EXPR,
1890                                                  TYPE_SIZE_UNIT (innertype),
1891                                                  size_int (nunits), 0);
1892         TYPE_SIZE (type) = int_const_binop (MULT_EXPR, TYPE_SIZE (innertype),
1893                                             bitsize_int (nunits), 0);
1894
1895         /* Always naturally align vectors.  This prevents ABI changes
1896            depending on whether or not native vector modes are supported.  */
1897         TYPE_ALIGN (type) = tree_low_cst (TYPE_SIZE (type), 0);
1898         break;
1899       }
1900
1901     case VOID_TYPE:
1902       /* This is an incomplete type and so doesn't have a size.  */
1903       TYPE_ALIGN (type) = 1;
1904       TYPE_USER_ALIGN (type) = 0;
1905       SET_TYPE_MODE (type, VOIDmode);
1906       break;
1907
1908     case OFFSET_TYPE:
1909       TYPE_SIZE (type) = bitsize_int (POINTER_SIZE);
1910       TYPE_SIZE_UNIT (type) = size_int (POINTER_SIZE / BITS_PER_UNIT);
1911       /* A pointer might be MODE_PARTIAL_INT,
1912          but ptrdiff_t must be integral.  */
1913       SET_TYPE_MODE (type, mode_for_size (POINTER_SIZE, MODE_INT, 0));
1914       break;
1915
1916     case FUNCTION_TYPE:
1917     case METHOD_TYPE:
1918       /* It's hard to see what the mode and size of a function ought to
1919          be, but we do know the alignment is FUNCTION_BOUNDARY, so
1920          make it consistent with that.  */
1921       SET_TYPE_MODE (type, mode_for_size (FUNCTION_BOUNDARY, MODE_INT, 0));
1922       TYPE_SIZE (type) = bitsize_int (FUNCTION_BOUNDARY);
1923       TYPE_SIZE_UNIT (type) = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1924       break;
1925
1926     case POINTER_TYPE:
1927     case REFERENCE_TYPE:
1928       {
1929         enum machine_mode mode = ((TREE_CODE (type) == REFERENCE_TYPE
1930                                    && reference_types_internal)
1931                                   ? Pmode : TYPE_MODE (type));
1932
1933         int nbits = GET_MODE_BITSIZE (mode);
1934
1935         TYPE_SIZE (type) = bitsize_int (nbits);
1936         TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (mode));
1937         TYPE_UNSIGNED (type) = 1;
1938         TYPE_PRECISION (type) = nbits;
1939       }
1940       break;
1941
1942     case ARRAY_TYPE:
1943       {
1944         tree index = TYPE_DOMAIN (type);
1945         tree element = TREE_TYPE (type);
1946
1947         build_pointer_type (element);
1948
1949         /* We need to know both bounds in order to compute the size.  */
1950         if (index && TYPE_MAX_VALUE (index) && TYPE_MIN_VALUE (index)
1951             && TYPE_SIZE (element))
1952           {
1953             tree ub = TYPE_MAX_VALUE (index);
1954             tree lb = TYPE_MIN_VALUE (index);
1955             tree length;
1956             tree element_size;
1957
1958             /* The initial subtraction should happen in the original type so
1959                that (possible) negative values are handled appropriately.  */
1960             length = size_binop (PLUS_EXPR, size_one_node,
1961                                  fold_convert (sizetype,
1962                                                fold_build2 (MINUS_EXPR,
1963                                                             TREE_TYPE (lb),
1964                                                             ub, lb)));
1965
1966             /* Special handling for arrays of bits (for Chill).  */
1967             element_size = TYPE_SIZE (element);
1968             if (TYPE_PACKED (type) && INTEGRAL_TYPE_P (element)
1969                 && (integer_zerop (TYPE_MAX_VALUE (element))
1970                     || integer_onep (TYPE_MAX_VALUE (element)))
1971                 && host_integerp (TYPE_MIN_VALUE (element), 1))
1972               {
1973                 HOST_WIDE_INT maxvalue
1974                   = tree_low_cst (TYPE_MAX_VALUE (element), 1);
1975                 HOST_WIDE_INT minvalue
1976                   = tree_low_cst (TYPE_MIN_VALUE (element), 1);
1977
1978                 if (maxvalue - minvalue == 1
1979                     && (maxvalue == 1 || maxvalue == 0))
1980                   element_size = integer_one_node;
1981               }
1982
1983             /* If neither bound is a constant and sizetype is signed, make
1984                sure the size is never negative.  We should really do this
1985                if *either* bound is non-constant, but this is the best
1986                compromise between C and Ada.  */
1987             if (!TYPE_UNSIGNED (sizetype)
1988                 && TREE_CODE (TYPE_MIN_VALUE (index)) != INTEGER_CST
1989                 && TREE_CODE (TYPE_MAX_VALUE (index)) != INTEGER_CST)
1990               length = size_binop (MAX_EXPR, length, size_zero_node);
1991
1992             TYPE_SIZE (type) = size_binop (MULT_EXPR, element_size,
1993                                            fold_convert (bitsizetype,
1994                                                          length));
1995
1996             /* If we know the size of the element, calculate the total
1997                size directly, rather than do some division thing below.
1998                This optimization helps Fortran assumed-size arrays
1999                (where the size of the array is determined at runtime)
2000                substantially.
2001                Note that we can't do this in the case where the size of
2002                the elements is one bit since TYPE_SIZE_UNIT cannot be
2003                set correctly in that case.  */
2004             if (TYPE_SIZE_UNIT (element) != 0 && ! integer_onep (element_size))
2005               TYPE_SIZE_UNIT (type)
2006                 = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (element), length);
2007           }
2008
2009         /* Now round the alignment and size,
2010            using machine-dependent criteria if any.  */
2011
2012 #ifdef ROUND_TYPE_ALIGN
2013         TYPE_ALIGN (type)
2014           = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (element), BITS_PER_UNIT);
2015 #else
2016         TYPE_ALIGN (type) = MAX (TYPE_ALIGN (element), BITS_PER_UNIT);
2017 #endif
2018         if (!TYPE_SIZE (element))
2019           /* We don't know the size of the underlying element type, so
2020              our alignment calculations will be wrong, forcing us to
2021              fall back on structural equality. */
2022           SET_TYPE_STRUCTURAL_EQUALITY (type);
2023         TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (element);
2024         SET_TYPE_MODE (type, BLKmode);
2025         if (TYPE_SIZE (type) != 0
2026 #ifdef MEMBER_TYPE_FORCES_BLK
2027             && ! MEMBER_TYPE_FORCES_BLK (type, VOIDmode)
2028 #endif
2029             /* BLKmode elements force BLKmode aggregate;
2030                else extract/store fields may lose.  */
2031             && (TYPE_MODE (TREE_TYPE (type)) != BLKmode
2032                 || TYPE_NO_FORCE_BLK (TREE_TYPE (type))))
2033           {
2034             /* One-element arrays get the component type's mode.  */
2035             if (simple_cst_equal (TYPE_SIZE (type),
2036                                   TYPE_SIZE (TREE_TYPE (type))))
2037               SET_TYPE_MODE (type, TYPE_MODE (TREE_TYPE (type)));
2038             else
2039               SET_TYPE_MODE (type, mode_for_size_tree (TYPE_SIZE (type),
2040                                                        MODE_INT, 1));
2041
2042             if (TYPE_MODE (type) != BLKmode
2043                 && STRICT_ALIGNMENT && TYPE_ALIGN (type) < BIGGEST_ALIGNMENT
2044                 && TYPE_ALIGN (type) < GET_MODE_ALIGNMENT (TYPE_MODE (type)))
2045               {
2046                 TYPE_NO_FORCE_BLK (type) = 1;
2047                 SET_TYPE_MODE (type, BLKmode);
2048               }
2049           }
2050         /* When the element size is constant, check that it is at least as
2051            large as the element alignment.  */
2052         if (TYPE_SIZE_UNIT (element)
2053             && TREE_CODE (TYPE_SIZE_UNIT (element)) == INTEGER_CST
2054             /* If TYPE_SIZE_UNIT overflowed, then it is certainly larger than
2055                TYPE_ALIGN_UNIT.  */
2056             && !TREE_OVERFLOW (TYPE_SIZE_UNIT (element))
2057             && !integer_zerop (TYPE_SIZE_UNIT (element))
2058             && compare_tree_int (TYPE_SIZE_UNIT (element),
2059                                  TYPE_ALIGN_UNIT (element)) < 0)
2060           error ("alignment of array elements is greater than element size");
2061         break;
2062       }
2063
2064     case RECORD_TYPE:
2065     case UNION_TYPE:
2066     case QUAL_UNION_TYPE:
2067       {
2068         tree field;
2069         record_layout_info rli;
2070
2071         /* Initialize the layout information.  */
2072         rli = start_record_layout (type);
2073
2074         /* If this is a QUAL_UNION_TYPE, we want to process the fields
2075            in the reverse order in building the COND_EXPR that denotes
2076            its size.  We reverse them again later.  */
2077         if (TREE_CODE (type) == QUAL_UNION_TYPE)
2078           TYPE_FIELDS (type) = nreverse (TYPE_FIELDS (type));
2079
2080         /* Place all the fields.  */
2081         for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
2082           place_field (rli, field);
2083
2084         if (TREE_CODE (type) == QUAL_UNION_TYPE)
2085           TYPE_FIELDS (type) = nreverse (TYPE_FIELDS (type));
2086
2087         /* Finish laying out the record.  */
2088         finish_record_layout (rli, /*free_p=*/true);
2089       }
2090       break;
2091
2092     default:
2093       gcc_unreachable ();
2094     }
2095
2096   /* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE.  For
2097      records and unions, finish_record_layout already called this
2098      function.  */
2099   if (TREE_CODE (type) != RECORD_TYPE
2100       && TREE_CODE (type) != UNION_TYPE
2101       && TREE_CODE (type) != QUAL_UNION_TYPE)
2102     finalize_type_size (type);
2103
2104   /* We should never see alias sets on incomplete aggregates.  And we
2105      should not call layout_type on not incomplete aggregates.  */
2106   if (AGGREGATE_TYPE_P (type))
2107     gcc_assert (!TYPE_ALIAS_SET_KNOWN_P (type));
2108 }
2109
2110 /* Vector types need to re-check the target flags each time we report
2111    the machine mode.  We need to do this because attribute target can
2112    change the result of vector_mode_supported_p and have_regs_of_mode
2113    on a per-function basis.  Thus the TYPE_MODE of a VECTOR_TYPE can
2114    change on a per-function basis.  */
2115 /* ??? Possibly a better solution is to run through all the types
2116    referenced by a function and re-compute the TYPE_MODE once, rather
2117    than make the TYPE_MODE macro call a function.  */
2118
2119 enum machine_mode
2120 vector_type_mode (const_tree t)
2121 {
2122   enum machine_mode mode;
2123
2124   gcc_assert (TREE_CODE (t) == VECTOR_TYPE);
2125
2126   mode = t->type.mode;
2127   if (VECTOR_MODE_P (mode)
2128       && (!targetm.vector_mode_supported_p (mode)
2129           || !have_regs_of_mode[mode]))
2130     {
2131       enum machine_mode innermode = TREE_TYPE (t)->type.mode;
2132
2133       /* For integers, try mapping it to a same-sized scalar mode.  */
2134       if (GET_MODE_CLASS (innermode) == MODE_INT)
2135         {
2136           mode = mode_for_size (TYPE_VECTOR_SUBPARTS (t)
2137                                 * GET_MODE_BITSIZE (innermode), MODE_INT, 0);
2138
2139           if (mode != VOIDmode && have_regs_of_mode[mode])
2140             return mode;
2141         }
2142
2143       return BLKmode;
2144     }
2145
2146   return mode;
2147 }
2148 \f
2149 /* Create and return a type for signed integers of PRECISION bits.  */
2150
2151 tree
2152 make_signed_type (int precision)
2153 {
2154   tree type = make_node (INTEGER_TYPE);
2155
2156   TYPE_PRECISION (type) = precision;
2157
2158   fixup_signed_type (type);
2159   return type;
2160 }
2161
2162 /* Create and return a type for unsigned integers of PRECISION bits.  */
2163
2164 tree
2165 make_unsigned_type (int precision)
2166 {
2167   tree type = make_node (INTEGER_TYPE);
2168
2169   TYPE_PRECISION (type) = precision;
2170
2171   fixup_unsigned_type (type);
2172   return type;
2173 }
2174 \f
2175 /* Create and return a type for fract of PRECISION bits, UNSIGNEDP,
2176    and SATP.  */
2177
2178 tree
2179 make_fract_type (int precision, int unsignedp, int satp)
2180 {
2181   tree type = make_node (FIXED_POINT_TYPE);
2182
2183   TYPE_PRECISION (type) = precision;
2184
2185   if (satp)
2186     TYPE_SATURATING (type) = 1;
2187
2188   /* Lay out the type: set its alignment, size, etc.  */
2189   if (unsignedp)
2190     {
2191       TYPE_UNSIGNED (type) = 1;
2192       SET_TYPE_MODE (type, mode_for_size (precision, MODE_UFRACT, 0));
2193     }
2194   else
2195     SET_TYPE_MODE (type, mode_for_size (precision, MODE_FRACT, 0));
2196   layout_type (type);
2197
2198   return type;
2199 }
2200
2201 /* Create and return a type for accum of PRECISION bits, UNSIGNEDP,
2202    and SATP.  */
2203
2204 tree
2205 make_accum_type (int precision, int unsignedp, int satp)
2206 {
2207   tree type = make_node (FIXED_POINT_TYPE);
2208
2209   TYPE_PRECISION (type) = precision;
2210
2211   if (satp)
2212     TYPE_SATURATING (type) = 1;
2213
2214   /* Lay out the type: set its alignment, size, etc.  */
2215   if (unsignedp)
2216     {
2217       TYPE_UNSIGNED (type) = 1;
2218       SET_TYPE_MODE (type, mode_for_size (precision, MODE_UACCUM, 0));
2219     }
2220   else
2221     SET_TYPE_MODE (type, mode_for_size (precision, MODE_ACCUM, 0));
2222   layout_type (type);
2223
2224   return type;
2225 }
2226
2227 /* Initialize sizetype and bitsizetype to a reasonable and temporary
2228    value to enable integer types to be created.  */
2229
2230 void
2231 initialize_sizetypes (bool signed_p)
2232 {
2233   tree t = make_node (INTEGER_TYPE);
2234   int precision = GET_MODE_BITSIZE (SImode);
2235
2236   SET_TYPE_MODE (t, SImode);
2237   TYPE_ALIGN (t) = GET_MODE_ALIGNMENT (SImode);
2238   TYPE_USER_ALIGN (t) = 0;
2239   TYPE_IS_SIZETYPE (t) = 1;
2240   TYPE_UNSIGNED (t) = !signed_p;
2241   TYPE_SIZE (t) = build_int_cst (t, precision);
2242   TYPE_SIZE_UNIT (t) = build_int_cst (t, GET_MODE_SIZE (SImode));
2243   TYPE_PRECISION (t) = precision;
2244
2245   /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE.  */
2246   set_min_and_max_values_for_integral_type (t, precision, !signed_p);
2247
2248   sizetype = t;
2249   bitsizetype = build_distinct_type_copy (t);
2250 }
2251
2252 /* Make sizetype a version of TYPE, and initialize *sizetype
2253    accordingly.  We do this by overwriting the stub sizetype and
2254    bitsizetype nodes created by initialize_sizetypes.  This makes sure
2255    that (a) anything stubby about them no longer exists, (b) any
2256    INTEGER_CSTs created with such a type, remain valid.  */
2257
2258 void
2259 set_sizetype (tree type)
2260 {
2261   tree t;
2262   int oprecision = TYPE_PRECISION (type);
2263   /* The *bitsizetype types use a precision that avoids overflows when
2264      calculating signed sizes / offsets in bits.  However, when
2265      cross-compiling from a 32 bit to a 64 bit host, we are limited to 64 bit
2266      precision.  */
2267   int precision
2268     = MIN (oprecision + BITS_PER_UNIT_LOG + 1, MAX_FIXED_MODE_SIZE);
2269   precision
2270     = GET_MODE_PRECISION (smallest_mode_for_size (precision, MODE_INT));
2271   if (precision > HOST_BITS_PER_WIDE_INT * 2)
2272     precision = HOST_BITS_PER_WIDE_INT * 2;
2273
2274   gcc_assert (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (sizetype));
2275
2276   t = build_distinct_type_copy (type);
2277   /* We do want to use sizetype's cache, as we will be replacing that
2278      type.  */
2279   TYPE_CACHED_VALUES (t) = TYPE_CACHED_VALUES (sizetype);
2280   TYPE_CACHED_VALUES_P (t) = TYPE_CACHED_VALUES_P (sizetype);
2281   TREE_TYPE (TYPE_CACHED_VALUES (t)) = type;
2282   TYPE_UID (t) = TYPE_UID (sizetype);
2283   TYPE_IS_SIZETYPE (t) = 1;
2284
2285   /* Replace our original stub sizetype.  */
2286   memcpy (sizetype, t, tree_size (sizetype));
2287   TYPE_MAIN_VARIANT (sizetype) = sizetype;
2288   TYPE_CANONICAL (sizetype) = sizetype;
2289
2290   t = make_node (INTEGER_TYPE);
2291   TYPE_NAME (t) = get_identifier ("bit_size_type");
2292   /* We do want to use bitsizetype's cache, as we will be replacing that
2293      type.  */
2294   TYPE_CACHED_VALUES (t) = TYPE_CACHED_VALUES (bitsizetype);
2295   TYPE_CACHED_VALUES_P (t) = TYPE_CACHED_VALUES_P (bitsizetype);
2296   TYPE_PRECISION (t) = precision;
2297   TYPE_UID (t) = TYPE_UID (bitsizetype);
2298   TYPE_IS_SIZETYPE (t) = 1;
2299
2300   /* Replace our original stub bitsizetype.  */
2301   memcpy (bitsizetype, t, tree_size (bitsizetype));
2302   TYPE_MAIN_VARIANT (bitsizetype) = bitsizetype;
2303   TYPE_CANONICAL (bitsizetype) = bitsizetype;
2304
2305   if (TYPE_UNSIGNED (type))
2306     {
2307       fixup_unsigned_type (bitsizetype);
2308       ssizetype = build_distinct_type_copy (make_signed_type (oprecision));
2309       TYPE_IS_SIZETYPE (ssizetype) = 1;
2310       sbitsizetype = build_distinct_type_copy (make_signed_type (precision));
2311       TYPE_IS_SIZETYPE (sbitsizetype) = 1;
2312     }
2313   else
2314     {
2315       fixup_signed_type (bitsizetype);
2316       ssizetype = sizetype;
2317       sbitsizetype = bitsizetype;
2318     }
2319
2320   /* If SIZETYPE is unsigned, we need to fix TYPE_MAX_VALUE so that
2321      it is sign extended in a way consistent with force_fit_type.  */
2322   if (TYPE_UNSIGNED (type))
2323     {
2324       tree orig_max, new_max;
2325
2326       orig_max = TYPE_MAX_VALUE (sizetype);
2327
2328       /* Build a new node with the same values, but a different type.
2329          Sign extend it to ensure consistency.  */
2330       new_max = build_int_cst_wide_type (sizetype,
2331                                          TREE_INT_CST_LOW (orig_max),
2332                                          TREE_INT_CST_HIGH (orig_max));
2333       TYPE_MAX_VALUE (sizetype) = new_max;
2334     }
2335 }
2336 \f
2337 /* TYPE is an integral type, i.e., an INTEGRAL_TYPE, ENUMERAL_TYPE
2338    or BOOLEAN_TYPE.  Set TYPE_MIN_VALUE and TYPE_MAX_VALUE
2339    for TYPE, based on the PRECISION and whether or not the TYPE
2340    IS_UNSIGNED.  PRECISION need not correspond to a width supported
2341    natively by the hardware; for example, on a machine with 8-bit,
2342    16-bit, and 32-bit register modes, PRECISION might be 7, 23, or
2343    61.  */
2344
2345 void
2346 set_min_and_max_values_for_integral_type (tree type,
2347                                           int precision,
2348                                           bool is_unsigned)
2349 {
2350   tree min_value;
2351   tree max_value;
2352
2353   if (is_unsigned)
2354     {
2355       min_value = build_int_cst (type, 0);
2356       max_value
2357         = build_int_cst_wide (type, precision - HOST_BITS_PER_WIDE_INT >= 0
2358                               ? -1
2359                               : ((HOST_WIDE_INT) 1 << precision) - 1,
2360                               precision - HOST_BITS_PER_WIDE_INT > 0
2361                               ? ((unsigned HOST_WIDE_INT) ~0
2362                                  >> (HOST_BITS_PER_WIDE_INT
2363                                      - (precision - HOST_BITS_PER_WIDE_INT)))
2364                               : 0);
2365     }
2366   else
2367     {
2368       min_value
2369         = build_int_cst_wide (type,
2370                               (precision - HOST_BITS_PER_WIDE_INT > 0
2371                                ? 0
2372                                : (HOST_WIDE_INT) (-1) << (precision - 1)),
2373                               (((HOST_WIDE_INT) (-1)
2374                                 << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
2375                                     ? precision - HOST_BITS_PER_WIDE_INT - 1
2376                                     : 0))));
2377       max_value
2378         = build_int_cst_wide (type,
2379                               (precision - HOST_BITS_PER_WIDE_INT > 0
2380                                ? -1
2381                                : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1),
2382                               (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
2383                                ? (((HOST_WIDE_INT) 1
2384                                    << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1
2385                                : 0));
2386     }
2387
2388   TYPE_MIN_VALUE (type) = min_value;
2389   TYPE_MAX_VALUE (type) = max_value;
2390 }
2391
2392 /* Set the extreme values of TYPE based on its precision in bits,
2393    then lay it out.  Used when make_signed_type won't do
2394    because the tree code is not INTEGER_TYPE.
2395    E.g. for Pascal, when the -fsigned-char option is given.  */
2396
2397 void
2398 fixup_signed_type (tree type)
2399 {
2400   int precision = TYPE_PRECISION (type);
2401
2402   /* We can not represent properly constants greater then
2403      2 * HOST_BITS_PER_WIDE_INT, still we need the types
2404      as they are used by i386 vector extensions and friends.  */
2405   if (precision > HOST_BITS_PER_WIDE_INT * 2)
2406     precision = HOST_BITS_PER_WIDE_INT * 2;
2407
2408   set_min_and_max_values_for_integral_type (type, precision,
2409                                             /*is_unsigned=*/false);
2410
2411   /* Lay out the type: set its alignment, size, etc.  */
2412   layout_type (type);
2413 }
2414
2415 /* Set the extreme values of TYPE based on its precision in bits,
2416    then lay it out.  This is used both in `make_unsigned_type'
2417    and for enumeral types.  */
2418
2419 void
2420 fixup_unsigned_type (tree type)
2421 {
2422   int precision = TYPE_PRECISION (type);
2423
2424   /* We can not represent properly constants greater then
2425      2 * HOST_BITS_PER_WIDE_INT, still we need the types
2426      as they are used by i386 vector extensions and friends.  */
2427   if (precision > HOST_BITS_PER_WIDE_INT * 2)
2428     precision = HOST_BITS_PER_WIDE_INT * 2;
2429
2430   TYPE_UNSIGNED (type) = 1;
2431
2432   set_min_and_max_values_for_integral_type (type, precision,
2433                                             /*is_unsigned=*/true);
2434
2435   /* Lay out the type: set its alignment, size, etc.  */
2436   layout_type (type);
2437 }
2438 \f
2439 /* Find the best machine mode to use when referencing a bit field of length
2440    BITSIZE bits starting at BITPOS.
2441
2442    The underlying object is known to be aligned to a boundary of ALIGN bits.
2443    If LARGEST_MODE is not VOIDmode, it means that we should not use a mode
2444    larger than LARGEST_MODE (usually SImode).
2445
2446    If no mode meets all these conditions, we return VOIDmode.
2447
2448    If VOLATILEP is false and SLOW_BYTE_ACCESS is false, we return the
2449    smallest mode meeting these conditions.
2450
2451    If VOLATILEP is false and SLOW_BYTE_ACCESS is true, we return the
2452    largest mode (but a mode no wider than UNITS_PER_WORD) that meets
2453    all the conditions.
2454
2455    If VOLATILEP is true the narrow_volatile_bitfields target hook is used to
2456    decide which of the above modes should be used.  */
2457
2458 enum machine_mode
2459 get_best_mode (int bitsize, int bitpos, unsigned int align,
2460                enum machine_mode largest_mode, int volatilep)
2461 {
2462   enum machine_mode mode;
2463   unsigned int unit = 0;
2464
2465   /* Find the narrowest integer mode that contains the bit field.  */
2466   for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
2467        mode = GET_MODE_WIDER_MODE (mode))
2468     {
2469       unit = GET_MODE_BITSIZE (mode);
2470       if ((bitpos % unit) + bitsize <= unit)
2471         break;
2472     }
2473
2474   if (mode == VOIDmode
2475       /* It is tempting to omit the following line
2476          if STRICT_ALIGNMENT is true.
2477          But that is incorrect, since if the bitfield uses part of 3 bytes
2478          and we use a 4-byte mode, we could get a spurious segv
2479          if the extra 4th byte is past the end of memory.
2480          (Though at least one Unix compiler ignores this problem:
2481          that on the Sequent 386 machine.  */
2482       || MIN (unit, BIGGEST_ALIGNMENT) > align
2483       || (largest_mode != VOIDmode && unit > GET_MODE_BITSIZE (largest_mode)))
2484     return VOIDmode;
2485
2486   if ((SLOW_BYTE_ACCESS && ! volatilep)
2487       || (volatilep && !targetm.narrow_volatile_bitfield ()))
2488     {
2489       enum machine_mode wide_mode = VOIDmode, tmode;
2490
2491       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT); tmode != VOIDmode;
2492            tmode = GET_MODE_WIDER_MODE (tmode))
2493         {
2494           unit = GET_MODE_BITSIZE (tmode);
2495           if (bitpos / unit == (bitpos + bitsize - 1) / unit
2496               && unit <= BITS_PER_WORD
2497               && unit <= MIN (align, BIGGEST_ALIGNMENT)
2498               && (largest_mode == VOIDmode
2499                   || unit <= GET_MODE_BITSIZE (largest_mode)))
2500             wide_mode = tmode;
2501         }
2502
2503       if (wide_mode != VOIDmode)
2504         return wide_mode;
2505     }
2506
2507   return mode;
2508 }
2509
2510 /* Gets minimal and maximal values for MODE (signed or unsigned depending on
2511    SIGN).  The returned constants are made to be usable in TARGET_MODE.  */
2512
2513 void
2514 get_mode_bounds (enum machine_mode mode, int sign,
2515                  enum machine_mode target_mode,
2516                  rtx *mmin, rtx *mmax)
2517 {
2518   unsigned size = GET_MODE_BITSIZE (mode);
2519   unsigned HOST_WIDE_INT min_val, max_val;
2520
2521   gcc_assert (size <= HOST_BITS_PER_WIDE_INT);
2522
2523   if (sign)
2524     {
2525       min_val = -((unsigned HOST_WIDE_INT) 1 << (size - 1));
2526       max_val = ((unsigned HOST_WIDE_INT) 1 << (size - 1)) - 1;
2527     }
2528   else
2529     {
2530       min_val = 0;
2531       max_val = ((unsigned HOST_WIDE_INT) 1 << (size - 1) << 1) - 1;
2532     }
2533
2534   *mmin = gen_int_mode (min_val, target_mode);
2535   *mmax = gen_int_mode (max_val, target_mode);
2536 }
2537
2538 #include "gt-stor-layout.h"