LCOV - code coverage report
Current view: top level - gcc - stor-layout.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1101 1261 87.3 %
Date: 2020-04-04 11:58:09 Functions: 52 57 91.2 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

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

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.