gcc/stor-layout.c

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