LCOV - code coverage report
Current view: top level - gcc - gimple.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1236 1408 87.8 %
Date: 2020-04-04 11:58:09 Functions: 128 135 94.8 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Gimple IR support functions.
       2                 :            : 
       3                 :            :    Copyright (C) 2007-2020 Free Software Foundation, Inc.
       4                 :            :    Contributed by Aldy Hernandez <aldyh@redhat.com>
       5                 :            : 
       6                 :            : This file is part of GCC.
       7                 :            : 
       8                 :            : GCC is free software; you can redistribute it and/or modify it under
       9                 :            : the terms of the GNU General Public License as published by the Free
      10                 :            : Software Foundation; either version 3, or (at your option) any later
      11                 :            : version.
      12                 :            : 
      13                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      14                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      15                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      16                 :            : for more details.
      17                 :            : 
      18                 :            : You should have received a copy of the GNU General Public License
      19                 :            : along with GCC; see the file COPYING3.  If not see
      20                 :            : <http://www.gnu.org/licenses/>.  */
      21                 :            : 
      22                 :            : #include "config.h"
      23                 :            : #include "system.h"
      24                 :            : #include "coretypes.h"
      25                 :            : #include "backend.h"
      26                 :            : #include "tree.h"
      27                 :            : #include "gimple.h"
      28                 :            : #include "ssa.h"
      29                 :            : #include "cgraph.h"
      30                 :            : #include "diagnostic.h"
      31                 :            : #include "alias.h"
      32                 :            : #include "fold-const.h"
      33                 :            : #include "calls.h"
      34                 :            : #include "stor-layout.h"
      35                 :            : #include "internal-fn.h"
      36                 :            : #include "tree-eh.h"
      37                 :            : #include "gimple-iterator.h"
      38                 :            : #include "gimple-walk.h"
      39                 :            : #include "gimplify.h"
      40                 :            : #include "target.h"
      41                 :            : #include "builtins.h"
      42                 :            : #include "selftest.h"
      43                 :            : #include "gimple-pretty-print.h"
      44                 :            : #include "stringpool.h"
      45                 :            : #include "attribs.h"
      46                 :            : #include "asan.h"
      47                 :            : #include "langhooks.h"
      48                 :            : 
      49                 :            : 
      50                 :            : /* All the tuples have their operand vector (if present) at the very bottom
      51                 :            :    of the structure.  Therefore, the offset required to find the
      52                 :            :    operands vector the size of the structure minus the size of the 1
      53                 :            :    element tree array at the end (see gimple_ops).  */
      54                 :            : #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
      55                 :            :         (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
      56                 :            : EXPORTED_CONST size_t gimple_ops_offset_[] = {
      57                 :            : #include "gsstruct.def"
      58                 :            : };
      59                 :            : #undef DEFGSSTRUCT
      60                 :            : 
      61                 :            : #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
      62                 :            : static const size_t gsstruct_code_size[] = {
      63                 :            : #include "gsstruct.def"
      64                 :            : };
      65                 :            : #undef DEFGSSTRUCT
      66                 :            : 
      67                 :            : #define DEFGSCODE(SYM, NAME, GSSCODE)   NAME,
      68                 :            : const char *const gimple_code_name[] = {
      69                 :            : #include "gimple.def"
      70                 :            : };
      71                 :            : #undef DEFGSCODE
      72                 :            : 
      73                 :            : #define DEFGSCODE(SYM, NAME, GSSCODE)   GSSCODE,
      74                 :            : EXPORTED_CONST enum gimple_statement_structure_enum gss_for_code_[] = {
      75                 :            : #include "gimple.def"
      76                 :            : };
      77                 :            : #undef DEFGSCODE
      78                 :            : 
      79                 :            : /* Gimple stats.  */
      80                 :            : 
      81                 :            : uint64_t gimple_alloc_counts[(int) gimple_alloc_kind_all];
      82                 :            : uint64_t gimple_alloc_sizes[(int) gimple_alloc_kind_all];
      83                 :            : 
      84                 :            : /* Keep in sync with gimple.h:enum gimple_alloc_kind.  */
      85                 :            : static const char * const gimple_alloc_kind_names[] = {
      86                 :            :     "assignments",
      87                 :            :     "phi nodes",
      88                 :            :     "conditionals",
      89                 :            :     "everything else"
      90                 :            : };
      91                 :            : 
      92                 :            : /* Static gimple tuple members.  */
      93                 :            : const enum gimple_code gassign::code_;
      94                 :            : const enum gimple_code gcall::code_;
      95                 :            : const enum gimple_code gcond::code_;
      96                 :            : 
      97                 :            : 
      98                 :            : /* Gimple tuple constructors.
      99                 :            :    Note: Any constructor taking a ``gimple_seq'' as a parameter, can
     100                 :            :    be passed a NULL to start with an empty sequence.  */
     101                 :            : 
     102                 :            : /* Set the code for statement G to CODE.  */
     103                 :            : 
     104                 :            : static inline void
     105                 :  191050000 : gimple_set_code (gimple *g, enum gimple_code code)
     106                 :            : {
     107                 :  191050000 :   g->code = code;
     108                 :            : }
     109                 :            : 
     110                 :            : /* Return the number of bytes needed to hold a GIMPLE statement with
     111                 :            :    code CODE.  */
     112                 :            : 
     113                 :            : size_t
     114                 :  222675000 : gimple_size (enum gimple_code code, unsigned num_ops)
     115                 :            : {
     116                 :  222675000 :   size_t size = gsstruct_code_size[gss_for_code (code)];
     117                 :  222675000 :   if (num_ops > 0)
     118                 :  159289000 :     size += (sizeof (tree) * (num_ops - 1));
     119                 :  222675000 :   return size;
     120                 :            : }
     121                 :            : 
     122                 :            : /* Initialize GIMPLE statement G with CODE and NUM_OPS.  */
     123                 :            : 
     124                 :            : void
     125                 :  191050000 : gimple_init (gimple *g, enum gimple_code code, unsigned num_ops)
     126                 :            : {
     127                 :  191050000 :   gimple_set_code (g, code);
     128                 :  191050000 :   gimple_set_num_ops (g, num_ops);
     129                 :            : 
     130                 :            :   /* Do not call gimple_set_modified here as it has other side
     131                 :            :      effects and this tuple is still not completely built.  */
     132                 :  191050000 :   g->modified = 1;
     133                 :  191050000 :   gimple_init_singleton (g);
     134                 :  191050000 : }
     135                 :            : 
     136                 :            : /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
     137                 :            :    operands.  */
     138                 :            : 
     139                 :            : gimple *
     140                 :  190395000 : gimple_alloc (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
     141                 :            : {
     142                 :  190395000 :   size_t size;
     143                 :  190395000 :   gimple *stmt;
     144                 :            : 
     145                 :  190395000 :   size = gimple_size (code, num_ops);
     146                 :  190395000 :   if (GATHER_STATISTICS)
     147                 :            :     {
     148                 :            :       enum gimple_alloc_kind kind = gimple_alloc_kind (code);
     149                 :            :       gimple_alloc_counts[(int) kind]++;
     150                 :            :       gimple_alloc_sizes[(int) kind] += size;
     151                 :            :     }
     152                 :            : 
     153                 :  190395000 :   stmt = ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT);
     154                 :  190395000 :   gimple_init (stmt, code, num_ops);
     155                 :  190395000 :   return stmt;
     156                 :            : }
     157                 :            : 
     158                 :            : /* Set SUBCODE to be the code of the expression computed by statement G.  */
     159                 :            : 
     160                 :            : static inline void
     161                 :  145623000 : gimple_set_subcode (gimple *g, unsigned subcode)
     162                 :            : {
     163                 :            :   /* We only have 16 bits for the RHS code.  Assert that we are not
     164                 :            :      overflowing it.  */
     165                 :          0 :   gcc_assert (subcode < (1 << 16));
     166                 :  145623000 :   g->subcode = subcode;
     167                 :            : }
     168                 :            : 
     169                 :            : 
     170                 :            : 
     171                 :            : /* Build a tuple with operands.  CODE is the statement to build (which
     172                 :            :    must be one of the GIMPLE_WITH_OPS tuples).  SUBCODE is the subcode
     173                 :            :    for the new tuple.  NUM_OPS is the number of operands to allocate.  */
     174                 :            : 
     175                 :            : #define gimple_build_with_ops(c, s, n) \
     176                 :            :   gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
     177                 :            : 
     178                 :            : static gimple *
     179                 :  139885000 : gimple_build_with_ops_stat (enum gimple_code code, unsigned subcode,
     180                 :            :                             unsigned num_ops MEM_STAT_DECL)
     181                 :            : {
     182                 :   72551400 :   gimple *s = gimple_alloc (code, num_ops PASS_MEM_STAT);
     183                 :   72551400 :   gimple_set_subcode (s, subcode);
     184                 :            : 
     185                 :  139885000 :   return s;
     186                 :            : }
     187                 :            : 
     188                 :            : 
     189                 :            : /* Build a GIMPLE_RETURN statement returning RETVAL.  */
     190                 :            : 
     191                 :            : greturn *
     192                 :    2218010 : gimple_build_return (tree retval)
     193                 :            : {
     194                 :    2218010 :   greturn *s
     195                 :    2218010 :     = as_a <greturn *> (gimple_build_with_ops (GIMPLE_RETURN, ERROR_MARK,
     196                 :            :                                                2));
     197                 :    2218010 :   if (retval)
     198                 :    1306690 :     gimple_return_set_retval (s, retval);
     199                 :    2218010 :   return s;
     200                 :            : }
     201                 :            : 
     202                 :            : /* Reset alias information on call S.  */
     203                 :            : 
     204                 :            : void
     205                 :   10154500 : gimple_call_reset_alias_info (gcall *s)
     206                 :            : {
     207                 :   10154500 :   if (gimple_call_flags (s) & ECF_CONST)
     208                 :     897146 :     memset (gimple_call_use_set (s), 0, sizeof (struct pt_solution));
     209                 :            :   else
     210                 :    9257320 :     pt_solution_reset (gimple_call_use_set (s));
     211                 :   10154500 :   if (gimple_call_flags (s) & (ECF_CONST|ECF_PURE|ECF_NOVOPS))
     212                 :    1287420 :     memset (gimple_call_clobber_set (s), 0, sizeof (struct pt_solution));
     213                 :            :   else
     214                 :    8867050 :     pt_solution_reset (gimple_call_clobber_set (s));
     215                 :   10154500 : }
     216                 :            : 
     217                 :            : /* Helper for gimple_build_call, gimple_build_call_valist,
     218                 :            :    gimple_build_call_vec and gimple_build_call_from_tree.  Build the basic
     219                 :            :    components of a GIMPLE_CALL statement to function FN with NARGS
     220                 :            :    arguments.  */
     221                 :            : 
     222                 :            : static inline gcall *
     223                 :    7473840 : gimple_build_call_1 (tree fn, unsigned nargs)
     224                 :            : {
     225                 :    7473840 :   gcall *s
     226                 :    7473840 :     = as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
     227                 :            :                                              nargs + 3));
     228                 :    7473840 :   if (TREE_CODE (fn) == FUNCTION_DECL)
     229                 :    7301950 :     fn = build_fold_addr_expr (fn);
     230                 :    7473840 :   gimple_set_op (s, 1, fn);
     231                 :    7473840 :   gimple_call_set_fntype (s, TREE_TYPE (TREE_TYPE (fn)));
     232                 :    7473840 :   gimple_call_reset_alias_info (s);
     233                 :    7473840 :   return s;
     234                 :            : }
     235                 :            : 
     236                 :            : 
     237                 :            : /* Build a GIMPLE_CALL statement to function FN with the arguments
     238                 :            :    specified in vector ARGS.  */
     239                 :            : 
     240                 :            : gcall *
     241                 :     255278 : gimple_build_call_vec (tree fn, vec<tree> args)
     242                 :            : {
     243                 :     255278 :   unsigned i;
     244                 :     255278 :   unsigned nargs = args.length ();
     245                 :     255278 :   gcall *call = gimple_build_call_1 (fn, nargs);
     246                 :            : 
     247                 :     911955 :   for (i = 0; i < nargs; i++)
     248                 :     656677 :     gimple_call_set_arg (call, i, args[i]);
     249                 :            : 
     250                 :     255278 :   return call;
     251                 :            : }
     252                 :            : 
     253                 :            : 
     254                 :            : /* Build a GIMPLE_CALL statement to function FN.  NARGS is the number of
     255                 :            :    arguments.  The ... are the arguments.  */
     256                 :            : 
     257                 :            : gcall *
     258                 :     394528 : gimple_build_call (tree fn, unsigned nargs, ...)
     259                 :            : {
     260                 :     394528 :   va_list ap;
     261                 :     394528 :   gcall *call;
     262                 :     394528 :   unsigned i;
     263                 :            : 
     264                 :     394528 :   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
     265                 :            : 
     266                 :     394528 :   call = gimple_build_call_1 (fn, nargs);
     267                 :            : 
     268                 :     394528 :   va_start (ap, nargs);
     269                 :     835655 :   for (i = 0; i < nargs; i++)
     270                 :     441127 :     gimple_call_set_arg (call, i, va_arg (ap, tree));
     271                 :     394528 :   va_end (ap);
     272                 :            : 
     273                 :     394528 :   return call;
     274                 :            : }
     275                 :            : 
     276                 :            : 
     277                 :            : /* Build a GIMPLE_CALL statement to function FN.  NARGS is the number of
     278                 :            :    arguments.  AP contains the arguments.  */
     279                 :            : 
     280                 :            : gcall *
     281                 :       1934 : gimple_build_call_valist (tree fn, unsigned nargs, va_list ap)
     282                 :            : {
     283                 :       1934 :   gcall *call;
     284                 :       1934 :   unsigned i;
     285                 :            : 
     286                 :       1934 :   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
     287                 :            : 
     288                 :       1934 :   call = gimple_build_call_1 (fn, nargs);
     289                 :            : 
     290                 :       7534 :   for (i = 0; i < nargs; i++)
     291                 :       5600 :     gimple_call_set_arg (call, i, va_arg (ap, tree));
     292                 :            : 
     293                 :       1934 :   return call;
     294                 :            : }
     295                 :            : 
     296                 :            : 
     297                 :            : /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
     298                 :            :    Build the basic components of a GIMPLE_CALL statement to internal
     299                 :            :    function FN with NARGS arguments.  */
     300                 :            : 
     301                 :            : static inline gcall *
     302                 :     406941 : gimple_build_call_internal_1 (enum internal_fn fn, unsigned nargs)
     303                 :            : {
     304                 :     406941 :   gcall *s
     305                 :     406941 :     = as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
     306                 :            :                                              nargs + 3));
     307                 :     406941 :   s->subcode |= GF_CALL_INTERNAL;
     308                 :     406941 :   gimple_call_set_internal_fn (s, fn);
     309                 :     406941 :   gimple_call_reset_alias_info (s);
     310                 :     406941 :   return s;
     311                 :            : }
     312                 :            : 
     313                 :            : 
     314                 :            : /* Build a GIMPLE_CALL statement to internal function FN.  NARGS is
     315                 :            :    the number of arguments.  The ... are the arguments.  */
     316                 :            : 
     317                 :            : gcall *
     318                 :     248353 : gimple_build_call_internal (enum internal_fn fn, unsigned nargs, ...)
     319                 :            : {
     320                 :     248353 :   va_list ap;
     321                 :     248353 :   gcall *call;
     322                 :     248353 :   unsigned i;
     323                 :            : 
     324                 :     248353 :   call = gimple_build_call_internal_1 (fn, nargs);
     325                 :     248353 :   va_start (ap, nargs);
     326                 :    1024350 :   for (i = 0; i < nargs; i++)
     327                 :     776000 :     gimple_call_set_arg (call, i, va_arg (ap, tree));
     328                 :     248353 :   va_end (ap);
     329                 :            : 
     330                 :     248353 :   return call;
     331                 :            : }
     332                 :            : 
     333                 :            : 
     334                 :            : /* Build a GIMPLE_CALL statement to internal function FN with the arguments
     335                 :            :    specified in vector ARGS.  */
     336                 :            : 
     337                 :            : gcall *
     338                 :     158585 : gimple_build_call_internal_vec (enum internal_fn fn, vec<tree> args)
     339                 :            : {
     340                 :     158585 :   unsigned i, nargs;
     341                 :     158585 :   gcall *call;
     342                 :            : 
     343                 :     158585 :   nargs = args.length ();
     344                 :     158585 :   call = gimple_build_call_internal_1 (fn, nargs);
     345                 :     632602 :   for (i = 0; i < nargs; i++)
     346                 :     474017 :     gimple_call_set_arg (call, i, args[i]);
     347                 :            : 
     348                 :     158585 :   return call;
     349                 :            : }
     350                 :            : 
     351                 :            : 
     352                 :            : /* Build a GIMPLE_CALL statement from CALL_EXPR T.  Note that T is
     353                 :            :    assumed to be in GIMPLE form already.  Minimal checking is done of
     354                 :            :    this fact.  */
     355                 :            : 
     356                 :            : gcall *
     357                 :    6822100 : gimple_build_call_from_tree (tree t, tree fnptrtype)
     358                 :            : {
     359                 :    6822100 :   unsigned i, nargs;
     360                 :    6822100 :   gcall *call;
     361                 :            : 
     362                 :    6822100 :   gcc_assert (TREE_CODE (t) == CALL_EXPR);
     363                 :            : 
     364                 :    6822100 :   nargs = call_expr_nargs (t);
     365                 :            : 
     366                 :    6822100 :   tree fndecl = NULL_TREE;
     367                 :    6822100 :   if (CALL_EXPR_FN (t) == NULL_TREE)
     368                 :          3 :     call = gimple_build_call_internal_1 (CALL_EXPR_IFN (t), nargs);
     369                 :            :   else
     370                 :            :     {
     371                 :    6822100 :       fndecl = get_callee_fndecl (t);
     372                 :    6962790 :       call = gimple_build_call_1 (fndecl ? fndecl : CALL_EXPR_FN (t), nargs);
     373                 :            :     }
     374                 :            : 
     375                 :   18182300 :   for (i = 0; i < nargs; i++)
     376                 :   11360200 :     gimple_call_set_arg (call, i, CALL_EXPR_ARG (t, i));
     377                 :            : 
     378                 :    6822100 :   gimple_set_block (call, TREE_BLOCK (t));
     379                 :    6822100 :   gimple_set_location (call, EXPR_LOCATION (t));
     380                 :            : 
     381                 :            :   /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL.  */
     382                 :    6822100 :   gimple_call_set_chain (call, CALL_EXPR_STATIC_CHAIN (t));
     383                 :    6822100 :   gimple_call_set_tail (call, CALL_EXPR_TAILCALL (t));
     384                 :    6822100 :   gimple_call_set_must_tail (call, CALL_EXPR_MUST_TAIL_CALL (t));
     385                 :    6822100 :   gimple_call_set_return_slot_opt (call, CALL_EXPR_RETURN_SLOT_OPT (t));
     386                 :    6822100 :   if (fndecl
     387                 :    6681410 :       && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL)
     388                 :    8215670 :       && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (fndecl)))
     389                 :      17765 :     gimple_call_set_alloca_for_var (call, CALL_ALLOCA_FOR_VAR_P (t));
     390                 :            :   else
     391                 :    6804340 :     gimple_call_set_from_thunk (call, CALL_FROM_THUNK_P (t));
     392                 :    6822100 :   gimple_call_set_va_arg_pack (call, CALL_EXPR_VA_ARG_PACK (t));
     393                 :    6822100 :   gimple_call_set_nothrow (call, TREE_NOTHROW (t));
     394                 :    6822100 :   gimple_call_set_by_descriptor (call, CALL_EXPR_BY_DESCRIPTOR (t));
     395                 :    6822100 :   gimple_set_no_warning (call, TREE_NO_WARNING (t));
     396                 :            : 
     397                 :    6822100 :   if (fnptrtype)
     398                 :            :     {
     399                 :    6822090 :       gimple_call_set_fntype (call, TREE_TYPE (fnptrtype));
     400                 :            : 
     401                 :            :       /* Check if it's an indirect CALL and the type has the
     402                 :            :          nocf_check attribute. In that case propagate the information
     403                 :            :          to the gimple CALL insn.  */
     404                 :    6822090 :       if (!fndecl)
     405                 :            :         {
     406                 :     140679 :           gcc_assert (POINTER_TYPE_P (fnptrtype));
     407                 :     140679 :           tree fntype = TREE_TYPE (fnptrtype);
     408                 :            : 
     409                 :     140679 :           if (lookup_attribute ("nocf_check", TYPE_ATTRIBUTES (fntype)))
     410                 :         22 :             gimple_call_set_nocf_check (call, TRUE);
     411                 :            :         }
     412                 :            :     }
     413                 :            : 
     414                 :    6822100 :   return call;
     415                 :            : }
     416                 :            : 
     417                 :            : 
     418                 :            : /* Build a GIMPLE_ASSIGN statement.
     419                 :            : 
     420                 :            :    LHS of the assignment.
     421                 :            :    RHS of the assignment which can be unary or binary.  */
     422                 :            : 
     423                 :            : gassign *
     424                 :   63846300 : gimple_build_assign (tree lhs, tree rhs MEM_STAT_DECL)
     425                 :            : {
     426                 :   63846300 :   enum tree_code subcode;
     427                 :   63846300 :   tree op1, op2, op3;
     428                 :            : 
     429                 :   63846300 :   extract_ops_from_tree (rhs, &subcode, &op1, &op2, &op3);
     430                 :   63846300 :   return gimple_build_assign (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
     431                 :            : }
     432                 :            : 
     433                 :            : 
     434                 :            : /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
     435                 :            :    OP1, OP2 and OP3.  */
     436                 :            : 
     437                 :            : static inline gassign *
     438                 :   66026100 : gimple_build_assign_1 (tree lhs, enum tree_code subcode, tree op1,
     439                 :            :                        tree op2, tree op3 MEM_STAT_DECL)
     440                 :            : {
     441                 :   66026100 :   unsigned num_ops;
     442                 :   66026100 :   gassign *p;
     443                 :            : 
     444                 :            :   /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
     445                 :            :      code).  */
     446                 :   66026100 :   num_ops = get_gimple_rhs_num_ops (subcode) + 1;
     447                 :            : 
     448                 :   66026100 :   p = as_a <gassign *> (
     449                 :            :         gimple_build_with_ops_stat (GIMPLE_ASSIGN, (unsigned)subcode, num_ops
     450                 :            :                                     PASS_MEM_STAT));
     451                 :   66026100 :   gimple_assign_set_lhs (p, lhs);
     452                 :   66026100 :   gimple_assign_set_rhs1 (p, op1);
     453                 :   66026100 :   if (op2)
     454                 :            :     {
     455                 :    8065480 :       gcc_assert (num_ops > 2);
     456                 :    8065480 :       gimple_assign_set_rhs2 (p, op2);
     457                 :            :     }
     458                 :            : 
     459                 :   66026100 :   if (op3)
     460                 :            :     {
     461                 :      82962 :       gcc_assert (num_ops > 3);
     462                 :      82962 :       gimple_assign_set_rhs3 (p, op3);
     463                 :            :     }
     464                 :            : 
     465                 :   66026100 :   return p;
     466                 :            : }
     467                 :            : 
     468                 :            : /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
     469                 :            :    OP1, OP2 and OP3.  */
     470                 :            : 
     471                 :            : gassign *
     472                 :   64123000 : gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
     473                 :            :                      tree op2, tree op3 MEM_STAT_DECL)
     474                 :            : {
     475                 :   64123000 :   return gimple_build_assign_1 (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
     476                 :            : }
     477                 :            : 
     478                 :            : /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
     479                 :            :    OP1 and OP2.  */
     480                 :            : 
     481                 :            : gassign *
     482                 :    1472730 : gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
     483                 :            :                      tree op2 MEM_STAT_DECL)
     484                 :            : {
     485                 :    1472730 :   return gimple_build_assign_1 (lhs, subcode, op1, op2, NULL_TREE
     486                 :    1472730 :                                 PASS_MEM_STAT);
     487                 :            : }
     488                 :            : 
     489                 :            : /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1.  */
     490                 :            : 
     491                 :            : gassign *
     492                 :     430405 : gimple_build_assign (tree lhs, enum tree_code subcode, tree op1 MEM_STAT_DECL)
     493                 :            : {
     494                 :     430405 :   return gimple_build_assign_1 (lhs, subcode, op1, NULL_TREE, NULL_TREE
     495                 :     430405 :                                 PASS_MEM_STAT);
     496                 :            : }
     497                 :            : 
     498                 :            : 
     499                 :            : /* Build a GIMPLE_COND statement.
     500                 :            : 
     501                 :            :    PRED is the condition used to compare LHS and the RHS.
     502                 :            :    T_LABEL is the label to jump to if the condition is true.
     503                 :            :    F_LABEL is the label to jump to otherwise.  */
     504                 :            : 
     505                 :            : gcond *
     506                 :    6525350 : gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs,
     507                 :            :                    tree t_label, tree f_label)
     508                 :            : {
     509                 :    6525350 :   gcond *p;
     510                 :            : 
     511                 :    6525350 :   gcc_assert (TREE_CODE_CLASS (pred_code) == tcc_comparison);
     512                 :    6525350 :   p = as_a <gcond *> (gimple_build_with_ops (GIMPLE_COND, pred_code, 4));
     513                 :    6525350 :   gimple_cond_set_lhs (p, lhs);
     514                 :    6525350 :   gimple_cond_set_rhs (p, rhs);
     515                 :    6525350 :   gimple_cond_set_true_label (p, t_label);
     516                 :    6525350 :   gimple_cond_set_false_label (p, f_label);
     517                 :    6525350 :   return p;
     518                 :            : }
     519                 :            : 
     520                 :            : /* Build a GIMPLE_COND statement from the conditional expression tree
     521                 :            :    COND.  T_LABEL and F_LABEL are as in gimple_build_cond.  */
     522                 :            : 
     523                 :            : gcond *
     524                 :      32362 : gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
     525                 :            : {
     526                 :      32362 :   enum tree_code code;
     527                 :      32362 :   tree lhs, rhs;
     528                 :            : 
     529                 :      32362 :   gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
     530                 :      32362 :   return gimple_build_cond (code, lhs, rhs, t_label, f_label);
     531                 :            : }
     532                 :            : 
     533                 :            : /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
     534                 :            :    boolean expression tree COND.  */
     535                 :            : 
     536                 :            : void
     537                 :     517238 : gimple_cond_set_condition_from_tree (gcond *stmt, tree cond)
     538                 :            : {
     539                 :     517238 :   enum tree_code code;
     540                 :     517238 :   tree lhs, rhs;
     541                 :            : 
     542                 :     517238 :   gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
     543                 :     517238 :   gimple_cond_set_condition (stmt, code, lhs, rhs);
     544                 :     517238 : }
     545                 :            : 
     546                 :            : /* Build a GIMPLE_LABEL statement for LABEL.  */
     547                 :            : 
     548                 :            : glabel *
     549                 :   12731200 : gimple_build_label (tree label)
     550                 :            : {
     551                 :   12731200 :   glabel *p
     552                 :   12731200 :     = as_a <glabel *> (gimple_build_with_ops (GIMPLE_LABEL, ERROR_MARK, 1));
     553                 :   12731200 :   gimple_label_set_label (p, label);
     554                 :   12731200 :   return p;
     555                 :            : }
     556                 :            : 
     557                 :            : /* Build a GIMPLE_GOTO statement to label DEST.  */
     558                 :            : 
     559                 :            : ggoto *
     560                 :    4349190 : gimple_build_goto (tree dest)
     561                 :            : {
     562                 :    4349190 :   ggoto *p
     563                 :    4349190 :     = as_a <ggoto *> (gimple_build_with_ops (GIMPLE_GOTO, ERROR_MARK, 1));
     564                 :    4349190 :   gimple_goto_set_dest (p, dest);
     565                 :    4349190 :   return p;
     566                 :            : }
     567                 :            : 
     568                 :            : 
     569                 :            : /* Build a GIMPLE_NOP statement.  */
     570                 :            : 
     571                 :            : gimple *
     572                 :    9273420 : gimple_build_nop (void)
     573                 :            : {
     574                 :    9273420 :   return gimple_alloc (GIMPLE_NOP, 0);
     575                 :            : }
     576                 :            : 
     577                 :            : 
     578                 :            : /* Build a GIMPLE_BIND statement.
     579                 :            :    VARS are the variables in BODY.
     580                 :            :    BLOCK is the containing block.  */
     581                 :            : 
     582                 :            : gbind *
     583                 :    5104590 : gimple_build_bind (tree vars, gimple_seq body, tree block)
     584                 :            : {
     585                 :    5104590 :   gbind *p = as_a <gbind *> (gimple_alloc (GIMPLE_BIND, 0));
     586                 :    5104590 :   gimple_bind_set_vars (p, vars);
     587                 :    5104590 :   if (body)
     588                 :    1008030 :     gimple_bind_set_body (p, body);
     589                 :    5104590 :   if (block)
     590                 :    3961910 :     gimple_bind_set_block (p, block);
     591                 :    5104590 :   return p;
     592                 :            : }
     593                 :            : 
     594                 :            : /* Helper function to set the simple fields of a asm stmt.
     595                 :            : 
     596                 :            :    STRING is a pointer to a string that is the asm blocks assembly code.
     597                 :            :    NINPUT is the number of register inputs.
     598                 :            :    NOUTPUT is the number of register outputs.
     599                 :            :    NCLOBBERS is the number of clobbered registers.
     600                 :            :    */
     601                 :            : 
     602                 :            : static inline gasm *
     603                 :      84474 : gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
     604                 :            :                     unsigned nclobbers, unsigned nlabels)
     605                 :            : {
     606                 :      84474 :   gasm *p;
     607                 :      84474 :   int size = strlen (string);
     608                 :            : 
     609                 :            :   /* ASMs with labels cannot have outputs.  This should have been
     610                 :            :      enforced by the front end.  */
     611                 :      84474 :   gcc_assert (nlabels == 0 || noutputs == 0);
     612                 :            : 
     613                 :      84474 :   p = as_a <gasm *> (
     614                 :      84474 :         gimple_build_with_ops (GIMPLE_ASM, ERROR_MARK,
     615                 :            :                                ninputs + noutputs + nclobbers + nlabels));
     616                 :            : 
     617                 :      84474 :   p->ni = ninputs;
     618                 :      84474 :   p->no = noutputs;
     619                 :      84474 :   p->nc = nclobbers;
     620                 :      84474 :   p->nl = nlabels;
     621                 :      84474 :   p->string = ggc_alloc_string (string, size);
     622                 :            : 
     623                 :      84474 :   if (GATHER_STATISTICS)
     624                 :            :     gimple_alloc_sizes[(int) gimple_alloc_kind (GIMPLE_ASM)] += size;
     625                 :            : 
     626                 :      84474 :   return p;
     627                 :            : }
     628                 :            : 
     629                 :            : /* Build a GIMPLE_ASM statement.
     630                 :            : 
     631                 :            :    STRING is the assembly code.
     632                 :            :    NINPUT is the number of register inputs.
     633                 :            :    NOUTPUT is the number of register outputs.
     634                 :            :    NCLOBBERS is the number of clobbered registers.
     635                 :            :    INPUTS is a vector of the input register parameters.
     636                 :            :    OUTPUTS is a vector of the output register parameters.
     637                 :            :    CLOBBERS is a vector of the clobbered register parameters.
     638                 :            :    LABELS is a vector of destination labels.  */
     639                 :            : 
     640                 :            : gasm *
     641                 :      84474 : gimple_build_asm_vec (const char *string, vec<tree, va_gc> *inputs,
     642                 :            :                       vec<tree, va_gc> *outputs, vec<tree, va_gc> *clobbers,
     643                 :            :                       vec<tree, va_gc> *labels)
     644                 :            : {
     645                 :      84474 :   gasm *p;
     646                 :      84474 :   unsigned i;
     647                 :            : 
     648                 :     167008 :   p = gimple_build_asm_1 (string,
     649                 :            :                           vec_safe_length (inputs),
     650                 :            :                           vec_safe_length (outputs),
     651                 :            :                           vec_safe_length (clobbers),
     652                 :            :                           vec_safe_length (labels));
     653                 :            : 
     654                 :     194678 :   for (i = 0; i < vec_safe_length (inputs); i++)
     655                 :      80500 :     gimple_asm_set_input_op (p, i, (*inputs)[i]);
     656                 :            : 
     657                 :     236989 :   for (i = 0; i < vec_safe_length (outputs); i++)
     658                 :     127030 :     gimple_asm_set_output_op (p, i, (*outputs)[i]);
     659                 :            : 
     660                 :     312539 :   for (i = 0; i < vec_safe_length (clobbers); i++)
     661                 :      85631 :     gimple_asm_set_clobber_op (p, i, (*clobbers)[i]);
     662                 :            : 
     663                 :      85452 :   for (i = 0; i < vec_safe_length (labels); i++)
     664                 :        366 :     gimple_asm_set_label_op (p, i, (*labels)[i]);
     665                 :            : 
     666                 :      84474 :   return p;
     667                 :            : }
     668                 :            : 
     669                 :            : /* Build a GIMPLE_CATCH statement.
     670                 :            : 
     671                 :            :   TYPES are the catch types.
     672                 :            :   HANDLER is the exception handler.  */
     673                 :            : 
     674                 :            : gcatch *
     675                 :      37518 : gimple_build_catch (tree types, gimple_seq handler)
     676                 :            : {
     677                 :      37518 :   gcatch *p = as_a <gcatch *> (gimple_alloc (GIMPLE_CATCH, 0));
     678                 :      37518 :   gimple_catch_set_types (p, types);
     679                 :      37518 :   if (handler)
     680                 :      37502 :     gimple_catch_set_handler (p, handler);
     681                 :            : 
     682                 :      37518 :   return p;
     683                 :            : }
     684                 :            : 
     685                 :            : /* Build a GIMPLE_EH_FILTER statement.
     686                 :            : 
     687                 :            :    TYPES are the filter's types.
     688                 :            :    FAILURE is the filter's failure action.  */
     689                 :            : 
     690                 :            : geh_filter *
     691                 :       8389 : gimple_build_eh_filter (tree types, gimple_seq failure)
     692                 :            : {
     693                 :       8389 :   geh_filter *p = as_a <geh_filter *> (gimple_alloc (GIMPLE_EH_FILTER, 0));
     694                 :       8389 :   gimple_eh_filter_set_types (p, types);
     695                 :       8389 :   if (failure)
     696                 :       8389 :     gimple_eh_filter_set_failure (p, failure);
     697                 :            : 
     698                 :       8389 :   return p;
     699                 :            : }
     700                 :            : 
     701                 :            : /* Build a GIMPLE_EH_MUST_NOT_THROW statement.  */
     702                 :            : 
     703                 :            : geh_mnt *
     704                 :     739335 : gimple_build_eh_must_not_throw (tree decl)
     705                 :            : {
     706                 :     739335 :   geh_mnt *p = as_a <geh_mnt *> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW, 0));
     707                 :            : 
     708                 :     739335 :   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
     709                 :     739335 :   gcc_assert (flags_from_decl_or_type (decl) & ECF_NORETURN);
     710                 :     739335 :   gimple_eh_must_not_throw_set_fndecl (p, decl);
     711                 :            : 
     712                 :     739335 :   return p;
     713                 :            : }
     714                 :            : 
     715                 :            : /* Build a GIMPLE_EH_ELSE statement.  */
     716                 :            : 
     717                 :            : geh_else *
     718                 :        336 : gimple_build_eh_else (gimple_seq n_body, gimple_seq e_body)
     719                 :            : {
     720                 :        336 :   geh_else *p = as_a <geh_else *> (gimple_alloc (GIMPLE_EH_ELSE, 0));
     721                 :        336 :   gimple_eh_else_set_n_body (p, n_body);
     722                 :        336 :   gimple_eh_else_set_e_body (p, e_body);
     723                 :        336 :   return p;
     724                 :            : }
     725                 :            : 
     726                 :            : /* Build a GIMPLE_TRY statement.
     727                 :            : 
     728                 :            :    EVAL is the expression to evaluate.
     729                 :            :    CLEANUP is the cleanup expression.
     730                 :            :    KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
     731                 :            :    whether this is a try/catch or a try/finally respectively.  */
     732                 :            : 
     733                 :            : gtry *
     734                 :    1917700 : gimple_build_try (gimple_seq eval, gimple_seq cleanup,
     735                 :            :                   enum gimple_try_flags kind)
     736                 :            : {
     737                 :    1917700 :   gtry *p;
     738                 :            : 
     739                 :    1917700 :   gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
     740                 :    1917700 :   p = as_a <gtry *> (gimple_alloc (GIMPLE_TRY, 0));
     741                 :    1917700 :   gimple_set_subcode (p, kind);
     742                 :    1917700 :   if (eval)
     743                 :    1821710 :     gimple_try_set_eval (p, eval);
     744                 :    1917700 :   if (cleanup)
     745                 :    1917700 :     gimple_try_set_cleanup (p, cleanup);
     746                 :            : 
     747                 :    1917700 :   return p;
     748                 :            : }
     749                 :            : 
     750                 :            : /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
     751                 :            : 
     752                 :            :    CLEANUP is the cleanup expression.  */
     753                 :            : 
     754                 :            : gimple *
     755                 :     288455 : gimple_build_wce (gimple_seq cleanup)
     756                 :            : {
     757                 :     288455 :   gimple *p = gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR, 0);
     758                 :     288455 :   if (cleanup)
     759                 :     288455 :     gimple_wce_set_cleanup (p, cleanup);
     760                 :            : 
     761                 :     288455 :   return p;
     762                 :            : }
     763                 :            : 
     764                 :            : 
     765                 :            : /* Build a GIMPLE_RESX statement.  */
     766                 :            : 
     767                 :            : gresx *
     768                 :     527960 : gimple_build_resx (int region)
     769                 :            : {
     770                 :     527960 :   gresx *p
     771                 :     527960 :     = as_a <gresx *> (gimple_build_with_ops (GIMPLE_RESX, ERROR_MARK, 0));
     772                 :     527960 :   p->region = region;
     773                 :     527960 :   return p;
     774                 :            : }
     775                 :            : 
     776                 :            : 
     777                 :            : /* The helper for constructing a gimple switch statement.
     778                 :            :    INDEX is the switch's index.
     779                 :            :    NLABELS is the number of labels in the switch excluding the default.
     780                 :            :    DEFAULT_LABEL is the default label for the switch statement.  */
     781                 :            : 
     782                 :            : gswitch *
     783                 :      47751 : gimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)
     784                 :            : {
     785                 :            :   /* nlabels + 1 default label + 1 index.  */
     786                 :      47751 :   gcc_checking_assert (default_label);
     787                 :      47751 :   gswitch *p = as_a <gswitch *> (gimple_build_with_ops (GIMPLE_SWITCH,
     788                 :            :                                                         ERROR_MARK,
     789                 :            :                                                         1 + 1 + nlabels));
     790                 :      47751 :   gimple_switch_set_index (p, index);
     791                 :      47751 :   gimple_switch_set_default_label (p, default_label);
     792                 :      47751 :   return p;
     793                 :            : }
     794                 :            : 
     795                 :            : /* Build a GIMPLE_SWITCH statement.
     796                 :            : 
     797                 :            :    INDEX is the switch's index.
     798                 :            :    DEFAULT_LABEL is the default label
     799                 :            :    ARGS is a vector of labels excluding the default.  */
     800                 :            : 
     801                 :            : gswitch *
     802                 :      47751 : gimple_build_switch (tree index, tree default_label, vec<tree> args)
     803                 :            : {
     804                 :      47751 :   unsigned i, nlabels = args.length ();
     805                 :            : 
     806                 :      47751 :   gswitch *p = gimple_build_switch_nlabels (nlabels, index, default_label);
     807                 :            : 
     808                 :            :   /* Copy the labels from the vector to the switch statement.  */
     809                 :    1019680 :   for (i = 0; i < nlabels; i++)
     810                 :     971931 :     gimple_switch_set_label (p, i + 1, args[i]);
     811                 :            : 
     812                 :      47751 :   return p;
     813                 :            : }
     814                 :            : 
     815                 :            : /* Build a GIMPLE_EH_DISPATCH statement.  */
     816                 :            : 
     817                 :            : geh_dispatch *
     818                 :      41426 : gimple_build_eh_dispatch (int region)
     819                 :            : {
     820                 :      41426 :   geh_dispatch *p
     821                 :      41426 :     = as_a <geh_dispatch *> (
     822                 :            :         gimple_build_with_ops (GIMPLE_EH_DISPATCH, ERROR_MARK, 0));
     823                 :      41426 :   p->region = region;
     824                 :      41426 :   return p;
     825                 :            : }
     826                 :            : 
     827                 :            : /* Build a new GIMPLE_DEBUG_BIND statement.
     828                 :            : 
     829                 :            :    VAR is bound to VALUE; block and location are taken from STMT.  */
     830                 :            : 
     831                 :            : gdebug *
     832                 :   35151400 : gimple_build_debug_bind (tree var, tree value, gimple *stmt MEM_STAT_DECL)
     833                 :            : {
     834                 :   35151400 :   gdebug *p
     835                 :   35151400 :     = as_a <gdebug *> (gimple_build_with_ops_stat (GIMPLE_DEBUG,
     836                 :            :                                                    (unsigned)GIMPLE_DEBUG_BIND, 2
     837                 :            :                                                    PASS_MEM_STAT));
     838                 :   35151400 :   gimple_debug_bind_set_var (p, var);
     839                 :   35151400 :   gimple_debug_bind_set_value (p, value);
     840                 :   35151400 :   if (stmt)
     841                 :   34563600 :     gimple_set_location (p, gimple_location (stmt));
     842                 :            : 
     843                 :   35151400 :   return p;
     844                 :            : }
     845                 :            : 
     846                 :            : 
     847                 :            : /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
     848                 :            : 
     849                 :            :    VAR is bound to VALUE; block and location are taken from STMT.  */
     850                 :            : 
     851                 :            : gdebug *
     852                 :     195186 : gimple_build_debug_source_bind (tree var, tree value,
     853                 :            :                                      gimple *stmt MEM_STAT_DECL)
     854                 :            : {
     855                 :     195186 :   gdebug *p
     856                 :     195186 :     = as_a <gdebug *> (
     857                 :            :         gimple_build_with_ops_stat (GIMPLE_DEBUG,
     858                 :            :                                     (unsigned)GIMPLE_DEBUG_SOURCE_BIND, 2
     859                 :            :                                     PASS_MEM_STAT));
     860                 :            : 
     861                 :     195186 :   gimple_debug_source_bind_set_var (p, var);
     862                 :     195186 :   gimple_debug_source_bind_set_value (p, value);
     863                 :     195186 :   if (stmt)
     864                 :     140124 :     gimple_set_location (p, gimple_location (stmt));
     865                 :            : 
     866                 :     195186 :   return p;
     867                 :            : }
     868                 :            : 
     869                 :            : 
     870                 :            : /* Build a new GIMPLE_DEBUG_BEGIN_STMT statement in BLOCK at
     871                 :            :    LOCATION.  */
     872                 :            : 
     873                 :            : gdebug *
     874                 :    1935160 : gimple_build_debug_begin_stmt (tree block, location_t location
     875                 :            :                                     MEM_STAT_DECL)
     876                 :            : {
     877                 :    1935160 :   gdebug *p
     878                 :    1935160 :     = as_a <gdebug *> (
     879                 :            :         gimple_build_with_ops_stat (GIMPLE_DEBUG,
     880                 :            :                                     (unsigned)GIMPLE_DEBUG_BEGIN_STMT, 0
     881                 :            :                                     PASS_MEM_STAT));
     882                 :            : 
     883                 :    1935160 :   gimple_set_location (p, location);
     884                 :    1935160 :   gimple_set_block (p, block);
     885                 :    1935160 :   cfun->debug_marker_count++;
     886                 :            : 
     887                 :    1935160 :   return p;
     888                 :            : }
     889                 :            : 
     890                 :            : 
     891                 :            : /* Build a new GIMPLE_DEBUG_INLINE_ENTRY statement in BLOCK at
     892                 :            :    LOCATION.  The BLOCK links to the inlined function.  */
     893                 :            : 
     894                 :            : gdebug *
     895                 :    2171160 : gimple_build_debug_inline_entry (tree block, location_t location
     896                 :            :                                       MEM_STAT_DECL)
     897                 :            : {
     898                 :    2171160 :   gdebug *p
     899                 :    2171160 :     = as_a <gdebug *> (
     900                 :            :         gimple_build_with_ops_stat (GIMPLE_DEBUG,
     901                 :            :                                     (unsigned)GIMPLE_DEBUG_INLINE_ENTRY, 0
     902                 :            :                                     PASS_MEM_STAT));
     903                 :            : 
     904                 :    2171160 :   gimple_set_location (p, location);
     905                 :    2171160 :   gimple_set_block (p, block);
     906                 :    2171160 :   cfun->debug_marker_count++;
     907                 :            : 
     908                 :    2171160 :   return p;
     909                 :            : }
     910                 :            : 
     911                 :            : 
     912                 :            : /* Build a GIMPLE_OMP_CRITICAL statement.
     913                 :            : 
     914                 :            :    BODY is the sequence of statements for which only one thread can execute.
     915                 :            :    NAME is optional identifier for this critical block.
     916                 :            :    CLAUSES are clauses for this critical block.  */
     917                 :            : 
     918                 :            : gomp_critical *
     919                 :        408 : gimple_build_omp_critical (gimple_seq body, tree name, tree clauses)
     920                 :            : {
     921                 :        408 :   gomp_critical *p
     922                 :        408 :     = as_a <gomp_critical *> (gimple_alloc (GIMPLE_OMP_CRITICAL, 0));
     923                 :        408 :   gimple_omp_critical_set_name (p, name);
     924                 :        408 :   gimple_omp_critical_set_clauses (p, clauses);
     925                 :        408 :   if (body)
     926                 :        339 :     gimple_omp_set_body (p, body);
     927                 :            : 
     928                 :        408 :   return p;
     929                 :            : }
     930                 :            : 
     931                 :            : /* Build a GIMPLE_OMP_FOR statement.
     932                 :            : 
     933                 :            :    BODY is sequence of statements inside the for loop.
     934                 :            :    KIND is the `for' variant.
     935                 :            :    CLAUSES are any of the construct's clauses.
     936                 :            :    COLLAPSE is the collapse count.
     937                 :            :    PRE_BODY is the sequence of statements that are loop invariant.  */
     938                 :            : 
     939                 :            : gomp_for *
     940                 :      41376 : gimple_build_omp_for (gimple_seq body, int kind, tree clauses, size_t collapse,
     941                 :            :                       gimple_seq pre_body)
     942                 :            : {
     943                 :      41376 :   gomp_for *p = as_a <gomp_for *> (gimple_alloc (GIMPLE_OMP_FOR, 0));
     944                 :      41376 :   if (body)
     945                 :      37651 :     gimple_omp_set_body (p, body);
     946                 :      41376 :   gimple_omp_for_set_clauses (p, clauses);
     947                 :      41376 :   gimple_omp_for_set_kind (p, kind);
     948                 :      41376 :   p->collapse = collapse;
     949                 :      41376 :   p->iter =  ggc_cleared_vec_alloc<gimple_omp_for_iter> (collapse);
     950                 :            : 
     951                 :      41376 :   if (pre_body)
     952                 :       2060 :     gimple_omp_for_set_pre_body (p, pre_body);
     953                 :            : 
     954                 :      41376 :   return p;
     955                 :            : }
     956                 :            : 
     957                 :            : 
     958                 :            : /* Build a GIMPLE_OMP_PARALLEL statement.
     959                 :            : 
     960                 :            :    BODY is sequence of statements which are executed in parallel.
     961                 :            :    CLAUSES are the OMP parallel construct's clauses.
     962                 :            :    CHILD_FN is the function created for the parallel threads to execute.
     963                 :            :    DATA_ARG are the shared data argument(s).  */
     964                 :            : 
     965                 :            : gomp_parallel *
     966                 :      14265 : gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
     967                 :            :                            tree data_arg)
     968                 :            : {
     969                 :      14265 :   gomp_parallel *p
     970                 :      14265 :     = as_a <gomp_parallel *> (gimple_alloc (GIMPLE_OMP_PARALLEL, 0));
     971                 :      14265 :   if (body)
     972                 :      14081 :     gimple_omp_set_body (p, body);
     973                 :      14265 :   gimple_omp_parallel_set_clauses (p, clauses);
     974                 :      14265 :   gimple_omp_parallel_set_child_fn (p, child_fn);
     975                 :      14265 :   gimple_omp_parallel_set_data_arg (p, data_arg);
     976                 :            : 
     977                 :      14265 :   return p;
     978                 :            : }
     979                 :            : 
     980                 :            : 
     981                 :            : /* Build a GIMPLE_OMP_TASK statement.
     982                 :            : 
     983                 :            :    BODY is sequence of statements which are executed by the explicit task.
     984                 :            :    CLAUSES are the OMP task construct's clauses.
     985                 :            :    CHILD_FN is the function created for the parallel threads to execute.
     986                 :            :    DATA_ARG are the shared data argument(s).
     987                 :            :    COPY_FN is the optional function for firstprivate initialization.
     988                 :            :    ARG_SIZE and ARG_ALIGN are size and alignment of the data block.  */
     989                 :            : 
     990                 :            : gomp_task *
     991                 :       3364 : gimple_build_omp_task (gimple_seq body, tree clauses, tree child_fn,
     992                 :            :                        tree data_arg, tree copy_fn, tree arg_size,
     993                 :            :                        tree arg_align)
     994                 :            : {
     995                 :       3364 :   gomp_task *p = as_a <gomp_task *> (gimple_alloc (GIMPLE_OMP_TASK, 0));
     996                 :       3364 :   if (body)
     997                 :       3352 :     gimple_omp_set_body (p, body);
     998                 :       3364 :   gimple_omp_task_set_clauses (p, clauses);
     999                 :       3364 :   gimple_omp_task_set_child_fn (p, child_fn);
    1000                 :       3364 :   gimple_omp_task_set_data_arg (p, data_arg);
    1001                 :       3364 :   gimple_omp_task_set_copy_fn (p, copy_fn);
    1002                 :       3364 :   gimple_omp_task_set_arg_size (p, arg_size);
    1003                 :       3364 :   gimple_omp_task_set_arg_align (p, arg_align);
    1004                 :            : 
    1005                 :       3364 :   return p;
    1006                 :            : }
    1007                 :            : 
    1008                 :            : 
    1009                 :            : /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
    1010                 :            : 
    1011                 :            :    BODY is the sequence of statements in the section.  */
    1012                 :            : 
    1013                 :            : gimple *
    1014                 :       1122 : gimple_build_omp_section (gimple_seq body)
    1015                 :            : {
    1016                 :       1122 :   gimple *p = gimple_alloc (GIMPLE_OMP_SECTION, 0);
    1017                 :       1122 :   if (body)
    1018                 :        969 :     gimple_omp_set_body (p, body);
    1019                 :            : 
    1020                 :       1122 :   return p;
    1021                 :            : }
    1022                 :            : 
    1023                 :            : 
    1024                 :            : /* Build a GIMPLE_OMP_MASTER statement.
    1025                 :            : 
    1026                 :            :    BODY is the sequence of statements to be executed by just the master.  */
    1027                 :            : 
    1028                 :            : gimple *
    1029                 :        485 : gimple_build_omp_master (gimple_seq body)
    1030                 :            : {
    1031                 :        485 :   gimple *p = gimple_alloc (GIMPLE_OMP_MASTER, 0);
    1032                 :        485 :   if (body)
    1033                 :        414 :     gimple_omp_set_body (p, body);
    1034                 :            : 
    1035                 :        485 :   return p;
    1036                 :            : }
    1037                 :            : 
    1038                 :            : /* Build a GIMPLE_OMP_GRID_BODY statement.
    1039                 :            : 
    1040                 :            :    BODY is the sequence of statements to be executed by the kernel.  */
    1041                 :            : 
    1042                 :            : gimple *
    1043                 :          0 : gimple_build_omp_grid_body (gimple_seq body)
    1044                 :            : {
    1045                 :          0 :   gimple *p = gimple_alloc (GIMPLE_OMP_GRID_BODY, 0);
    1046                 :          0 :   if (body)
    1047                 :          0 :     gimple_omp_set_body (p, body);
    1048                 :            : 
    1049                 :          0 :   return p;
    1050                 :            : }
    1051                 :            : 
    1052                 :            : /* Build a GIMPLE_OMP_TASKGROUP statement.
    1053                 :            : 
    1054                 :            :    BODY is the sequence of statements to be executed by the taskgroup
    1055                 :            :    construct.
    1056                 :            :    CLAUSES are any of the construct's clauses.  */
    1057                 :            : 
    1058                 :            : gimple *
    1059                 :        314 : gimple_build_omp_taskgroup (gimple_seq body, tree clauses)
    1060                 :            : {
    1061                 :        314 :   gimple *p = gimple_alloc (GIMPLE_OMP_TASKGROUP, 0);
    1062                 :        314 :   gimple_omp_taskgroup_set_clauses (p, clauses);
    1063                 :        314 :   if (body)
    1064                 :        314 :     gimple_omp_set_body (p, body);
    1065                 :            : 
    1066                 :        314 :   return p;
    1067                 :            : }
    1068                 :            : 
    1069                 :            : 
    1070                 :            : /* Build a GIMPLE_OMP_CONTINUE statement.
    1071                 :            : 
    1072                 :            :    CONTROL_DEF is the definition of the control variable.
    1073                 :            :    CONTROL_USE is the use of the control variable.  */
    1074                 :            : 
    1075                 :            : gomp_continue *
    1076                 :      38961 : gimple_build_omp_continue (tree control_def, tree control_use)
    1077                 :            : {
    1078                 :      38961 :   gomp_continue *p
    1079                 :      38961 :     = as_a <gomp_continue *> (gimple_alloc (GIMPLE_OMP_CONTINUE, 0));
    1080                 :      38961 :   gimple_omp_continue_set_control_def (p, control_def);
    1081                 :      38961 :   gimple_omp_continue_set_control_use (p, control_use);
    1082                 :      38961 :   return p;
    1083                 :            : }
    1084                 :            : 
    1085                 :            : /* Build a GIMPLE_OMP_ORDERED statement.
    1086                 :            : 
    1087                 :            :    BODY is the sequence of statements inside a loop that will executed in
    1088                 :            :    sequence.
    1089                 :            :    CLAUSES are clauses for this statement.  */
    1090                 :            : 
    1091                 :            : gomp_ordered *
    1092                 :       1484 : gimple_build_omp_ordered (gimple_seq body, tree clauses)
    1093                 :            : {
    1094                 :       1484 :   gomp_ordered *p
    1095                 :       1484 :     = as_a <gomp_ordered *> (gimple_alloc (GIMPLE_OMP_ORDERED, 0));
    1096                 :       1484 :   gimple_omp_ordered_set_clauses (p, clauses);
    1097                 :       1484 :   if (body)
    1098                 :        449 :     gimple_omp_set_body (p, body);
    1099                 :            : 
    1100                 :       1484 :   return p;
    1101                 :            : }
    1102                 :            : 
    1103                 :            : 
    1104                 :            : /* Build a GIMPLE_OMP_RETURN statement.
    1105                 :            :    WAIT_P is true if this is a non-waiting return.  */
    1106                 :            : 
    1107                 :            : gimple *
    1108                 :      74444 : gimple_build_omp_return (bool wait_p)
    1109                 :            : {
    1110                 :      74444 :   gimple *p = gimple_alloc (GIMPLE_OMP_RETURN, 0);
    1111                 :      74444 :   if (wait_p)
    1112                 :      28510 :     gimple_omp_return_set_nowait (p);
    1113                 :            : 
    1114                 :      74444 :   return p;
    1115                 :            : }
    1116                 :            : 
    1117                 :            : 
    1118                 :            : /* Build a GIMPLE_OMP_SCAN statement.
    1119                 :            : 
    1120                 :            :    BODY is the sequence of statements to be executed by the scan
    1121                 :            :    construct.
    1122                 :            :    CLAUSES are any of the construct's clauses.  */
    1123                 :            : 
    1124                 :            : gomp_scan *
    1125                 :       1112 : gimple_build_omp_scan (gimple_seq body, tree clauses)
    1126                 :            : {
    1127                 :       1112 :   gomp_scan *p
    1128                 :       1112 :     = as_a <gomp_scan *> (gimple_alloc (GIMPLE_OMP_SCAN, 0));
    1129                 :       1112 :   gimple_omp_scan_set_clauses (p, clauses);
    1130                 :       1112 :   if (body)
    1131                 :        958 :     gimple_omp_set_body (p, body);
    1132                 :            : 
    1133                 :       1112 :   return p;
    1134                 :            : }
    1135                 :            : 
    1136                 :            : 
    1137                 :            : /* Build a GIMPLE_OMP_SECTIONS statement.
    1138                 :            : 
    1139                 :            :    BODY is a sequence of section statements.
    1140                 :            :    CLAUSES are any of the OMP sections contsruct's clauses: private,
    1141                 :            :    firstprivate, lastprivate, reduction, and nowait.  */
    1142                 :            : 
    1143                 :            : gomp_sections *
    1144                 :        570 : gimple_build_omp_sections (gimple_seq body, tree clauses)
    1145                 :            : {
    1146                 :        570 :   gomp_sections *p
    1147                 :        570 :     = as_a <gomp_sections *> (gimple_alloc (GIMPLE_OMP_SECTIONS, 0));
    1148                 :        570 :   if (body)
    1149                 :        570 :     gimple_omp_set_body (p, body);
    1150                 :        570 :   gimple_omp_sections_set_clauses (p, clauses);
    1151                 :            : 
    1152                 :        570 :   return p;
    1153                 :            : }
    1154                 :            : 
    1155                 :            : 
    1156                 :            : /* Build a GIMPLE_OMP_SECTIONS_SWITCH.  */
    1157                 :            : 
    1158                 :            : gimple *
    1159                 :        343 : gimple_build_omp_sections_switch (void)
    1160                 :            : {
    1161                 :        343 :   return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH, 0);
    1162                 :            : }
    1163                 :            : 
    1164                 :            : 
    1165                 :            : /* Build a GIMPLE_OMP_SINGLE statement.
    1166                 :            : 
    1167                 :            :    BODY is the sequence of statements that will be executed once.
    1168                 :            :    CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
    1169                 :            :    copyprivate, nowait.  */
    1170                 :            : 
    1171                 :            : gomp_single *
    1172                 :       1099 : gimple_build_omp_single (gimple_seq body, tree clauses)
    1173                 :            : {
    1174                 :       1099 :   gomp_single *p
    1175                 :       1099 :     = as_a <gomp_single *> (gimple_alloc (GIMPLE_OMP_SINGLE, 0));
    1176                 :       1099 :   if (body)
    1177                 :       1017 :     gimple_omp_set_body (p, body);
    1178                 :       1099 :   gimple_omp_single_set_clauses (p, clauses);
    1179                 :            : 
    1180                 :       1099 :   return p;
    1181                 :            : }
    1182                 :            : 
    1183                 :            : 
    1184                 :            : /* Build a GIMPLE_OMP_TARGET statement.
    1185                 :            : 
    1186                 :            :    BODY is the sequence of statements that will be executed.
    1187                 :            :    KIND is the kind of the region.
    1188                 :            :    CLAUSES are any of the construct's clauses.  */
    1189                 :            : 
    1190                 :            : gomp_target *
    1191                 :      27310 : gimple_build_omp_target (gimple_seq body, int kind, tree clauses)
    1192                 :            : {
    1193                 :      27310 :   gomp_target *p
    1194                 :      27310 :     = as_a <gomp_target *> (gimple_alloc (GIMPLE_OMP_TARGET, 0));
    1195                 :      27310 :   if (body)
    1196                 :      18907 :     gimple_omp_set_body (p, body);
    1197                 :      27310 :   gimple_omp_target_set_clauses (p, clauses);
    1198                 :      27310 :   gimple_omp_target_set_kind (p, kind);
    1199                 :            : 
    1200                 :      27310 :   return p;
    1201                 :            : }
    1202                 :            : 
    1203                 :            : 
    1204                 :            : /* Build a GIMPLE_OMP_TEAMS statement.
    1205                 :            : 
    1206                 :            :    BODY is the sequence of statements that will be executed.
    1207                 :            :    CLAUSES are any of the OMP teams construct's clauses.  */
    1208                 :            : 
    1209                 :            : gomp_teams *
    1210                 :       4831 : gimple_build_omp_teams (gimple_seq body, tree clauses)
    1211                 :            : {
    1212                 :       4831 :   gomp_teams *p = as_a <gomp_teams *> (gimple_alloc (GIMPLE_OMP_TEAMS, 0));
    1213                 :       4831 :   if (body)
    1214                 :       4831 :     gimple_omp_set_body (p, body);
    1215                 :       4831 :   gimple_omp_teams_set_clauses (p, clauses);
    1216                 :            : 
    1217                 :       4831 :   return p;
    1218                 :            : }
    1219                 :            : 
    1220                 :            : 
    1221                 :            : /* Build a GIMPLE_OMP_ATOMIC_LOAD statement.  */
    1222                 :            : 
    1223                 :            : gomp_atomic_load *
    1224                 :       6727 : gimple_build_omp_atomic_load (tree lhs, tree rhs, enum omp_memory_order mo)
    1225                 :            : {
    1226                 :       6727 :   gomp_atomic_load *p
    1227                 :       6727 :     = as_a <gomp_atomic_load *> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD, 0));
    1228                 :       6727 :   gimple_omp_atomic_load_set_lhs (p, lhs);
    1229                 :       6727 :   gimple_omp_atomic_load_set_rhs (p, rhs);
    1230                 :       6727 :   gimple_omp_atomic_set_memory_order (p, mo);
    1231                 :       6727 :   return p;
    1232                 :            : }
    1233                 :            : 
    1234                 :            : /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
    1235                 :            : 
    1236                 :            :    VAL is the value we are storing.  */
    1237                 :            : 
    1238                 :            : gomp_atomic_store *
    1239                 :       6727 : gimple_build_omp_atomic_store (tree val, enum omp_memory_order mo)
    1240                 :            : {
    1241                 :       6727 :   gomp_atomic_store *p
    1242                 :       6727 :     = as_a <gomp_atomic_store *> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE, 0));
    1243                 :       6727 :   gimple_omp_atomic_store_set_val (p, val);
    1244                 :       6727 :   gimple_omp_atomic_set_memory_order (p, mo);
    1245                 :       6727 :   return p;
    1246                 :            : }
    1247                 :            : 
    1248                 :            : /* Build a GIMPLE_TRANSACTION statement.  */
    1249                 :            : 
    1250                 :            : gtransaction *
    1251                 :        587 : gimple_build_transaction (gimple_seq body)
    1252                 :            : {
    1253                 :        587 :   gtransaction *p
    1254                 :        587 :     = as_a <gtransaction *> (gimple_alloc (GIMPLE_TRANSACTION, 0));
    1255                 :        587 :   gimple_transaction_set_body (p, body);
    1256                 :        587 :   gimple_transaction_set_label_norm (p, 0);
    1257                 :        587 :   gimple_transaction_set_label_uninst (p, 0);
    1258                 :        587 :   gimple_transaction_set_label_over (p, 0);
    1259                 :        587 :   return p;
    1260                 :            : }
    1261                 :            : 
    1262                 :            : #if defined ENABLE_GIMPLE_CHECKING
    1263                 :            : /* Complain of a gimple type mismatch and die.  */
    1264                 :            : 
    1265                 :            : void
    1266                 :          0 : gimple_check_failed (const gimple *gs, const char *file, int line,
    1267                 :            :                      const char *function, enum gimple_code code,
    1268                 :            :                      enum tree_code subcode)
    1269                 :            : {
    1270                 :          0 :   internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
    1271                 :          0 :                   gimple_code_name[code],
    1272                 :            :                   get_tree_code_name (subcode),
    1273                 :          0 :                   gimple_code_name[gimple_code (gs)],
    1274                 :          0 :                   gs->subcode > 0
    1275                 :          0 :                     ? get_tree_code_name ((enum tree_code) gs->subcode)
    1276                 :            :                     : "",
    1277                 :            :                   function, trim_filename (file), line);
    1278                 :            : }
    1279                 :            : #endif /* ENABLE_GIMPLE_CHECKING */
    1280                 :            : 
    1281                 :            : 
    1282                 :            : /* Link gimple statement GS to the end of the sequence *SEQ_P.  If
    1283                 :            :    *SEQ_P is NULL, a new sequence is allocated.  */
    1284                 :            : 
    1285                 :            : void
    1286                 :   73731900 : gimple_seq_add_stmt (gimple_seq *seq_p, gimple *gs)
    1287                 :            : {
    1288                 :   73731900 :   gimple_stmt_iterator si;
    1289                 :   73731900 :   if (gs == NULL)
    1290                 :          0 :     return;
    1291                 :            : 
    1292                 :   73731900 :   si = gsi_last (*seq_p);
    1293                 :   73731900 :   gsi_insert_after (&si, gs, GSI_NEW_STMT);
    1294                 :            : }
    1295                 :            : 
    1296                 :            : /* Link gimple statement GS to the end of the sequence *SEQ_P.  If
    1297                 :            :    *SEQ_P is NULL, a new sequence is allocated.  This function is
    1298                 :            :    similar to gimple_seq_add_stmt, but does not scan the operands.
    1299                 :            :    During gimplification, we need to manipulate statement sequences
    1300                 :            :    before the def/use vectors have been constructed.  */
    1301                 :            : 
    1302                 :            : void
    1303                 :   62700100 : gimple_seq_add_stmt_without_update (gimple_seq *seq_p, gimple *gs)
    1304                 :            : {
    1305                 :   62700100 :   gimple_stmt_iterator si;
    1306                 :            : 
    1307                 :   62700100 :   if (gs == NULL)
    1308                 :          0 :     return;
    1309                 :            : 
    1310                 :   62700100 :   si = gsi_last (*seq_p);
    1311                 :   62700100 :   gsi_insert_after_without_update (&si, gs, GSI_NEW_STMT);
    1312                 :            : }
    1313                 :            : 
    1314                 :            : /* Append sequence SRC to the end of sequence *DST_P.  If *DST_P is
    1315                 :            :    NULL, a new sequence is allocated.  */
    1316                 :            : 
    1317                 :            : void
    1318                 :    9743430 : gimple_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
    1319                 :            : {
    1320                 :    9743430 :   gimple_stmt_iterator si;
    1321                 :    9743430 :   if (src == NULL)
    1322                 :    2449270 :     return;
    1323                 :            : 
    1324                 :    7294160 :   si = gsi_last (*dst_p);
    1325                 :    7294160 :   gsi_insert_seq_after (&si, src, GSI_NEW_STMT);
    1326                 :            : }
    1327                 :            : 
    1328                 :            : /* Append sequence SRC to the end of sequence *DST_P.  If *DST_P is
    1329                 :            :    NULL, a new sequence is allocated.  This function is
    1330                 :            :    similar to gimple_seq_add_seq, but does not scan the operands.  */
    1331                 :            : 
    1332                 :            : void
    1333                 :      86874 : gimple_seq_add_seq_without_update (gimple_seq *dst_p, gimple_seq src)
    1334                 :            : {
    1335                 :      86874 :   gimple_stmt_iterator si;
    1336                 :      86874 :   if (src == NULL)
    1337                 :      79582 :     return;
    1338                 :            : 
    1339                 :       7292 :   si = gsi_last (*dst_p);
    1340                 :       7292 :   gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
    1341                 :            : }
    1342                 :            : 
    1343                 :            : /* Determine whether to assign a location to the statement GS.  */
    1344                 :            : 
    1345                 :            : static bool
    1346                 :  228042000 : should_carry_location_p (gimple *gs)
    1347                 :            : {
    1348                 :            :   /* Don't emit a line note for a label.  We particularly don't want to
    1349                 :            :      emit one for the break label, since it doesn't actually correspond
    1350                 :            :      to the beginning of the loop/switch.  */
    1351                 :  228042000 :   if (gimple_code (gs) == GIMPLE_LABEL)
    1352                 :          0 :     return false;
    1353                 :            : 
    1354                 :            :   return true;
    1355                 :            : }
    1356                 :            : 
    1357                 :            : /* Set the location for gimple statement GS to LOCATION.  */
    1358                 :            : 
    1359                 :            : static void
    1360                 :  500342000 : annotate_one_with_location (gimple *gs, location_t location)
    1361                 :            : {
    1362                 :  500342000 :   if (!gimple_has_location (gs)
    1363                 :  292330000 :       && !gimple_do_not_emit_location_p (gs)
    1364                 :  500342000 :       && should_carry_location_p (gs))
    1365                 :   20893700 :     gimple_set_location (gs, location);
    1366                 :  500342000 : }
    1367                 :            : 
    1368                 :            : /* Set LOCATION for all the statements after iterator GSI in sequence
    1369                 :            :    SEQ.  If GSI is pointing to the end of the sequence, start with the
    1370                 :            :    first statement in SEQ.  */
    1371                 :            : 
    1372                 :            : void
    1373                 :   65226500 : annotate_all_with_location_after (gimple_seq seq, gimple_stmt_iterator gsi,
    1374                 :            :                                   location_t location)
    1375                 :            : {
    1376                 :   65226500 :   if (gsi_end_p (gsi))
    1377                 :   22275600 :     gsi = gsi_start (seq);
    1378                 :            :   else
    1379                 :   42950900 :     gsi_next (&gsi);
    1380                 :            : 
    1381                 :  565517000 :   for (; !gsi_end_p (gsi); gsi_next (&gsi))
    1382                 :  500291000 :     annotate_one_with_location (gsi_stmt (gsi), location);
    1383                 :   65226500 : }
    1384                 :            : 
    1385                 :            : /* Set the location for all the statements in a sequence STMT_P to LOCATION.  */
    1386                 :            : 
    1387                 :            : void
    1388                 :      35972 : annotate_all_with_location (gimple_seq stmt_p, location_t location)
    1389                 :            : {
    1390                 :      35972 :   gimple_stmt_iterator i;
    1391                 :            : 
    1392                 :      35972 :   if (gimple_seq_empty_p (stmt_p))
    1393                 :          0 :     return;
    1394                 :            : 
    1395                 :      87585 :   for (i = gsi_start (stmt_p); !gsi_end_p (i); gsi_next (&i))
    1396                 :            :     {
    1397                 :      51613 :       gimple *gs = gsi_stmt (i);
    1398                 :      51613 :       annotate_one_with_location (gs, location);
    1399                 :            :     }
    1400                 :            : }
    1401                 :            : 
    1402                 :            : /* Helper function of empty_body_p.  Return true if STMT is an empty
    1403                 :            :    statement.  */
    1404                 :            : 
    1405                 :            : static bool
    1406                 :      28152 : empty_stmt_p (gimple *stmt)
    1407                 :            : {
    1408                 :      28152 :   if (gimple_code (stmt) == GIMPLE_NOP)
    1409                 :            :     return true;
    1410                 :      28152 :   if (gbind *bind_stmt = dyn_cast <gbind *> (stmt))
    1411                 :      16408 :     return empty_body_p (gimple_bind_body (bind_stmt));
    1412                 :            :   return false;
    1413                 :            : }
    1414                 :            : 
    1415                 :            : 
    1416                 :            : /* Return true if BODY contains nothing but empty statements.  */
    1417                 :            : 
    1418                 :            : bool
    1419                 :      28181 : empty_body_p (gimple_seq body)
    1420                 :            : {
    1421                 :      28181 :   gimple_stmt_iterator i;
    1422                 :            : 
    1423                 :      28181 :   if (gimple_seq_empty_p (body))
    1424                 :            :     return true;
    1425                 :      28210 :   for (i = gsi_start (body); !gsi_end_p (i); gsi_next (&i))
    1426                 :      28213 :     if (!empty_stmt_p (gsi_stmt (i))
    1427                 :      28152 :         && !is_gimple_debug (gsi_stmt (i)))
    1428                 :            :       return false;
    1429                 :            : 
    1430                 :            :   return true;
    1431                 :            : }
    1432                 :            : 
    1433                 :            : 
    1434                 :            : /* Perform a deep copy of sequence SRC and return the result.  */
    1435                 :            : 
    1436                 :            : gimple_seq
    1437                 :    1137170 : gimple_seq_copy (gimple_seq src)
    1438                 :            : {
    1439                 :    1137170 :   gimple_stmt_iterator gsi;
    1440                 :    1137170 :   gimple_seq new_seq = NULL;
    1441                 :    1137170 :   gimple *stmt;
    1442                 :            : 
    1443                 :    2503130 :   for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi))
    1444                 :            :     {
    1445                 :    1365960 :       stmt = gimple_copy (gsi_stmt (gsi));
    1446                 :    1365960 :       gimple_seq_add_stmt (&new_seq, stmt);
    1447                 :            :     }
    1448                 :            : 
    1449                 :    1137170 :   return new_seq;
    1450                 :            : }
    1451                 :            : 
    1452                 :            : 
    1453                 :            : 
    1454                 :            : /* Return true if calls C1 and C2 are known to go to the same function.  */
    1455                 :            : 
    1456                 :            : bool
    1457                 :     433440 : gimple_call_same_target_p (const gimple *c1, const gimple *c2)
    1458                 :            : {
    1459                 :     433440 :   if (gimple_call_internal_p (c1))
    1460                 :       1712 :     return (gimple_call_internal_p (c2)
    1461                 :       1712 :             && gimple_call_internal_fn (c1) == gimple_call_internal_fn (c2)
    1462                 :       3424 :             && (!gimple_call_internal_unique_p (as_a <const gcall *> (c1))
    1463                 :          0 :                 || c1 == c2));
    1464                 :            :   else
    1465                 :     431728 :     return (gimple_call_fn (c1) == gimple_call_fn (c2)
    1466                 :     431728 :             || (gimple_call_fndecl (c1)
    1467                 :     430838 :                 && gimple_call_fndecl (c1) == gimple_call_fndecl (c2)));
    1468                 :            : }
    1469                 :            : 
    1470                 :            : /* Detect flags from a GIMPLE_CALL.  This is just like
    1471                 :            :    call_expr_flags, but for gimple tuples.  */
    1472                 :            : 
    1473                 :            : int
    1474                 : 1781630000 : gimple_call_flags (const gimple *stmt)
    1475                 :            : {
    1476                 : 1781630000 :   int flags = 0;
    1477                 :            : 
    1478                 : 1781630000 :   if (gimple_call_internal_p (stmt))
    1479                 :   36993300 :     flags = internal_fn_flags (gimple_call_internal_fn (stmt));
    1480                 :            :   else
    1481                 :            :     {
    1482                 : 1744630000 :       tree decl = gimple_call_fndecl (stmt);
    1483                 : 1744630000 :       if (decl)
    1484                 : 1677600000 :         flags = flags_from_decl_or_type (decl);
    1485                 : 1744630000 :       flags |= flags_from_decl_or_type (gimple_call_fntype (stmt));
    1486                 :            :     }
    1487                 :            : 
    1488                 : 1781630000 :   if (stmt->subcode & GF_CALL_NOTHROW)
    1489                 :  252622000 :     flags |= ECF_NOTHROW;
    1490                 :            : 
    1491                 : 1781630000 :   if (stmt->subcode & GF_CALL_BY_DESCRIPTOR)
    1492                 :          0 :     flags |= ECF_BY_DESCRIPTOR;
    1493                 :            : 
    1494                 : 1781630000 :   return flags;
    1495                 :            : }
    1496                 :            : 
    1497                 :            : /* Return the "fn spec" string for call STMT.  */
    1498                 :            : 
    1499                 :            : static const_tree
    1500                 :   50253000 : gimple_call_fnspec (const gcall *stmt)
    1501                 :            : {
    1502                 :   50253000 :   tree type, attr;
    1503                 :            : 
    1504                 :   50253000 :   if (gimple_call_internal_p (stmt))
    1505                 :     763971 :     return internal_fn_fnspec (gimple_call_internal_fn (stmt));
    1506                 :            : 
    1507                 :   49489100 :   type = gimple_call_fntype (stmt);
    1508                 :   49489100 :   if (!type)
    1509                 :            :     return NULL_TREE;
    1510                 :            : 
    1511                 :   49489100 :   attr = lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type));
    1512                 :   49489100 :   if (!attr)
    1513                 :            :     return NULL_TREE;
    1514                 :            : 
    1515                 :    3950750 :   return TREE_VALUE (TREE_VALUE (attr));
    1516                 :            : }
    1517                 :            : 
    1518                 :            : /* Detects argument flags for argument number ARG on call STMT.  */
    1519                 :            : 
    1520                 :            : int
    1521                 :   26238100 : gimple_call_arg_flags (const gcall *stmt, unsigned arg)
    1522                 :            : {
    1523                 :   26238100 :   const_tree attr = gimple_call_fnspec (stmt);
    1524                 :            : 
    1525                 :   26238100 :   if (!attr || 1 + arg >= (unsigned) TREE_STRING_LENGTH (attr))
    1526                 :            :     return 0;
    1527                 :            : 
    1528                 :    2253910 :   switch (TREE_STRING_POINTER (attr)[1 + arg])
    1529                 :            :     {
    1530                 :            :     case 'x':
    1531                 :            :     case 'X':
    1532                 :            :       return EAF_UNUSED;
    1533                 :            : 
    1534                 :            :     case 'R':
    1535                 :            :       return EAF_DIRECT | EAF_NOCLOBBER | EAF_NOESCAPE;
    1536                 :            : 
    1537                 :            :     case 'r':
    1538                 :            :       return EAF_NOCLOBBER | EAF_NOESCAPE;
    1539                 :            : 
    1540                 :            :     case 'W':
    1541                 :            :       return EAF_DIRECT | EAF_NOESCAPE;
    1542                 :            : 
    1543                 :            :     case 'w':
    1544                 :            :       return EAF_NOESCAPE;
    1545                 :            : 
    1546                 :            :     case '.':
    1547                 :            :     default:
    1548                 :            :       return 0;
    1549                 :            :     }
    1550                 :            : }
    1551                 :            : 
    1552                 :            : /* Detects return flags for the call STMT.  */
    1553                 :            : 
    1554                 :            : int
    1555                 :   24743600 : gimple_call_return_flags (const gcall *stmt)
    1556                 :            : {
    1557                 :   24743600 :   const_tree attr;
    1558                 :            : 
    1559                 :   24743600 :   if (gimple_call_flags (stmt) & ECF_MALLOC)
    1560                 :            :     return ERF_NOALIAS;
    1561                 :            : 
    1562                 :   24015000 :   attr = gimple_call_fnspec (stmt);
    1563                 :   25111700 :   if (!attr || TREE_STRING_LENGTH (attr) < 1)
    1564                 :            :     return 0;
    1565                 :            : 
    1566                 :    1096760 :   switch (TREE_STRING_POINTER (attr)[0])
    1567                 :            :     {
    1568                 :     222361 :     case '1':
    1569                 :     222361 :     case '2':
    1570                 :     222361 :     case '3':
    1571                 :     222361 :     case '4':
    1572                 :     222361 :       return ERF_RETURNS_ARG | (TREE_STRING_POINTER (attr)[0] - '1');
    1573                 :            : 
    1574                 :            :     case 'm':
    1575                 :            :       return ERF_NOALIAS;
    1576                 :            : 
    1577                 :     874394 :     case '.':
    1578                 :     874394 :     default:
    1579                 :     874394 :       return 0;
    1580                 :            :     }
    1581                 :            : }
    1582                 :            : 
    1583                 :            : 
    1584                 :            : /* Return true if call STMT is known to return a non-zero result.  */
    1585                 :            : 
    1586                 :            : bool
    1587                 :    7016370 : gimple_call_nonnull_result_p (gcall *call)
    1588                 :            : {
    1589                 :    7016370 :   tree fndecl = gimple_call_fndecl (call);
    1590                 :    7016370 :   if (!fndecl)
    1591                 :            :     return false;
    1592                 :    6552510 :   if (flag_delete_null_pointer_checks && !flag_check_new
    1593                 :    6552460 :       && DECL_IS_OPERATOR_NEW_P (fndecl)
    1594                 :    6690610 :       && !TREE_NOTHROW (fndecl))
    1595                 :            :     return true;
    1596                 :            : 
    1597                 :            :   /* References are always non-NULL.  */
    1598                 :    6430850 :   if (flag_delete_null_pointer_checks
    1599                 :   12853800 :       && TREE_CODE (TREE_TYPE (fndecl)) == REFERENCE_TYPE)
    1600                 :            :     return true;
    1601                 :            : 
    1602                 :    6430850 :   if (flag_delete_null_pointer_checks
    1603                 :   12853800 :       && lookup_attribute ("returns_nonnull",
    1604                 :    6422900 :                            TYPE_ATTRIBUTES (gimple_call_fntype (call))))
    1605                 :            :     return true;
    1606                 :    6379220 :   return gimple_alloca_call_p (call);
    1607                 :            : }
    1608                 :            : 
    1609                 :            : 
    1610                 :            : /* If CALL returns a non-null result in an argument, return that arg.  */
    1611                 :            : 
    1612                 :            : tree
    1613                 :    6820150 : gimple_call_nonnull_arg (gcall *call)
    1614                 :            : {
    1615                 :    6820150 :   tree fndecl = gimple_call_fndecl (call);
    1616                 :    6820150 :   if (!fndecl)
    1617                 :            :     return NULL_TREE;
    1618                 :            : 
    1619                 :    6364250 :   unsigned rf = gimple_call_return_flags (call);
    1620                 :    6364250 :   if (rf & ERF_RETURNS_ARG)
    1621                 :            :     {
    1622                 :      32367 :       unsigned argnum = rf & ERF_RETURN_ARG_MASK;
    1623                 :      32367 :       if (argnum < gimple_call_num_args (call))
    1624                 :            :         {
    1625                 :      32297 :           tree arg = gimple_call_arg (call, argnum);
    1626                 :      32297 :           if (SSA_VAR_P (arg)
    1627                 :      56659 :               && infer_nonnull_range_by_attribute (call, arg))
    1628                 :      24362 :             return arg;
    1629                 :            :         }
    1630                 :            :     }
    1631                 :            :   return NULL_TREE;
    1632                 :            : }
    1633                 :            : 
    1634                 :            : 
    1635                 :            : /* Return true if GS is a copy assignment.  */
    1636                 :            : 
    1637                 :            : bool
    1638                 :  163735000 : gimple_assign_copy_p (gimple *gs)
    1639                 :            : {
    1640                 :  163735000 :   return (gimple_assign_single_p (gs)
    1641                 :   63413500 :           && is_gimple_val (gimple_op (gs, 1)));
    1642                 :            : }
    1643                 :            : 
    1644                 :            : 
    1645                 :            : /* Return true if GS is a SSA_NAME copy assignment.  */
    1646                 :            : 
    1647                 :            : bool
    1648                 :   26249300 : gimple_assign_ssa_name_copy_p (gimple *gs)
    1649                 :            : {
    1650                 :   41019500 :   return (gimple_assign_single_p (gs)
    1651                 :   14770200 :           && TREE_CODE (gimple_assign_lhs (gs)) == SSA_NAME
    1652                 :    7905890 :           && TREE_CODE (gimple_assign_rhs1 (gs)) == SSA_NAME);
    1653                 :            : }
    1654                 :            : 
    1655                 :            : 
    1656                 :            : /* Return true if GS is an assignment with a unary RHS, but the
    1657                 :            :    operator has no effect on the assigned value.  The logic is adapted
    1658                 :            :    from STRIP_NOPS.  This predicate is intended to be used in tuplifying
    1659                 :            :    instances in which STRIP_NOPS was previously applied to the RHS of
    1660                 :            :    an assignment.
    1661                 :            : 
    1662                 :            :    NOTE: In the use cases that led to the creation of this function
    1663                 :            :    and of gimple_assign_single_p, it is typical to test for either
    1664                 :            :    condition and to proceed in the same manner.  In each case, the
    1665                 :            :    assigned value is represented by the single RHS operand of the
    1666                 :            :    assignment.  I suspect there may be cases where gimple_assign_copy_p,
    1667                 :            :    gimple_assign_single_p, or equivalent logic is used where a similar
    1668                 :            :    treatment of unary NOPs is appropriate.  */
    1669                 :            : 
    1670                 :            : bool
    1671                 :      26019 : gimple_assign_unary_nop_p (gimple *gs)
    1672                 :            : {
    1673                 :      26019 :   return (is_gimple_assign (gs)
    1674                 :      26019 :           && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs))
    1675                 :      23694 :               || gimple_assign_rhs_code (gs) == NON_LVALUE_EXPR)
    1676                 :       2325 :           && gimple_assign_rhs1 (gs) != error_mark_node
    1677                 :      30669 :           && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs)))
    1678                 :       2325 :               == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs)))));
    1679                 :            : }
    1680                 :            : 
    1681                 :            : /* Set BB to be the basic block holding G.  */
    1682                 :            : 
    1683                 :            : void
    1684                 :  398775000 : gimple_set_bb (gimple *stmt, basic_block bb)
    1685                 :            : {
    1686                 :  398775000 :   stmt->bb = bb;
    1687                 :            : 
    1688                 :  398775000 :   if (gimple_code (stmt) != GIMPLE_LABEL)
    1689                 :            :     return;
    1690                 :            : 
    1691                 :            :   /* If the statement is a label, add the label to block-to-labels map
    1692                 :            :      so that we can speed up edge creation for GIMPLE_GOTOs.  */
    1693                 :   25271600 :   if (cfun->cfg)
    1694                 :            :     {
    1695                 :   25271600 :       tree t;
    1696                 :   25271600 :       int uid;
    1697                 :            : 
    1698                 :   25271600 :       t = gimple_label_label (as_a <glabel *> (stmt));
    1699                 :   25271600 :       uid = LABEL_DECL_UID (t);
    1700                 :   25271600 :       if (uid == -1)
    1701                 :            :         {
    1702                 :   12878100 :           unsigned old_len =
    1703                 :   12878100 :             vec_safe_length (label_to_block_map_for_fn (cfun));
    1704                 :   12878100 :           LABEL_DECL_UID (t) = uid = cfun->cfg->last_label_uid++;
    1705                 :   12878100 :           if (old_len <= (unsigned) uid)
    1706                 :            :             {
    1707                 :     275509 :               unsigned new_len = 3 * uid / 2 + 1;
    1708                 :            : 
    1709                 :     275509 :               vec_safe_grow_cleared (label_to_block_map_for_fn (cfun),
    1710                 :            :                                      new_len);
    1711                 :            :             }
    1712                 :            :         }
    1713                 :            : 
    1714                 :   25271600 :       (*label_to_block_map_for_fn (cfun))[uid] = bb;
    1715                 :            :     }
    1716                 :            : }
    1717                 :            : 
    1718                 :            : 
    1719                 :            : /* Modify the RHS of the assignment pointed-to by GSI using the
    1720                 :            :    operands in the expression tree EXPR.
    1721                 :            : 
    1722                 :            :    NOTE: The statement pointed-to by GSI may be reallocated if it
    1723                 :            :    did not have enough operand slots.
    1724                 :            : 
    1725                 :            :    This function is useful to convert an existing tree expression into
    1726                 :            :    the flat representation used for the RHS of a GIMPLE assignment.
    1727                 :            :    It will reallocate memory as needed to expand or shrink the number
    1728                 :            :    of operand slots needed to represent EXPR.
    1729                 :            : 
    1730                 :            :    NOTE: If you find yourself building a tree and then calling this
    1731                 :            :    function, you are most certainly doing it the slow way.  It is much
    1732                 :            :    better to build a new assignment or to use the function
    1733                 :            :    gimple_assign_set_rhs_with_ops, which does not require an
    1734                 :            :    expression tree to be built.  */
    1735                 :            : 
    1736                 :            : void
    1737                 :    2544040 : gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *gsi, tree expr)
    1738                 :            : {
    1739                 :    2544040 :   enum tree_code subcode;
    1740                 :    2544040 :   tree op1, op2, op3;
    1741                 :            : 
    1742                 :    2544040 :   extract_ops_from_tree (expr, &subcode, &op1, &op2, &op3);
    1743                 :    2544040 :   gimple_assign_set_rhs_with_ops (gsi, subcode, op1, op2, op3);
    1744                 :    2544040 : }
    1745                 :            : 
    1746                 :            : 
    1747                 :            : /* Set the RHS of assignment statement pointed-to by GSI to CODE with
    1748                 :            :    operands OP1, OP2 and OP3.
    1749                 :            : 
    1750                 :            :    NOTE: The statement pointed-to by GSI may be reallocated if it
    1751                 :            :    did not have enough operand slots.  */
    1752                 :            : 
    1753                 :            : void
    1754                 :    3820490 : gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
    1755                 :            :                                 tree op1, tree op2, tree op3)
    1756                 :            : {
    1757                 :    3820490 :   unsigned new_rhs_ops = get_gimple_rhs_num_ops (code);
    1758                 :    3820490 :   gimple *stmt = gsi_stmt (*gsi);
    1759                 :    3820490 :   gimple *old_stmt = stmt;
    1760                 :            : 
    1761                 :            :   /* If the new CODE needs more operands, allocate a new statement.  */
    1762                 :    3820490 :   if (gimple_num_ops (stmt) < new_rhs_ops + 1)
    1763                 :            :     {
    1764                 :      67498 :       tree lhs = gimple_assign_lhs (old_stmt);
    1765                 :      67498 :       stmt = gimple_alloc (gimple_code (old_stmt), new_rhs_ops + 1);
    1766                 :      67498 :       memcpy (stmt, old_stmt, gimple_size (gimple_code (old_stmt)));
    1767                 :      67498 :       gimple_init_singleton (stmt);
    1768                 :            : 
    1769                 :            :       /* The LHS needs to be reset as this also changes the SSA name
    1770                 :            :          on the LHS.  */
    1771                 :      67498 :       gimple_assign_set_lhs (stmt, lhs);
    1772                 :            :     }
    1773                 :            : 
    1774                 :    3820490 :   gimple_set_num_ops (stmt, new_rhs_ops + 1);
    1775                 :    3820490 :   gimple_set_subcode (stmt, code);
    1776                 :    3820490 :   gimple_assign_set_rhs1 (stmt, op1);
    1777                 :    3820490 :   if (new_rhs_ops > 1)
    1778                 :     483382 :     gimple_assign_set_rhs2 (stmt, op2);
    1779                 :    3820490 :   if (new_rhs_ops > 2)
    1780                 :      26416 :     gimple_assign_set_rhs3 (stmt, op3);
    1781                 :    3820490 :   if (stmt != old_stmt)
    1782                 :      67498 :     gsi_replace (gsi, stmt, false);
    1783                 :    3820490 : }
    1784                 :            : 
    1785                 :            : 
    1786                 :            : /* Return the LHS of a statement that performs an assignment,
    1787                 :            :    either a GIMPLE_ASSIGN or a GIMPLE_CALL.  Returns NULL_TREE
    1788                 :            :    for a call to a function that returns no value, or for a
    1789                 :            :    statement other than an assignment or a call.  */
    1790                 :            : 
    1791                 :            : tree
    1792                 : 3250610000 : gimple_get_lhs (const gimple *stmt)
    1793                 :            : {
    1794                 : 3250610000 :   enum gimple_code code = gimple_code (stmt);
    1795                 :            : 
    1796                 : 3250610000 :   if (code == GIMPLE_ASSIGN)
    1797                 : 2330350000 :     return gimple_assign_lhs (stmt);
    1798                 :  920264000 :   else if (code == GIMPLE_CALL)
    1799                 :  235741000 :     return gimple_call_lhs (stmt);
    1800                 :  684523000 :   else if (code == GIMPLE_PHI)
    1801                 :    2035950 :     return gimple_phi_result (stmt);
    1802                 :            :   else
    1803                 :            :     return NULL_TREE;
    1804                 :            : }
    1805                 :            : 
    1806                 :            : 
    1807                 :            : /* Set the LHS of a statement that performs an assignment,
    1808                 :            :    either a GIMPLE_ASSIGN or a GIMPLE_CALL.  */
    1809                 :            : 
    1810                 :            : void
    1811                 :    1664490 : gimple_set_lhs (gimple *stmt, tree lhs)
    1812                 :            : {
    1813                 :    1664490 :   enum gimple_code code = gimple_code (stmt);
    1814                 :            : 
    1815                 :    1664490 :   if (code == GIMPLE_ASSIGN)
    1816                 :     821203 :     gimple_assign_set_lhs (stmt, lhs);
    1817                 :     843289 :   else if (code == GIMPLE_CALL)
    1818                 :     843289 :     gimple_call_set_lhs (stmt, lhs);
    1819                 :            :   else
    1820                 :          0 :     gcc_unreachable ();
    1821                 :    1664490 : }
    1822                 :            : 
    1823                 :            : 
    1824                 :            : /* Return a deep copy of statement STMT.  All the operands from STMT
    1825                 :            :    are reallocated and copied using unshare_expr.  The DEF, USE, VDEF
    1826                 :            :    and VUSE operand arrays are set to empty in the new copy.  The new
    1827                 :            :    copy isn't part of any sequence.  */
    1828                 :            : 
    1829                 :            : gimple *
    1830                 :   31557600 : gimple_copy (gimple *stmt)
    1831                 :            : {
    1832                 :   31557600 :   enum gimple_code code = gimple_code (stmt);
    1833                 :   31557600 :   unsigned num_ops = gimple_num_ops (stmt);
    1834                 :   31557600 :   gimple *copy = gimple_alloc (code, num_ops);
    1835                 :   31557600 :   unsigned i;
    1836                 :            : 
    1837                 :            :   /* Shallow copy all the fields from STMT.  */
    1838                 :   31557600 :   memcpy (copy, stmt, gimple_size (code));
    1839                 :   31557600 :   gimple_init_singleton (copy);
    1840                 :            : 
    1841                 :            :   /* If STMT has sub-statements, deep-copy them as well.  */
    1842                 :   31557600 :   if (gimple_has_substatements (stmt))
    1843                 :            :     {
    1844                 :      46936 :       gimple_seq new_seq;
    1845                 :      46936 :       tree t;
    1846                 :            : 
    1847                 :      46936 :       switch (gimple_code (stmt))
    1848                 :            :         {
    1849                 :        344 :         case GIMPLE_BIND:
    1850                 :        344 :           {
    1851                 :        344 :             gbind *bind_stmt = as_a <gbind *> (stmt);
    1852                 :        344 :             gbind *bind_copy = as_a <gbind *> (copy);
    1853                 :        344 :             new_seq = gimple_seq_copy (gimple_bind_body (bind_stmt));
    1854                 :        344 :             gimple_bind_set_body (bind_copy, new_seq);
    1855                 :        344 :             gimple_bind_set_vars (bind_copy,
    1856                 :            :                                   unshare_expr (gimple_bind_vars (bind_stmt)));
    1857                 :        344 :             gimple_bind_set_block (bind_copy, gimple_bind_block (bind_stmt));
    1858                 :            :           }
    1859                 :            :           break;
    1860                 :            : 
    1861                 :      15218 :         case GIMPLE_CATCH:
    1862                 :      15218 :           {
    1863                 :      15218 :             gcatch *catch_stmt = as_a <gcatch *> (stmt);
    1864                 :      15218 :             gcatch *catch_copy = as_a <gcatch *> (copy);
    1865                 :      15218 :             new_seq = gimple_seq_copy (gimple_catch_handler (catch_stmt));
    1866                 :      15218 :             gimple_catch_set_handler (catch_copy, new_seq);
    1867                 :      15218 :             t = unshare_expr (gimple_catch_types (catch_stmt));
    1868                 :      15218 :             gimple_catch_set_types (catch_copy, t);
    1869                 :            :           }
    1870                 :            :           break;
    1871                 :            : 
    1872                 :          0 :         case GIMPLE_EH_FILTER:
    1873                 :          0 :           {
    1874                 :          0 :             geh_filter *eh_filter_stmt = as_a <geh_filter *> (stmt);
    1875                 :          0 :             geh_filter *eh_filter_copy = as_a <geh_filter *> (copy);
    1876                 :          0 :             new_seq
    1877                 :          0 :               = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt));
    1878                 :          0 :             gimple_eh_filter_set_failure (eh_filter_copy, new_seq);
    1879                 :          0 :             t = unshare_expr (gimple_eh_filter_types (eh_filter_stmt));
    1880                 :          0 :             gimple_eh_filter_set_types (eh_filter_copy, t);
    1881                 :            :           }
    1882                 :            :           break;
    1883                 :            : 
    1884                 :        330 :         case GIMPLE_EH_ELSE:
    1885                 :        330 :           {
    1886                 :        330 :             geh_else *eh_else_stmt = as_a <geh_else *> (stmt);
    1887                 :        330 :             geh_else *eh_else_copy = as_a <geh_else *> (copy);
    1888                 :        330 :             new_seq = gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt));
    1889                 :        330 :             gimple_eh_else_set_n_body (eh_else_copy, new_seq);
    1890                 :        330 :             new_seq = gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt));
    1891                 :        330 :             gimple_eh_else_set_e_body (eh_else_copy, new_seq);
    1892                 :            :           }
    1893                 :            :           break;
    1894                 :            : 
    1895                 :      30806 :         case GIMPLE_TRY:
    1896                 :      30806 :           {
    1897                 :      30806 :             gtry *try_stmt = as_a <gtry *> (stmt);
    1898                 :      30806 :             gtry *try_copy = as_a <gtry *> (copy);
    1899                 :      30806 :             new_seq = gimple_seq_copy (gimple_try_eval (try_stmt));
    1900                 :      30806 :             gimple_try_set_eval (try_copy, new_seq);
    1901                 :      30806 :             new_seq = gimple_seq_copy (gimple_try_cleanup (try_stmt));
    1902                 :      30806 :             gimple_try_set_cleanup (try_copy, new_seq);
    1903                 :            :           }
    1904                 :            :           break;
    1905                 :            : 
    1906                 :        232 :         case GIMPLE_OMP_FOR:
    1907                 :        232 :           new_seq = gimple_seq_copy (gimple_omp_for_pre_body (stmt));
    1908                 :        232 :           gimple_omp_for_set_pre_body (copy, new_seq);
    1909                 :        232 :           t = unshare_expr (gimple_omp_for_clauses (stmt));
    1910                 :        232 :           gimple_omp_for_set_clauses (copy, t);
    1911                 :        232 :           {
    1912                 :        232 :             gomp_for *omp_for_copy = as_a <gomp_for *> (copy);
    1913                 :        232 :             omp_for_copy->iter = ggc_vec_alloc<gimple_omp_for_iter>
    1914                 :        232 :               ( gimple_omp_for_collapse (stmt));
    1915                 :            :           }
    1916                 :        464 :           for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
    1917                 :            :             {
    1918                 :        232 :               gimple_omp_for_set_cond (copy, i,
    1919                 :            :                                        gimple_omp_for_cond (stmt, i));
    1920                 :        232 :               gimple_omp_for_set_index (copy, i,
    1921                 :            :                                         gimple_omp_for_index (stmt, i));
    1922                 :        232 :               t = unshare_expr (gimple_omp_for_initial (stmt, i));
    1923                 :        232 :               gimple_omp_for_set_initial (copy, i, t);
    1924                 :        232 :               t = unshare_expr (gimple_omp_for_final (stmt, i));
    1925                 :        232 :               gimple_omp_for_set_final (copy, i, t);
    1926                 :        232 :               t = unshare_expr (gimple_omp_for_incr (stmt, i));
    1927                 :        232 :               gimple_omp_for_set_incr (copy, i, t);
    1928                 :            :             }
    1929                 :        232 :           goto copy_omp_body;
    1930                 :            : 
    1931                 :          0 :         case GIMPLE_OMP_PARALLEL:
    1932                 :          0 :           {
    1933                 :          0 :             gomp_parallel *omp_par_stmt = as_a <gomp_parallel *> (stmt);
    1934                 :          0 :             gomp_parallel *omp_par_copy = as_a <gomp_parallel *> (copy);
    1935                 :          0 :             t = unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt));
    1936                 :          0 :             gimple_omp_parallel_set_clauses (omp_par_copy, t);
    1937                 :          0 :             t = unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt));
    1938                 :          0 :             gimple_omp_parallel_set_child_fn (omp_par_copy, t);
    1939                 :          0 :             t = unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt));
    1940                 :          0 :             gimple_omp_parallel_set_data_arg (omp_par_copy, t);
    1941                 :            :           }
    1942                 :          0 :           goto copy_omp_body;
    1943                 :            : 
    1944                 :          0 :         case GIMPLE_OMP_TASK:
    1945                 :          0 :           t = unshare_expr (gimple_omp_task_clauses (stmt));
    1946                 :          0 :           gimple_omp_task_set_clauses (copy, t);
    1947                 :          0 :           t = unshare_expr (gimple_omp_task_child_fn (stmt));
    1948                 :          0 :           gimple_omp_task_set_child_fn (copy, t);
    1949                 :          0 :           t = unshare_expr (gimple_omp_task_data_arg (stmt));
    1950                 :          0 :           gimple_omp_task_set_data_arg (copy, t);
    1951                 :          0 :           t = unshare_expr (gimple_omp_task_copy_fn (stmt));
    1952                 :          0 :           gimple_omp_task_set_copy_fn (copy, t);
    1953                 :          0 :           t = unshare_expr (gimple_omp_task_arg_size (stmt));
    1954                 :          0 :           gimple_omp_task_set_arg_size (copy, t);
    1955                 :          0 :           t = unshare_expr (gimple_omp_task_arg_align (stmt));
    1956                 :          0 :           gimple_omp_task_set_arg_align (copy, t);
    1957                 :          0 :           goto copy_omp_body;
    1958                 :            : 
    1959                 :          0 :         case GIMPLE_OMP_CRITICAL:
    1960                 :          0 :           t = unshare_expr (gimple_omp_critical_name
    1961                 :          0 :                                 (as_a <gomp_critical *> (stmt)));
    1962                 :          0 :           gimple_omp_critical_set_name (as_a <gomp_critical *> (copy), t);
    1963                 :          0 :           t = unshare_expr (gimple_omp_critical_clauses
    1964                 :          0 :                                 (as_a <gomp_critical *> (stmt)));
    1965                 :          0 :           gimple_omp_critical_set_clauses (as_a <gomp_critical *> (copy), t);
    1966                 :          0 :           goto copy_omp_body;
    1967                 :            : 
    1968                 :          0 :         case GIMPLE_OMP_ORDERED:
    1969                 :          0 :           t = unshare_expr (gimple_omp_ordered_clauses
    1970                 :          0 :                                 (as_a <gomp_ordered *> (stmt)));
    1971                 :          0 :           gimple_omp_ordered_set_clauses (as_a <gomp_ordered *> (copy), t);
    1972                 :          0 :           goto copy_omp_body;
    1973                 :            : 
    1974                 :          0 :         case GIMPLE_OMP_SCAN:
    1975                 :          0 :           t = gimple_omp_scan_clauses (as_a <gomp_scan *> (stmt));
    1976                 :          0 :           t = unshare_expr (t);
    1977                 :          0 :           gimple_omp_scan_set_clauses (as_a <gomp_scan *> (copy), t);
    1978                 :          0 :           goto copy_omp_body;
    1979                 :            : 
    1980                 :          0 :         case GIMPLE_OMP_TASKGROUP:
    1981                 :          0 :           t = unshare_expr (gimple_omp_taskgroup_clauses (stmt));
    1982                 :          0 :           gimple_omp_taskgroup_set_clauses (copy, t);
    1983                 :          0 :           goto copy_omp_body;
    1984                 :            : 
    1985                 :          0 :         case GIMPLE_OMP_SECTIONS:
    1986                 :          0 :           t = unshare_expr (gimple_omp_sections_clauses (stmt));
    1987                 :          0 :           gimple_omp_sections_set_clauses (copy, t);
    1988                 :          0 :           t = unshare_expr (gimple_omp_sections_control (stmt));
    1989                 :          0 :           gimple_omp_sections_set_control (copy, t);
    1990                 :          0 :           goto copy_omp_body;
    1991                 :            : 
    1992                 :          0 :         case GIMPLE_OMP_SINGLE:
    1993                 :          0 :           {
    1994                 :          0 :             gomp_single *omp_single_copy = as_a <gomp_single *> (copy);
    1995                 :          0 :             t = unshare_expr (gimple_omp_single_clauses (stmt));
    1996                 :          0 :             gimple_omp_single_set_clauses (omp_single_copy, t);
    1997                 :            :           }
    1998                 :          0 :           goto copy_omp_body;
    1999                 :            : 
    2000                 :          0 :         case GIMPLE_OMP_TARGET:
    2001                 :          0 :           {
    2002                 :          0 :             gomp_target *omp_target_stmt = as_a <gomp_target *> (stmt);
    2003                 :          0 :             gomp_target *omp_target_copy = as_a <gomp_target *> (copy);
    2004                 :          0 :             t = unshare_expr (gimple_omp_target_clauses (omp_target_stmt));
    2005                 :          0 :             gimple_omp_target_set_clauses (omp_target_copy, t);
    2006                 :          0 :             t = unshare_expr (gimple_omp_target_data_arg (omp_target_stmt));
    2007                 :          0 :             gimple_omp_target_set_data_arg (omp_target_copy, t);
    2008                 :            :           }
    2009                 :          0 :           goto copy_omp_body;
    2010                 :            : 
    2011                 :          0 :         case GIMPLE_OMP_TEAMS:
    2012                 :          0 :           {
    2013                 :          0 :             gomp_teams *omp_teams_copy = as_a <gomp_teams *> (copy);
    2014                 :          0 :             t = unshare_expr (gimple_omp_teams_clauses (stmt));
    2015                 :          0 :             gimple_omp_teams_set_clauses (omp_teams_copy, t);
    2016                 :            :           }
    2017                 :            :           /* FALLTHRU  */
    2018                 :            : 
    2019                 :        232 :         case GIMPLE_OMP_SECTION:
    2020                 :        232 :         case GIMPLE_OMP_MASTER:
    2021                 :        232 :         case GIMPLE_OMP_GRID_BODY:
    2022                 :        232 :         copy_omp_body:
    2023                 :        232 :           new_seq = gimple_seq_copy (gimple_omp_body (stmt));
    2024                 :        232 :           gimple_omp_set_body (copy, new_seq);
    2025                 :            :           break;
    2026                 :            : 
    2027                 :          6 :         case GIMPLE_TRANSACTION:
    2028                 :          6 :           new_seq = gimple_seq_copy (gimple_transaction_body (
    2029                 :          6 :                                        as_a <gtransaction *> (stmt)));
    2030                 :          6 :           gimple_transaction_set_body (as_a <gtransaction *> (copy),
    2031                 :            :                                        new_seq);
    2032                 :            :           break;
    2033                 :            : 
    2034                 :          0 :         case GIMPLE_WITH_CLEANUP_EXPR:
    2035                 :          0 :           new_seq = gimple_seq_copy (gimple_wce_cleanup (stmt));
    2036                 :          0 :           gimple_wce_set_cleanup (copy, new_seq);
    2037                 :            :           break;
    2038                 :            : 
    2039                 :          0 :         default:
    2040                 :          0 :           gcc_unreachable ();
    2041                 :            :         }
    2042                 :            :     }
    2043                 :            : 
    2044                 :            :   /* Make copy of operands.  */
    2045                 :   90877400 :   for (i = 0; i < num_ops; i++)
    2046                 :   59319800 :     gimple_set_op (copy, i, unshare_expr (gimple_op (stmt, i)));
    2047                 :            : 
    2048                 :   31557600 :   if (gimple_has_mem_ops (stmt))
    2049                 :            :     {
    2050                 :   14754900 :       gimple_set_vdef (copy, gimple_vdef (stmt));
    2051                 :   14754900 :       gimple_set_vuse (copy, gimple_vuse (stmt));
    2052                 :            :     }
    2053                 :            : 
    2054                 :            :   /* Clear out SSA operand vectors on COPY.  */
    2055                 :   31557600 :   if (gimple_has_ops (stmt))
    2056                 :            :     {
    2057                 :   31425100 :       gimple_set_use_ops (copy, NULL);
    2058                 :            : 
    2059                 :            :       /* SSA operands need to be updated.  */
    2060                 :   31425100 :       gimple_set_modified (copy, true);
    2061                 :            :     }
    2062                 :            : 
    2063                 :   31557600 :   if (gimple_debug_nonbind_marker_p (stmt))
    2064                 :    9023180 :     cfun->debug_marker_count++;
    2065                 :            : 
    2066                 :   31557600 :   return copy;
    2067                 :            : }
    2068                 :            : 
    2069                 :            : /* Move OLD_STMT's vuse and vdef operands to NEW_STMT, on the assumption
    2070                 :            :    that OLD_STMT is about to be removed.  */
    2071                 :            : 
    2072                 :            : void
    2073                 :     287664 : gimple_move_vops (gimple *new_stmt, gimple *old_stmt)
    2074                 :            : {
    2075                 :     287664 :   tree vdef = gimple_vdef (old_stmt);
    2076                 :     575328 :   gimple_set_vuse (new_stmt, gimple_vuse (old_stmt));
    2077                 :     287664 :   gimple_set_vdef (new_stmt, vdef);
    2078                 :     287664 :   if (vdef && TREE_CODE (vdef) == SSA_NAME)
    2079                 :     100148 :     SSA_NAME_DEF_STMT (vdef) = new_stmt;
    2080                 :     287664 : }
    2081                 :            : 
    2082                 :            : /* Return true if statement S has side-effects.  We consider a
    2083                 :            :    statement to have side effects if:
    2084                 :            : 
    2085                 :            :    - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
    2086                 :            :    - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS.  */
    2087                 :            : 
    2088                 :            : bool
    2089                 :  298688000 : gimple_has_side_effects (const gimple *s)
    2090                 :            : {
    2091                 :  298688000 :   if (is_gimple_debug (s))
    2092                 :            :     return false;
    2093                 :            : 
    2094                 :            :   /* We don't have to scan the arguments to check for
    2095                 :            :      volatile arguments, though, at present, we still
    2096                 :            :      do a scan to check for TREE_SIDE_EFFECTS.  */
    2097                 :  381253000 :   if (gimple_has_volatile_ops (s))
    2098                 :            :     return true;
    2099                 :            : 
    2100                 :  186863000 :   if (gimple_code (s) == GIMPLE_ASM
    2101                 :  186863000 :       && gimple_asm_volatile_p (as_a <const gasm *> (s)))
    2102                 :            :     return true;
    2103                 :            : 
    2104                 :  186674000 :   if (is_gimple_call (s))
    2105                 :            :     {
    2106                 :   40178700 :       int flags = gimple_call_flags (s);
    2107                 :            : 
    2108                 :            :       /* An infinite loop is considered a side effect.  */
    2109                 :   40178700 :       if (!(flags & (ECF_CONST | ECF_PURE))
    2110                 :    5272170 :           || (flags & ECF_LOOPING_CONST_OR_PURE))
    2111                 :            :         return true;
    2112                 :            : 
    2113                 :    4850540 :       return false;
    2114                 :            :     }
    2115                 :            : 
    2116                 :            :   return false;
    2117                 :            : }
    2118                 :            : 
    2119                 :            : /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
    2120                 :            :    Return true if S can trap.  When INCLUDE_MEM is true, check whether
    2121                 :            :    the memory operations could trap.  When INCLUDE_STORES is true and
    2122                 :            :    S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked.  */
    2123                 :            : 
    2124                 :            : bool
    2125                 :   24666400 : gimple_could_trap_p_1 (gimple *s, bool include_mem, bool include_stores)
    2126                 :            : {
    2127                 :   24666400 :   tree t, div = NULL_TREE;
    2128                 :   24666400 :   enum tree_code op;
    2129                 :            : 
    2130                 :   24666400 :   if (include_mem)
    2131                 :            :     {
    2132                 :    9569350 :       unsigned i, start = (is_gimple_assign (s) && !include_stores) ? 1 : 0;
    2133                 :            : 
    2134                 :   31777800 :       for (i = start; i < gimple_num_ops (s); i++)
    2135                 :   23899000 :         if (tree_could_trap_p (gimple_op (s, i)))
    2136                 :            :           return true;
    2137                 :            :     }
    2138                 :            : 
    2139                 :   22975900 :   switch (gimple_code (s))
    2140                 :            :     {
    2141                 :      38364 :     case GIMPLE_ASM:
    2142                 :      38364 :       return gimple_asm_volatile_p (as_a <gasm *> (s));
    2143                 :            : 
    2144                 :     462324 :     case GIMPLE_CALL:
    2145                 :     462324 :       t = gimple_call_fndecl (s);
    2146                 :            :       /* Assume that calls to weak functions may trap.  */
    2147                 :     820296 :       if (!t || !DECL_P (t) || DECL_WEAK (t))
    2148                 :     106909 :         return true;
    2149                 :            :       return false;
    2150                 :            : 
    2151                 :   16378500 :     case GIMPLE_ASSIGN:
    2152                 :   16378500 :       op = gimple_assign_rhs_code (s);
    2153                 :            : 
    2154                 :            :       /* For COND_EXPR and VEC_COND_EXPR only the condition may trap.  */
    2155                 :   16378500 :       if (op == COND_EXPR || op == VEC_COND_EXPR)
    2156                 :      22148 :         return tree_could_trap_p (gimple_assign_rhs1 (s));
    2157                 :            : 
    2158                 :            :       /* For comparisons we need to check rhs operand types instead of rhs type
    2159                 :            :          (which is BOOLEAN_TYPE).  */
    2160                 :   16356300 :       if (TREE_CODE_CLASS (op) == tcc_comparison)
    2161                 :     548594 :         t = TREE_TYPE (gimple_assign_rhs1 (s));
    2162                 :            :       else
    2163                 :   15807700 :         t = gimple_expr_type (s);
    2164                 :            : 
    2165                 :   16356300 :       if (get_gimple_rhs_class (op) == GIMPLE_BINARY_RHS)
    2166                 :    7470310 :         div = gimple_assign_rhs2 (s);
    2167                 :            : 
    2168                 :   16645300 :       return (operation_could_trap_p (op, FLOAT_TYPE_P (t),
    2169                 :   16356300 :                                       (INTEGRAL_TYPE_P (t)
    2170                 :   16356300 :                                        && TYPE_OVERFLOW_TRAPS (t)),
    2171                 :   16356300 :                                       div));
    2172                 :            : 
    2173                 :    3690930 :     case GIMPLE_COND:
    2174                 :    3690930 :       t = TREE_TYPE (gimple_cond_lhs (s));
    2175                 :    3690930 :       return operation_could_trap_p (gimple_cond_code (s),
    2176                 :    7381990 :                                      FLOAT_TYPE_P (t), false, NULL_TREE);
    2177                 :            : 
    2178                 :            :     default:
    2179                 :            :       break;
    2180                 :            :     }
    2181                 :            : 
    2182                 :            :   return false;
    2183                 :            : }
    2184                 :            : 
    2185                 :            : /* Return true if statement S can trap.  */
    2186                 :            : 
    2187                 :            : bool
    2188                 :    8863630 : gimple_could_trap_p (gimple *s)
    2189                 :            : {
    2190                 :    8863630 :   return gimple_could_trap_p_1 (s, true, true);
    2191                 :            : }
    2192                 :            : 
    2193                 :            : /* Return true if RHS of a GIMPLE_ASSIGN S can trap.  */
    2194                 :            : 
    2195                 :            : bool
    2196                 :     705716 : gimple_assign_rhs_could_trap_p (gimple *s)
    2197                 :            : {
    2198                 :     705716 :   gcc_assert (is_gimple_assign (s));
    2199                 :     705716 :   return gimple_could_trap_p_1 (s, true, false);
    2200                 :            : }
    2201                 :            : 
    2202                 :            : 
    2203                 :            : /* Print debugging information for gimple stmts generated.  */
    2204                 :            : 
    2205                 :            : void
    2206                 :          0 : dump_gimple_statistics (void)
    2207                 :            : {
    2208                 :          0 :   int i;
    2209                 :          0 :   uint64_t total_tuples = 0, total_bytes = 0;
    2210                 :            : 
    2211                 :          0 :   if (! GATHER_STATISTICS)
    2212                 :            :     {
    2213                 :          0 :       fprintf (stderr, "No GIMPLE statistics\n");
    2214                 :          0 :       return;
    2215                 :            :     }
    2216                 :            : 
    2217                 :            :   fprintf (stderr, "\nGIMPLE statements\n");
    2218                 :            :   fprintf (stderr, "Kind                   Stmts      Bytes\n");
    2219                 :            :   fprintf (stderr, "---------------------------------------\n");
    2220                 :            :   for (i = 0; i < (int) gimple_alloc_kind_all; ++i)
    2221                 :            :     {
    2222                 :            :       fprintf (stderr, "%-20s %7" PRIu64 "%c %10" PRIu64 "%c\n",
    2223                 :            :                gimple_alloc_kind_names[i],
    2224                 :            :                SIZE_AMOUNT (gimple_alloc_counts[i]),
    2225                 :            :                SIZE_AMOUNT (gimple_alloc_sizes[i]));
    2226                 :            :       total_tuples += gimple_alloc_counts[i];
    2227                 :            :       total_bytes += gimple_alloc_sizes[i];
    2228                 :            :     }
    2229                 :            :   fprintf (stderr, "---------------------------------------\n");
    2230                 :            :   fprintf (stderr, "%-20s %7" PRIu64 "%c %10" PRIu64 "%c\n", "Total",
    2231                 :            :            SIZE_AMOUNT (total_tuples), SIZE_AMOUNT (total_bytes));
    2232                 :            :   fprintf (stderr, "---------------------------------------\n");
    2233                 :            : }
    2234                 :            : 
    2235                 :            : 
    2236                 :            : /* Return the number of operands needed on the RHS of a GIMPLE
    2237                 :            :    assignment for an expression with tree code CODE.  */
    2238                 :            : 
    2239                 :            : unsigned
    2240                 :   69995600 : get_gimple_rhs_num_ops (enum tree_code code)
    2241                 :            : {
    2242                 :   69995600 :   switch (get_gimple_rhs_class (code))
    2243                 :            :     {
    2244                 :            :     case GIMPLE_UNARY_RHS:
    2245                 :            :     case GIMPLE_SINGLE_RHS:
    2246                 :            :       return 1;
    2247                 :            :     case GIMPLE_BINARY_RHS:
    2248                 :            :       return 2;
    2249                 :            :     case GIMPLE_TERNARY_RHS:
    2250                 :            :       return 3;
    2251                 :          0 :     default:
    2252                 :          0 :       gcc_unreachable ();
    2253                 :            :     }
    2254                 :            : }
    2255                 :            : 
    2256                 :            : #define DEFTREECODE(SYM, STRING, TYPE, NARGS)                               \
    2257                 :            :   (unsigned char)                                                           \
    2258                 :            :   ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS                                   \
    2259                 :            :    : ((TYPE) == tcc_binary                                                  \
    2260                 :            :       || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS                      \
    2261                 :            :    : ((TYPE) == tcc_constant                                                \
    2262                 :            :       || (TYPE) == tcc_declaration                                          \
    2263                 :            :       || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS                       \
    2264                 :            :    : ((SYM) == TRUTH_AND_EXPR                                               \
    2265                 :            :       || (SYM) == TRUTH_OR_EXPR                                             \
    2266                 :            :       || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS                       \
    2267                 :            :    : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS                             \
    2268                 :            :    : ((SYM) == COND_EXPR                                                    \
    2269                 :            :       || (SYM) == WIDEN_MULT_PLUS_EXPR                                      \
    2270                 :            :       || (SYM) == WIDEN_MULT_MINUS_EXPR                                     \
    2271                 :            :       || (SYM) == DOT_PROD_EXPR                                             \
    2272                 :            :       || (SYM) == SAD_EXPR                                                  \
    2273                 :            :       || (SYM) == REALIGN_LOAD_EXPR                                         \
    2274                 :            :       || (SYM) == VEC_COND_EXPR                                             \
    2275                 :            :       || (SYM) == VEC_PERM_EXPR                                             \
    2276                 :            :       || (SYM) == BIT_INSERT_EXPR) ? GIMPLE_TERNARY_RHS                     \
    2277                 :            :    : ((SYM) == CONSTRUCTOR                                                  \
    2278                 :            :       || (SYM) == OBJ_TYPE_REF                                              \
    2279                 :            :       || (SYM) == ASSERT_EXPR                                               \
    2280                 :            :       || (SYM) == ADDR_EXPR                                                 \
    2281                 :            :       || (SYM) == WITH_SIZE_EXPR                                            \
    2282                 :            :       || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS                             \
    2283                 :            :    : GIMPLE_INVALID_RHS),
    2284                 :            : #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
    2285                 :            : 
    2286                 :            : const unsigned char gimple_rhs_class_table[] = {
    2287                 :            : #include "all-tree.def"
    2288                 :            : };
    2289                 :            : 
    2290                 :            : #undef DEFTREECODE
    2291                 :            : #undef END_OF_BASE_TREE_CODES
    2292                 :            : 
    2293                 :            : /* Canonicalize a tree T for use in a COND_EXPR as conditional.  Returns
    2294                 :            :    a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
    2295                 :            :    we failed to create one.  */
    2296                 :            : 
    2297                 :            : tree
    2298                 :    2531750 : canonicalize_cond_expr_cond (tree t)
    2299                 :            : {
    2300                 :            :   /* Strip conversions around boolean operations.  */
    2301                 :    2401430 :   if (CONVERT_EXPR_P (t)
    2302                 :    2531750 :       && (truth_value_p (TREE_CODE (TREE_OPERAND (t, 0)))
    2303                 :     129704 :           || TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0)))
    2304                 :            :              == BOOLEAN_TYPE))
    2305                 :        612 :     t = TREE_OPERAND (t, 0);
    2306                 :            : 
    2307                 :            :   /* For !x use x == 0.  */
    2308                 :    2531750 :   if (TREE_CODE (t) == TRUTH_NOT_EXPR)
    2309                 :            :     {
    2310                 :      15443 :       tree top0 = TREE_OPERAND (t, 0);
    2311                 :      15443 :       t = build2 (EQ_EXPR, TREE_TYPE (t),
    2312                 :      15443 :                   top0, build_int_cst (TREE_TYPE (top0), 0));
    2313                 :            :     }
    2314                 :            :   /* For cmp ? 1 : 0 use cmp.  */
    2315                 :    2516300 :   else if (TREE_CODE (t) == COND_EXPR
    2316                 :      48393 :            && COMPARISON_CLASS_P (TREE_OPERAND (t, 0))
    2317                 :      48390 :            && integer_onep (TREE_OPERAND (t, 1))
    2318                 :    2564670 :            && integer_zerop (TREE_OPERAND (t, 2)))
    2319                 :            :     {
    2320                 :      48363 :       tree top0 = TREE_OPERAND (t, 0);
    2321                 :      48363 :       t = build2 (TREE_CODE (top0), TREE_TYPE (t),
    2322                 :      48363 :                   TREE_OPERAND (top0, 0), TREE_OPERAND (top0, 1));
    2323                 :            :     }
    2324                 :            :   /* For x ^ y use x != y.  */
    2325                 :    2467940 :   else if (TREE_CODE (t) == BIT_XOR_EXPR)
    2326                 :          0 :     t = build2 (NE_EXPR, TREE_TYPE (t),
    2327                 :          0 :                 TREE_OPERAND (t, 0), TREE_OPERAND (t, 1));
    2328                 :            :   
    2329                 :    2531750 :   if (is_gimple_condexpr (t))
    2330                 :    1022470 :     return t;
    2331                 :            : 
    2332                 :            :   return NULL_TREE;
    2333                 :            : }
    2334                 :            : 
    2335                 :            : /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
    2336                 :            :    the positions marked by the set ARGS_TO_SKIP.  */
    2337                 :            : 
    2338                 :            : gcall *
    2339                 :          0 : gimple_call_copy_skip_args (gcall *stmt, bitmap args_to_skip)
    2340                 :            : {
    2341                 :          0 :   int i;
    2342                 :          0 :   int nargs = gimple_call_num_args (stmt);
    2343                 :          0 :   auto_vec<tree> vargs (nargs);
    2344                 :            :   gcall *new_stmt;
    2345                 :            : 
    2346                 :          0 :   for (i = 0; i < nargs; i++)
    2347                 :          0 :     if (!bitmap_bit_p (args_to_skip, i))
    2348                 :          0 :       vargs.quick_push (gimple_call_arg (stmt, i));
    2349                 :            : 
    2350                 :          0 :   if (gimple_call_internal_p (stmt))
    2351                 :          0 :     new_stmt = gimple_build_call_internal_vec (gimple_call_internal_fn (stmt),
    2352                 :            :                                                vargs);
    2353                 :            :   else
    2354                 :          0 :     new_stmt = gimple_build_call_vec (gimple_call_fn (stmt), vargs);
    2355                 :            : 
    2356                 :          0 :   if (gimple_call_lhs (stmt))
    2357                 :          0 :     gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
    2358                 :            : 
    2359                 :          0 :   gimple_set_vuse (new_stmt, gimple_vuse (stmt));
    2360                 :          0 :   gimple_set_vdef (new_stmt, gimple_vdef (stmt));
    2361                 :            : 
    2362                 :          0 :   if (gimple_has_location (stmt))
    2363                 :          0 :     gimple_set_location (new_stmt, gimple_location (stmt));
    2364                 :          0 :   gimple_call_copy_flags (new_stmt, stmt);
    2365                 :          0 :   gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
    2366                 :            : 
    2367                 :          0 :   gimple_set_modified (new_stmt, true);
    2368                 :            : 
    2369                 :          0 :   return new_stmt;
    2370                 :            : }
    2371                 :            : 
    2372                 :            : 
    2373                 :            : 
    2374                 :            : /* Return true if the field decls F1 and F2 are at the same offset.
    2375                 :            : 
    2376                 :            :    This is intended to be used on GIMPLE types only.  */
    2377                 :            : 
    2378                 :            : bool
    2379                 :    8029390 : gimple_compare_field_offset (tree f1, tree f2)
    2380                 :            : {
    2381                 :    8029390 :   if (DECL_OFFSET_ALIGN (f1) == DECL_OFFSET_ALIGN (f2))
    2382                 :            :     {
    2383                 :    8029350 :       tree offset1 = DECL_FIELD_OFFSET (f1);
    2384                 :    8029350 :       tree offset2 = DECL_FIELD_OFFSET (f2);
    2385                 :    8029350 :       return ((offset1 == offset2
    2386                 :            :                /* Once gimplification is done, self-referential offsets are
    2387                 :            :                   instantiated as operand #2 of the COMPONENT_REF built for
    2388                 :            :                   each access and reset.  Therefore, they are not relevant
    2389                 :            :                   anymore and fields are interchangeable provided that they
    2390                 :            :                   represent the same access.  */
    2391                 :          0 :                || (TREE_CODE (offset1) == PLACEHOLDER_EXPR
    2392                 :          0 :                    && TREE_CODE (offset2) == PLACEHOLDER_EXPR
    2393                 :          0 :                    && (DECL_SIZE (f1) == DECL_SIZE (f2)
    2394                 :          0 :                        || (TREE_CODE (DECL_SIZE (f1)) == PLACEHOLDER_EXPR
    2395                 :          0 :                            && TREE_CODE (DECL_SIZE (f2)) == PLACEHOLDER_EXPR)
    2396                 :          0 :                        || operand_equal_p (DECL_SIZE (f1), DECL_SIZE (f2), 0))
    2397                 :          0 :                    && DECL_ALIGN (f1) == DECL_ALIGN (f2))
    2398                 :          0 :                || operand_equal_p (offset1, offset2, 0))
    2399                 :   16058700 :               && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1),
    2400                 :    8029350 :                                      DECL_FIELD_BIT_OFFSET (f2)));
    2401                 :            :     }
    2402                 :            : 
    2403                 :            :   /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
    2404                 :            :      should be, so handle differing ones specially by decomposing
    2405                 :            :      the offset into a byte and bit offset manually.  */
    2406                 :         36 :   if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1))
    2407                 :         36 :       && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2)))
    2408                 :            :     {
    2409                 :         36 :       unsigned HOST_WIDE_INT byte_offset1, byte_offset2;
    2410                 :         36 :       unsigned HOST_WIDE_INT bit_offset1, bit_offset2;
    2411                 :         36 :       bit_offset1 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1));
    2412                 :         36 :       byte_offset1 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1))
    2413                 :         36 :                       + bit_offset1 / BITS_PER_UNIT);
    2414                 :         36 :       bit_offset2 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2));
    2415                 :         36 :       byte_offset2 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2))
    2416                 :         36 :                       + bit_offset2 / BITS_PER_UNIT);
    2417                 :         36 :       if (byte_offset1 != byte_offset2)
    2418                 :            :         return false;
    2419                 :         36 :       return bit_offset1 % BITS_PER_UNIT == bit_offset2 % BITS_PER_UNIT;
    2420                 :            :     }
    2421                 :            : 
    2422                 :            :   return false;
    2423                 :            : }
    2424                 :            : 
    2425                 :            : 
    2426                 :            : /* Return a type the same as TYPE except unsigned or
    2427                 :            :    signed according to UNSIGNEDP.  */
    2428                 :            : 
    2429                 :            : static tree
    2430                 :     331102 : gimple_signed_or_unsigned_type (bool unsignedp, tree type)
    2431                 :            : {
    2432                 :     331102 :   tree type1;
    2433                 :     331102 :   int i;
    2434                 :            : 
    2435                 :     331102 :   type1 = TYPE_MAIN_VARIANT (type);
    2436                 :     331102 :   if (type1 == signed_char_type_node
    2437                 :     331102 :       || type1 == char_type_node
    2438                 :     331102 :       || type1 == unsigned_char_type_node)
    2439                 :          0 :     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
    2440                 :     331102 :   if (type1 == integer_type_node || type1 == unsigned_type_node)
    2441                 :     217735 :     return unsignedp ? unsigned_type_node : integer_type_node;
    2442                 :     113367 :   if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
    2443                 :     103964 :     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
    2444                 :       9403 :   if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
    2445                 :          0 :     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
    2446                 :       9403 :   if (type1 == long_long_integer_type_node
    2447                 :       9403 :       || type1 == long_long_unsigned_type_node)
    2448                 :          0 :     return unsignedp
    2449                 :          0 :            ? long_long_unsigned_type_node
    2450                 :          0 :            : long_long_integer_type_node;
    2451                 :            : 
    2452                 :      14469 :   for (i = 0; i < NUM_INT_N_ENTS; i ++)
    2453                 :       9403 :     if (int_n_enabled_p[i]
    2454                 :       9403 :         && (type1 == int_n_trees[i].unsigned_type
    2455                 :       5066 :             || type1 == int_n_trees[i].signed_type))
    2456                 :       4337 :         return unsignedp
    2457                 :       4337 :           ? int_n_trees[i].unsigned_type
    2458                 :       4337 :           : int_n_trees[i].signed_type;
    2459                 :            : 
    2460                 :            : #if HOST_BITS_PER_WIDE_INT >= 64
    2461                 :       5066 :   if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
    2462                 :          0 :     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
    2463                 :            : #endif
    2464                 :       5066 :   if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
    2465                 :          0 :     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
    2466                 :       5066 :   if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
    2467                 :          0 :     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
    2468                 :       5066 :   if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
    2469                 :          0 :     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
    2470                 :       5066 :   if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
    2471                 :          0 :     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
    2472                 :            : 
    2473                 :            : #define GIMPLE_FIXED_TYPES(NAME)            \
    2474                 :            :   if (type1 == short_ ## NAME ## _type_node \
    2475                 :            :       || type1 == unsigned_short_ ## NAME ## _type_node) \
    2476                 :            :     return unsignedp ? unsigned_short_ ## NAME ## _type_node \
    2477                 :            :                      : short_ ## NAME ## _type_node; \
    2478                 :            :   if (type1 == NAME ## _type_node \
    2479                 :            :       || type1 == unsigned_ ## NAME ## _type_node) \
    2480                 :            :     return unsignedp ? unsigned_ ## NAME ## _type_node \
    2481                 :            :                      : NAME ## _type_node; \
    2482                 :            :   if (type1 == long_ ## NAME ## _type_node \
    2483                 :            :       || type1 == unsigned_long_ ## NAME ## _type_node) \
    2484                 :            :     return unsignedp ? unsigned_long_ ## NAME ## _type_node \
    2485                 :            :                      : long_ ## NAME ## _type_node; \
    2486                 :            :   if (type1 == long_long_ ## NAME ## _type_node \
    2487                 :            :       || type1 == unsigned_long_long_ ## NAME ## _type_node) \
    2488                 :            :     return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
    2489                 :            :                      : long_long_ ## NAME ## _type_node;
    2490                 :            : 
    2491                 :            : #define GIMPLE_FIXED_MODE_TYPES(NAME) \
    2492                 :            :   if (type1 == NAME ## _type_node \
    2493                 :            :       || type1 == u ## NAME ## _type_node) \
    2494                 :            :     return unsignedp ? u ## NAME ## _type_node \
    2495                 :            :                      : NAME ## _type_node;
    2496                 :            : 
    2497                 :            : #define GIMPLE_FIXED_TYPES_SAT(NAME) \
    2498                 :            :   if (type1 == sat_ ## short_ ## NAME ## _type_node \
    2499                 :            :       || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
    2500                 :            :     return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
    2501                 :            :                      : sat_ ## short_ ## NAME ## _type_node; \
    2502                 :            :   if (type1 == sat_ ## NAME ## _type_node \
    2503                 :            :       || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
    2504                 :            :     return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
    2505                 :            :                      : sat_ ## NAME ## _type_node; \
    2506                 :            :   if (type1 == sat_ ## long_ ## NAME ## _type_node \
    2507                 :            :       || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
    2508                 :            :     return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
    2509                 :            :                      : sat_ ## long_ ## NAME ## _type_node; \
    2510                 :            :   if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
    2511                 :            :       || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
    2512                 :            :     return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
    2513                 :            :                      : sat_ ## long_long_ ## NAME ## _type_node;
    2514                 :            : 
    2515                 :            : #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME)       \
    2516                 :            :   if (type1 == sat_ ## NAME ## _type_node \
    2517                 :            :       || type1 == sat_ ## u ## NAME ## _type_node) \
    2518                 :            :     return unsignedp ? sat_ ## u ## NAME ## _type_node \
    2519                 :            :                      : sat_ ## NAME ## _type_node;
    2520                 :            : 
    2521                 :       5066 :   GIMPLE_FIXED_TYPES (fract);
    2522                 :       5066 :   GIMPLE_FIXED_TYPES_SAT (fract);
    2523                 :       5066 :   GIMPLE_FIXED_TYPES (accum);
    2524                 :       5066 :   GIMPLE_FIXED_TYPES_SAT (accum);
    2525                 :            : 
    2526                 :       5066 :   GIMPLE_FIXED_MODE_TYPES (qq);
    2527                 :       5066 :   GIMPLE_FIXED_MODE_TYPES (hq);
    2528                 :       5066 :   GIMPLE_FIXED_MODE_TYPES (sq);
    2529                 :       5066 :   GIMPLE_FIXED_MODE_TYPES (dq);
    2530                 :       5066 :   GIMPLE_FIXED_MODE_TYPES (tq);
    2531                 :       5066 :   GIMPLE_FIXED_MODE_TYPES_SAT (qq);
    2532                 :       5066 :   GIMPLE_FIXED_MODE_TYPES_SAT (hq);
    2533                 :       5066 :   GIMPLE_FIXED_MODE_TYPES_SAT (sq);
    2534                 :       5066 :   GIMPLE_FIXED_MODE_TYPES_SAT (dq);
    2535                 :       5066 :   GIMPLE_FIXED_MODE_TYPES_SAT (tq);
    2536                 :       5066 :   GIMPLE_FIXED_MODE_TYPES (ha);
    2537                 :       5066 :   GIMPLE_FIXED_MODE_TYPES (sa);
    2538                 :       5066 :   GIMPLE_FIXED_MODE_TYPES (da);
    2539                 :       5066 :   GIMPLE_FIXED_MODE_TYPES (ta);
    2540                 :       5066 :   GIMPLE_FIXED_MODE_TYPES_SAT (ha);
    2541                 :       5066 :   GIMPLE_FIXED_MODE_TYPES_SAT (sa);
    2542                 :       5066 :   GIMPLE_FIXED_MODE_TYPES_SAT (da);
    2543                 :       5066 :   GIMPLE_FIXED_MODE_TYPES_SAT (ta);
    2544                 :            : 
    2545                 :            :   /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
    2546                 :            :      the precision; they have precision set to match their range, but
    2547                 :            :      may use a wider mode to match an ABI.  If we change modes, we may
    2548                 :            :      wind up with bad conversions.  For INTEGER_TYPEs in C, must check
    2549                 :            :      the precision as well, so as to yield correct results for
    2550                 :            :      bit-field types.  C++ does not have these separate bit-field
    2551                 :            :      types, and producing a signed or unsigned variant of an
    2552                 :            :      ENUMERAL_TYPE may cause other problems as well.  */
    2553                 :       5066 :   if (!INTEGRAL_TYPE_P (type)
    2554                 :       5066 :       || TYPE_UNSIGNED (type) == unsignedp)
    2555                 :            :     return type;
    2556                 :            : 
    2557                 :            : #define TYPE_OK(node)                                                       \
    2558                 :            :   (TYPE_MODE (type) == TYPE_MODE (node)                                     \
    2559                 :            :    && TYPE_PRECISION (type) == TYPE_PRECISION (node))
    2560                 :       7734 :   if (TYPE_OK (signed_char_type_node))
    2561                 :         24 :     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
    2562                 :       5730 :   if (TYPE_OK (integer_type_node))
    2563                 :         20 :     return unsignedp ? unsigned_type_node : integer_type_node;
    2564                 :       6636 :   if (TYPE_OK (short_integer_type_node))
    2565                 :          2 :     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
    2566                 :       5116 :   if (TYPE_OK (long_integer_type_node))
    2567                 :          0 :     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
    2568                 :       5116 :   if (TYPE_OK (long_long_integer_type_node))
    2569                 :          0 :     return (unsignedp
    2570                 :          0 :             ? long_long_unsigned_type_node
    2571                 :          0 :             : long_long_integer_type_node);
    2572                 :            : 
    2573                 :      10040 :   for (i = 0; i < NUM_INT_N_ENTS; i ++)
    2574                 :       5020 :     if (int_n_enabled_p[i]
    2575                 :       5020 :         && TYPE_MODE (type) == int_n_data[i].m
    2576                 :       5020 :         && TYPE_PRECISION (type) == int_n_data[i].bitsize)
    2577                 :          0 :         return unsignedp
    2578                 :          0 :           ? int_n_trees[i].unsigned_type
    2579                 :          0 :           : int_n_trees[i].signed_type;
    2580                 :            : 
    2581                 :            : #if HOST_BITS_PER_WIDE_INT >= 64
    2582                 :       5020 :   if (TYPE_OK (intTI_type_node))
    2583                 :          0 :     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
    2584                 :            : #endif
    2585                 :       5116 :   if (TYPE_OK (intDI_type_node))
    2586                 :          0 :     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
    2587                 :       5688 :   if (TYPE_OK (intSI_type_node))
    2588                 :          0 :     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
    2589                 :       6632 :   if (TYPE_OK (intHI_type_node))
    2590                 :          0 :     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
    2591                 :       7664 :   if (TYPE_OK (intQI_type_node))
    2592                 :          0 :     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
    2593                 :            : 
    2594                 :            : #undef GIMPLE_FIXED_TYPES
    2595                 :            : #undef GIMPLE_FIXED_MODE_TYPES
    2596                 :            : #undef GIMPLE_FIXED_TYPES_SAT
    2597                 :            : #undef GIMPLE_FIXED_MODE_TYPES_SAT
    2598                 :            : #undef TYPE_OK
    2599                 :            : 
    2600                 :       5020 :   return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
    2601                 :            : }
    2602                 :            : 
    2603                 :            : 
    2604                 :            : /* Return an unsigned type the same as TYPE in other respects.  */
    2605                 :            : 
    2606                 :            : tree
    2607                 :          0 : gimple_unsigned_type (tree type)
    2608                 :            : {
    2609                 :          0 :   return gimple_signed_or_unsigned_type (true, type);
    2610                 :            : }
    2611                 :            : 
    2612                 :            : 
    2613                 :            : /* Return a signed type the same as TYPE in other respects.  */
    2614                 :            : 
    2615                 :            : tree
    2616                 :     331102 : gimple_signed_type (tree type)
    2617                 :            : {
    2618                 :     331102 :   return gimple_signed_or_unsigned_type (false, type);
    2619                 :            : }
    2620                 :            : 
    2621                 :            : 
    2622                 :            : /* Return the typed-based alias set for T, which may be an expression
    2623                 :            :    or a type.  Return -1 if we don't do anything special.  */
    2624                 :            : 
    2625                 :            : alias_set_type
    2626                 :    4607380 : gimple_get_alias_set (tree t)
    2627                 :            : {
    2628                 :            :   /* That's all the expressions we handle specially.  */
    2629                 :    4607380 :   if (!TYPE_P (t))
    2630                 :            :     return -1;
    2631                 :            : 
    2632                 :            :   /* For convenience, follow the C standard when dealing with
    2633                 :            :      character types.  Any object may be accessed via an lvalue that
    2634                 :            :      has character type.  */
    2635                 :    1347870 :   if (t == char_type_node
    2636                 :    1017570 :       || t == signed_char_type_node
    2637                 :    1017570 :       || t == unsigned_char_type_node)
    2638                 :            :     return 0;
    2639                 :            : 
    2640                 :            :   /* Allow aliasing between signed and unsigned variants of the same
    2641                 :            :      type.  We treat the signed variant as canonical.  */
    2642                 :    1017570 :   if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
    2643                 :            :     {
    2644                 :     331102 :       tree t1 = gimple_signed_type (t);
    2645                 :            : 
    2646                 :            :       /* t1 == t can happen for boolean nodes which are always unsigned.  */
    2647                 :     331102 :       if (t1 != t)
    2648                 :     331102 :         return get_alias_set (t1);
    2649                 :            :     }
    2650                 :            : 
    2651                 :            :   /* Allow aliasing between enumeral types and the underlying
    2652                 :            :      integer type.  This is required for C since those are
    2653                 :            :      compatible types.  */
    2654                 :     686464 :   else if (TREE_CODE (t) == ENUMERAL_TYPE)
    2655                 :            :     {
    2656                 :          0 :       tree t1 = lang_hooks.types.type_for_size (tree_to_uhwi (TYPE_SIZE (t)),
    2657                 :            :                                                 false /* short-cut above */);
    2658                 :          0 :       return get_alias_set (t1);
    2659                 :            :     }
    2660                 :            : 
    2661                 :            :   return -1;
    2662                 :            : }
    2663                 :            : 
    2664                 :            : 
    2665                 :            : /* Helper for gimple_ior_addresses_taken_1.  */
    2666                 :            : 
    2667                 :            : static bool
    2668                 :   26812900 : gimple_ior_addresses_taken_1 (gimple *, tree addr, tree, void *data)
    2669                 :            : {
    2670                 :   26812900 :   bitmap addresses_taken = (bitmap)data;
    2671                 :   26812900 :   addr = get_base_address (addr);
    2672                 :   26812900 :   if (addr
    2673                 :   26812900 :       && DECL_P (addr))
    2674                 :            :     {
    2675                 :   17829300 :       bitmap_set_bit (addresses_taken, DECL_UID (addr));
    2676                 :   17829300 :       return true;
    2677                 :            :     }
    2678                 :            :   return false;
    2679                 :            : }
    2680                 :            : 
    2681                 :            : /* Set the bit for the uid of all decls that have their address taken
    2682                 :            :    in STMT in the ADDRESSES_TAKEN bitmap.  Returns true if there
    2683                 :            :    were any in this stmt.  */
    2684                 :            : 
    2685                 :            : bool
    2686                 :  405854000 : gimple_ior_addresses_taken (bitmap addresses_taken, gimple *stmt)
    2687                 :            : {
    2688                 :  405854000 :   return walk_stmt_load_store_addr_ops (stmt, addresses_taken, NULL, NULL,
    2689                 :  405854000 :                                         gimple_ior_addresses_taken_1);
    2690                 :            : }
    2691                 :            : 
    2692                 :            : 
    2693                 :            : /* Return true when STMTs arguments and return value match those of FNDECL,
    2694                 :            :    a decl of a builtin function.  */
    2695                 :            : 
    2696                 :            : bool
    2697                 :   67717300 : gimple_builtin_call_types_compatible_p (const gimple *stmt, tree fndecl)
    2698                 :            : {
    2699                 :   67717300 :   gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN);
    2700                 :            : 
    2701                 :   67717300 :   tree ret = gimple_call_lhs (stmt);
    2702                 :   67717300 :   if (ret
    2703                 :  107069000 :       && !useless_type_conversion_p (TREE_TYPE (ret),
    2704                 :   39352200 :                                      TREE_TYPE (TREE_TYPE (fndecl))))
    2705                 :            :     return false;
    2706                 :            : 
    2707                 :   67711800 :   tree targs = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
    2708                 :   67711800 :   unsigned nargs = gimple_call_num_args (stmt);
    2709                 :  197350000 :   for (unsigned i = 0; i < nargs; ++i)
    2710                 :            :     {
    2711                 :            :       /* Variadic args follow.  */
    2712                 :  135959000 :       if (!targs)
    2713                 :            :         return true;
    2714                 :  131174000 :       tree arg = gimple_call_arg (stmt, i);
    2715                 :  131174000 :       tree type = TREE_VALUE (targs);
    2716                 :  131174000 :       if (!useless_type_conversion_p (type, TREE_TYPE (arg))
    2717                 :            :           /* char/short integral arguments are promoted to int
    2718                 :            :              by several frontends if targetm.calls.promote_prototypes
    2719                 :            :              is true.  Allow such promotion too.  */
    2720                 :  133282000 :           && !(INTEGRAL_TYPE_P (type)
    2721                 :    2907340 :                && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
    2722                 :    2107660 :                && targetm.calls.promote_prototypes (TREE_TYPE (fndecl))
    2723                 :    2107660 :                && useless_type_conversion_p (integer_type_node,
    2724                 :    2107660 :                                              TREE_TYPE (arg))))
    2725                 :    1535500 :         return false;
    2726                 :  129639000 :       targs = TREE_CHAIN (targs);
    2727                 :            :     }
    2728                 :  122531000 :   if (targs && !VOID_TYPE_P (TREE_VALUE (targs)))
    2729                 :      13514 :     return false;
    2730                 :            :   return true;
    2731                 :            : }
    2732                 :            : 
    2733                 :            : /* Return true when STMT is operator delete call.  */
    2734                 :            : 
    2735                 :            : bool
    2736                 :   46286200 : gimple_call_operator_delete_p (const gcall *stmt)
    2737                 :            : {
    2738                 :   46286200 :   tree fndecl;
    2739                 :            : 
    2740                 :   46286200 :   if ((fndecl = gimple_call_fndecl (stmt)) != NULL_TREE)
    2741                 :   43468600 :     return DECL_IS_OPERATOR_DELETE_P (fndecl);
    2742                 :            :   return false;
    2743                 :            : }
    2744                 :            : 
    2745                 :            : /* Return true when STMT is builtins call.  */
    2746                 :            : 
    2747                 :            : bool
    2748                 :   43553300 : gimple_call_builtin_p (const gimple *stmt)
    2749                 :            : {
    2750                 :   43553300 :   tree fndecl;
    2751                 :   43553300 :   if (is_gimple_call (stmt)
    2752                 :   12920600 :       && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
    2753                 :   55749400 :       && DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN)
    2754                 :    2440230 :     return gimple_builtin_call_types_compatible_p (stmt, fndecl);
    2755                 :            :   return false;
    2756                 :            : }
    2757                 :            : 
    2758                 :            : /* Return true when STMT is builtins call to CLASS.  */
    2759                 :            : 
    2760                 :            : bool
    2761                 :  373782000 : gimple_call_builtin_p (const gimple *stmt, enum built_in_class klass)
    2762                 :            : {
    2763                 :  373782000 :   tree fndecl;
    2764                 :  373782000 :   if (is_gimple_call (stmt)
    2765                 :  204161000 :       && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
    2766                 :  569909000 :       && DECL_BUILT_IN_CLASS (fndecl) == klass)
    2767                 :   43689500 :     return gimple_builtin_call_types_compatible_p (stmt, fndecl);
    2768                 :            :   return false;
    2769                 :            : }
    2770                 :            : 
    2771                 :            : /* Return true when STMT is builtins call to CODE of CLASS.  */
    2772                 :            : 
    2773                 :            : bool
    2774                 : 1278320000 : gimple_call_builtin_p (const gimple *stmt, enum built_in_function code)
    2775                 :            : {
    2776                 : 1278320000 :   tree fndecl;
    2777                 : 1278320000 :   if (is_gimple_call (stmt)
    2778                 :  449211000 :       && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
    2779                 : 1705570000 :       && fndecl_built_in_p (fndecl, code))
    2780                 :     657565 :     return gimple_builtin_call_types_compatible_p (stmt, fndecl);
    2781                 :            :   return false;
    2782                 :            : }
    2783                 :            : 
    2784                 :            : /* If CALL is a call to a combined_fn (i.e. an internal function or
    2785                 :            :    a normal built-in function), return its code, otherwise return
    2786                 :            :    CFN_LAST.  */
    2787                 :            : 
    2788                 :            : combined_fn
    2789                 :   29169100 : gimple_call_combined_fn (const gimple *stmt)
    2790                 :            : {
    2791                 :   29169100 :   if (const gcall *call = dyn_cast <const gcall *> (stmt))
    2792                 :            :     {
    2793                 :   28926000 :       if (gimple_call_internal_p (call))
    2794                 :    1875110 :         return as_combined_fn (gimple_call_internal_fn (call));
    2795                 :            : 
    2796                 :   27050900 :       tree fndecl = gimple_call_fndecl (stmt);
    2797                 :   27050900 :       if (fndecl
    2798                 :   25522700 :           && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL)
    2799                 :   35758100 :           && gimple_builtin_call_types_compatible_p (stmt, fndecl))
    2800                 :    8587340 :         return as_combined_fn (DECL_FUNCTION_CODE (fndecl));
    2801                 :            :     }
    2802                 :            :   return CFN_LAST;
    2803                 :            : }
    2804                 :            : 
    2805                 :            : /* Return true if STMT clobbers memory.  STMT is required to be a
    2806                 :            :    GIMPLE_ASM.  */
    2807                 :            : 
    2808                 :            : bool
    2809                 :    8402070 : gimple_asm_clobbers_memory_p (const gasm *stmt)
    2810                 :            : {
    2811                 :    8402070 :   unsigned i;
    2812                 :            : 
    2813                 :   12527100 :   for (i = 0; i < gimple_asm_nclobbers (stmt); i++)
    2814                 :            :     {
    2815                 :    6795670 :       tree op = gimple_asm_clobber_op (stmt, i);
    2816                 :    6795670 :       if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op)), "memory") == 0)
    2817                 :            :         return true;
    2818                 :            :     }
    2819                 :            : 
    2820                 :            :   /* Non-empty basic ASM implicitly clobbers memory.  */
    2821                 :    5731400 :   if (gimple_asm_input_p (stmt) && strlen (gimple_asm_string (stmt)) != 0)
    2822                 :      48205 :     return true;
    2823                 :            : 
    2824                 :            :   return false;
    2825                 :            : }
    2826                 :            : 
    2827                 :            : /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE.  */
    2828                 :            : 
    2829                 :            : void
    2830                 :       2774 : dump_decl_set (FILE *file, bitmap set)
    2831                 :            : {
    2832                 :       2774 :   if (set)
    2833                 :            :     {
    2834                 :       2774 :       bitmap_iterator bi;
    2835                 :       2774 :       unsigned i;
    2836                 :            : 
    2837                 :       2774 :       fprintf (file, "{ ");
    2838                 :            : 
    2839                 :       6133 :       EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi)
    2840                 :            :         {
    2841                 :       3359 :           fprintf (file, "D.%u", i);
    2842                 :       3359 :           fprintf (file, " ");
    2843                 :            :         }
    2844                 :            : 
    2845                 :       2774 :       fprintf (file, "}");
    2846                 :            :     }
    2847                 :            :   else
    2848                 :          0 :     fprintf (file, "NIL");
    2849                 :       2774 : }
    2850                 :            : 
    2851                 :            : /* Return true when CALL is a call stmt that definitely doesn't
    2852                 :            :    free any memory or makes it unavailable otherwise.  */
    2853                 :            : bool
    2854                 :    6084350 : nonfreeing_call_p (gimple *call)
    2855                 :            : {
    2856                 :    6084350 :   if (gimple_call_builtin_p (call, BUILT_IN_NORMAL)
    2857                 :    6084350 :       && gimple_call_flags (call) & ECF_LEAF)
    2858                 :    2289600 :     switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call)))
    2859                 :            :       {
    2860                 :            :         /* Just in case these become ECF_LEAF in the future.  */
    2861                 :            :         case BUILT_IN_FREE:
    2862                 :            :         case BUILT_IN_TM_FREE:
    2863                 :            :         case BUILT_IN_REALLOC:
    2864                 :            :         case BUILT_IN_STACK_RESTORE:
    2865                 :            :           return false;
    2866                 :    2182980 :         default:
    2867                 :    2182980 :           return true;
    2868                 :            :       }
    2869                 :    3794750 :   else if (gimple_call_internal_p (call))
    2870                 :     526735 :     switch (gimple_call_internal_fn (call))
    2871                 :            :       {
    2872                 :            :       case IFN_ABNORMAL_DISPATCHER:
    2873                 :            :         return true;
    2874                 :      22394 :       case IFN_ASAN_MARK:
    2875                 :      22394 :         return tree_to_uhwi (gimple_call_arg (call, 0)) == ASAN_MARK_UNPOISON;
    2876                 :     499818 :       default:
    2877                 :     499818 :         if (gimple_call_flags (call) & ECF_LEAF)
    2878                 :            :           return true;
    2879                 :     118122 :         return false;
    2880                 :            :       }
    2881                 :            : 
    2882                 :    3268020 :   tree fndecl = gimple_call_fndecl (call);
    2883                 :    3268020 :   if (!fndecl)
    2884                 :            :     return false;
    2885                 :    3147500 :   struct cgraph_node *n = cgraph_node::get (fndecl);
    2886                 :    3147500 :   if (!n)
    2887                 :            :     return false;
    2888                 :    3147160 :   enum availability availability;
    2889                 :    3147160 :   n = n->function_symbol (&availability);
    2890                 :    3147160 :   if (!n || availability <= AVAIL_INTERPOSABLE)
    2891                 :            :     return false;
    2892                 :     661502 :   return n->nonfreeing_fn;
    2893                 :            : }
    2894                 :            : 
    2895                 :            : /* Return true when CALL is a call stmt that definitely need not
    2896                 :            :    be considered to be a memory barrier.  */
    2897                 :            : bool
    2898                 :     856803 : nonbarrier_call_p (gimple *call)
    2899                 :            : {
    2900                 :     856803 :   if (gimple_call_flags (call) & (ECF_PURE | ECF_CONST))
    2901                 :     210528 :     return true;
    2902                 :            :   /* Should extend this to have a nonbarrier_fn flag, just as above in
    2903                 :            :      the nonfreeing case.  */
    2904                 :            :   return false;
    2905                 :            : }
    2906                 :            : 
    2907                 :            : /* Callback for walk_stmt_load_store_ops.
    2908                 :            :  
    2909                 :            :    Return TRUE if OP will dereference the tree stored in DATA, FALSE
    2910                 :            :    otherwise.
    2911                 :            : 
    2912                 :            :    This routine only makes a superficial check for a dereference.  Thus
    2913                 :            :    it must only be used if it is safe to return a false negative.  */
    2914                 :            : static bool
    2915                 :   40758000 : check_loadstore (gimple *, tree op, tree, void *data)
    2916                 :            : {
    2917                 :   40758000 :   if (TREE_CODE (op) == MEM_REF || TREE_CODE (op) == TARGET_MEM_REF)
    2918                 :            :     {
    2919                 :            :       /* Some address spaces may legitimately dereference zero.  */
    2920                 :   28870400 :       addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (op));
    2921                 :   28870400 :       if (targetm.addr_space.zero_address_valid (as))
    2922                 :            :         return false;
    2923                 :            : 
    2924                 :   28870100 :       return operand_equal_p (TREE_OPERAND (op, 0), (tree)data, 0);
    2925                 :            :     }
    2926                 :            :   return false;
    2927                 :            : }
    2928                 :            : 
    2929                 :            : 
    2930                 :            : /* Return true if OP can be inferred to be non-NULL after STMT executes,
    2931                 :            :    either by using a pointer dereference or attributes.  */
    2932                 :            : bool
    2933                 :  140782000 : infer_nonnull_range (gimple *stmt, tree op)
    2934                 :            : {
    2935                 :  140782000 :   return infer_nonnull_range_by_dereference (stmt, op)
    2936                 :  140782000 :     || infer_nonnull_range_by_attribute (stmt, op);
    2937                 :            : }
    2938                 :            : 
    2939                 :            : /* Return true if OP can be inferred to be non-NULL after STMT
    2940                 :            :    executes by using a pointer dereference.  */
    2941                 :            : bool
    2942                 :  186442000 : infer_nonnull_range_by_dereference (gimple *stmt, tree op)
    2943                 :            : {
    2944                 :            :   /* We can only assume that a pointer dereference will yield
    2945                 :            :      non-NULL if -fdelete-null-pointer-checks is enabled.  */
    2946                 :  186442000 :   if (!flag_delete_null_pointer_checks
    2947                 :  186252000 :       || !POINTER_TYPE_P (TREE_TYPE (op))
    2948                 :  294476000 :       || gimple_code (stmt) == GIMPLE_ASM)
    2949                 :            :     return false;
    2950                 :            : 
    2951                 :  107952000 :   if (walk_stmt_load_store_ops (stmt, (void *)op,
    2952                 :            :                                 check_loadstore, check_loadstore))
    2953                 :   22111000 :     return true;
    2954                 :            : 
    2955                 :            :   return false;
    2956                 :            : }
    2957                 :            : 
    2958                 :            : /* Return true if OP can be inferred to be a non-NULL after STMT
    2959                 :            :    executes by using attributes.  */
    2960                 :            : bool
    2961                 :  164359000 : infer_nonnull_range_by_attribute (gimple *stmt, tree op)
    2962                 :            : {
    2963                 :            :   /* We can only assume that a pointer dereference will yield
    2964                 :            :      non-NULL if -fdelete-null-pointer-checks is enabled.  */
    2965                 :  164359000 :   if (!flag_delete_null_pointer_checks
    2966                 :  164169000 :       || !POINTER_TYPE_P (TREE_TYPE (op))
    2967                 :  250310000 :       || gimple_code (stmt) == GIMPLE_ASM)
    2968                 :            :     return false;
    2969                 :            : 
    2970                 :   85868900 :   if (is_gimple_call (stmt) && !gimple_call_internal_p (stmt))
    2971                 :            :     {
    2972                 :   11637200 :       tree fntype = gimple_call_fntype (stmt);
    2973                 :   11637200 :       tree attrs = TYPE_ATTRIBUTES (fntype);
    2974                 :   11735900 :       for (; attrs; attrs = TREE_CHAIN (attrs))
    2975                 :            :         {
    2976                 :    2152010 :           attrs = lookup_attribute ("nonnull", attrs);
    2977                 :            : 
    2978                 :            :           /* If "nonnull" wasn't specified, we know nothing about
    2979                 :            :              the argument.  */
    2980                 :    2152010 :           if (attrs == NULL_TREE)
    2981                 :            :             return false;
    2982                 :            : 
    2983                 :            :           /* If "nonnull" applies to all the arguments, then ARG
    2984                 :            :              is non-null if it's in the argument list.  */
    2985                 :     894022 :           if (TREE_VALUE (attrs) == NULL_TREE)
    2986                 :            :             {
    2987                 :     837155 :               for (unsigned int i = 0; i < gimple_call_num_args (stmt); i++)
    2988                 :            :                 {
    2989                 :     849323 :                   if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt, i)))
    2990                 :     769195 :                       && operand_equal_p (op, gimple_call_arg (stmt, i), 0))
    2991                 :            :                     return true;
    2992                 :            :                 }
    2993                 :            :               return false;
    2994                 :            :             }
    2995                 :            : 
    2996                 :            :           /* Now see if op appears in the nonnull list.  */
    2997                 :     561941 :           for (tree t = TREE_VALUE (attrs); t; t = TREE_CHAIN (t))
    2998                 :            :             {
    2999                 :     463209 :               unsigned int idx = TREE_INT_CST_LOW (TREE_VALUE (t)) - 1;
    3000                 :     463209 :               if (idx < gimple_call_num_args (stmt))
    3001                 :            :                 {
    3002                 :     463209 :                   tree arg = gimple_call_arg (stmt, idx);
    3003                 :     463209 :                   if (operand_equal_p (op, arg, 0))
    3004                 :            :                     return true;
    3005                 :            :                 }
    3006                 :            :             }
    3007                 :            :         }
    3008                 :            :     }
    3009                 :            : 
    3010                 :            :   /* If this function is marked as returning non-null, then we can
    3011                 :            :      infer OP is non-null if it is used in the return statement.  */
    3012                 :   83815700 :   if (greturn *return_stmt = dyn_cast <greturn *> (stmt))
    3013                 :    1043550 :     if (gimple_return_retval (return_stmt)
    3014                 :     759677 :         && operand_equal_p (gimple_return_retval (return_stmt), op, 0)
    3015                 :    1521810 :         && lookup_attribute ("returns_nonnull",
    3016                 :     478260 :                              TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
    3017                 :       5266 :       return true;
    3018                 :            : 
    3019                 :            :   return false;
    3020                 :            : }
    3021                 :            : 
    3022                 :            : /* Compare two case labels.  Because the front end should already have
    3023                 :            :    made sure that case ranges do not overlap, it is enough to only compare
    3024                 :            :    the CASE_LOW values of each case label.  */
    3025                 :            : 
    3026                 :            : static int
    3027                 :   41470600 : compare_case_labels (const void *p1, const void *p2)
    3028                 :            : {
    3029                 :   41470600 :   const_tree const case1 = *(const_tree const*)p1;
    3030                 :   41470600 :   const_tree const case2 = *(const_tree const*)p2;
    3031                 :            : 
    3032                 :            :   /* The 'default' case label always goes first.  */
    3033                 :   41470600 :   if (!CASE_LOW (case1))
    3034                 :            :     return -1;
    3035                 :   41470600 :   else if (!CASE_LOW (case2))
    3036                 :            :     return 1;
    3037                 :            :   else
    3038                 :   41470600 :     return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
    3039                 :            : }
    3040                 :            : 
    3041                 :            : /* Sort the case labels in LABEL_VEC in place in ascending order.  */
    3042                 :            : 
    3043                 :            : void
    3044                 :      44306 : sort_case_labels (vec<tree> label_vec)
    3045                 :            : {
    3046                 :      44306 :   label_vec.qsort (compare_case_labels);
    3047                 :      44306 : }
    3048                 :            : 
    3049                 :            : /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
    3050                 :            : 
    3051                 :            :    LABELS is a vector that contains all case labels to look at.
    3052                 :            : 
    3053                 :            :    INDEX_TYPE is the type of the switch index expression.  Case labels
    3054                 :            :    in LABELS are discarded if their values are not in the value range
    3055                 :            :    covered by INDEX_TYPE.  The remaining case label values are folded
    3056                 :            :    to INDEX_TYPE.
    3057                 :            : 
    3058                 :            :    If a default case exists in LABELS, it is removed from LABELS and
    3059                 :            :    returned in DEFAULT_CASEP.  If no default case exists, but the
    3060                 :            :    case labels already cover the whole range of INDEX_TYPE, a default
    3061                 :            :    case is returned pointing to one of the existing case labels.
    3062                 :            :    Otherwise DEFAULT_CASEP is set to NULL_TREE.
    3063                 :            : 
    3064                 :            :    DEFAULT_CASEP may be NULL, in which case the above comment doesn't
    3065                 :            :    apply and no action is taken regardless of whether a default case is
    3066                 :            :    found or not.  */
    3067                 :            : 
    3068                 :            : void
    3069                 :      40680 : preprocess_case_label_vec_for_gimple (vec<tree> labels,
    3070                 :            :                                       tree index_type,
    3071                 :            :                                       tree *default_casep)
    3072                 :            : {
    3073                 :      40680 :   tree min_value, max_value;
    3074                 :      40680 :   tree default_case = NULL_TREE;
    3075                 :      40680 :   size_t i, len;
    3076                 :            : 
    3077                 :      40680 :   i = 0;
    3078                 :      40680 :   min_value = TYPE_MIN_VALUE (index_type);
    3079                 :      40680 :   max_value = TYPE_MAX_VALUE (index_type);
    3080                 :     967914 :   while (i < labels.length ())
    3081                 :            :     {
    3082                 :     927234 :       tree elt = labels[i];
    3083                 :     927234 :       tree low = CASE_LOW (elt);
    3084                 :     927234 :       tree high = CASE_HIGH (elt);
    3085                 :     927234 :       bool remove_element = FALSE;
    3086                 :            : 
    3087                 :     927234 :       if (low)
    3088                 :            :         {
    3089                 :     905669 :           gcc_checking_assert (TREE_CODE (low) == INTEGER_CST);
    3090                 :     905669 :           gcc_checking_assert (!high || TREE_CODE (high) == INTEGER_CST);
    3091                 :            : 
    3092                 :            :           /* This is a non-default case label, i.e. it has a value.
    3093                 :            : 
    3094                 :            :              See if the case label is reachable within the range of
    3095                 :            :              the index type.  Remove out-of-range case values.  Turn
    3096                 :            :              case ranges into a canonical form (high > low strictly)
    3097                 :            :              and convert the case label values to the index type.
    3098                 :            : 
    3099                 :            :              NB: The type of gimple_switch_index() may be the promoted
    3100                 :            :              type, but the case labels retain the original type.  */
    3101                 :            : 
    3102                 :     905669 :           if (high)
    3103                 :            :             {
    3104                 :            :               /* This is a case range.  Discard empty ranges.
    3105                 :            :                  If the bounds or the range are equal, turn this
    3106                 :            :                  into a simple (one-value) case.  */
    3107                 :        998 :               int cmp = tree_int_cst_compare (high, low);
    3108                 :        998 :               if (cmp < 0)
    3109                 :            :                 remove_element = TRUE;
    3110                 :        995 :               else if (cmp == 0)
    3111                 :            :                 high = NULL_TREE;
    3112                 :            :             }
    3113                 :            : 
    3114                 :     905631 :           if (! high)
    3115                 :            :             {
    3116                 :            :               /* If the simple case value is unreachable, ignore it.  */
    3117                 :     904709 :               if ((TREE_CODE (min_value) == INTEGER_CST
    3118                 :     904709 :                    && tree_int_cst_compare (low, min_value) < 0)
    3119                 :    1809370 :                   || (TREE_CODE (max_value) == INTEGER_CST
    3120                 :     904661 :                       && tree_int_cst_compare (low, max_value) > 0))
    3121                 :            :                 remove_element = TRUE;
    3122                 :            :               else
    3123                 :     904516 :                 low = fold_convert (index_type, low);
    3124                 :            :             }
    3125                 :            :           else
    3126                 :            :             {
    3127                 :            :               /* If the entire case range is unreachable, ignore it.  */
    3128                 :        960 :               if ((TREE_CODE (min_value) == INTEGER_CST
    3129                 :        960 :                    && tree_int_cst_compare (high, min_value) < 0)
    3130                 :       1911 :                   || (TREE_CODE (max_value) == INTEGER_CST
    3131                 :        951 :                       && tree_int_cst_compare (low, max_value) > 0))
    3132                 :            :                 remove_element = TRUE;
    3133                 :            :               else
    3134                 :            :                 {
    3135                 :            :                   /* If the lower bound is less than the index type's
    3136                 :            :                      minimum value, truncate the range bounds.  */
    3137                 :        951 :                   if (TREE_CODE (min_value) == INTEGER_CST
    3138                 :        951 :                       && tree_int_cst_compare (low, min_value) < 0)
    3139                 :            :                     low = min_value;
    3140                 :        951 :                   low = fold_convert (index_type, low);
    3141                 :            : 
    3142                 :            :                   /* If the upper bound is greater than the index type's
    3143                 :            :                      maximum value, truncate the range bounds.  */
    3144                 :        951 :                   if (TREE_CODE (max_value) == INTEGER_CST
    3145                 :        951 :                       && tree_int_cst_compare (high, max_value) > 0)
    3146                 :            :                     high = max_value;
    3147                 :        951 :                   high = fold_convert (index_type, high);
    3148                 :            : 
    3149                 :            :                   /* We may have folded a case range to a one-value case.  */
    3150                 :        951 :                   if (tree_int_cst_equal (low, high))
    3151                 :          0 :                     high = NULL_TREE;
    3152                 :            :                 }
    3153                 :            :             }
    3154                 :            : 
    3155                 :     905669 :           CASE_LOW (elt) = low;
    3156                 :     905669 :           CASE_HIGH (elt) = high;
    3157                 :            :         }
    3158                 :            :       else
    3159                 :            :         {
    3160                 :      21565 :           gcc_assert (!default_case);
    3161                 :      21565 :           default_case = elt;
    3162                 :            :           /* The default case must be passed separately to the
    3163                 :            :              gimple_build_switch routine.  But if DEFAULT_CASEP
    3164                 :            :              is NULL, we do not remove the default case (it would
    3165                 :            :              be completely lost).  */
    3166                 :      21565 :           if (default_casep)
    3167                 :            :             remove_element = TRUE;
    3168                 :            :         }
    3169                 :            : 
    3170                 :     905669 :       if (remove_element)
    3171                 :     989684 :         labels.ordered_remove (i);
    3172                 :            :       else
    3173                 :     905464 :         i++;
    3174                 :            :     }
    3175                 :      40680 :   len = i;
    3176                 :            : 
    3177                 :      40680 :   if (!labels.is_empty ())
    3178                 :      39916 :     sort_case_labels (labels);
    3179                 :            : 
    3180                 :      40680 :   if (default_casep && !default_case)
    3181                 :            :     {
    3182                 :            :       /* If the switch has no default label, add one, so that we jump
    3183                 :            :          around the switch body.  If the labels already cover the whole
    3184                 :            :          range of the switch index_type, add the default label pointing
    3185                 :            :          to one of the existing labels.  */
    3186                 :      11581 :       if (len
    3187                 :      11094 :           && TYPE_MIN_VALUE (index_type)
    3188                 :      11094 :           && TYPE_MAX_VALUE (index_type)
    3189                 :      22675 :           && tree_int_cst_equal (CASE_LOW (labels[0]),
    3190                 :      11094 :                                  TYPE_MIN_VALUE (index_type)))
    3191                 :            :         {
    3192                 :       3377 :           tree low, high = CASE_HIGH (labels[len - 1]);
    3193                 :       3377 :           if (!high)
    3194                 :       3330 :             high = CASE_LOW (labels[len - 1]);
    3195                 :       3377 :           if (tree_int_cst_equal (high, TYPE_MAX_VALUE (index_type)))
    3196                 :            :             {
    3197                 :         68 :               tree widest_label = labels[0];
    3198                 :        135 :               for (i = 1; i < len; i++)
    3199                 :            :                 {
    3200                 :         86 :                   high = CASE_LOW (labels[i]);
    3201                 :         86 :                   low = CASE_HIGH (labels[i - 1]);
    3202                 :         86 :                   if (!low)
    3203                 :         52 :                     low = CASE_LOW (labels[i - 1]);
    3204                 :            : 
    3205                 :         86 :                   if (CASE_HIGH (labels[i]) != NULL_TREE
    3206                 :        120 :                       && (CASE_HIGH (widest_label) == NULL_TREE
    3207                 :         29 :                           || (wi::gtu_p
    3208                 :         58 :                               (wi::to_wide (CASE_HIGH (labels[i]))
    3209                 :         58 :                                - wi::to_wide (CASE_LOW (labels[i])),
    3210                 :         29 :                                wi::to_wide (CASE_HIGH (widest_label))
    3211                 :        127 :                                - wi::to_wide (CASE_LOW (widest_label))))))
    3212                 :         17 :                     widest_label = labels[i];
    3213                 :            : 
    3214                 :         86 :                   if (wi::to_wide (low) + 1 != wi::to_wide (high))
    3215                 :            :                     break;
    3216                 :            :                 }
    3217                 :         68 :               if (i == len)
    3218                 :            :                 {
    3219                 :            :                   /* Designate the label with the widest range to be the
    3220                 :            :                      default label.  */
    3221                 :         49 :                   tree label = CASE_LABEL (widest_label);
    3222                 :         49 :                   default_case = build_case_label (NULL_TREE, NULL_TREE,
    3223                 :            :                                                    label);
    3224                 :            :                 }
    3225                 :            :             }
    3226                 :            :         }
    3227                 :            :     }
    3228                 :            : 
    3229                 :      40680 :   if (default_casep)
    3230                 :      33146 :     *default_casep = default_case;
    3231                 :      40680 : }
    3232                 :            : 
    3233                 :            : /* Set the location of all statements in SEQ to LOC.  */
    3234                 :            : 
    3235                 :            : void
    3236                 :       2966 : gimple_seq_set_location (gimple_seq seq, location_t loc)
    3237                 :            : {
    3238                 :      17097 :   for (gimple_stmt_iterator i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
    3239                 :      14131 :     gimple_set_location (gsi_stmt (i), loc);
    3240                 :       2966 : }
    3241                 :            : 
    3242                 :            : /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements.  */
    3243                 :            : 
    3244                 :            : void
    3245                 :       3264 : gimple_seq_discard (gimple_seq seq)
    3246                 :            : {
    3247                 :       3264 :   gimple_stmt_iterator gsi;
    3248                 :            : 
    3249                 :       9265 :   for (gsi = gsi_start (seq); !gsi_end_p (gsi); )
    3250                 :            :     {
    3251                 :       4663 :       gimple *stmt = gsi_stmt (gsi);
    3252                 :       4663 :       gsi_remove (&gsi, true);
    3253                 :       4663 :       release_defs (stmt);
    3254                 :       4663 :       ggc_free (stmt);
    3255                 :            :     }
    3256                 :       3264 : }
    3257                 :            : 
    3258                 :            : /* See if STMT now calls function that takes no parameters and if so, drop
    3259                 :            :    call arguments.  This is used when devirtualization machinery redirects
    3260                 :            :    to __builtin_unreachable or __cxa_pure_virtual.  */
    3261                 :            : 
    3262                 :            : void
    3263                 :     391340 : maybe_remove_unused_call_args (struct function *fn, gimple *stmt)
    3264                 :            : {
    3265                 :     391340 :   tree decl = gimple_call_fndecl (stmt);
    3266                 :     391340 :   if (TYPE_ARG_TYPES (TREE_TYPE (decl))
    3267                 :     561297 :       && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))) == void_type_node
    3268                 :     462176 :       && gimple_call_num_args (stmt))
    3269                 :            :     {
    3270                 :      29073 :       gimple_set_num_ops (stmt, 3);
    3271                 :      29073 :       update_stmt_fn (fn, stmt);
    3272                 :            :     }
    3273                 :     391340 : }
    3274                 :            : 
    3275                 :            : /* Return false if STMT will likely expand to real function call.  */
    3276                 :            : 
    3277                 :            : bool
    3278                 :    2008020 : gimple_inexpensive_call_p (gcall *stmt)
    3279                 :            : {
    3280                 :    2008020 :   if (gimple_call_internal_p (stmt))
    3281                 :            :     return true;
    3282                 :    1987390 :   tree decl = gimple_call_fndecl (stmt);
    3283                 :    1987390 :   if (decl && is_inexpensive_builtin (decl))
    3284                 :      72724 :     return true;
    3285                 :            :   return false;
    3286                 :            : }
    3287                 :            : 
    3288                 :            : /* Return a non-artificial location for STMT.  If STMT does not have
    3289                 :            :    location information, get the location from EXPR.  */
    3290                 :            : 
    3291                 :            : location_t
    3292                 :     638493 : gimple_or_expr_nonartificial_location (gimple *stmt, tree expr)
    3293                 :            : {
    3294                 :     638493 :   location_t loc = gimple_nonartificial_location (stmt);
    3295                 :     638493 :   if (loc == UNKNOWN_LOCATION && EXPR_HAS_LOCATION (expr))
    3296                 :        418 :     loc = tree_nonartificial_location (expr);
    3297                 :     638493 :   return expansion_point_location_if_in_system_header (loc);
    3298                 :            : }
    3299                 :            : 
    3300                 :            : 
    3301                 :            : #if CHECKING_P
    3302                 :            : 
    3303                 :            : namespace selftest {
    3304                 :            : 
    3305                 :            : /* Selftests for core gimple structures.  */
    3306                 :            : 
    3307                 :            : /* Verify that STMT is pretty-printed as EXPECTED.
    3308                 :            :    Helper function for selftests.  */
    3309                 :            : 
    3310                 :            : static void
    3311                 :         10 : verify_gimple_pp (const char *expected, gimple *stmt)
    3312                 :            : {
    3313                 :         10 :   pretty_printer pp;
    3314                 :         10 :   pp_gimple_stmt_1 (&pp, stmt, 0 /* spc */, TDF_NONE /* flags */);
    3315                 :         10 :   ASSERT_STREQ (expected, pp_formatted_text (&pp));
    3316                 :         10 : }
    3317                 :            : 
    3318                 :            : /* Build a GIMPLE_ASSIGN equivalent to
    3319                 :            :      tmp = 5;
    3320                 :            :    and verify various properties of it.  */
    3321                 :            : 
    3322                 :            : static void
    3323                 :          2 : test_assign_single ()
    3324                 :            : {
    3325                 :          2 :   tree type = integer_type_node;
    3326                 :          2 :   tree lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
    3327                 :            :                          get_identifier ("tmp"),
    3328                 :            :                          type);
    3329                 :          2 :   tree rhs = build_int_cst (type, 5);
    3330                 :          2 :   gassign *stmt = gimple_build_assign (lhs, rhs);
    3331                 :          2 :   verify_gimple_pp ("tmp = 5;", stmt);
    3332                 :            : 
    3333                 :          2 :   ASSERT_TRUE (is_gimple_assign (stmt));
    3334                 :          2 :   ASSERT_EQ (lhs, gimple_assign_lhs (stmt));
    3335                 :          2 :   ASSERT_EQ (lhs, gimple_get_lhs (stmt));
    3336                 :          2 :   ASSERT_EQ (rhs, gimple_assign_rhs1 (stmt));
    3337                 :          2 :   ASSERT_EQ (NULL, gimple_assign_rhs2 (stmt));
    3338                 :          2 :   ASSERT_EQ (NULL, gimple_assign_rhs3 (stmt));
    3339                 :          4 :   ASSERT_TRUE (gimple_assign_single_p (stmt));
    3340                 :          4 :   ASSERT_EQ (INTEGER_CST, gimple_assign_rhs_code (stmt));
    3341                 :          2 : }
    3342                 :            : 
    3343                 :            : /* Build a GIMPLE_ASSIGN equivalent to
    3344                 :            :      tmp = a * b;
    3345                 :            :    and verify various properties of it.  */
    3346                 :            : 
    3347                 :            : static void
    3348                 :          2 : test_assign_binop ()
    3349                 :            : {
    3350                 :          2 :   tree type = integer_type_node;
    3351                 :          2 :   tree lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
    3352                 :            :                          get_identifier ("tmp"),
    3353                 :            :                          type);
    3354                 :          2 :   tree a = build_decl (UNKNOWN_LOCATION, VAR_DECL,
    3355                 :            :                        get_identifier ("a"),
    3356                 :            :                        type);
    3357                 :          2 :   tree b = build_decl (UNKNOWN_LOCATION, VAR_DECL,
    3358                 :            :                        get_identifier ("b"),
    3359                 :            :                        type);
    3360                 :          2 :   gassign *stmt = gimple_build_assign (lhs, MULT_EXPR, a, b);
    3361                 :          2 :   verify_gimple_pp ("tmp = a * b;", stmt);
    3362                 :            : 
    3363                 :          2 :   ASSERT_TRUE (is_gimple_assign (stmt));
    3364                 :          2 :   ASSERT_EQ (lhs, gimple_assign_lhs (stmt));
    3365                 :          2 :   ASSERT_EQ (lhs, gimple_get_lhs (stmt));
    3366                 :          2 :   ASSERT_EQ (a, gimple_assign_rhs1 (stmt));
    3367                 :          4 :   ASSERT_EQ (b, gimple_assign_rhs2 (stmt));
    3368                 :          2 :   ASSERT_EQ (NULL, gimple_assign_rhs3 (stmt));
    3369                 :          4 :   ASSERT_FALSE (gimple_assign_single_p (stmt));
    3370                 :          2 :   ASSERT_EQ (MULT_EXPR, gimple_assign_rhs_code (stmt));
    3371                 :          2 : }
    3372                 :            : 
    3373                 :            : /* Build a GIMPLE_NOP and verify various properties of it.  */
    3374                 :            : 
    3375                 :            : static void
    3376                 :          2 : test_nop_stmt ()
    3377                 :            : {
    3378                 :          2 :   gimple *stmt = gimple_build_nop ();
    3379                 :          2 :   verify_gimple_pp ("GIMPLE_NOP", stmt);
    3380                 :          2 :   ASSERT_EQ (GIMPLE_NOP, gimple_code (stmt));
    3381                 :          2 :   ASSERT_EQ (NULL, gimple_get_lhs (stmt));
    3382                 :          2 :   ASSERT_FALSE (gimple_assign_single_p (stmt));
    3383                 :          2 : }
    3384                 :            : 
    3385                 :            : /* Build a GIMPLE_RETURN equivalent to
    3386                 :            :      return 7;
    3387                 :            :    and verify various properties of it.  */
    3388                 :            : 
    3389                 :            : static void
    3390                 :          2 : test_return_stmt ()
    3391                 :            : {
    3392                 :          2 :   tree type = integer_type_node;
    3393                 :          2 :   tree val = build_int_cst (type, 7);
    3394                 :          2 :   greturn *stmt = gimple_build_return (val);
    3395                 :          2 :   verify_gimple_pp ("return 7;", stmt);
    3396                 :            : 
    3397                 :          2 :   ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt));
    3398                 :          2 :   ASSERT_EQ (NULL, gimple_get_lhs (stmt));
    3399                 :          2 :   ASSERT_EQ (val, gimple_return_retval (stmt));
    3400                 :          2 :   ASSERT_FALSE (gimple_assign_single_p (stmt));
    3401                 :          2 : }
    3402                 :            : 
    3403                 :            : /* Build a GIMPLE_RETURN equivalent to
    3404                 :            :      return;
    3405                 :            :    and verify various properties of it.  */
    3406                 :            : 
    3407                 :            : static void
    3408                 :          2 : test_return_without_value ()
    3409                 :            : {
    3410                 :          2 :   greturn *stmt = gimple_build_return (NULL);
    3411                 :          2 :   verify_gimple_pp ("return;", stmt);
    3412                 :            : 
    3413                 :          2 :   ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt));
    3414                 :          2 :   ASSERT_EQ (NULL, gimple_get_lhs (stmt));
    3415                 :          2 :   ASSERT_EQ (NULL, gimple_return_retval (stmt));
    3416                 :          2 :   ASSERT_FALSE (gimple_assign_single_p (stmt));
    3417                 :          2 : }
    3418                 :            : 
    3419                 :            : /* Run all of the selftests within this file.  */
    3420                 :            : 
    3421                 :            : void
    3422                 :          2 : gimple_c_tests ()
    3423                 :            : {
    3424                 :          2 :   test_assign_single ();
    3425                 :          2 :   test_assign_binop ();
    3426                 :          2 :   test_nop_stmt ();
    3427                 :          2 :   test_return_stmt ();
    3428                 :          2 :   test_return_without_value ();
    3429                 :          2 : }
    3430                 :            : 
    3431                 :            : } // namespace selftest
    3432                 :            : 
    3433                 :            : 
    3434                 :            : #endif /* CHECKING_P */

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.