gcc/stor-layout.c

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