LCOV - code coverage report
Current view: top level - gcc - gimple.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 87.4 % 1609 1406
Test Date: 2026-11-14 16:39:50 Functions: 96.5 % 143 138
Legend: Lines:     hit not hit

            Line data    Source code
       1              : /* Gimple IR support functions.
       2              : 
       3              :    Copyright (C) 2007-2026 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 "ubsan.h"
      48              : #include "langhooks.h"
      49              : #include "attr-fnspec.h"
      50              : #include "ipa-modref-tree.h"
      51              : #include "ipa-modref.h"
      52              : #include "dbgcnt.h"
      53              : 
      54              : /* All the tuples have their operand vector (if present) at the very bottom of
      55              :    the structure.  Therefore, the offset required to find the operands vector is
      56              :    the size of the structure minus the size of the 1-element tree array at the
      57              :    end (see gimple_ops).  An adjustment may be required if there is tail
      58              :    padding, as may happen on a host (e.g. sparc) where a pointer has 4-byte
      59              :    alignment while a uint64_t has 8-byte alignment.
      60              : 
      61              :    Unfortunately, we can't use offsetof to do this computation 100%
      62              :    straightforwardly, because these structs use inheritance and so are not
      63              :    standard layout types.  However, the fact that they are not standard layout
      64              :    types also means that tail padding will be reused in inheritance, which makes
      65              :    it possible to check for the problematic case with the following logic
      66              :    instead.  If tail padding is detected, the offset should be decreased
      67              :    accordingly.  */
      68              : 
      69              : template<typename G>
      70              : static constexpr size_t
      71              : get_tail_padding_adjustment ()
      72              : {
      73              :   struct padding_check : G
      74              :   {
      75              :     tree t;
      76              :   };
      77              :   return sizeof (padding_check) == sizeof (G) ? sizeof (tree) : 0;
      78              : }
      79              : 
      80              : #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
      81              :   (HAS_TREE_OP \
      82              :    ? sizeof (STRUCT) - sizeof (tree) - get_tail_padding_adjustment<STRUCT> () \
      83              :    : 0),
      84              : EXPORTED_CONST size_t gimple_ops_offset_[] = {
      85              : #include "gsstruct.def"
      86              : };
      87              : #undef DEFGSSTRUCT
      88              : 
      89              : #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
      90              : static const size_t gsstruct_code_size[] = {
      91              : #include "gsstruct.def"
      92              : };
      93              : #undef DEFGSSTRUCT
      94              : 
      95              : #define DEFGSCODE(SYM, NAME, GSSCODE)   NAME,
      96              : const char *const gimple_code_name[] = {
      97              : #include "gimple.def"
      98              : };
      99              : #undef DEFGSCODE
     100              : 
     101              : #define DEFGSCODE(SYM, NAME, GSSCODE)   GSSCODE,
     102              : EXPORTED_CONST enum gimple_statement_structure_enum gss_for_code_[] = {
     103              : #include "gimple.def"
     104              : };
     105              : #undef DEFGSCODE
     106              : 
     107              : /* Gimple stats.  */
     108              : 
     109              : uint64_t gimple_alloc_counts[(int) gimple_alloc_kind_all];
     110              : uint64_t gimple_alloc_sizes[(int) gimple_alloc_kind_all];
     111              : 
     112              : /* Keep in sync with gimple.h:enum gimple_alloc_kind.  */
     113              : static const char * const gimple_alloc_kind_names[] = {
     114              :     "assignments",
     115              :     "phi nodes",
     116              :     "conditionals",
     117              :     "everything else"
     118              : };
     119              : 
     120              : /* Static gimple tuple members.  */
     121              : const enum gimple_code gassign::code_;
     122              : const enum gimple_code gcall::code_;
     123              : const enum gimple_code gcond::code_;
     124              : 
     125              : 
     126              : /* Gimple tuple constructors.
     127              :    Note: Any constructor taking a ``gimple_seq'' as a parameter, can
     128              :    be passed a NULL to start with an empty sequence.  */
     129              : 
     130              : /* Set the code for statement G to CODE.  */
     131              : 
     132              : static inline void
     133    334320339 : gimple_set_code (gimple *g, enum gimple_code code)
     134              : {
     135    334320339 :   g->code = code;
     136              : }
     137              : 
     138              : /* Return the number of bytes needed to hold a GIMPLE statement with
     139              :    code CODE.  */
     140              : 
     141              : size_t
     142    409871300 : gimple_size (enum gimple_code code, unsigned num_ops)
     143              : {
     144    409871300 :   size_t size = gsstruct_code_size[gss_for_code (code)];
     145    409871300 :   if (num_ops > 0)
     146    280050500 :     size += (sizeof (tree) * (num_ops - 1));
     147    409871300 :   return size;
     148              : }
     149              : 
     150              : /* Initialize GIMPLE statement G with CODE and NUM_OPS.  */
     151              : 
     152              : void
     153    334320339 : gimple_init (gimple *g, enum gimple_code code, unsigned num_ops)
     154              : {
     155    334320339 :   gimple_set_code (g, code);
     156    334320339 :   gimple_set_num_ops (g, num_ops);
     157              : 
     158              :   /* Do not call gimple_set_modified here as it has other side
     159              :      effects and this tuple is still not completely built.  */
     160    334320339 :   g->modified = 1;
     161    334320339 :   gimple_init_singleton (g);
     162    334320339 : }
     163              : 
     164              : /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
     165              :    operands.  */
     166              : 
     167              : gimple *
     168    332637233 : gimple_alloc (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
     169              : {
     170    332637233 :   size_t size;
     171    332637233 :   gimple *stmt;
     172              : 
     173    332637233 :   size = gimple_size (code, num_ops);
     174    332637233 :   if (GATHER_STATISTICS)
     175              :     {
     176              :       enum gimple_alloc_kind kind = gimple_alloc_kind (code);
     177              :       gimple_alloc_counts[(int) kind]++;
     178              :       gimple_alloc_sizes[(int) kind] += size;
     179              :     }
     180              : 
     181    332637233 :   stmt = ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT);
     182    332637233 :   gimple_init (stmt, code, num_ops);
     183    332637233 :   return stmt;
     184              : }
     185              : 
     186              : /* Set SUBCODE to be the code of the expression computed by statement G.  */
     187              : 
     188              : static inline void
     189    237397479 : gimple_set_subcode (gimple *g, unsigned subcode)
     190              : {
     191              :   /* We only have 16 bits for the RHS code.  Assert that we are not
     192              :      overflowing it.  */
     193    237397479 :   gcc_assert (subcode < (1 << 16));
     194    237397479 :   g->subcode = subcode;
     195    237397479 : }
     196              : 
     197              : 
     198              : 
     199              : /* Build a tuple with operands.  CODE is the statement to build (which
     200              :    must be one of the GIMPLE_WITH_OPS tuples).  SUBCODE is the subcode
     201              :    for the new tuple.  NUM_OPS is the number of operands to allocate.  */
     202              : 
     203              : #define gimple_build_with_ops(c, s, n) \
     204              :   gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
     205              : 
     206              : static gimple *
     207    226073738 : gimple_build_with_ops_stat (enum gimple_code code, unsigned subcode,
     208              :                             unsigned num_ops MEM_STAT_DECL)
     209              : {
     210            0 :   gimple *s = gimple_alloc (code, num_ops PASS_MEM_STAT);
     211    226073738 :   gimple_set_subcode (s, subcode);
     212              : 
     213    226073738 :   return s;
     214              : }
     215              : 
     216              : 
     217              : /* Build a GIMPLE_RETURN statement returning RETVAL.  */
     218              : 
     219              : greturn *
     220      3662555 : gimple_build_return (tree retval)
     221              : {
     222      3662555 :   greturn *s
     223      3662555 :     = as_a <greturn *> (gimple_build_with_ops (GIMPLE_RETURN, ERROR_MARK,
     224              :                                                2));
     225      3662555 :   if (retval)
     226      2221193 :     gimple_return_set_retval (s, retval);
     227      3662555 :   return s;
     228              : }
     229              : 
     230              : /* Reset alias information on call S.  */
     231              : 
     232              : void
     233     18780702 : gimple_call_reset_alias_info (gcall *s)
     234              : {
     235     18780702 :   if (gimple_call_flags (s) & ECF_CONST)
     236      2390482 :     memset (gimple_call_use_set (s), 0, sizeof (struct pt_solution));
     237              :   else
     238     16390220 :     pt_solution_reset (gimple_call_use_set (s));
     239     18780702 :   if (gimple_call_flags (s) & (ECF_CONST|ECF_PURE|ECF_NOVOPS))
     240      3631438 :     memset (gimple_call_clobber_set (s), 0, sizeof (struct pt_solution));
     241              :   else
     242     15149264 :     pt_solution_reset (gimple_call_clobber_set (s));
     243     18780702 : }
     244              : 
     245              : /* Helper for gimple_build_call, gimple_build_call_valist,
     246              :    gimple_build_call_vec and gimple_build_call_from_tree.  Build the basic
     247              :    components of a GIMPLE_CALL statement to function FN with NARGS
     248              :    arguments.  */
     249              : 
     250              : static inline gcall *
     251     12320221 : gimple_build_call_1 (tree fn, unsigned nargs)
     252              : {
     253     12320221 :   gcall *s
     254     24640442 :     = as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
     255              :                                              nargs + 3));
     256     12320221 :   if (TREE_CODE (fn) == FUNCTION_DECL)
     257     12098326 :     fn = build_fold_addr_expr (fn);
     258     12320221 :   gimple_set_op (s, 1, fn);
     259     12320221 :   gimple_call_set_fntype (s, TREE_TYPE (TREE_TYPE (fn)));
     260     12320221 :   gimple_call_reset_alias_info (s);
     261     12320221 :   return s;
     262              : }
     263              : 
     264              : 
     265              : /* Build a GIMPLE_CALL statement to function FN with the arguments
     266              :    specified in vector ARGS.  */
     267              : 
     268              : gcall *
     269       761842 : gimple_build_call_vec (tree fn, const vec<tree> &args)
     270              : {
     271       761842 :   unsigned i;
     272       761842 :   unsigned nargs = args.length ();
     273       761842 :   gcall *call = gimple_build_call_1 (fn, nargs);
     274              : 
     275      3364941 :   for (i = 0; i < nargs; i++)
     276      1841257 :     gimple_call_set_arg (call, i, args[i]);
     277              : 
     278       761842 :   return call;
     279              : }
     280              : 
     281              : 
     282              : /* Build a GIMPLE_CALL statement to function FN.  NARGS is the number of
     283              :    arguments.  The ... are the arguments.  */
     284              : 
     285              : gcall *
     286       644851 : gimple_build_call (tree fn, unsigned nargs, ...)
     287              : {
     288       644851 :   va_list ap;
     289       644851 :   gcall *call;
     290       644851 :   unsigned i;
     291              : 
     292       644851 :   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
     293              : 
     294       644851 :   call = gimple_build_call_1 (fn, nargs);
     295              : 
     296       644851 :   va_start (ap, nargs);
     297      1334510 :   for (i = 0; i < nargs; i++)
     298       689659 :     gimple_call_set_arg (call, i, va_arg (ap, tree));
     299       644851 :   va_end (ap);
     300              : 
     301       644851 :   return call;
     302              : }
     303              : 
     304              : 
     305              : /* Build a GIMPLE_CALL statement to function FN.  NARGS is the number of
     306              :    arguments.  AP contains the arguments.  */
     307              : 
     308              : gcall *
     309         2452 : gimple_build_call_valist (tree fn, unsigned nargs, va_list ap)
     310              : {
     311         2452 :   gcall *call;
     312         2452 :   unsigned i;
     313              : 
     314         2452 :   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
     315              : 
     316         2452 :   call = gimple_build_call_1 (fn, nargs);
     317              : 
     318        11940 :   for (i = 0; i < nargs; i++)
     319         7036 :     gimple_call_set_arg (call, i, va_arg (ap, tree));
     320              : 
     321         2452 :   return call;
     322              : }
     323              : 
     324              : 
     325              : /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
     326              :    Build the basic components of a GIMPLE_CALL statement to internal
     327              :    function FN with NARGS arguments.  */
     328              : 
     329              : static inline gcall *
     330       878371 : gimple_build_call_internal_1 (enum internal_fn fn, unsigned nargs)
     331              : {
     332       878371 :   gcall *s
     333      1756742 :     = as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
     334              :                                              nargs + 3));
     335       878371 :   s->subcode |= GF_CALL_INTERNAL;
     336       878371 :   gimple_call_set_internal_fn (s, fn);
     337       878371 :   gimple_call_reset_alias_info (s);
     338       878371 :   return s;
     339              : }
     340              : 
     341              : 
     342              : /* Build a GIMPLE_CALL statement to internal function FN.  NARGS is
     343              :    the number of arguments.  The ... are the arguments.  */
     344              : 
     345              : gcall *
     346       486250 : gimple_build_call_internal (enum internal_fn fn, unsigned nargs, ...)
     347              : {
     348       486250 :   va_list ap;
     349       486250 :   gcall *call;
     350       486250 :   unsigned i;
     351              : 
     352       486250 :   call = gimple_build_call_internal_1 (fn, nargs);
     353       486250 :   va_start (ap, nargs);
     354      1960317 :   for (i = 0; i < nargs; i++)
     355      1474067 :     gimple_call_set_arg (call, i, va_arg (ap, tree));
     356       486250 :   va_end (ap);
     357              : 
     358       486250 :   return call;
     359              : }
     360              : 
     361              : 
     362              : /* Build a GIMPLE_CALL statement to internal function FN with the arguments
     363              :    specified in vector ARGS.  */
     364              : 
     365              : gcall *
     366       391979 : gimple_build_call_internal_vec (enum internal_fn fn, const vec<tree> &args)
     367              : {
     368       391979 :   unsigned i, nargs;
     369       391979 :   gcall *call;
     370              : 
     371       391979 :   nargs = args.length ();
     372       391979 :   call = gimple_build_call_internal_1 (fn, nargs);
     373      1947997 :   for (i = 0; i < nargs; i++)
     374      1164039 :     gimple_call_set_arg (call, i, args[i]);
     375              : 
     376       391979 :   return call;
     377              : }
     378              : 
     379              : 
     380              : /* Build a GIMPLE_CALL statement from CALL_EXPR T.  Note that T is
     381              :    assumed to be in GIMPLE form already.  Minimal checking is done of
     382              :    this fact.  */
     383              : 
     384              : gcall *
     385     10911218 : gimple_build_call_from_tree (tree t, tree fnptrtype)
     386              : {
     387     10911218 :   unsigned i, nargs;
     388     10911218 :   gcall *call;
     389              : 
     390     10911218 :   gcc_assert (TREE_CODE (t) == CALL_EXPR);
     391              : 
     392     10911218 :   nargs = call_expr_nargs (t);
     393              : 
     394     10911218 :   tree fndecl = NULL_TREE;
     395     10911218 :   if (CALL_EXPR_FN (t) == NULL_TREE)
     396          142 :     call = gimple_build_call_internal_1 (CALL_EXPR_IFN (t), nargs);
     397              :   else
     398              :     {
     399     10911076 :       fndecl = get_callee_fndecl (t);
     400     11075743 :       call = gimple_build_call_1 (fndecl ? fndecl : CALL_EXPR_FN (t), nargs);
     401              :     }
     402              : 
     403     30492135 :   for (i = 0; i < nargs; i++)
     404     19580917 :     gimple_call_set_arg (call, i, CALL_EXPR_ARG (t, i));
     405              : 
     406     10911218 :   gimple_set_block (call, TREE_BLOCK (t));
     407     10911218 :   gimple_set_location (call, EXPR_LOCATION (t));
     408              : 
     409              :   /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL.  */
     410     10911218 :   gimple_call_set_chain (call, CALL_EXPR_STATIC_CHAIN (t));
     411     10911218 :   gimple_call_set_tail (call, CALL_EXPR_TAILCALL (t));
     412     10911218 :   gimple_call_set_must_tail (call, CALL_EXPR_MUST_TAIL_CALL (t));
     413     10911218 :   gimple_call_set_return_slot_opt (call, CALL_EXPR_RETURN_SLOT_OPT (t));
     414     10911218 :   if (fndecl
     415     10746409 :       && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL)
     416     13230175 :       && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (fndecl)))
     417        83074 :     gimple_call_set_alloca_for_var (call, CALL_ALLOCA_FOR_VAR_P (t));
     418     10869681 :   else if (fndecl
     419     21574553 :            && (DECL_IS_OPERATOR_NEW_P (fndecl)
     420     10649253 :                || DECL_IS_OPERATOR_DELETE_P (fndecl)))
     421       264734 :     gimple_call_set_from_new_or_delete (call, CALL_FROM_NEW_OR_DELETE_P (t));
     422              :   else
     423     21474628 :     gimple_call_set_from_thunk (call, CALL_FROM_THUNK_P (t));
     424     10911218 :   gimple_call_set_va_arg_pack (call, CALL_EXPR_VA_ARG_PACK (t));
     425     10911218 :   gimple_call_set_nothrow (call, TREE_NOTHROW (t));
     426     10911218 :   if (fndecl)
     427     10746409 :     gimple_call_set_expected_throw (call,
     428     10746409 :                                     flags_from_decl_or_type (fndecl)
     429     10746409 :                                     & ECF_XTHROW);
     430     10911218 :   gimple_call_set_by_descriptor (call, CALL_EXPR_BY_DESCRIPTOR (t));
     431     10911218 :   copy_warning (call, t);
     432              : 
     433     10911218 :   if (fnptrtype)
     434              :     {
     435     10910939 :       gimple_call_set_fntype (call, TREE_TYPE (fnptrtype));
     436              : 
     437              :       /* Check if it's an indirect CALL and the type has the
     438              :          nocf_check attribute. In that case propagate the information
     439              :          to the gimple CALL insn.  */
     440     10910939 :       if (!fndecl)
     441              :         {
     442       164530 :           gcc_assert (POINTER_TYPE_P (fnptrtype));
     443       164530 :           tree fntype = TREE_TYPE (fnptrtype);
     444              : 
     445       164530 :           if (lookup_attribute ("nocf_check", TYPE_ATTRIBUTES (fntype)))
     446           21 :             gimple_call_set_nocf_check (call, true);
     447              :         }
     448              :     }
     449              : 
     450     10911218 :   return call;
     451              : }
     452              : 
     453              : /* Build a gcall to __builtin_unreachable as rewritten by
     454              :    -fsanitize=unreachable.  */
     455              : 
     456              : gcall *
     457       189481 : gimple_build_builtin_unreachable (location_t loc)
     458              : {
     459       189481 :   tree data = NULL_TREE;
     460       189481 :   tree fn = sanitize_unreachable_fn (&data, loc);
     461       189481 :   gcall *g = gimple_build_call (fn, data != NULL_TREE, data);
     462       189481 :   gimple_call_set_ctrl_altering (g, true);
     463       189481 :   gimple_set_location (g, loc);
     464       189481 :   return g;
     465              : }
     466              : 
     467              : /* Build a GIMPLE_ASSIGN statement.
     468              : 
     469              :    LHS of the assignment.
     470              :    RHS of the assignment which can be unary or binary.  */
     471              : 
     472              : gassign *
     473     89446907 : gimple_build_assign (tree lhs, tree rhs MEM_STAT_DECL)
     474              : {
     475     89446907 :   enum tree_code subcode;
     476     89446907 :   tree op1, op2, op3;
     477              : 
     478     89446907 :   extract_ops_from_tree (rhs, &subcode, &op1, &op2, &op3);
     479     89446907 :   return gimple_build_assign (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
     480              : }
     481              : 
     482              : 
     483              : /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
     484              :    OP1, OP2 and OP3.  */
     485              : 
     486              : static inline gassign *
     487     95862216 : gimple_build_assign_1 (tree lhs, enum tree_code subcode, tree op1,
     488              :                        tree op2, tree op3 MEM_STAT_DECL)
     489              : {
     490     95862216 :   unsigned num_ops;
     491     95862216 :   gassign *p;
     492              : 
     493              :   /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
     494              :      code).  */
     495     95862216 :   num_ops = get_gimple_rhs_num_ops (subcode) + 1;
     496              : 
     497    191724432 :   p = as_a <gassign *> (
     498              :         gimple_build_with_ops_stat (GIMPLE_ASSIGN, (unsigned)subcode, num_ops
     499              :                                     PASS_MEM_STAT));
     500     95862216 :   gimple_assign_set_lhs (p, lhs);
     501              :   /* For COND_EXPR, op1 should not be a comparison. */
     502     95862216 :   if (op1 && subcode == COND_EXPR)
     503       221755 :     gcc_assert (!COMPARISON_CLASS_P  (op1));
     504     95862216 :   gimple_assign_set_rhs1 (p, op1);
     505     95862216 :   if (op2)
     506              :     {
     507     15034450 :       gcc_assert (num_ops > 2);
     508     15034450 :       gimple_assign_set_rhs2 (p, op2);
     509              :     }
     510              : 
     511     95862216 :   if (op3)
     512              :     {
     513       337963 :       gcc_assert (num_ops > 3);
     514       337963 :       gimple_assign_set_rhs3 (p, op3);
     515              :     }
     516              : 
     517     95862216 :   return p;
     518              : }
     519              : 
     520              : /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
     521              :    OP1, OP2 and OP3.  */
     522              : 
     523              : gassign *
     524     90804913 : gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
     525              :                      tree op2, tree op3 MEM_STAT_DECL)
     526              : {
     527     90804913 :   return gimple_build_assign_1 (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
     528              : }
     529              : 
     530              : /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
     531              :    OP1 and OP2.  */
     532              : 
     533              : gassign *
     534      3516181 : gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
     535              :                      tree op2 MEM_STAT_DECL)
     536              : {
     537      3516181 :   return gimple_build_assign_1 (lhs, subcode, op1, op2, NULL_TREE
     538      3516181 :                                 PASS_MEM_STAT);
     539              : }
     540              : 
     541              : /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1.  */
     542              : 
     543              : gassign *
     544      1541122 : gimple_build_assign (tree lhs, enum tree_code subcode, tree op1 MEM_STAT_DECL)
     545              : {
     546      1541122 :   return gimple_build_assign_1 (lhs, subcode, op1, NULL_TREE, NULL_TREE
     547      1541122 :                                 PASS_MEM_STAT);
     548              : }
     549              : 
     550              : 
     551              : /* Build a GIMPLE_COND statement.
     552              : 
     553              :    PRED is the condition used to compare LHS and the RHS.
     554              :    T_LABEL is the label to jump to if the condition is true.
     555              :    F_LABEL is the label to jump to otherwise.  */
     556              : 
     557              : gcond *
     558      8800689 : gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs,
     559              :                    tree t_label, tree f_label)
     560              : {
     561      8800689 :   gcond *p;
     562              : 
     563      8800689 :   gcc_assert (TREE_CODE_CLASS (pred_code) == tcc_comparison);
     564     17601378 :   p = as_a <gcond *> (gimple_build_with_ops (GIMPLE_COND, pred_code, 4));
     565      8800689 :   gimple_cond_set_lhs (p, lhs);
     566      8800689 :   gimple_cond_set_rhs (p, rhs);
     567      8800689 :   gimple_cond_set_true_label (p, t_label);
     568      8800689 :   gimple_cond_set_false_label (p, f_label);
     569      8800689 :   return p;
     570              : }
     571              : 
     572              : /* Build a GIMPLE_COND statement from the conditional expression tree
     573              :    COND.  T_LABEL and F_LABEL are as in gimple_build_cond.  */
     574              : 
     575              : gcond *
     576       100644 : gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
     577              : {
     578       100644 :   enum tree_code code;
     579       100644 :   tree lhs, rhs;
     580              : 
     581       100644 :   gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
     582       100644 :   return gimple_build_cond (code, lhs, rhs, t_label, f_label);
     583              : }
     584              : 
     585              : /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
     586              :    boolean expression tree COND.  */
     587              : 
     588              : void
     589       410519 : gimple_cond_set_condition_from_tree (gcond *stmt, tree cond)
     590              : {
     591       410519 :   enum tree_code code;
     592       410519 :   tree lhs, rhs;
     593              : 
     594       410519 :   gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
     595       410519 :   gimple_cond_set_condition (stmt, code, lhs, rhs);
     596       410519 : }
     597              : 
     598              : /* Build a GIMPLE_LABEL statement for LABEL.  */
     599              : 
     600              : glabel *
     601     19680464 : gimple_build_label (tree label)
     602              : {
     603     19680464 :   glabel *p
     604     19680464 :     = as_a <glabel *> (gimple_build_with_ops (GIMPLE_LABEL, ERROR_MARK, 1));
     605     19680464 :   gimple_label_set_label (p, label);
     606     19680464 :   return p;
     607              : }
     608              : 
     609              : /* Build a GIMPLE_GOTO statement to label DEST.  */
     610              : 
     611              : ggoto *
     612      7198160 : gimple_build_goto (tree dest)
     613              : {
     614      7198160 :   ggoto *p
     615      7198160 :     = as_a <ggoto *> (gimple_build_with_ops (GIMPLE_GOTO, ERROR_MARK, 1));
     616      7198160 :   gimple_goto_set_dest (p, dest);
     617      7198160 :   return p;
     618              : }
     619              : 
     620              : 
     621              : /* Build a GIMPLE_NOP statement.  */
     622              : 
     623              : gimple *
     624     15823758 : gimple_build_nop (void)
     625              : {
     626     15823758 :   return gimple_alloc (GIMPLE_NOP, 0);
     627              : }
     628              : 
     629              : 
     630              : /* Build a GIMPLE_BIND statement.
     631              :    VARS are the variables in BODY.
     632              :    BLOCK is the containing block.  */
     633              : 
     634              : gbind *
     635      7558114 : gimple_build_bind (tree vars, gimple_seq body, tree block)
     636              : {
     637      7558114 :   gbind *p = as_a <gbind *> (gimple_alloc (GIMPLE_BIND, 0));
     638      7558114 :   gimple_bind_set_vars (p, vars);
     639      7558114 :   if (body)
     640      1341934 :     gimple_bind_set_body (p, body);
     641      7558114 :   if (block)
     642      6069429 :     gimple_bind_set_block (p, block);
     643      7558114 :   return p;
     644              : }
     645              : 
     646              : /* Helper function to set the simple fields of a asm stmt.
     647              : 
     648              :    STRING is a pointer to a string that is the asm blocks assembly code.
     649              :    NINPUT is the number of register inputs.
     650              :    NOUTPUT is the number of register outputs.
     651              :    NCLOBBERS is the number of clobbered registers.
     652              :    */
     653              : 
     654              : static inline gasm *
     655        88041 : gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
     656              :                     unsigned nclobbers, unsigned nlabels)
     657              : {
     658        88041 :   gasm *p;
     659        88041 :   int size = strlen (string);
     660              : 
     661        88041 :   p = as_a <gasm *> (
     662        88041 :         gimple_build_with_ops (GIMPLE_ASM, ERROR_MARK,
     663              :                                ninputs + noutputs + nclobbers + nlabels));
     664              : 
     665        88041 :   p->ni = ninputs;
     666        88041 :   p->no = noutputs;
     667        88041 :   p->nc = nclobbers;
     668        88041 :   p->nl = nlabels;
     669        88041 :   p->string = ggc_alloc_string (string, size);
     670              : 
     671        88041 :   if (GATHER_STATISTICS)
     672              :     gimple_alloc_sizes[(int) gimple_alloc_kind (GIMPLE_ASM)] += size;
     673              : 
     674        88041 :   return p;
     675              : }
     676              : 
     677              : /* Build a GIMPLE_ASM statement.
     678              : 
     679              :    STRING is the assembly code.
     680              :    NINPUT is the number of register inputs.
     681              :    NOUTPUT is the number of register outputs.
     682              :    NCLOBBERS is the number of clobbered registers.
     683              :    INPUTS is a vector of the input register parameters.
     684              :    OUTPUTS is a vector of the output register parameters.
     685              :    CLOBBERS is a vector of the clobbered register parameters.
     686              :    LABELS is a vector of destination labels.  */
     687              : 
     688              : gasm *
     689        88041 : gimple_build_asm_vec (const char *string, vec<tree, va_gc> *inputs,
     690              :                       vec<tree, va_gc> *outputs, vec<tree, va_gc> *clobbers,
     691              :                       vec<tree, va_gc> *labels)
     692              : {
     693        88041 :   gasm *p;
     694        88041 :   unsigned i;
     695              : 
     696       172501 :   p = gimple_build_asm_1 (string,
     697              :                           vec_safe_length (inputs),
     698              :                           vec_safe_length (outputs),
     699              :                           vec_safe_length (clobbers),
     700              :                           vec_safe_length (labels));
     701              : 
     702       304272 :   for (i = 0; i < vec_safe_length (inputs); i++)
     703        47284 :     gimple_asm_set_input_op (p, i, (*inputs)[i]);
     704              : 
     705       251172 :   for (i = 0; i < vec_safe_length (outputs); i++)
     706        66237 :     gimple_asm_set_output_op (p, i, (*outputs)[i]);
     707              : 
     708       302786 :   for (i = 0; i < vec_safe_length (clobbers); i++)
     709        80780 :     gimple_asm_set_clobber_op (p, i, (*clobbers)[i]);
     710              : 
     711        88998 :   for (i = 0; i < vec_safe_length (labels); i++)
     712          957 :     gimple_asm_set_label_op (p, i, (*labels)[i]);
     713              : 
     714        88041 :   return p;
     715              : }
     716              : 
     717              : /* Build a GIMPLE_CATCH statement.
     718              : 
     719              :   TYPES are the catch types.
     720              :   HANDLER is the exception handler.  */
     721              : 
     722              : gcatch *
     723        43030 : gimple_build_catch (tree types, gimple_seq handler)
     724              : {
     725        43030 :   gcatch *p = as_a <gcatch *> (gimple_alloc (GIMPLE_CATCH, 0));
     726        43030 :   gimple_catch_set_types (p, types);
     727        43030 :   if (handler)
     728        43018 :     gimple_catch_set_handler (p, handler);
     729              : 
     730        43030 :   return p;
     731              : }
     732              : 
     733              : /* Build a GIMPLE_EH_FILTER statement.
     734              : 
     735              :    TYPES are the filter's types.
     736              :    FAILURE is the filter's failure action.  */
     737              : 
     738              : geh_filter *
     739         4491 : gimple_build_eh_filter (tree types, gimple_seq failure)
     740              : {
     741         4491 :   geh_filter *p = as_a <geh_filter *> (gimple_alloc (GIMPLE_EH_FILTER, 0));
     742         4491 :   gimple_eh_filter_set_types (p, types);
     743         4491 :   if (failure)
     744         4491 :     gimple_eh_filter_set_failure (p, failure);
     745              : 
     746         4491 :   return p;
     747              : }
     748              : 
     749              : /* Build a GIMPLE_EH_MUST_NOT_THROW statement.  */
     750              : 
     751              : geh_mnt *
     752      1340033 : gimple_build_eh_must_not_throw (tree decl)
     753              : {
     754      1340033 :   geh_mnt *p = as_a <geh_mnt *> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW, 0));
     755              : 
     756      1340033 :   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
     757      1340033 :   gcc_assert (flags_from_decl_or_type (decl) & ECF_NORETURN);
     758      1340033 :   gimple_eh_must_not_throw_set_fndecl (p, decl);
     759              : 
     760      1340033 :   return p;
     761              : }
     762              : 
     763              : /* Build a GIMPLE_EH_ELSE statement.  */
     764              : 
     765              : geh_else *
     766          554 : gimple_build_eh_else (gimple_seq n_body, gimple_seq e_body)
     767              : {
     768          554 :   geh_else *p = as_a <geh_else *> (gimple_alloc (GIMPLE_EH_ELSE, 0));
     769          554 :   gimple_eh_else_set_n_body (p, n_body);
     770          554 :   gimple_eh_else_set_e_body (p, e_body);
     771          554 :   return p;
     772              : }
     773              : 
     774              : /* Build a GIMPLE_TRY statement.
     775              : 
     776              :    EVAL is the expression to evaluate.
     777              :    CLEANUP is the cleanup expression.
     778              :    KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
     779              :    whether this is a try/catch or a try/finally respectively.  */
     780              : 
     781              : gtry *
     782      3272592 : gimple_build_try (gimple_seq eval, gimple_seq cleanup,
     783              :                   enum gimple_try_flags kind)
     784              : {
     785      3272592 :   gtry *p;
     786              : 
     787      3272592 :   gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
     788      3272592 :   p = as_a <gtry *> (gimple_alloc (GIMPLE_TRY, 0));
     789      3272592 :   gimple_set_subcode (p, kind);
     790      3272592 :   if (eval)
     791      3179566 :     gimple_try_set_eval (p, eval);
     792      3272592 :   if (cleanup)
     793      3272592 :     gimple_try_set_cleanup (p, cleanup);
     794              : 
     795      3272592 :   return p;
     796              : }
     797              : 
     798              : /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
     799              : 
     800              :    CLEANUP is the cleanup expression.  */
     801              : 
     802              : gimple *
     803       650491 : gimple_build_wce (gimple_seq cleanup)
     804              : {
     805       650491 :   gimple *p = gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR, 0);
     806       650491 :   if (cleanup)
     807       650491 :     gimple_wce_set_cleanup (p, cleanup);
     808              : 
     809       650491 :   return p;
     810              : }
     811              : 
     812              : 
     813              : /* Build a GIMPLE_RESX statement.  */
     814              : 
     815              : gresx *
     816       947013 : gimple_build_resx (int region)
     817              : {
     818       947013 :   gresx *p
     819       947013 :     = as_a <gresx *> (gimple_build_with_ops (GIMPLE_RESX, ERROR_MARK, 0));
     820       947013 :   p->region = region;
     821       947013 :   return p;
     822              : }
     823              : 
     824              : 
     825              : /* The helper for constructing a gimple switch statement.
     826              :    INDEX is the switch's index.
     827              :    NLABELS is the number of labels in the switch excluding the default.
     828              :    DEFAULT_LABEL is the default label for the switch statement.  */
     829              : 
     830              : gswitch *
     831        70062 : gimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)
     832              : {
     833              :   /* nlabels + 1 default label + 1 index.  */
     834        70062 :   gcc_checking_assert (default_label);
     835       140124 :   gswitch *p = as_a <gswitch *> (gimple_build_with_ops (GIMPLE_SWITCH,
     836              :                                                         ERROR_MARK,
     837              :                                                         1 + 1 + nlabels));
     838        70062 :   gimple_switch_set_index (p, index);
     839        70062 :   gimple_switch_set_default_label (p, default_label);
     840        70062 :   return p;
     841              : }
     842              : 
     843              : /* Build a GIMPLE_SWITCH statement.
     844              : 
     845              :    INDEX is the switch's index.
     846              :    DEFAULT_LABEL is the default label
     847              :    ARGS is a vector of labels excluding the default.  */
     848              : 
     849              : gswitch *
     850        70062 : gimple_build_switch (tree index, tree default_label, const vec<tree> &args)
     851              : {
     852        70062 :   unsigned i, nlabels = args.length ();
     853              : 
     854        70062 :   gswitch *p = gimple_build_switch_nlabels (nlabels, index, default_label);
     855              : 
     856              :   /* Copy the labels from the vector to the switch statement.  */
     857      1248770 :   for (i = 0; i < nlabels; i++)
     858      1108646 :     gimple_switch_set_label (p, i + 1, args[i]);
     859              : 
     860        70062 :   return p;
     861              : }
     862              : 
     863              : /* Build a GIMPLE_EH_DISPATCH statement.  */
     864              : 
     865              : geh_dispatch *
     866        44493 : gimple_build_eh_dispatch (int region)
     867              : {
     868        44493 :   geh_dispatch *p
     869        44493 :     = as_a <geh_dispatch *> (
     870              :         gimple_build_with_ops (GIMPLE_EH_DISPATCH, ERROR_MARK, 0));
     871        44493 :   p->region = region;
     872        44493 :   return p;
     873              : }
     874              : 
     875              : /* Build a new GIMPLE_DEBUG_BIND statement.
     876              : 
     877              :    VAR is bound to VALUE; block and location are taken from STMT.  */
     878              : 
     879              : gdebug *
     880     69246040 : gimple_build_debug_bind (tree var, tree value, gimple *stmt MEM_STAT_DECL)
     881              : {
     882     69246040 :   gdebug *p
     883     69246040 :     = as_a <gdebug *> (gimple_build_with_ops_stat (GIMPLE_DEBUG,
     884              :                                                    (unsigned)GIMPLE_DEBUG_BIND, 2
     885              :                                                    PASS_MEM_STAT));
     886     69246040 :   gimple_debug_bind_set_var (p, var);
     887     69246040 :   gimple_debug_bind_set_value (p, value);
     888     69246040 :   if (stmt)
     889     68250309 :     gimple_set_location (p, gimple_location (stmt));
     890              : 
     891     69246040 :   return p;
     892              : }
     893              : 
     894              : 
     895              : /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
     896              : 
     897              :    VAR is bound to VALUE; block and location are taken from STMT.  */
     898              : 
     899              : gdebug *
     900       710934 : gimple_build_debug_source_bind (tree var, tree value,
     901              :                                      gimple *stmt MEM_STAT_DECL)
     902              : {
     903       710934 :   gdebug *p
     904       710934 :     = as_a <gdebug *> (
     905              :         gimple_build_with_ops_stat (GIMPLE_DEBUG,
     906              :                                     (unsigned)GIMPLE_DEBUG_SOURCE_BIND, 2
     907              :                                     PASS_MEM_STAT));
     908              : 
     909       710934 :   gimple_debug_source_bind_set_var (p, var);
     910       710934 :   gimple_debug_source_bind_set_value (p, value);
     911       710934 :   if (stmt)
     912       563968 :     gimple_set_location (p, gimple_location (stmt));
     913              : 
     914       710934 :   return p;
     915              : }
     916              : 
     917              : 
     918              : /* Build a new GIMPLE_DEBUG_BEGIN_STMT statement in BLOCK at
     919              :    LOCATION.  */
     920              : 
     921              : gdebug *
     922      2486415 : gimple_build_debug_begin_stmt (tree block, location_t location
     923              :                                     MEM_STAT_DECL)
     924              : {
     925      2486415 :   gdebug *p
     926      2486415 :     = as_a <gdebug *> (
     927              :         gimple_build_with_ops_stat (GIMPLE_DEBUG,
     928              :                                     (unsigned)GIMPLE_DEBUG_BEGIN_STMT, 0
     929              :                                     PASS_MEM_STAT));
     930              : 
     931      2486415 :   gimple_set_location (p, location);
     932      2486415 :   gimple_set_block (p, block);
     933      2486415 :   cfun->debug_marker_count++;
     934              : 
     935      2486415 :   return p;
     936              : }
     937              : 
     938              : 
     939              : /* Build a new GIMPLE_DEBUG_INLINE_ENTRY statement in BLOCK at
     940              :    LOCATION.  The BLOCK links to the inlined function.  */
     941              : 
     942              : gdebug *
     943      4078064 : gimple_build_debug_inline_entry (tree block, location_t location
     944              :                                       MEM_STAT_DECL)
     945              : {
     946      4078064 :   gdebug *p
     947      4078064 :     = as_a <gdebug *> (
     948              :         gimple_build_with_ops_stat (GIMPLE_DEBUG,
     949              :                                     (unsigned)GIMPLE_DEBUG_INLINE_ENTRY, 0
     950              :                                     PASS_MEM_STAT));
     951              : 
     952      4078064 :   gimple_set_location (p, location);
     953      4078064 :   gimple_set_block (p, block);
     954      4078064 :   cfun->debug_marker_count++;
     955              : 
     956      4078064 :   return p;
     957              : }
     958              : 
     959              : 
     960              : /* Build a GIMPLE_OMP_CRITICAL statement.
     961              : 
     962              :    BODY is the sequence of statements for which only one thread can execute.
     963              :    NAME is optional identifier for this critical block.
     964              :    CLAUSES are clauses for this critical block.  */
     965              : 
     966              : gomp_critical *
     967          552 : gimple_build_omp_critical (gimple_seq body, tree name, tree clauses)
     968              : {
     969          552 :   gomp_critical *p
     970          552 :     = as_a <gomp_critical *> (gimple_alloc (GIMPLE_OMP_CRITICAL, 0));
     971          552 :   gimple_omp_critical_set_name (p, name);
     972          552 :   gimple_omp_critical_set_clauses (p, clauses);
     973          552 :   if (body)
     974          457 :     gimple_omp_set_body (p, body);
     975              : 
     976          552 :   return p;
     977              : }
     978              : 
     979              : /* Build a GIMPLE_OMP_FOR statement.
     980              : 
     981              :    BODY is sequence of statements inside the for loop.
     982              :    KIND is the `for' variant.
     983              :    CLAUSES are any of the construct's clauses.
     984              :    COLLAPSE is the collapse count.
     985              :    PRE_BODY is the sequence of statements that are loop invariant.  */
     986              : 
     987              : gomp_for *
     988        53696 : gimple_build_omp_for (gimple_seq body, int kind, tree clauses, size_t collapse,
     989              :                       gimple_seq pre_body)
     990              : {
     991        53696 :   gomp_for *p = as_a <gomp_for *> (gimple_alloc (GIMPLE_OMP_FOR, 0));
     992        53696 :   if (body)
     993        49844 :     gimple_omp_set_body (p, body);
     994        53696 :   gimple_omp_for_set_clauses (p, clauses);
     995        53696 :   gimple_omp_for_set_kind (p, kind);
     996        53696 :   p->collapse = collapse;
     997        53696 :   p->iter =  ggc_cleared_vec_alloc<gimple_omp_for_iter> (collapse);
     998              : 
     999        53696 :   if (pre_body)
    1000         3583 :     gimple_omp_for_set_pre_body (p, pre_body);
    1001              : 
    1002        53696 :   return p;
    1003              : }
    1004              : 
    1005              : 
    1006              : /* Build a GIMPLE_OMP_PARALLEL statement.
    1007              : 
    1008              :    BODY is sequence of statements which are executed in parallel.
    1009              :    CLAUSES are the OMP parallel construct's clauses.
    1010              :    CHILD_FN is the function created for the parallel threads to execute.
    1011              :    DATA_ARG are the shared data argument(s).  */
    1012              : 
    1013              : gomp_parallel *
    1014        18657 : gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
    1015              :                            tree data_arg)
    1016              : {
    1017        18657 :   gomp_parallel *p
    1018        18657 :     = as_a <gomp_parallel *> (gimple_alloc (GIMPLE_OMP_PARALLEL, 0));
    1019        18657 :   if (body)
    1020        18464 :     gimple_omp_set_body (p, body);
    1021        18657 :   gimple_omp_parallel_set_clauses (p, clauses);
    1022        18657 :   gimple_omp_parallel_set_child_fn (p, child_fn);
    1023        18657 :   gimple_omp_parallel_set_data_arg (p, data_arg);
    1024              : 
    1025        18657 :   return p;
    1026              : }
    1027              : 
    1028              : 
    1029              : /* Build a GIMPLE_OMP_TASK statement.
    1030              : 
    1031              :    BODY is sequence of statements which are executed by the explicit task.
    1032              :    CLAUSES are the OMP task construct's clauses.
    1033              :    CHILD_FN is the function created for the parallel threads to execute.
    1034              :    DATA_ARG are the shared data argument(s).
    1035              :    COPY_FN is the optional function for firstprivate initialization.
    1036              :    ARG_SIZE and ARG_ALIGN are size and alignment of the data block.  */
    1037              : 
    1038              : gomp_task *
    1039         5713 : gimple_build_omp_task (gimple_seq body, tree clauses, tree child_fn,
    1040              :                        tree data_arg, tree copy_fn, tree arg_size,
    1041              :                        tree arg_align)
    1042              : {
    1043         5713 :   gomp_task *p = as_a <gomp_task *> (gimple_alloc (GIMPLE_OMP_TASK, 0));
    1044         5713 :   if (body)
    1045         5620 :     gimple_omp_set_body (p, body);
    1046         5713 :   gimple_omp_task_set_clauses (p, clauses);
    1047         5713 :   gimple_omp_task_set_child_fn (p, child_fn);
    1048         5713 :   gimple_omp_task_set_data_arg (p, data_arg);
    1049         5713 :   gimple_omp_task_set_copy_fn (p, copy_fn);
    1050         5713 :   gimple_omp_task_set_arg_size (p, arg_size);
    1051         5713 :   gimple_omp_task_set_arg_align (p, arg_align);
    1052              : 
    1053         5713 :   return p;
    1054              : }
    1055              : 
    1056              : 
    1057              : /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
    1058              : 
    1059              :    BODY is the sequence of statements in the section.  */
    1060              : 
    1061              : gimple *
    1062         1279 : gimple_build_omp_section (gimple_seq body)
    1063              : {
    1064         1279 :   gimple *p = gimple_alloc (GIMPLE_OMP_SECTION, 0);
    1065         1279 :   if (body)
    1066         1087 :     gimple_omp_set_body (p, body);
    1067              : 
    1068         1279 :   return p;
    1069              : }
    1070              : 
    1071              : 
    1072              : /* Build a GIMPLE_OMP_STRUCTURED_BLOCK statement.
    1073              : 
    1074              :    BODY is the structured block sequence.  */
    1075              : 
    1076              : gimple *
    1077          791 : gimple_build_omp_structured_block (gimple_seq body)
    1078              : {
    1079          791 :   gimple *p = gimple_alloc (GIMPLE_OMP_STRUCTURED_BLOCK, 0);
    1080          791 :   if (body)
    1081          791 :     gimple_omp_set_body (p, body);
    1082              : 
    1083          791 :   return p;
    1084              : }
    1085              : 
    1086              : 
    1087              : /* Build a GIMPLE_OMP_MASTER statement.
    1088              : 
    1089              :    BODY is the sequence of statements to be executed by just the master.  */
    1090              : 
    1091              : gimple *
    1092          874 : gimple_build_omp_master (gimple_seq body)
    1093              : {
    1094          874 :   gimple *p = gimple_alloc (GIMPLE_OMP_MASTER, 0);
    1095          874 :   if (body)
    1096          793 :     gimple_omp_set_body (p, body);
    1097              : 
    1098          874 :   return p;
    1099              : }
    1100              : 
    1101              : /* Build a GIMPLE_OMP_MASKED statement.
    1102              : 
    1103              :    BODY is the sequence of statements to be executed by the selected thread(s).  */
    1104              : 
    1105              : gimple *
    1106          500 : gimple_build_omp_masked (gimple_seq body, tree clauses)
    1107              : {
    1108          500 :   gimple *p = gimple_alloc (GIMPLE_OMP_MASKED, 0);
    1109          500 :   gimple_omp_masked_set_clauses (p, clauses);
    1110          500 :   if (body)
    1111          420 :     gimple_omp_set_body (p, body);
    1112              : 
    1113          500 :   return p;
    1114              : }
    1115              : 
    1116              : /* Build a GIMPLE_OMP_TASKGROUP statement.
    1117              : 
    1118              :    BODY is the sequence of statements to be executed by the taskgroup
    1119              :    construct.
    1120              :    CLAUSES are any of the construct's clauses.  */
    1121              : 
    1122              : gimple *
    1123          611 : gimple_build_omp_taskgroup (gimple_seq body, tree clauses)
    1124              : {
    1125          611 :   gimple *p = gimple_alloc (GIMPLE_OMP_TASKGROUP, 0);
    1126          611 :   gimple_omp_taskgroup_set_clauses (p, clauses);
    1127          611 :   if (body)
    1128          611 :     gimple_omp_set_body (p, body);
    1129              : 
    1130          611 :   return p;
    1131              : }
    1132              : 
    1133              : 
    1134              : /* Build a GIMPLE_OMP_CONTINUE statement.
    1135              : 
    1136              :    CONTROL_DEF is the definition of the control variable.
    1137              :    CONTROL_USE is the use of the control variable.  */
    1138              : 
    1139              : gomp_continue *
    1140        52123 : gimple_build_omp_continue (tree control_def, tree control_use)
    1141              : {
    1142        52123 :   gomp_continue *p
    1143        52123 :     = as_a <gomp_continue *> (gimple_alloc (GIMPLE_OMP_CONTINUE, 0));
    1144        52123 :   gimple_omp_continue_set_control_def (p, control_def);
    1145        52123 :   gimple_omp_continue_set_control_use (p, control_use);
    1146        52123 :   return p;
    1147              : }
    1148              : 
    1149              : /* Build a GIMPLE_OMP_ORDERED statement.
    1150              : 
    1151              :    BODY is the sequence of statements inside a loop that will executed in
    1152              :    sequence.
    1153              :    CLAUSES are clauses for this statement.  */
    1154              : 
    1155              : gomp_ordered *
    1156         1852 : gimple_build_omp_ordered (gimple_seq body, tree clauses)
    1157              : {
    1158         1852 :   gomp_ordered *p
    1159         1852 :     = as_a <gomp_ordered *> (gimple_alloc (GIMPLE_OMP_ORDERED, 0));
    1160         1852 :   gimple_omp_ordered_set_clauses (p, clauses);
    1161         1852 :   if (body)
    1162          501 :     gimple_omp_set_body (p, body);
    1163              : 
    1164         1852 :   return p;
    1165              : }
    1166              : 
    1167              : 
    1168              : /* Build a GIMPLE_OMP_RETURN statement.
    1169              :    WAIT_P is true if this is a non-waiting return.  */
    1170              : 
    1171              : gimple *
    1172       102438 : gimple_build_omp_return (bool wait_p)
    1173              : {
    1174       102438 :   gimple *p = gimple_alloc (GIMPLE_OMP_RETURN, 0);
    1175       102438 :   if (wait_p)
    1176        37894 :     gimple_omp_return_set_nowait (p);
    1177              : 
    1178       102438 :   return p;
    1179              : }
    1180              : 
    1181              : 
    1182              : /* Build a GIMPLE_OMP_SCAN statement.
    1183              : 
    1184              :    BODY is the sequence of statements to be executed by the scan
    1185              :    construct.
    1186              :    CLAUSES are any of the construct's clauses.  */
    1187              : 
    1188              : gomp_scan *
    1189         1324 : gimple_build_omp_scan (gimple_seq body, tree clauses)
    1190              : {
    1191         1324 :   gomp_scan *p
    1192         1324 :     = as_a <gomp_scan *> (gimple_alloc (GIMPLE_OMP_SCAN, 0));
    1193         1324 :   gimple_omp_scan_set_clauses (p, clauses);
    1194         1324 :   if (body)
    1195         1094 :     gimple_omp_set_body (p, body);
    1196              : 
    1197         1324 :   return p;
    1198              : }
    1199              : 
    1200              : 
    1201              : /* Build a GIMPLE_OMP_SECTIONS statement.
    1202              : 
    1203              :    BODY is a sequence of section statements.
    1204              :    CLAUSES are any of the OMP sections contsruct's clauses: private,
    1205              :    firstprivate, lastprivate, reduction, and nowait.  */
    1206              : 
    1207              : gomp_sections *
    1208          634 : gimple_build_omp_sections (gimple_seq body, tree clauses)
    1209              : {
    1210          634 :   gomp_sections *p
    1211          634 :     = as_a <gomp_sections *> (gimple_alloc (GIMPLE_OMP_SECTIONS, 0));
    1212          634 :   if (body)
    1213          634 :     gimple_omp_set_body (p, body);
    1214          634 :   gimple_omp_sections_set_clauses (p, clauses);
    1215              : 
    1216          634 :   return p;
    1217              : }
    1218              : 
    1219              : 
    1220              : /* Build a GIMPLE_OMP_SECTIONS_SWITCH.  */
    1221              : 
    1222              : gimple *
    1223          386 : gimple_build_omp_sections_switch (void)
    1224              : {
    1225          386 :   return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH, 0);
    1226              : }
    1227              : 
    1228              : 
    1229              : /* Build a GIMPLE_OMP_SINGLE statement.
    1230              : 
    1231              :    BODY is the sequence of statements that will be executed once.
    1232              :    CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
    1233              :    copyprivate, nowait.  */
    1234              : 
    1235              : gomp_single *
    1236         1299 : gimple_build_omp_single (gimple_seq body, tree clauses)
    1237              : {
    1238         1299 :   gomp_single *p
    1239         1299 :     = as_a <gomp_single *> (gimple_alloc (GIMPLE_OMP_SINGLE, 0));
    1240         1299 :   if (body)
    1241         1186 :     gimple_omp_set_body (p, body);
    1242         1299 :   gimple_omp_single_set_clauses (p, clauses);
    1243              : 
    1244         1299 :   return p;
    1245              : }
    1246              : 
    1247              : 
    1248              : /* Build a GIMPLE_OMP_SCOPE statement.
    1249              : 
    1250              :    BODY is the sequence of statements that will be executed once.
    1251              :    CLAUSES are any of the OMP scope construct's clauses: private, reduction,
    1252              :    nowait.  */
    1253              : 
    1254              : gimple *
    1255          242 : gimple_build_omp_scope (gimple_seq body, tree clauses)
    1256              : {
    1257          242 :   gimple *p = gimple_alloc (GIMPLE_OMP_SCOPE, 0);
    1258          242 :   gimple_omp_scope_set_clauses (p, clauses);
    1259          242 :   if (body)
    1260          168 :     gimple_omp_set_body (p, body);
    1261              : 
    1262          242 :   return p;
    1263              : }
    1264              : 
    1265              : /* Build a GIMPLE_OMP_DISPATCH statement.
    1266              : 
    1267              :    BODY is the target function call to be dispatched.
    1268              :    CLAUSES are any of the OMP dispatch construct's clauses.  */
    1269              : 
    1270              : gimple *
    1271          852 : gimple_build_omp_dispatch (gimple_seq body, tree clauses)
    1272              : {
    1273          852 :   gimple *p = gimple_alloc (GIMPLE_OMP_DISPATCH, 0);
    1274          852 :   gimple_omp_dispatch_set_clauses (p, clauses);
    1275          852 :   if (body)
    1276          852 :     gimple_omp_set_body (p, body);
    1277              : 
    1278          852 :   return p;
    1279              : }
    1280              : 
    1281              : /* Build a GIMPLE_OMP_INTEROP statement.
    1282              : 
    1283              :    CLAUSES are any of the OMP interop construct's clauses.  */
    1284              : 
    1285              : gimple *
    1286          612 : gimple_build_omp_interop (tree clauses)
    1287              : {
    1288          612 :   gimple *p = gimple_alloc (GIMPLE_OMP_INTEROP, 0);
    1289          612 :   gimple_omp_interop_set_clauses (p, clauses);
    1290              : 
    1291          612 :   return p;
    1292              : }
    1293              : 
    1294              : /* Build a GIMPLE_OMP_TARGET statement.
    1295              : 
    1296              :    BODY is the sequence of statements that will be executed.
    1297              :    KIND is the kind of the region.
    1298              :    CLAUSES are any of the construct's clauses.
    1299              :    ITERATOR_LOOPS is an optional sequence containing constructed loops
    1300              :    for OpenMP iterators.  */
    1301              : 
    1302              : gomp_target *
    1303        43265 : gimple_build_omp_target (gimple_seq body, int kind, tree clauses,
    1304              :                          gimple_seq iterator_loops)
    1305              : {
    1306        43265 :   gomp_target *p
    1307        43265 :     = as_a <gomp_target *> (gimple_alloc (GIMPLE_OMP_TARGET, 0));
    1308        43265 :   if (body)
    1309        29450 :     gimple_omp_set_body (p, body);
    1310        43265 :   gimple_omp_target_set_clauses (p, clauses);
    1311        43265 :   gimple_omp_target_set_kind (p, kind);
    1312        43265 :   gimple_omp_target_set_iterator_loops (p, iterator_loops);
    1313              : 
    1314        43265 :   return p;
    1315              : }
    1316              : 
    1317              : 
    1318              : /* Build a GIMPLE_OMP_TEAMS statement.
    1319              : 
    1320              :    BODY is the sequence of statements that will be executed.
    1321              :    CLAUSES are any of the OMP teams construct's clauses.  */
    1322              : 
    1323              : gomp_teams *
    1324         8935 : gimple_build_omp_teams (gimple_seq body, tree clauses)
    1325              : {
    1326         8935 :   gomp_teams *p = as_a <gomp_teams *> (gimple_alloc (GIMPLE_OMP_TEAMS, 0));
    1327         8935 :   if (body)
    1328         8935 :     gimple_omp_set_body (p, body);
    1329         8935 :   gimple_omp_teams_set_clauses (p, clauses);
    1330              : 
    1331         8935 :   return p;
    1332              : }
    1333              : 
    1334              : 
    1335              : /* Build a GIMPLE_OMP_ATOMIC_LOAD statement.  */
    1336              : 
    1337              : gomp_atomic_load *
    1338        10397 : gimple_build_omp_atomic_load (tree lhs, tree rhs, enum omp_memory_order mo)
    1339              : {
    1340        10397 :   gomp_atomic_load *p
    1341        10397 :     = as_a <gomp_atomic_load *> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD, 0));
    1342        10397 :   gimple_omp_atomic_load_set_lhs (p, lhs);
    1343        10397 :   gimple_omp_atomic_load_set_rhs (p, rhs);
    1344        10397 :   gimple_omp_atomic_set_memory_order (p, mo);
    1345        10397 :   return p;
    1346              : }
    1347              : 
    1348              : /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
    1349              : 
    1350              :    VAL is the value we are storing.  */
    1351              : 
    1352              : gomp_atomic_store *
    1353        10397 : gimple_build_omp_atomic_store (tree val, enum omp_memory_order mo)
    1354              : {
    1355        10397 :   gomp_atomic_store *p
    1356        10397 :     = as_a <gomp_atomic_store *> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE, 0));
    1357        10397 :   gimple_omp_atomic_store_set_val (p, val);
    1358        10397 :   gimple_omp_atomic_set_memory_order (p, mo);
    1359        10397 :   return p;
    1360              : }
    1361              : 
    1362              : /* Build a GIMPLE_ASSUME statement.  */
    1363              : 
    1364              : gimple *
    1365          168 : gimple_build_assume (tree guard, gimple_seq body)
    1366              : {
    1367          168 :   gimple_statement_assume *p
    1368          168 :     = as_a <gimple_statement_assume *> (gimple_alloc (GIMPLE_ASSUME, 0));
    1369          168 :   gimple_assume_set_guard (p, guard);
    1370          168 :   *gimple_assume_body_ptr (p) = body;
    1371          168 :   return p;
    1372              : }
    1373              : 
    1374              : /* Build a GIMPLE_TRANSACTION statement.  */
    1375              : 
    1376              : gtransaction *
    1377          545 : gimple_build_transaction (gimple_seq body)
    1378              : {
    1379          545 :   gtransaction *p
    1380          545 :     = as_a <gtransaction *> (gimple_alloc (GIMPLE_TRANSACTION, 0));
    1381          545 :   gimple_transaction_set_body (p, body);
    1382          545 :   gimple_transaction_set_label_norm (p, 0);
    1383          545 :   gimple_transaction_set_label_uninst (p, 0);
    1384          545 :   gimple_transaction_set_label_over (p, 0);
    1385          545 :   return p;
    1386              : }
    1387              : 
    1388              : #if defined ENABLE_GIMPLE_CHECKING
    1389              : /* Complain of a gimple type mismatch and die.  */
    1390              : 
    1391              : void
    1392            0 : gimple_check_failed (const gimple *gs, const char *file, int line,
    1393              :                      const char *function, enum gimple_code code,
    1394              :                      enum tree_code subcode)
    1395              : {
    1396            0 :   internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
    1397            0 :                   gimple_code_name[code],
    1398              :                   get_tree_code_name (subcode),
    1399            0 :                   gimple_code_name[gimple_code (gs)],
    1400            0 :                   gs->subcode > 0
    1401            0 :                     ? get_tree_code_name ((enum tree_code) gs->subcode)
    1402              :                     : "",
    1403              :                   function, trim_filename (file), line);
    1404              : }
    1405              : #endif /* ENABLE_GIMPLE_CHECKING */
    1406              : 
    1407              : 
    1408              : /* Link gimple statement GS to the end of the sequence *SEQ_P.  If
    1409              :    *SEQ_P is NULL, a new sequence is allocated.  */
    1410              : 
    1411              : void
    1412     47704885 : gimple_seq_add_stmt (gimple_seq *seq_p, gimple *gs)
    1413              : {
    1414     47704885 :   gimple_stmt_iterator si;
    1415     47704885 :   if (gs == NULL)
    1416            0 :     return;
    1417              : 
    1418     47704885 :   si = gsi_last (*seq_p);
    1419     47704885 :   gsi_insert_after (&si, gs, GSI_NEW_STMT);
    1420              : }
    1421              : 
    1422              : /* Link gimple statement GS to the end of the sequence *SEQ_P.  If
    1423              :    *SEQ_P is NULL, a new sequence is allocated.  This function is
    1424              :    similar to gimple_seq_add_stmt, but does not scan the operands.
    1425              :    During gimplification, we need to manipulate statement sequences
    1426              :    before the def/use vectors have been constructed.  */
    1427              : 
    1428              : void
    1429    196737090 : gimple_seq_add_stmt_without_update (gimple_seq *seq_p, gimple *gs)
    1430              : {
    1431    196737090 :   gimple_stmt_iterator si;
    1432              : 
    1433    196737090 :   if (gs == NULL)
    1434            0 :     return;
    1435              : 
    1436    196737090 :   si = gsi_last (*seq_p);
    1437    196737090 :   gsi_insert_after_without_update (&si, gs, GSI_NEW_STMT);
    1438              : }
    1439              : 
    1440              : /* Append sequence SRC to the end of sequence *DST_P.  If *DST_P is
    1441              :    NULL, a new sequence is allocated.  */
    1442              : 
    1443              : void
    1444     17136679 : gimple_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
    1445              : {
    1446     17136679 :   gimple_stmt_iterator si;
    1447     17136679 :   if (src == NULL)
    1448      5198099 :     return;
    1449              : 
    1450     11938580 :   si = gsi_last (*dst_p);
    1451     11938580 :   gsi_insert_seq_after (&si, src, GSI_NEW_STMT);
    1452              : }
    1453              : 
    1454              : /* Append sequence SRC to the end of sequence *DST_P.  If *DST_P is
    1455              :    NULL, a new sequence is allocated.  This function is
    1456              :    similar to gimple_seq_add_seq, but does not scan the operands.  */
    1457              : 
    1458              : void
    1459       279008 : gimple_seq_add_seq_without_update (gimple_seq *dst_p, gimple_seq src)
    1460              : {
    1461       279008 :   gimple_stmt_iterator si;
    1462       279008 :   if (src == NULL)
    1463        98832 :     return;
    1464              : 
    1465       180176 :   si = gsi_last (*dst_p);
    1466       180176 :   gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
    1467              : }
    1468              : 
    1469              : /* Determine whether to assign a location to the statement GS.  */
    1470              : 
    1471              : static bool
    1472    268372194 : should_carry_location_p (gimple *gs)
    1473              : {
    1474              :   /* Don't emit a line note for a label.  We particularly don't want to
    1475              :      emit one for the break label, since it doesn't actually correspond
    1476              :      to the beginning of the loop/switch.  */
    1477    268372194 :   if (gimple_code (gs) == GIMPLE_LABEL)
    1478            0 :     return false;
    1479              : 
    1480              :   return true;
    1481              : }
    1482              : 
    1483              : /* Set the location for gimple statement GS to LOCATION.  */
    1484              : 
    1485              : static void
    1486    681794330 : annotate_one_with_location (gimple *gs, location_t location)
    1487              : {
    1488    681794330 :   if (!gimple_has_location (gs)
    1489    338021704 :       && !gimple_do_not_emit_location_p (gs)
    1490    681794330 :       && should_carry_location_p (gs))
    1491     26288969 :     gimple_set_location (gs, location);
    1492    681794330 : }
    1493              : 
    1494              : /* Set LOCATION for all the statements after iterator GSI in sequence
    1495              :    SEQ.  If GSI is pointing to the end of the sequence, start with the
    1496              :    first statement in SEQ.  */
    1497              : 
    1498              : void
    1499    101052310 : annotate_all_with_location_after (gimple_seq seq, gimple_stmt_iterator gsi,
    1500              :                                   location_t location)
    1501              : {
    1502    101052310 :   if (gsi_end_p (gsi))
    1503    101052310 :     gsi = gsi_start (seq);
    1504              :   else
    1505     66233505 :     gsi_next (&gsi);
    1506              : 
    1507    782500786 :   for (; !gsi_end_p (gsi); gsi_next (&gsi))
    1508    681448476 :     annotate_one_with_location (gsi_stmt (gsi), location);
    1509    101052310 : }
    1510              : 
    1511              : /* Set the location for all the statements in a sequence STMT_P to LOCATION.  */
    1512              : 
    1513              : void
    1514       223907 : annotate_all_with_location (gimple_seq stmt_p, location_t location)
    1515              : {
    1516       223907 :   gimple_stmt_iterator i;
    1517              : 
    1518       223907 :   if (gimple_seq_empty_p (stmt_p))
    1519       223907 :     return;
    1520              : 
    1521       561166 :   for (i = gsi_start (stmt_p); !gsi_end_p (i); gsi_next (&i))
    1522              :     {
    1523       345854 :       gimple *gs = gsi_stmt (i);
    1524       345854 :       annotate_one_with_location (gs, location);
    1525              :     }
    1526              : }
    1527              : 
    1528              : /* Helper function of empty_body_p.  Return true if STMT is an empty
    1529              :    statement.  */
    1530              : 
    1531              : static bool
    1532        36993 : empty_stmt_p (gimple *stmt)
    1533              : {
    1534        36993 :   if (gimple_code (stmt) == GIMPLE_NOP)
    1535              :     return true;
    1536        36991 :   if (gbind *bind_stmt = dyn_cast <gbind *> (stmt))
    1537        21950 :     return empty_body_p (gimple_bind_body (bind_stmt));
    1538              :   return false;
    1539              : }
    1540              : 
    1541              : 
    1542              : /* Return true if BODY contains nothing but empty statements.  */
    1543              : 
    1544              : bool
    1545        37072 : empty_body_p (gimple_seq body)
    1546              : {
    1547        37072 :   gimple_stmt_iterator i;
    1548              : 
    1549        37072 :   if (gimple_seq_empty_p (body))
    1550              :     return true;
    1551        37180 :   for (i = gsi_start (body); !gsi_end_p (i); gsi_next (&i))
    1552        36993 :     if (!empty_stmt_p (gsi_stmt (i))
    1553        36993 :         && !is_gimple_debug (gsi_stmt (i)))
    1554              :       return false;
    1555              : 
    1556              :   return true;
    1557              : }
    1558              : 
    1559              : 
    1560              : /* Perform a deep copy of sequence SRC and return the result.  */
    1561              : 
    1562              : gimple_seq
    1563      1882372 : gimple_seq_copy (gimple_seq src)
    1564              : {
    1565      1882372 :   gimple_stmt_iterator gsi;
    1566      1882372 :   gimple_seq new_seq = NULL;
    1567      1882372 :   gimple *stmt;
    1568              : 
    1569      4229951 :   for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi))
    1570              :     {
    1571      2347579 :       stmt = gimple_copy (gsi_stmt (gsi));
    1572      2347579 :       gimple_seq_add_stmt (&new_seq, stmt);
    1573              :     }
    1574              : 
    1575      1882372 :   return new_seq;
    1576              : }
    1577              : 
    1578              : 
    1579              : 
    1580              : /* Return true if calls C1 and C2 are known to go to the same function.  */
    1581              : 
    1582              : bool
    1583      1008054 : gimple_call_same_target_p (const gimple *c1, const gimple *c2)
    1584              : {
    1585      1008054 :   if (gimple_call_internal_p (c1))
    1586         8279 :     return (gimple_call_internal_p (c2)
    1587         8279 :             && gimple_call_internal_fn (c1) == gimple_call_internal_fn (c2)
    1588        16558 :             && (!gimple_call_internal_unique_p (as_a <const gcall *> (c1))
    1589            0 :                 || c1 == c2));
    1590              :   else
    1591       999775 :     return (gimple_call_fn (c1) == gimple_call_fn (c2)
    1592       999775 :             || (gimple_call_fndecl (c1)
    1593       999146 :                 && gimple_call_fndecl (c1) == gimple_call_fndecl (c2)));
    1594              : }
    1595              : 
    1596              : /* Detect flags from a GIMPLE_CALL.  This is just like
    1597              :    call_expr_flags, but for gimple tuples.  */
    1598              : 
    1599              : int
    1600   4344526838 : gimple_call_flags (const gimple *stmt)
    1601              : {
    1602   4344526838 :   int flags = 0;
    1603              : 
    1604   4344526838 :   if (gimple_call_internal_p (stmt))
    1605    124747134 :     flags = internal_fn_flags (gimple_call_internal_fn (stmt));
    1606              :   else
    1607              :     {
    1608   4219779704 :       tree decl = gimple_call_fndecl (stmt);
    1609   4219779704 :       if (decl)
    1610   4095479499 :         flags = flags_from_decl_or_type (decl);
    1611   4219779704 :       flags |= flags_from_decl_or_type (gimple_call_fntype (stmt));
    1612              :     }
    1613              : 
    1614   4344526838 :   if (stmt->subcode & GF_CALL_NOTHROW)
    1615    755272274 :     flags |= ECF_NOTHROW;
    1616   4344526838 :   if (stmt->subcode & GF_CALL_XTHROW)
    1617     16945049 :     flags |= ECF_XTHROW;
    1618              : 
    1619   4344526838 :   if (stmt->subcode & GF_CALL_BY_DESCRIPTOR)
    1620            0 :     flags |= ECF_BY_DESCRIPTOR;
    1621              : 
    1622   4344526838 :   return flags;
    1623              : }
    1624              : 
    1625              : /* Return the "fn spec" string for call STMT.  */
    1626              : 
    1627              : attr_fnspec
    1628    452954616 : gimple_call_fnspec (const gcall *stmt)
    1629              : {
    1630    452954616 :   tree type, attr;
    1631              : 
    1632    452954616 :   if (gimple_call_internal_p (stmt))
    1633              :     {
    1634      9895944 :       const_tree spec = internal_fn_fnspec (gimple_call_internal_fn (stmt));
    1635      9895944 :       if (spec)
    1636       432650 :         return spec;
    1637              :       else
    1638      9463294 :         return "";
    1639              :     }
    1640              : 
    1641    443058672 :   type = gimple_call_fntype (stmt);
    1642    443058672 :   if (type)
    1643              :     {
    1644    443058672 :       attr = lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type));
    1645    443058672 :       if (attr)
    1646     61918557 :         return TREE_VALUE (TREE_VALUE (attr));
    1647              :     }
    1648    381140115 :   if (gimple_call_builtin_p (stmt, BUILT_IN_NORMAL))
    1649    115260208 :     return builtin_fnspec (gimple_call_fndecl (stmt));
    1650    265879907 :   tree fndecl = gimple_call_fndecl (stmt);
    1651              :   /* If the call is to a replaceable operator delete and results
    1652              :      from a delete expression as opposed to a direct call to
    1653              :      such operator, then we can treat it as free.  */
    1654    265879907 :   if (fndecl
    1655    251825017 :       && DECL_IS_OPERATOR_DELETE_P (fndecl)
    1656      7247811 :       && DECL_IS_REPLACEABLE_OPERATOR (fndecl)
    1657    273121855 :       && gimple_call_from_new_or_delete (stmt))
    1658              :     {
    1659      7187952 :       if (flag_assume_sane_operators_new_delete)
    1660      7186457 :         return ".co ";
    1661              :       else
    1662         1495 :         return ". o ";
    1663              :     }
    1664              :   /* Similarly operator new can be treated as malloc.  */
    1665    258691955 :   if (fndecl
    1666    244637065 :       && DECL_IS_REPLACEABLE_OPERATOR_NEW_P (fndecl)
    1667    261794170 :       && gimple_call_from_new_or_delete (stmt))
    1668              :     {
    1669      3068778 :       if (flag_assume_sane_operators_new_delete)
    1670      3067785 :         return "mC";
    1671              :       else
    1672          993 :         return "m ";
    1673              :     }
    1674    255623177 :   return "";
    1675              : }
    1676              : 
    1677              : /* Detects argument flags for argument number ARG on call STMT.  */
    1678              : 
    1679              : int
    1680    125502935 : gimple_call_arg_flags (const gcall *stmt, unsigned arg)
    1681              : {
    1682    125502935 :   attr_fnspec fnspec = gimple_call_fnspec (stmt);
    1683    125502935 :   int flags = 0;
    1684              : 
    1685    125502935 :   if (fnspec.known_p ())
    1686     24390397 :     flags = fnspec.arg_eaf_flags (arg);
    1687    125502935 :   tree callee = gimple_call_fndecl (stmt);
    1688    125502935 :   if (callee)
    1689              :     {
    1690    117393361 :       cgraph_node *node = cgraph_node::get (callee);
    1691    117393361 :       modref_summary *summary = node ? get_modref_function_summary (node)
    1692              :                                 : NULL;
    1693              : 
    1694    117162431 :       if (summary && summary->arg_flags.length () > arg)
    1695              :         {
    1696     23650754 :           int modref_flags = summary->arg_flags[arg];
    1697              : 
    1698              :           /* We have possibly optimized out load.  Be conservative here.  */
    1699     23650754 :           if (!node->binds_to_current_def_p ())
    1700     11703990 :             modref_flags = interposable_eaf_flags (modref_flags, flags);
    1701     23650754 :           if (dbg_cnt (ipa_mod_ref_pta))
    1702     23650754 :             flags |= modref_flags;
    1703              :         }
    1704              :     }
    1705    125502935 :   return flags;
    1706              : }
    1707              : 
    1708              : /* Detects argument flags for return slot on call STMT.  */
    1709              : 
    1710              : int
    1711       101308 : gimple_call_retslot_flags (const gcall *stmt)
    1712              : {
    1713       101308 :   int flags = implicit_retslot_eaf_flags;
    1714              : 
    1715       101308 :   tree callee = gimple_call_fndecl (stmt);
    1716       101308 :   if (callee)
    1717              :     {
    1718        92544 :       cgraph_node *node = cgraph_node::get (callee);
    1719        92544 :       modref_summary *summary = node ? get_modref_function_summary (node)
    1720              :                                 : NULL;
    1721              : 
    1722        92544 :       if (summary)
    1723              :         {
    1724        65318 :           int modref_flags = summary->retslot_flags;
    1725              : 
    1726              :           /* We have possibly optimized out load.  Be conservative here.  */
    1727        65318 :           if (!node->binds_to_current_def_p ())
    1728        54966 :             modref_flags = interposable_eaf_flags (modref_flags, flags);
    1729        65318 :           if (dbg_cnt (ipa_mod_ref_pta))
    1730        65318 :             flags |= modref_flags;
    1731              :         }
    1732              :     }
    1733       101308 :   return flags;
    1734              : }
    1735              : 
    1736              : /* Detects argument flags for static chain on call STMT.  */
    1737              : 
    1738              : int
    1739       180608 : gimple_call_static_chain_flags (const gcall *stmt)
    1740              : {
    1741       180608 :   int flags = 0;
    1742              : 
    1743       180608 :   tree callee = gimple_call_fndecl (stmt);
    1744       180608 :   if (callee)
    1745              :     {
    1746        28100 :       cgraph_node *node = cgraph_node::get (callee);
    1747        28100 :       modref_summary *summary = node ? get_modref_function_summary (node)
    1748              :                                 : NULL;
    1749              : 
    1750              :       /* Nested functions should always bind to current def since
    1751              :          there is no public ABI for them.  */
    1752        28100 :       gcc_checking_assert (node->binds_to_current_def_p ());
    1753        28100 :       if (summary)
    1754              :         {
    1755        26236 :           int modref_flags = summary->static_chain_flags;
    1756              : 
    1757        26236 :           if (dbg_cnt (ipa_mod_ref_pta))
    1758       180608 :             flags |= modref_flags;
    1759              :         }
    1760              :     }
    1761       180608 :   return flags;
    1762              : }
    1763              : 
    1764              : /* Detects return flags for the call STMT.  */
    1765              : 
    1766              : int
    1767     49535128 : gimple_call_return_flags (const gcall *stmt)
    1768              : {
    1769     49535128 :   if (gimple_call_flags (stmt) & ECF_MALLOC)
    1770              :     return ERF_NOALIAS;
    1771              : 
    1772     47534261 :   attr_fnspec fnspec = gimple_call_fnspec (stmt);
    1773              : 
    1774     47534261 :   unsigned int arg_no;
    1775     47534261 :   if (fnspec.returns_arg (&arg_no))
    1776      1105512 :     return ERF_RETURNS_ARG | arg_no;
    1777              : 
    1778     46428749 :   if (fnspec.returns_noalias_p ())
    1779         6076 :     return ERF_NOALIAS;
    1780              :   return 0;
    1781              : }
    1782              : 
    1783              : 
    1784              : /* Return true if call STMT is known to return a non-zero result.  */
    1785              : 
    1786              : bool
    1787     13418542 : gimple_call_nonnull_result_p (gcall *call)
    1788              : {
    1789     13418542 :   tree fndecl = gimple_call_fndecl (call);
    1790     13418542 :   if (!fndecl)
    1791              :     return false;
    1792     12239374 :   if (flag_delete_null_pointer_checks && !flag_check_new
    1793     12239319 :       && DECL_IS_OPERATOR_NEW_P (fndecl)
    1794     12772434 :       && !TREE_NOTHROW (fndecl))
    1795              :     return true;
    1796              : 
    1797              :   /* References are always non-NULL.  */
    1798     11722098 :   if (flag_delete_null_pointer_checks
    1799     11722098 :       && TREE_CODE (TREE_TYPE (fndecl)) == REFERENCE_TYPE)
    1800              :     return true;
    1801              : 
    1802     11722098 :   if (flag_delete_null_pointer_checks
    1803     23437821 :       && lookup_attribute ("returns_nonnull",
    1804     11715723 :                            TYPE_ATTRIBUTES (gimple_call_fntype (call))))
    1805              :     return true;
    1806     11663954 :   return gimple_alloca_call_p (call);
    1807              : }
    1808              : 
    1809              : 
    1810              : /* If CALL returns a non-null result in an argument, return that arg.  */
    1811              : 
    1812              : tree
    1813     12775585 : gimple_call_nonnull_arg (gcall *call)
    1814              : {
    1815     12775585 :   tree fndecl = gimple_call_fndecl (call);
    1816     12775585 :   if (!fndecl)
    1817              :     return NULL_TREE;
    1818              : 
    1819     11602792 :   unsigned rf = gimple_call_return_flags (call);
    1820     11602792 :   if (rf & ERF_RETURNS_ARG)
    1821              :     {
    1822            0 :       unsigned argnum = rf & ERF_RETURN_ARG_MASK;
    1823            0 :       if (argnum < gimple_call_num_args (call))
    1824              :         {
    1825            0 :           tree arg = gimple_call_arg (call, argnum);
    1826            0 :           if (SSA_VAR_P (arg)
    1827            0 :               && infer_nonnull_range_by_attribute (call, arg))
    1828            0 :             return arg;
    1829              :         }
    1830              :     }
    1831              :   return NULL_TREE;
    1832              : }
    1833              : 
    1834              : 
    1835              : /* Return true if GS is a copy assignment.  */
    1836              : 
    1837              : bool
    1838    204439166 : gimple_assign_copy_p (gimple *gs)
    1839              : {
    1840    204439166 :   return (gimple_assign_single_p (gs)
    1841    204439166 :           && is_gimple_val (gimple_op (gs, 1)));
    1842              : }
    1843              : 
    1844              : 
    1845              : /* Return true if GS is a SSA_NAME copy assignment.  */
    1846              : 
    1847              : bool
    1848     41102288 : gimple_assign_ssa_name_copy_p (gimple *gs)
    1849              : {
    1850     41102288 :   return (gimple_assign_single_p (gs)
    1851     23300005 :           && TREE_CODE (gimple_assign_lhs (gs)) == SSA_NAME
    1852     54585605 :           && TREE_CODE (gimple_assign_rhs1 (gs)) == SSA_NAME);
    1853              : }
    1854              : 
    1855              : 
    1856              : /* Return true if GS is an assignment with a unary RHS, but the
    1857              :    operator has no effect on the assigned value.  The logic is adapted
    1858              :    from STRIP_NOPS.  This predicate is intended to be used in tuplifying
    1859              :    instances in which STRIP_NOPS was previously applied to the RHS of
    1860              :    an assignment.
    1861              : 
    1862              :    NOTE: In the use cases that led to the creation of this function
    1863              :    and of gimple_assign_single_p, it is typical to test for either
    1864              :    condition and to proceed in the same manner.  In each case, the
    1865              :    assigned value is represented by the single RHS operand of the
    1866              :    assignment.  I suspect there may be cases where gimple_assign_copy_p,
    1867              :    gimple_assign_single_p, or equivalent logic is used where a similar
    1868              :    treatment of unary NOPs is appropriate.  */
    1869              : 
    1870              : bool
    1871        46430 : gimple_assign_unary_nop_p (gimple *gs)
    1872              : {
    1873        46430 :   return (is_gimple_assign (gs)
    1874        46430 :           && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs))
    1875        40960 :               || gimple_assign_rhs_code (gs) == NON_LVALUE_EXPR)
    1876         5470 :           && gimple_assign_rhs1 (gs) != error_mark_node
    1877        57370 :           && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs)))
    1878         5470 :               == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs)))));
    1879              : }
    1880              : 
    1881              : /* Return true if GS is an assignment that loads from its rhs1.  */
    1882              : 
    1883              : bool
    1884    554685932 : gimple_assign_load_p (const gimple *gs)
    1885              : {
    1886    554685932 :   tree rhs;
    1887    554685932 :   if (!gimple_assign_single_p (gs))
    1888              :     return false;
    1889    337054934 :   rhs = gimple_assign_rhs1 (gs);
    1890    337054934 :   if (TREE_CODE (rhs) == WITH_SIZE_EXPR)
    1891              :     return true;
    1892    337054930 :   if (handled_component_p (rhs))
    1893     91556789 :     rhs = TREE_OPERAND (rhs, 0);
    1894    337054930 :   return (handled_component_p (rhs)
    1895    311099534 :           || DECL_P (rhs)
    1896    251754455 :           || TREE_CODE (rhs) == MEM_REF
    1897    186135101 :           || TREE_CODE (rhs) == TARGET_MEM_REF);
    1898              : }
    1899              : 
    1900              : 
    1901              : /* Set BB to be the basic block holding G.  */
    1902              : 
    1903              : void
    1904    753857145 : gimple_set_bb (gimple *stmt, basic_block bb)
    1905              : {
    1906    753857145 :   stmt->bb = bb;
    1907              : 
    1908    753857145 :   if (gimple_code (stmt) != GIMPLE_LABEL)
    1909              :     return;
    1910              : 
    1911              :   /* If the statement is a label, add the label to block-to-labels map
    1912              :      so that we can speed up edge creation for GIMPLE_GOTOs.  */
    1913     39250674 :   if (cfun->cfg)
    1914              :     {
    1915     39250560 :       tree t;
    1916     39250560 :       int uid;
    1917              : 
    1918     39250560 :       t = gimple_label_label (as_a <glabel *> (stmt));
    1919     39250560 :       uid = LABEL_DECL_UID (t);
    1920     39250560 :       if (uid == -1)
    1921              :         {
    1922     20021954 :           unsigned old_len =
    1923     20021954 :             vec_safe_length (label_to_block_map_for_fn (cfun));
    1924     20021954 :           LABEL_DECL_UID (t) = uid = cfun->cfg->last_label_uid++;
    1925     20021954 :           if (old_len <= (unsigned) uid)
    1926      9508046 :             vec_safe_grow_cleared (label_to_block_map_for_fn (cfun), uid + 1);
    1927              :         }
    1928              : 
    1929     39250560 :       (*label_to_block_map_for_fn (cfun))[uid] = bb;
    1930              :     }
    1931              : }
    1932              : 
    1933              : 
    1934              : /* Modify the RHS of the assignment pointed-to by GSI using the
    1935              :    operands in the expression tree EXPR.
    1936              : 
    1937              :    NOTE: The statement pointed-to by GSI may be reallocated if it
    1938              :    did not have enough operand slots.
    1939              : 
    1940              :    This function is useful to convert an existing tree expression into
    1941              :    the flat representation used for the RHS of a GIMPLE assignment.
    1942              :    It will reallocate memory as needed to expand or shrink the number
    1943              :    of operand slots needed to represent EXPR.
    1944              : 
    1945              :    NOTE: If you find yourself building a tree and then calling this
    1946              :    function, you are most certainly doing it the slow way.  It is much
    1947              :    better to build a new assignment or to use the function
    1948              :    gimple_assign_set_rhs_with_ops, which does not require an
    1949              :    expression tree to be built.  */
    1950              : 
    1951              : void
    1952      5326185 : gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *gsi, tree expr)
    1953              : {
    1954      5326185 :   enum tree_code subcode;
    1955      5326185 :   tree op1, op2, op3;
    1956              : 
    1957      5326185 :   extract_ops_from_tree (expr, &subcode, &op1, &op2, &op3);
    1958      5326185 :   gimple_assign_set_rhs_with_ops (gsi, subcode, op1, op2, op3);
    1959      5326185 : }
    1960              : 
    1961              : 
    1962              : /* Set the RHS of assignment statement pointed-to by GSI to CODE with
    1963              :    operands OP1, OP2 and OP3.
    1964              : 
    1965              :    NOTE: The statement pointed-to by GSI may be reallocated if it
    1966              :    did not have enough operand slots.  */
    1967              : 
    1968              : void
    1969      8051149 : gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
    1970              :                                 tree op1, tree op2, tree op3)
    1971              : {
    1972      8051149 :   unsigned new_rhs_ops = get_gimple_rhs_num_ops (code);
    1973      8051149 :   gimple *stmt = gsi_stmt (*gsi);
    1974      8051149 :   gimple *old_stmt = stmt;
    1975              : 
    1976              :   /* If the new CODE needs more operands, allocate a new statement.  */
    1977      8051149 :   if (gimple_num_ops (stmt) < new_rhs_ops + 1)
    1978              :     {
    1979       209140 :       tree lhs = gimple_assign_lhs (old_stmt);
    1980       209140 :       stmt = gimple_alloc (gimple_code (old_stmt), new_rhs_ops + 1);
    1981       209140 :       memcpy (stmt, old_stmt, gimple_size (gimple_code (old_stmt)));
    1982       209140 :       gimple_init_singleton (stmt);
    1983              : 
    1984              :       /* The LHS needs to be reset as this also changes the SSA name
    1985              :          on the LHS.  */
    1986       209140 :       gimple_assign_set_lhs (stmt, lhs);
    1987              :     }
    1988              : 
    1989      8051149 :   gimple_set_num_ops (stmt, new_rhs_ops + 1);
    1990      8051149 :   gimple_set_subcode (stmt, code);
    1991      8051149 :   gimple_assign_set_rhs1 (stmt, op1);
    1992      8051149 :   if (new_rhs_ops > 1)
    1993      1189923 :     gimple_assign_set_rhs2 (stmt, op2);
    1994      1189923 :   if (new_rhs_ops > 2)
    1995        36981 :     gimple_assign_set_rhs3 (stmt, op3);
    1996      8051149 :   if (stmt != old_stmt)
    1997       209140 :     gsi_replace (gsi, stmt, false);
    1998      8051149 : }
    1999              : 
    2000              : 
    2001              : /* Return the LHS of a statement that performs an assignment,
    2002              :    either a GIMPLE_ASSIGN or a GIMPLE_CALL.  Returns NULL_TREE
    2003              :    for a call to a function that returns no value, or for a
    2004              :    statement other than an assignment or a call.  */
    2005              : 
    2006              : tree
    2007   7657798793 : gimple_get_lhs (const gimple *stmt)
    2008              : {
    2009   7657798793 :   enum gimple_code code = gimple_code (stmt);
    2010              : 
    2011   7657798793 :   if (code == GIMPLE_ASSIGN)
    2012   4768409339 :     return gimple_assign_lhs (stmt);
    2013   2889389454 :   else if (code == GIMPLE_CALL)
    2014    544508193 :     return gimple_call_lhs (stmt);
    2015   2344881261 :   else if (code == GIMPLE_PHI)
    2016    145879094 :     return gimple_phi_result (stmt);
    2017              :   else
    2018              :     return NULL_TREE;
    2019              : }
    2020              : 
    2021              : 
    2022              : /* Set the LHS of a statement that performs an assignment,
    2023              :    either a GIMPLE_ASSIGN or a GIMPLE_CALL.  */
    2024              : 
    2025              : void
    2026      2252114 : gimple_set_lhs (gimple *stmt, tree lhs)
    2027              : {
    2028      2252114 :   enum gimple_code code = gimple_code (stmt);
    2029              : 
    2030      2252114 :   if (code == GIMPLE_ASSIGN)
    2031      1053121 :     gimple_assign_set_lhs (stmt, lhs);
    2032      1198993 :   else if (code == GIMPLE_CALL)
    2033      1198993 :     gimple_call_set_lhs (stmt, lhs);
    2034              :   else
    2035            0 :     gcc_unreachable ();
    2036      2252114 : }
    2037              : 
    2038              : 
    2039              : /* Return a deep copy of statement STMT.  All the operands from STMT
    2040              :    are reallocated and copied using unshare_expr.  The DEF, USE, VDEF
    2041              :    and VUSE operand arrays are set to empty in the new copy.  The new
    2042              :    copy isn't part of any sequence.  */
    2043              : 
    2044              : gimple *
    2045     75341821 : gimple_copy (gimple *stmt)
    2046              : {
    2047     75341821 :   enum gimple_code code = gimple_code (stmt);
    2048     75341821 :   unsigned num_ops = gimple_num_ops (stmt);
    2049     75341821 :   gimple *copy = gimple_alloc (code, num_ops);
    2050     75341821 :   unsigned i;
    2051              : 
    2052              :   /* Shallow copy all the fields from STMT.  */
    2053     75341821 :   memcpy (copy, stmt, gimple_size (code));
    2054     75341821 :   gimple_init_singleton (copy);
    2055              : 
    2056              :   /* If STMT has sub-statements, deep-copy them as well.  */
    2057     75341821 :   if (gimple_has_substatements (stmt))
    2058              :     {
    2059        42597 :       gimple_seq new_seq;
    2060        42597 :       tree t;
    2061              : 
    2062        42597 :       switch (gimple_code (stmt))
    2063              :         {
    2064          357 :         case GIMPLE_BIND:
    2065          357 :           {
    2066          357 :             gbind *bind_stmt = as_a <gbind *> (stmt);
    2067          357 :             gbind *bind_copy = as_a <gbind *> (copy);
    2068          357 :             new_seq = gimple_seq_copy (gimple_bind_body (bind_stmt));
    2069          357 :             gimple_bind_set_body (bind_copy, new_seq);
    2070          357 :             gimple_bind_set_vars (bind_copy,
    2071              :                                   unshare_expr (gimple_bind_vars (bind_stmt)));
    2072          357 :             gimple_bind_set_block (bind_copy, gimple_bind_block (bind_stmt));
    2073              :           }
    2074          357 :           break;
    2075              : 
    2076        17498 :         case GIMPLE_CATCH:
    2077        17498 :           {
    2078        17498 :             gcatch *catch_stmt = as_a <gcatch *> (stmt);
    2079        17498 :             gcatch *catch_copy = as_a <gcatch *> (copy);
    2080        17498 :             new_seq = gimple_seq_copy (gimple_catch_handler (catch_stmt));
    2081        17498 :             gimple_catch_set_handler (catch_copy, new_seq);
    2082        17498 :             t = unshare_expr (gimple_catch_types (catch_stmt));
    2083        17498 :             gimple_catch_set_types (catch_copy, t);
    2084              :           }
    2085        17498 :           break;
    2086              : 
    2087            0 :         case GIMPLE_EH_FILTER:
    2088            0 :           {
    2089            0 :             geh_filter *eh_filter_stmt = as_a <geh_filter *> (stmt);
    2090            0 :             geh_filter *eh_filter_copy = as_a <geh_filter *> (copy);
    2091            0 :             new_seq
    2092            0 :               = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt));
    2093            0 :             gimple_eh_filter_set_failure (eh_filter_copy, new_seq);
    2094            0 :             t = unshare_expr (gimple_eh_filter_types (eh_filter_stmt));
    2095            0 :             gimple_eh_filter_set_types (eh_filter_copy, t);
    2096              :           }
    2097            0 :           break;
    2098              : 
    2099          273 :         case GIMPLE_EH_ELSE:
    2100          273 :           {
    2101          273 :             geh_else *eh_else_stmt = as_a <geh_else *> (stmt);
    2102          273 :             geh_else *eh_else_copy = as_a <geh_else *> (copy);
    2103          273 :             new_seq = gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt));
    2104          273 :             gimple_eh_else_set_n_body (eh_else_copy, new_seq);
    2105          273 :             new_seq = gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt));
    2106          273 :             gimple_eh_else_set_e_body (eh_else_copy, new_seq);
    2107              :           }
    2108          273 :           break;
    2109              : 
    2110        24187 :         case GIMPLE_TRY:
    2111        24187 :           {
    2112        24187 :             gtry *try_stmt = as_a <gtry *> (stmt);
    2113        24187 :             gtry *try_copy = as_a <gtry *> (copy);
    2114        24187 :             new_seq = gimple_seq_copy (gimple_try_eval (try_stmt));
    2115        24187 :             gimple_try_set_eval (try_copy, new_seq);
    2116        24187 :             new_seq = gimple_seq_copy (gimple_try_cleanup (try_stmt));
    2117        24187 :             gimple_try_set_cleanup (try_copy, new_seq);
    2118              :           }
    2119        24187 :           break;
    2120              : 
    2121          276 :         case GIMPLE_OMP_FOR:
    2122          276 :           new_seq = gimple_seq_copy (gimple_omp_for_pre_body (stmt));
    2123          276 :           gimple_omp_for_set_pre_body (copy, new_seq);
    2124          276 :           t = unshare_expr (gimple_omp_for_clauses (stmt));
    2125          276 :           gimple_omp_for_set_clauses (copy, t);
    2126          276 :           {
    2127          276 :             gomp_for *omp_for_copy = as_a <gomp_for *> (copy);
    2128          276 :             omp_for_copy->iter = ggc_vec_alloc<gimple_omp_for_iter>
    2129          276 :               ( gimple_omp_for_collapse (stmt));
    2130              :           }
    2131          564 :           for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
    2132              :             {
    2133          288 :               gimple_omp_for_set_cond (copy, i,
    2134              :                                        gimple_omp_for_cond (stmt, i));
    2135          288 :               gimple_omp_for_set_index (copy, i,
    2136              :                                         gimple_omp_for_index (stmt, i));
    2137          288 :               t = unshare_expr (gimple_omp_for_initial (stmt, i));
    2138          288 :               gimple_omp_for_set_initial (copy, i, t);
    2139          288 :               t = unshare_expr (gimple_omp_for_final (stmt, i));
    2140          288 :               gimple_omp_for_set_final (copy, i, t);
    2141          288 :               t = unshare_expr (gimple_omp_for_incr (stmt, i));
    2142          288 :               gimple_omp_for_set_incr (copy, i, t);
    2143              :             }
    2144          276 :           goto copy_omp_body;
    2145              : 
    2146            0 :         case GIMPLE_OMP_PARALLEL:
    2147            0 :           {
    2148            0 :             gomp_parallel *omp_par_stmt = as_a <gomp_parallel *> (stmt);
    2149            0 :             gomp_parallel *omp_par_copy = as_a <gomp_parallel *> (copy);
    2150            0 :             t = unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt));
    2151            0 :             gimple_omp_parallel_set_clauses (omp_par_copy, t);
    2152            0 :             t = unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt));
    2153            0 :             gimple_omp_parallel_set_child_fn (omp_par_copy, t);
    2154            0 :             t = unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt));
    2155            0 :             gimple_omp_parallel_set_data_arg (omp_par_copy, t);
    2156              :           }
    2157            0 :           goto copy_omp_body;
    2158              : 
    2159            0 :         case GIMPLE_OMP_TASK:
    2160            0 :           t = unshare_expr (gimple_omp_task_clauses (stmt));
    2161            0 :           gimple_omp_task_set_clauses (copy, t);
    2162            0 :           t = unshare_expr (gimple_omp_task_child_fn (stmt));
    2163            0 :           gimple_omp_task_set_child_fn (copy, t);
    2164            0 :           t = unshare_expr (gimple_omp_task_data_arg (stmt));
    2165            0 :           gimple_omp_task_set_data_arg (copy, t);
    2166            0 :           t = unshare_expr (gimple_omp_task_copy_fn (stmt));
    2167            0 :           gimple_omp_task_set_copy_fn (copy, t);
    2168            0 :           t = unshare_expr (gimple_omp_task_arg_size (stmt));
    2169            0 :           gimple_omp_task_set_arg_size (copy, t);
    2170            0 :           t = unshare_expr (gimple_omp_task_arg_align (stmt));
    2171            0 :           gimple_omp_task_set_arg_align (copy, t);
    2172            0 :           goto copy_omp_body;
    2173              : 
    2174            0 :         case GIMPLE_OMP_CRITICAL:
    2175            0 :           t = unshare_expr (gimple_omp_critical_name
    2176            0 :                                 (as_a <gomp_critical *> (stmt)));
    2177            0 :           gimple_omp_critical_set_name (as_a <gomp_critical *> (copy), t);
    2178            0 :           t = unshare_expr (gimple_omp_critical_clauses
    2179            0 :                                 (as_a <gomp_critical *> (stmt)));
    2180            0 :           gimple_omp_critical_set_clauses (as_a <gomp_critical *> (copy), t);
    2181            0 :           goto copy_omp_body;
    2182              : 
    2183            0 :         case GIMPLE_OMP_ORDERED:
    2184            0 :           t = unshare_expr (gimple_omp_ordered_clauses
    2185            0 :                                 (as_a <gomp_ordered *> (stmt)));
    2186            0 :           gimple_omp_ordered_set_clauses (as_a <gomp_ordered *> (copy), t);
    2187            0 :           goto copy_omp_body;
    2188              : 
    2189            0 :         case GIMPLE_OMP_SCAN:
    2190            0 :           t = gimple_omp_scan_clauses (as_a <gomp_scan *> (stmt));
    2191            0 :           t = unshare_expr (t);
    2192            0 :           gimple_omp_scan_set_clauses (as_a <gomp_scan *> (copy), t);
    2193            0 :           goto copy_omp_body;
    2194              : 
    2195            0 :         case GIMPLE_OMP_TASKGROUP:
    2196            0 :           t = unshare_expr (gimple_omp_taskgroup_clauses (stmt));
    2197            0 :           gimple_omp_taskgroup_set_clauses (copy, t);
    2198            0 :           goto copy_omp_body;
    2199              : 
    2200            0 :         case GIMPLE_OMP_SECTIONS:
    2201            0 :           t = unshare_expr (gimple_omp_sections_clauses (stmt));
    2202            0 :           gimple_omp_sections_set_clauses (copy, t);
    2203            0 :           t = unshare_expr (gimple_omp_sections_control (stmt));
    2204            0 :           gimple_omp_sections_set_control (copy, t);
    2205            0 :           goto copy_omp_body;
    2206              : 
    2207            0 :         case GIMPLE_OMP_SINGLE:
    2208            0 :           {
    2209            0 :             gomp_single *omp_single_copy = as_a <gomp_single *> (copy);
    2210            0 :             t = unshare_expr (gimple_omp_single_clauses (stmt));
    2211            0 :             gimple_omp_single_set_clauses (omp_single_copy, t);
    2212              :           }
    2213            0 :           goto copy_omp_body;
    2214              : 
    2215            0 :         case GIMPLE_OMP_SCOPE:
    2216            0 :           t = unshare_expr (gimple_omp_scope_clauses (stmt));
    2217            0 :           gimple_omp_scope_set_clauses (copy, t);
    2218            0 :           goto copy_omp_body;
    2219              : 
    2220            0 :         case GIMPLE_OMP_DISPATCH:
    2221            0 :           t = unshare_expr (gimple_omp_dispatch_clauses (stmt));
    2222            0 :           gimple_omp_dispatch_set_clauses (copy, t);
    2223            0 :           goto copy_omp_body;
    2224              : 
    2225            0 :         case GIMPLE_OMP_INTEROP:
    2226            0 :           t = unshare_expr (gimple_omp_interop_clauses (stmt));
    2227            0 :           gimple_omp_interop_set_clauses (copy, t);
    2228            0 :           break;
    2229              : 
    2230            0 :         case GIMPLE_OMP_TARGET:
    2231            0 :           {
    2232            0 :             gomp_target *omp_target_stmt = as_a <gomp_target *> (stmt);
    2233            0 :             gomp_target *omp_target_copy = as_a <gomp_target *> (copy);
    2234            0 :             t = unshare_expr (gimple_omp_target_clauses (omp_target_stmt));
    2235            0 :             gimple_omp_target_set_clauses (omp_target_copy, t);
    2236            0 :             t = unshare_expr (gimple_omp_target_data_arg (omp_target_stmt));
    2237            0 :             gimple_omp_target_set_data_arg (omp_target_copy, t);
    2238              :           }
    2239            0 :           goto copy_omp_body;
    2240              : 
    2241            0 :         case GIMPLE_OMP_TEAMS:
    2242            0 :           {
    2243            0 :             gomp_teams *omp_teams_copy = as_a <gomp_teams *> (copy);
    2244            0 :             t = unshare_expr (gimple_omp_teams_clauses (stmt));
    2245            0 :             gimple_omp_teams_set_clauses (omp_teams_copy, t);
    2246              :           }
    2247              :           /* FALLTHRU  */
    2248              : 
    2249          276 :         case GIMPLE_OMP_SECTION:
    2250          276 :         case GIMPLE_OMP_MASTER:
    2251          276 :         case GIMPLE_OMP_STRUCTURED_BLOCK:
    2252          276 :         copy_omp_body:
    2253          276 :           new_seq = gimple_seq_copy (gimple_omp_body (stmt));
    2254          276 :           gimple_omp_set_body (copy, new_seq);
    2255          276 :           break;
    2256              : 
    2257            0 :         case GIMPLE_OMP_MASKED:
    2258            0 :           t = unshare_expr (gimple_omp_masked_clauses (stmt));
    2259            0 :           gimple_omp_masked_set_clauses (copy, t);
    2260            0 :           goto copy_omp_body;
    2261              : 
    2262            0 :         case GIMPLE_ASSUME:
    2263            0 :           new_seq = gimple_seq_copy (gimple_assume_body (stmt));
    2264            0 :           *gimple_assume_body_ptr (copy) = new_seq;
    2265            0 :           gimple_assume_set_guard (copy,
    2266              :                                    unshare_expr (gimple_assume_guard (stmt)));
    2267            0 :           break;
    2268              : 
    2269            6 :         case GIMPLE_TRANSACTION:
    2270            6 :           new_seq = gimple_seq_copy (gimple_transaction_body (
    2271            6 :                                        as_a <gtransaction *> (stmt)));
    2272            6 :           gimple_transaction_set_body (as_a <gtransaction *> (copy),
    2273              :                                        new_seq);
    2274            6 :           break;
    2275              : 
    2276            0 :         case GIMPLE_WITH_CLEANUP_EXPR:
    2277            0 :           new_seq = gimple_seq_copy (gimple_wce_cleanup (stmt));
    2278            0 :           gimple_wce_set_cleanup (copy, new_seq);
    2279            0 :           break;
    2280              : 
    2281            0 :         default:
    2282            0 :           gcc_unreachable ();
    2283              :         }
    2284              :     }
    2285              : 
    2286     75341821 :   switch (gimple_code (stmt))
    2287              :     {
    2288            0 :     case GIMPLE_OMP_ATOMIC_LOAD:
    2289            0 :       {
    2290            0 :         gomp_atomic_load *g = as_a <gomp_atomic_load *> (copy);
    2291            0 :         gimple_omp_atomic_load_set_lhs (g,
    2292              :           unshare_expr (gimple_omp_atomic_load_lhs (g)));
    2293            0 :         gimple_omp_atomic_load_set_rhs (g,
    2294              :           unshare_expr (gimple_omp_atomic_load_rhs (g)));
    2295            0 :         break;
    2296              :       }
    2297            0 :     case GIMPLE_OMP_ATOMIC_STORE:
    2298            0 :       {
    2299            0 :         gomp_atomic_store *g = as_a <gomp_atomic_store *> (copy);
    2300            0 :         gimple_omp_atomic_store_set_val (g,
    2301              :           unshare_expr (gimple_omp_atomic_store_val (g)));
    2302            0 :         break;
    2303              :       }
    2304              :     default:
    2305              :       break;
    2306              :     }
    2307              : 
    2308              :   /* Make copy of operands.  */
    2309    229803711 :   for (i = 0; i < num_ops; i++)
    2310    154461890 :     gimple_set_op (copy, i, unshare_expr (gimple_op (stmt, i)));
    2311              : 
    2312     75341821 :   if (gimple_has_mem_ops (stmt))
    2313              :     {
    2314     34351487 :       gimple_set_vdef (copy, gimple_vdef (stmt));
    2315     34351487 :       gimple_set_vuse (copy, gimple_vuse (stmt));
    2316              :     }
    2317              : 
    2318              :   /* Clear out SSA operand vectors on COPY.  */
    2319     75341821 :   if (gimple_has_ops (stmt))
    2320              :     {
    2321     74887183 :       gimple_set_use_ops (copy, NULL);
    2322              : 
    2323              :       /* SSA operands need to be updated.  */
    2324     74887183 :       gimple_set_modified (copy, true);
    2325              :     }
    2326              : 
    2327     75341821 :   if (gimple_debug_nonbind_marker_p (stmt))
    2328     16638655 :     cfun->debug_marker_count++;
    2329              : 
    2330     75341821 :   return copy;
    2331              : }
    2332              : 
    2333              : /* Move OLD_STMT's vuse and vdef operands to NEW_STMT, on the assumption
    2334              :    that OLD_STMT is about to be removed.  */
    2335              : 
    2336              : void
    2337       731226 : gimple_move_vops (gimple *new_stmt, gimple *old_stmt)
    2338              : {
    2339       731226 :   tree vdef = gimple_vdef (old_stmt);
    2340      1462452 :   gimple_set_vuse (new_stmt, gimple_vuse (old_stmt));
    2341       731226 :   gimple_set_vdef (new_stmt, vdef);
    2342       731226 :   if (vdef && TREE_CODE (vdef) == SSA_NAME)
    2343       260513 :     SSA_NAME_DEF_STMT (vdef) = new_stmt;
    2344       731226 : }
    2345              : 
    2346              : /* Return true if statement S has side-effects.  We consider a
    2347              :    statement to have side effects if:
    2348              : 
    2349              :    - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
    2350              :    - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS.  */
    2351              : 
    2352              : bool
    2353    888414315 : gimple_has_side_effects (const gimple *s)
    2354              : {
    2355    888414315 :   if (is_gimple_debug (s))
    2356              :     return false;
    2357              : 
    2358              :   /* We don't have to scan the arguments to check for
    2359              :      volatile arguments, though, at present, we still
    2360              :      do a scan to check for TREE_SIDE_EFFECTS.  */
    2361   1340638181 :   if (gimple_has_volatile_ops (s))
    2362              :     return true;
    2363              : 
    2364    672732201 :   if (gimple_code (s) == GIMPLE_ASM
    2365    672732201 :       && gimple_asm_volatile_p (as_a <const gasm *> (s)))
    2366              :     return true;
    2367              : 
    2368    672194359 :   if (is_gimple_call (s))
    2369              :     {
    2370     96219938 :       int flags = gimple_call_flags (s);
    2371              : 
    2372              :       /* An infinite loop is considered a side effect.  */
    2373     96219938 :       if (!(flags & (ECF_CONST | ECF_PURE))
    2374     18963448 :           || (flags & ECF_LOOPING_CONST_OR_PURE))
    2375              :         return true;
    2376              : 
    2377     16902757 :       return false;
    2378              :     }
    2379              : 
    2380              :   return false;
    2381              : }
    2382              : 
    2383              : /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
    2384              :    Return true if S can trap.  When INCLUDE_MEM is true, check whether
    2385              :    the memory operations could trap.  When INCLUDE_STORES is true, also
    2386              :    check a memory LHS with store semantics.  */
    2387              : 
    2388              : bool
    2389     76573277 : gimple_could_trap_p_1 (const gimple *s, bool include_mem, bool include_stores)
    2390              : {
    2391     76573277 :   tree t, div = NULL_TREE;
    2392     76573277 :   enum tree_code op;
    2393              : 
    2394     76573277 :   if (include_mem)
    2395              :     {
    2396     51684695 :       unsigned i, start = 0;
    2397              : 
    2398              :       /* Use store semantics for the LHS.  A call marked for return-slot
    2399              :          optimization can still use a temporary and a caller-side copy.  */
    2400     51684695 :       if (include_stores
    2401     47404451 :           && gimple_store_p (s)
    2402     56425672 :           && lhs_could_trap_p (gimple_get_lhs (s)))
    2403              :         return true;
    2404              : 
    2405     51998480 :       if (gimple_has_lhs (s))
    2406     51095641 :         start = 1;
    2407              : 
    2408    132103473 :       for (i = start; i < gimple_num_ops (s); i++)
    2409     85742640 :         if (tree_could_trap_p (gimple_op (s, i)))
    2410              :           return true;
    2411              :     }
    2412              : 
    2413     71249415 :   switch (gimple_code (s))
    2414              :     {
    2415        10414 :     case GIMPLE_ASM:
    2416        10414 :       return gimple_asm_volatile_p (as_a <const gasm *> (s));
    2417              : 
    2418      1591887 :     case GIMPLE_CALL:
    2419      1591887 :       {
    2420      1591887 :         if (gimple_call_internal_p (s))
    2421              :           return false;
    2422      1371653 :         t = gimple_call_fndecl (s);
    2423              :         /* Assume that indirect and calls to weak functions may trap.  */
    2424      1371653 :         if (!t || !DECL_P (t) || DECL_WEAK (t))
    2425              :           return true;
    2426              : 
    2427              :         /* Any floating point builtin operation could trap.  */
    2428      1347052 :         if (gimple_call_builtin_p (s))
    2429              :           {
    2430       987219 :             if (fndecl_built_in_p (t, BUILT_IN_NORMAL))
    2431       881488 :               switch (DECL_FUNCTION_CODE (t))
    2432              :                 {
    2433              :                 CASE_FLT_FN (BUILT_IN_COPYSIGN):
    2434              :                 CASE_FLT_FN_FLOATN_NX (BUILT_IN_COPYSIGN):
    2435              :                   return false;
    2436              :                 default:
    2437              :                   break;
    2438              :                 }
    2439       936959 :             tree type = TREE_TYPE (gimple_call_fntype (s));
    2440       936959 :             bool fp_operation = FLOAT_TYPE_P (type);
    2441        53744 :             return fp_operation && flag_trapping_math;
    2442              :           }
    2443              :         return false;
    2444              :       }
    2445     58427658 :     case GIMPLE_ASSIGN:
    2446     58427658 :       op = gimple_assign_rhs_code (s);
    2447              : 
    2448              :       /* COND_EXPR does not trap.  */
    2449     58427658 :       if (op == COND_EXPR || op == VEC_COND_EXPR)
    2450              :         return false;
    2451              : 
    2452              :       /* For comparisons we need to check rhs operand types instead of lhs type
    2453              :          (which is BOOLEAN_TYPE).  */
    2454     58319621 :       if (TREE_CODE_CLASS (op) == tcc_comparison
    2455     55722535 :           || op == FIX_TRUNC_EXPR)
    2456      2638543 :         t = TREE_TYPE (gimple_assign_rhs1 (s));
    2457              :       else
    2458     55681078 :         t = TREE_TYPE (gimple_assign_lhs (s));
    2459              : 
    2460     58319621 :       if (get_gimple_rhs_class (op) == GIMPLE_BINARY_RHS)
    2461     35192280 :         div = gimple_assign_rhs2 (s);
    2462              : 
    2463     61418083 :       return (operation_could_trap_p (op, FLOAT_TYPE_P (t),
    2464     58319621 :                                       (INTEGRAL_TYPE_P (t)
    2465     44520198 :                                        && TYPE_OVERFLOW_TRAPS (t)),
    2466     58319621 :                                       div));
    2467              : 
    2468      6381436 :     case GIMPLE_COND:
    2469      6381436 :       t = TREE_TYPE (gimple_cond_lhs (s));
    2470      6381436 :       return operation_could_trap_p (gimple_cond_code (s),
    2471     12762872 :                                      FLOAT_TYPE_P (t), false, NULL_TREE);
    2472              : 
    2473              :     default:
    2474              :       break;
    2475              :     }
    2476              : 
    2477              :   return false;
    2478              : }
    2479              : 
    2480              : /* Return true if statement S can trap.  */
    2481              : 
    2482              : bool
    2483     47404451 : gimple_could_trap_p (const gimple *s)
    2484              : {
    2485     47404451 :   return gimple_could_trap_p_1 (s, true, true);
    2486              : }
    2487              : 
    2488              : /* Return true if RHS of a GIMPLE_ASSIGN S can trap.  */
    2489              : 
    2490              : bool
    2491      3304620 : gimple_assign_rhs_could_trap_p (gimple *s)
    2492              : {
    2493      3304620 :   gcc_assert (is_gimple_assign (s));
    2494      3304620 :   return gimple_could_trap_p_1 (s, true, false);
    2495              : }
    2496              : 
    2497              : 
    2498              : /* Print debugging information for gimple stmts generated.  */
    2499              : 
    2500              : void
    2501            0 : dump_gimple_statistics (void)
    2502              : {
    2503            0 :   int i;
    2504            0 :   uint64_t total_tuples = 0, total_bytes = 0;
    2505              : 
    2506            0 :   if (! GATHER_STATISTICS)
    2507              :     {
    2508            0 :       fprintf (stderr, "No GIMPLE statistics\n");
    2509            0 :       return;
    2510              :     }
    2511              : 
    2512              :   fprintf (stderr, "\nGIMPLE statements\n");
    2513              :   fprintf (stderr, "Kind                   Stmts      Bytes\n");
    2514              :   fprintf (stderr, "---------------------------------------\n");
    2515              :   for (i = 0; i < (int) gimple_alloc_kind_all; ++i)
    2516              :     {
    2517              :       fprintf (stderr, "%-20s %7" PRIu64 "%c %10" PRIu64 "%c\n",
    2518              :                gimple_alloc_kind_names[i],
    2519              :                SIZE_AMOUNT (gimple_alloc_counts[i]),
    2520              :                SIZE_AMOUNT (gimple_alloc_sizes[i]));
    2521              :       total_tuples += gimple_alloc_counts[i];
    2522              :       total_bytes += gimple_alloc_sizes[i];
    2523              :     }
    2524              :   fprintf (stderr, "---------------------------------------\n");
    2525              :   fprintf (stderr, "%-20s %7" PRIu64 "%c %10" PRIu64 "%c\n", "Total",
    2526              :            SIZE_AMOUNT (total_tuples), SIZE_AMOUNT (total_bytes));
    2527              :   fprintf (stderr, "---------------------------------------\n");
    2528              : }
    2529              : 
    2530              : 
    2531              : /* Return the number of operands needed on the RHS of a GIMPLE
    2532              :    assignment for an expression with tree code CODE.  */
    2533              : 
    2534              : unsigned
    2535    104216383 : get_gimple_rhs_num_ops (enum tree_code code)
    2536              : {
    2537    104216383 :   switch (get_gimple_rhs_class (code))
    2538              :     {
    2539              :     case GIMPLE_UNARY_RHS:
    2540              :     case GIMPLE_SINGLE_RHS:
    2541              :       return 1;
    2542              :     case GIMPLE_BINARY_RHS:
    2543              :       return 2;
    2544              :     case GIMPLE_TERNARY_RHS:
    2545              :       return 3;
    2546            0 :     default:
    2547            0 :       gcc_unreachable ();
    2548              :     }
    2549              : }
    2550              : 
    2551              : #define DEFTREECODE(SYM, STRING, TYPE, NARGS)                               \
    2552              :   (unsigned char)                                                           \
    2553              :   ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS                                   \
    2554              :    : ((TYPE) == tcc_binary                                                  \
    2555              :       || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS                      \
    2556              :    : ((TYPE) == tcc_constant                                                \
    2557              :       || (TYPE) == tcc_declaration                                          \
    2558              :       || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS                       \
    2559              :    : ((SYM) == TRUTH_AND_EXPR                                               \
    2560              :       || (SYM) == TRUTH_OR_EXPR                                             \
    2561              :       || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS                       \
    2562              :    : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS                             \
    2563              :    : ((SYM) == COND_EXPR                                                    \
    2564              :       || (SYM) == WIDEN_MULT_PLUS_EXPR                                      \
    2565              :       || (SYM) == WIDEN_MULT_MINUS_EXPR                                     \
    2566              :       || (SYM) == DOT_PROD_EXPR                                             \
    2567              :       || (SYM) == SAD_EXPR                                                  \
    2568              :       || (SYM) == REALIGN_LOAD_EXPR                                         \
    2569              :       || (SYM) == VEC_COND_EXPR                                             \
    2570              :       || (SYM) == VEC_PERM_EXPR                                             \
    2571              :       || (SYM) == BIT_INSERT_EXPR) ? GIMPLE_TERNARY_RHS                     \
    2572              :    : ((SYM) == CONSTRUCTOR                                                  \
    2573              :       || (SYM) == OBJ_TYPE_REF                                              \
    2574              :       || (SYM) == ADDR_EXPR                                                 \
    2575              :       || (SYM) == WITH_SIZE_EXPR                                            \
    2576              :       || (SYM) == SSA_NAME                                                  \
    2577              :       || (SYM) == OMP_NEXT_VARIANT                                          \
    2578              :       || (SYM) == OMP_TARGET_DEVICE_MATCHES) ? GIMPLE_SINGLE_RHS            \
    2579              :    : GIMPLE_INVALID_RHS),
    2580              : #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
    2581              : 
    2582              : const unsigned char gimple_rhs_class_table[] = {
    2583              : #include "all-tree.def"
    2584              : };
    2585              : 
    2586              : #undef DEFTREECODE
    2587              : #undef END_OF_BASE_TREE_CODES
    2588              : 
    2589              : /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
    2590              :    the positions marked by the set ARGS_TO_SKIP.  */
    2591              : 
    2592              : gcall *
    2593            0 : gimple_call_copy_skip_args (gcall *stmt, bitmap args_to_skip)
    2594              : {
    2595            0 :   int i;
    2596            0 :   int nargs = gimple_call_num_args (stmt);
    2597            0 :   auto_vec<tree> vargs (nargs);
    2598            0 :   gcall *new_stmt;
    2599              : 
    2600            0 :   for (i = 0; i < nargs; i++)
    2601            0 :     if (!bitmap_bit_p (args_to_skip, i))
    2602            0 :       vargs.quick_push (gimple_call_arg (stmt, i));
    2603              : 
    2604            0 :   if (gimple_call_internal_p (stmt))
    2605            0 :     new_stmt = gimple_build_call_internal_vec (gimple_call_internal_fn (stmt),
    2606              :                                                vargs);
    2607              :   else
    2608            0 :     new_stmt = gimple_build_call_vec (gimple_call_fn (stmt), vargs);
    2609              : 
    2610            0 :   if (gimple_call_lhs (stmt))
    2611            0 :     gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
    2612              : 
    2613            0 :   gimple_set_vuse (new_stmt, gimple_vuse (stmt));
    2614            0 :   gimple_set_vdef (new_stmt, gimple_vdef (stmt));
    2615              : 
    2616            0 :   if (gimple_has_location (stmt))
    2617            0 :     gimple_set_location (new_stmt, gimple_location (stmt));
    2618            0 :   gimple_call_copy_flags (new_stmt, stmt);
    2619            0 :   gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
    2620              : 
    2621            0 :   gimple_set_modified (new_stmt, true);
    2622              : 
    2623            0 :   return new_stmt;
    2624            0 : }
    2625              : 
    2626              : 
    2627              : 
    2628              : /* Return true if the field decls F1 and F2 are at the same offset.
    2629              : 
    2630              :    This is intended to be used on GIMPLE types only.  */
    2631              : 
    2632              : bool
    2633     61833882 : gimple_compare_field_offset (tree f1, tree f2)
    2634              : {
    2635     61833882 :   if (DECL_OFFSET_ALIGN (f1) == DECL_OFFSET_ALIGN (f2))
    2636              :     {
    2637     61833819 :       tree offset1 = DECL_FIELD_OFFSET (f1);
    2638     61833819 :       tree offset2 = DECL_FIELD_OFFSET (f2);
    2639     61833819 :       return ((offset1 == offset2
    2640              :                /* Once gimplification is done, self-referential offsets are
    2641              :                   instantiated as operand #2 of the COMPONENT_REF built for
    2642              :                   each access and reset.  Therefore, they are not relevant
    2643              :                   anymore and fields are interchangeable provided that they
    2644              :                   represent the same access.  */
    2645            0 :                || (TREE_CODE (offset1) == PLACEHOLDER_EXPR
    2646            0 :                    && TREE_CODE (offset2) == PLACEHOLDER_EXPR
    2647            0 :                    && (DECL_SIZE (f1) == DECL_SIZE (f2)
    2648            0 :                        || (TREE_CODE (DECL_SIZE (f1)) == PLACEHOLDER_EXPR
    2649            0 :                            && TREE_CODE (DECL_SIZE (f2)) == PLACEHOLDER_EXPR)
    2650            0 :                        || operand_equal_p (DECL_SIZE (f1), DECL_SIZE (f2), 0))
    2651            0 :                    && DECL_ALIGN (f1) == DECL_ALIGN (f2))
    2652            0 :                || operand_equal_p (offset1, offset2, 0))
    2653    123667638 :               && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1),
    2654     61833819 :                                      DECL_FIELD_BIT_OFFSET (f2)));
    2655              :     }
    2656              : 
    2657              :   /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
    2658              :      should be, so handle differing ones specially by decomposing
    2659              :      the offset into a byte and bit offset manually.  */
    2660           63 :   if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1))
    2661           63 :       && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2)))
    2662              :     {
    2663           63 :       unsigned HOST_WIDE_INT byte_offset1, byte_offset2;
    2664           63 :       unsigned HOST_WIDE_INT bit_offset1, bit_offset2;
    2665           63 :       bit_offset1 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1));
    2666           63 :       byte_offset1 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1))
    2667           63 :                       + bit_offset1 / BITS_PER_UNIT);
    2668           63 :       bit_offset2 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2));
    2669           63 :       byte_offset2 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2))
    2670           63 :                       + bit_offset2 / BITS_PER_UNIT);
    2671           63 :       if (byte_offset1 != byte_offset2)
    2672              :         return false;
    2673           63 :       return bit_offset1 % BITS_PER_UNIT == bit_offset2 % BITS_PER_UNIT;
    2674              :     }
    2675              : 
    2676              :   return false;
    2677              : }
    2678              : 
    2679              : 
    2680              : /* Return a type the same as TYPE except unsigned or
    2681              :    signed according to UNSIGNEDP.  */
    2682              : 
    2683              : static tree
    2684       701020 : gimple_signed_or_unsigned_type (bool unsignedp, tree type)
    2685              : {
    2686       701020 :   tree type1;
    2687       701020 :   int i;
    2688              : 
    2689       701020 :   type1 = TYPE_MAIN_VARIANT (type);
    2690       701020 :   if (type1 == signed_char_type_node
    2691       701020 :       || type1 == char_type_node
    2692       701020 :       || type1 == unsigned_char_type_node)
    2693            0 :     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
    2694       701020 :   if (type1 == integer_type_node || type1 == unsigned_type_node)
    2695       446279 :     return unsignedp ? unsigned_type_node : integer_type_node;
    2696       254741 :   if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
    2697       232830 :     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
    2698        21911 :   if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
    2699           30 :     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
    2700        21881 :   if (type1 == long_long_integer_type_node
    2701        21792 :       || type1 == long_long_unsigned_type_node)
    2702           89 :     return unsignedp
    2703           89 :            ? long_long_unsigned_type_node
    2704            0 :            : long_long_integer_type_node;
    2705              : 
    2706        36153 :   for (i = 0; i < NUM_INT_N_ENTS; i ++)
    2707        21792 :     if (int_n_enabled_p[i]
    2708        21792 :         && (type1 == int_n_trees[i].unsigned_type
    2709        14733 :             || type1 == int_n_trees[i].signed_type))
    2710         7431 :         return unsignedp
    2711         7431 :           ? int_n_trees[i].unsigned_type
    2712         7431 :           : int_n_trees[i].signed_type;
    2713              : 
    2714              : #if HOST_BITS_PER_WIDE_INT >= 64
    2715        14361 :   if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
    2716            0 :     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
    2717              : #endif
    2718        14361 :   if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
    2719            0 :     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
    2720        14361 :   if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
    2721            0 :     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
    2722        14361 :   if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
    2723            0 :     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
    2724        14361 :   if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
    2725            0 :     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
    2726              : 
    2727              : #define GIMPLE_FIXED_TYPES(NAME)            \
    2728              :   if (type1 == short_ ## NAME ## _type_node \
    2729              :       || type1 == unsigned_short_ ## NAME ## _type_node) \
    2730              :     return unsignedp ? unsigned_short_ ## NAME ## _type_node \
    2731              :                      : short_ ## NAME ## _type_node; \
    2732              :   if (type1 == NAME ## _type_node \
    2733              :       || type1 == unsigned_ ## NAME ## _type_node) \
    2734              :     return unsignedp ? unsigned_ ## NAME ## _type_node \
    2735              :                      : NAME ## _type_node; \
    2736              :   if (type1 == long_ ## NAME ## _type_node \
    2737              :       || type1 == unsigned_long_ ## NAME ## _type_node) \
    2738              :     return unsignedp ? unsigned_long_ ## NAME ## _type_node \
    2739              :                      : long_ ## NAME ## _type_node; \
    2740              :   if (type1 == long_long_ ## NAME ## _type_node \
    2741              :       || type1 == unsigned_long_long_ ## NAME ## _type_node) \
    2742              :     return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
    2743              :                      : long_long_ ## NAME ## _type_node;
    2744              : 
    2745              : #define GIMPLE_FIXED_MODE_TYPES(NAME) \
    2746              :   if (type1 == NAME ## _type_node \
    2747              :       || type1 == u ## NAME ## _type_node) \
    2748              :     return unsignedp ? u ## NAME ## _type_node \
    2749              :                      : NAME ## _type_node;
    2750              : 
    2751              : #define GIMPLE_FIXED_TYPES_SAT(NAME) \
    2752              :   if (type1 == sat_ ## short_ ## NAME ## _type_node \
    2753              :       || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
    2754              :     return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
    2755              :                      : sat_ ## short_ ## NAME ## _type_node; \
    2756              :   if (type1 == sat_ ## NAME ## _type_node \
    2757              :       || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
    2758              :     return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
    2759              :                      : sat_ ## NAME ## _type_node; \
    2760              :   if (type1 == sat_ ## long_ ## NAME ## _type_node \
    2761              :       || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
    2762              :     return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
    2763              :                      : sat_ ## long_ ## NAME ## _type_node; \
    2764              :   if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
    2765              :       || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
    2766              :     return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
    2767              :                      : sat_ ## long_long_ ## NAME ## _type_node;
    2768              : 
    2769              : #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME)       \
    2770              :   if (type1 == sat_ ## NAME ## _type_node \
    2771              :       || type1 == sat_ ## u ## NAME ## _type_node) \
    2772              :     return unsignedp ? sat_ ## u ## NAME ## _type_node \
    2773              :                      : sat_ ## NAME ## _type_node;
    2774              : 
    2775        14361 :   GIMPLE_FIXED_TYPES (fract);
    2776        14361 :   GIMPLE_FIXED_TYPES_SAT (fract);
    2777        14361 :   GIMPLE_FIXED_TYPES (accum);
    2778        14361 :   GIMPLE_FIXED_TYPES_SAT (accum);
    2779              : 
    2780        14361 :   GIMPLE_FIXED_MODE_TYPES (qq);
    2781        14361 :   GIMPLE_FIXED_MODE_TYPES (hq);
    2782        14361 :   GIMPLE_FIXED_MODE_TYPES (sq);
    2783        14361 :   GIMPLE_FIXED_MODE_TYPES (dq);
    2784        14361 :   GIMPLE_FIXED_MODE_TYPES (tq);
    2785        14361 :   GIMPLE_FIXED_MODE_TYPES_SAT (qq);
    2786        14361 :   GIMPLE_FIXED_MODE_TYPES_SAT (hq);
    2787        14361 :   GIMPLE_FIXED_MODE_TYPES_SAT (sq);
    2788        14361 :   GIMPLE_FIXED_MODE_TYPES_SAT (dq);
    2789        14361 :   GIMPLE_FIXED_MODE_TYPES_SAT (tq);
    2790        14361 :   GIMPLE_FIXED_MODE_TYPES (ha);
    2791        14361 :   GIMPLE_FIXED_MODE_TYPES (sa);
    2792        14361 :   GIMPLE_FIXED_MODE_TYPES (da);
    2793        14361 :   GIMPLE_FIXED_MODE_TYPES (ta);
    2794        14361 :   GIMPLE_FIXED_MODE_TYPES_SAT (ha);
    2795        14361 :   GIMPLE_FIXED_MODE_TYPES_SAT (sa);
    2796        14361 :   GIMPLE_FIXED_MODE_TYPES_SAT (da);
    2797        14361 :   GIMPLE_FIXED_MODE_TYPES_SAT (ta);
    2798              : 
    2799              :   /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
    2800              :      the precision; they have precision set to match their range, but
    2801              :      may use a wider mode to match an ABI.  If we change modes, we may
    2802              :      wind up with bad conversions.  For INTEGER_TYPEs in C, must check
    2803              :      the precision as well, so as to yield correct results for
    2804              :      bit-field types.  C++ does not have these separate bit-field
    2805              :      types, and producing a signed or unsigned variant of an
    2806              :      ENUMERAL_TYPE may cause other problems as well.  */
    2807        14361 :   if (!INTEGRAL_TYPE_P (type)
    2808        14361 :       || TYPE_UNSIGNED (type) == unsignedp)
    2809              :     return type;
    2810              : 
    2811        14361 :   if (BITINT_TYPE_P (type))
    2812            0 :     return build_bitint_type (TYPE_PRECISION (type), unsignedp);
    2813              : 
    2814              : #define TYPE_OK(node)                                                       \
    2815              :   (TYPE_MODE (type) == TYPE_MODE (node)                                     \
    2816              :    && TYPE_PRECISION (type) == TYPE_PRECISION (node))
    2817        14361 :   if (TYPE_OK (signed_char_type_node))
    2818          517 :     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
    2819        13844 :   if (TYPE_OK (integer_type_node))
    2820         3569 :     return unsignedp ? unsigned_type_node : integer_type_node;
    2821        10275 :   if (TYPE_OK (short_integer_type_node))
    2822         4754 :     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
    2823         5521 :   if (TYPE_OK (long_integer_type_node))
    2824            6 :     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
    2825         5515 :   if (TYPE_OK (long_long_integer_type_node))
    2826            0 :     return (unsignedp
    2827            0 :             ? long_long_unsigned_type_node
    2828            0 :             : long_long_integer_type_node);
    2829              : 
    2830        11003 :   for (i = 0; i < NUM_INT_N_ENTS; i ++)
    2831         5515 :     if (int_n_enabled_p[i]
    2832         5515 :         && TYPE_MODE (type) == int_n_data[i].m
    2833         5542 :         && TYPE_PRECISION (type) == int_n_data[i].bitsize)
    2834           27 :         return unsignedp
    2835           27 :           ? int_n_trees[i].unsigned_type
    2836           27 :           : int_n_trees[i].signed_type;
    2837              : 
    2838              : #if HOST_BITS_PER_WIDE_INT >= 64
    2839         5488 :   if (TYPE_OK (intTI_type_node))
    2840            0 :     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
    2841              : #endif
    2842         5488 :   if (TYPE_OK (intDI_type_node))
    2843            0 :     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
    2844         5488 :   if (TYPE_OK (intSI_type_node))
    2845            0 :     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
    2846         5488 :   if (TYPE_OK (intHI_type_node))
    2847            0 :     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
    2848         5488 :   if (TYPE_OK (intQI_type_node))
    2849            0 :     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
    2850              : 
    2851              : #undef GIMPLE_FIXED_TYPES
    2852              : #undef GIMPLE_FIXED_MODE_TYPES
    2853              : #undef GIMPLE_FIXED_TYPES_SAT
    2854              : #undef GIMPLE_FIXED_MODE_TYPES_SAT
    2855              : #undef TYPE_OK
    2856              : 
    2857         5488 :   return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
    2858              : }
    2859              : 
    2860              : 
    2861              : /* Return an unsigned type the same as TYPE in other respects.  */
    2862              : 
    2863              : tree
    2864            0 : gimple_unsigned_type (tree type)
    2865              : {
    2866            0 :   return gimple_signed_or_unsigned_type (true, type);
    2867              : }
    2868              : 
    2869              : 
    2870              : /* Return a signed type the same as TYPE in other respects.  */
    2871              : 
    2872              : tree
    2873       701020 : gimple_signed_type (tree type)
    2874              : {
    2875       701020 :   return gimple_signed_or_unsigned_type (false, type);
    2876              : }
    2877              : 
    2878              : 
    2879              : /* Return the typed-based alias set for T, which may be an expression
    2880              :    or a type.  Return -1 if we don't do anything special.  */
    2881              : 
    2882              : alias_set_type
    2883      9070331 : gimple_get_alias_set (tree t)
    2884              : {
    2885              :   /* That's all the expressions we handle specially.  */
    2886      9070331 :   if (!TYPE_P (t))
    2887              :     return -1;
    2888              : 
    2889              :   /* For convenience, follow the C standard when dealing with
    2890              :      character types.  Any object may be accessed via an lvalue that
    2891              :      has character type.  */
    2892      2616679 :   if (t == char_type_node
    2893      2055296 :       || t == signed_char_type_node
    2894      2055296 :       || t == unsigned_char_type_node)
    2895              :     return 0;
    2896              : 
    2897              :   /* Allow aliasing between signed and unsigned variants of the same
    2898              :      type.  We treat the signed variant as canonical.  BITINT_TYPEs
    2899              :      are handled by canonical type merging.  */
    2900      2055296 :   if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
    2901              :     {
    2902       700112 :       tree t1 = gimple_signed_type (t);
    2903              : 
    2904              :       /* t1 == t can happen for boolean nodes which are always unsigned.  */
    2905       700112 :       if (t1 != t)
    2906       700112 :         return get_alias_set (t1);
    2907              :     }
    2908              : 
    2909              :   /* Allow aliasing between enumeral types and the underlying
    2910              :      integer type.  This is required for C since those are
    2911              :      compatible types.  */
    2912      1355184 :   else if (TREE_CODE (t) == ENUMERAL_TYPE)
    2913              :     {
    2914            0 :       tree t1 = lang_hooks.types.type_for_size (tree_to_uhwi (TYPE_SIZE (t)),
    2915              :                                                 false /* short-cut above */);
    2916            0 :       return get_alias_set (t1);
    2917              :     }
    2918              : 
    2919              :   return -1;
    2920              : }
    2921              : 
    2922              : 
    2923              : /* Return true when STMTs arguments and return value match those of FNDECL,
    2924              :    a decl of a builtin function.  */
    2925              : 
    2926              : bool
    2927    295385023 : gimple_builtin_call_types_compatible_p (const gimple *stmt, tree fndecl)
    2928              : {
    2929    295385023 :   gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN);
    2930              : 
    2931    295385023 :   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
    2932    293001351 :     if (tree decl = builtin_decl_explicit (DECL_FUNCTION_CODE (fndecl)))
    2933    295385023 :       fndecl = decl;
    2934              : 
    2935    295385023 :   tree ret = gimple_call_lhs (stmt);
    2936    295385023 :   if (ret
    2937    477779435 :       && !useless_type_conversion_p (TREE_TYPE (ret),
    2938    182394412 :                                      TREE_TYPE (TREE_TYPE (fndecl))))
    2939              :     return false;
    2940              : 
    2941    295363040 :   tree targs = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
    2942    295363040 :   unsigned nargs = gimple_call_num_args (stmt);
    2943   1209286347 :   for (unsigned i = 0; i < nargs; ++i)
    2944              :     {
    2945              :       /* Variadic args follow.  */
    2946    652572287 :       if (!targs)
    2947              :         return true;
    2948    623735733 :       tree arg = gimple_call_arg (stmt, i);
    2949    623735733 :       tree type = TREE_VALUE (targs);
    2950    623735733 :       if (!useless_type_conversion_p (type, TREE_TYPE (arg)))
    2951              :         return false;
    2952    618560267 :       targs = TREE_CHAIN (targs);
    2953              :     }
    2954    521877965 :   if (targs && !VOID_TYPE_P (TREE_VALUE (targs)))
    2955         7153 :     return false;
    2956              :   return true;
    2957              : }
    2958              : 
    2959              : /* Return true when STMT is operator a replaceable delete call.  */
    2960              : 
    2961              : bool
    2962      2532178 : gimple_call_operator_delete_p (const gcall *stmt)
    2963              : {
    2964      2532178 :   tree fndecl;
    2965              : 
    2966      2532178 :   if ((fndecl = gimple_call_fndecl (stmt)) != NULL_TREE)
    2967      2532178 :     return DECL_IS_OPERATOR_DELETE_P (fndecl);
    2968              :   return false;
    2969              : }
    2970              : 
    2971              : /* Return true when STMT is builtins call.  */
    2972              : 
    2973              : bool
    2974     71135399 : gimple_call_builtin_p (const gimple *stmt)
    2975              : {
    2976     71135399 :   tree fndecl;
    2977     71135399 :   if (is_gimple_call (stmt)
    2978     22339862 :       && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
    2979     92198169 :       && DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN)
    2980      4986433 :     return gimple_builtin_call_types_compatible_p (stmt, fndecl);
    2981              :   return false;
    2982              : }
    2983              : 
    2984              : /* Return true when STMT is builtins call to CLASS.  */
    2985              : 
    2986              : bool
    2987   1049865568 : gimple_call_builtin_p (const gimple *stmt, enum built_in_class klass)
    2988              : {
    2989   1049865568 :   tree fndecl;
    2990   1049865568 :   if (is_gimple_call (stmt)
    2991    797863042 :       && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
    2992   1810158624 :       && DECL_BUILT_IN_CLASS (fndecl) == klass)
    2993    198156271 :     return gimple_builtin_call_types_compatible_p (stmt, fndecl);
    2994              :   return false;
    2995              : }
    2996              : 
    2997              : /* Return true when STMT is builtins call to CODE of CLASS.  */
    2998              : 
    2999              : bool
    3000   3005687095 : gimple_call_builtin_p (const gimple *stmt, enum built_in_function code)
    3001              : {
    3002   3005687095 :   tree fndecl;
    3003   3005687095 :   if (is_gimple_call (stmt)
    3004    897027830 :       && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
    3005   3859640430 :       && fndecl_built_in_p (fndecl, code))
    3006      2632663 :     return gimple_builtin_call_types_compatible_p (stmt, fndecl);
    3007              :   return false;
    3008              : }
    3009              : 
    3010              : /* If CALL is a call to a combined_fn (i.e. an internal function or
    3011              :    a normal built-in function), return its code, otherwise return
    3012              :    CFN_LAST.  */
    3013              : 
    3014              : combined_fn
    3015    191041845 : gimple_call_combined_fn (const gimple *stmt)
    3016              : {
    3017    191041845 :   if (const gcall *call = dyn_cast <const gcall *> (stmt))
    3018              :     {
    3019    190837771 :       if (gimple_call_internal_p (call))
    3020      8959959 :         return as_combined_fn (gimple_call_internal_fn (call));
    3021              : 
    3022    181877812 :       tree fndecl = gimple_call_fndecl (stmt);
    3023    181877812 :       if (fndecl
    3024    175421409 :           && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL)
    3025    253946042 :           && gimple_builtin_call_types_compatible_p (stmt, fndecl))
    3026     71474909 :         return as_combined_fn (DECL_FUNCTION_CODE (fndecl));
    3027              :     }
    3028              :   return CFN_LAST;
    3029              : }
    3030              : 
    3031              : /* Return true if STMT clobbers memory.  STMT is required to be a
    3032              :    GIMPLE_ASM.  */
    3033              : 
    3034              : bool
    3035     10744113 : gimple_asm_clobbers_memory_p (const gasm *stmt)
    3036              : {
    3037     10744113 :   unsigned i;
    3038              : 
    3039     14792482 :   for (i = 0; i < gimple_asm_nclobbers (stmt); i++)
    3040              :     {
    3041      8443356 :       tree op = gimple_asm_clobber_op (stmt, i);
    3042      8443356 :       if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op)), "memory") == 0)
    3043              :         return true;
    3044              :     }
    3045              : 
    3046              :   /* Non-empty basic ASM implicitly clobbers memory.  */
    3047      6349126 :   if (gimple_asm_basic_p (stmt) && strlen (gimple_asm_string (stmt)) != 0)
    3048        80348 :     return true;
    3049              : 
    3050              :   return false;
    3051              : }
    3052              : 
    3053              : /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE.  */
    3054              : 
    3055              : void
    3056         5343 : dump_decl_set (FILE *file, bitmap set)
    3057              : {
    3058         5343 :   if (set)
    3059              :     {
    3060         5343 :       bitmap_iterator bi;
    3061         5343 :       unsigned i;
    3062              : 
    3063         5343 :       fprintf (file, "{ ");
    3064              : 
    3065        22240 :       EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi)
    3066              :         {
    3067        16897 :           fprintf (file, "D.%u", i);
    3068        16897 :           fprintf (file, " ");
    3069              :         }
    3070              : 
    3071         5343 :       fprintf (file, "}");
    3072              :     }
    3073              :   else
    3074            0 :     fprintf (file, "NIL");
    3075         5343 : }
    3076              : 
    3077              : /* Return true when CALL is a call stmt that definitely doesn't
    3078              :    free any memory or makes it unavailable otherwise.  */
    3079              : bool
    3080     10142810 : nonfreeing_call_p (gimple *call)
    3081              : {
    3082     10142810 :   if (gimple_call_builtin_p (call, BUILT_IN_NORMAL)
    3083     10142810 :       && gimple_call_flags (call) & ECF_LEAF)
    3084      4426430 :     switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call)))
    3085              :       {
    3086              :         /* Just in case these become ECF_LEAF in the future.  */
    3087              :         case BUILT_IN_FREE:
    3088              :         case BUILT_IN_TM_FREE:
    3089              :         case BUILT_IN_REALLOC:
    3090              :         case BUILT_IN_STACK_RESTORE:
    3091              :         case BUILT_IN_GOMP_FREE:
    3092              :         case BUILT_IN_GOMP_REALLOC:
    3093              :           return false;
    3094      4221725 :         default:
    3095      4221725 :           return true;
    3096              :       }
    3097      5716380 :   else if (gimple_call_internal_p (call))
    3098       776577 :     switch (gimple_call_internal_fn (call))
    3099              :       {
    3100              :       case IFN_ABNORMAL_DISPATCHER:
    3101              :         return true;
    3102        35669 :       case IFN_ASAN_MARK:
    3103        35669 :         return tree_to_uhwi (gimple_call_arg (call, 0)) == ASAN_MARK_UNPOISON;
    3104       734766 :       default:
    3105       734766 :         if (gimple_call_flags (call) & ECF_LEAF)
    3106              :           return true;
    3107       148466 :         return false;
    3108              :       }
    3109              : 
    3110      4939803 :   tree fndecl = gimple_call_fndecl (call);
    3111      4939803 :   if (!fndecl)
    3112              :     return false;
    3113      4778973 :   struct cgraph_node *n = cgraph_node::get (fndecl);
    3114      4778973 :   if (!n)
    3115              :     return false;
    3116      4777595 :   enum availability availability;
    3117      4777595 :   n = n->function_symbol (&availability);
    3118      4777595 :   if (!n || availability <= AVAIL_INTERPOSABLE)
    3119              :     return false;
    3120      1155824 :   return n->nonfreeing_fn;
    3121              : }
    3122              : 
    3123              : /* Return true when CALL is a call stmt that definitely need not
    3124              :    be considered to be a memory barrier.  */
    3125              : bool
    3126      1655715 : nonbarrier_call_p (gimple *call)
    3127              : {
    3128      1655715 :   if (gimple_call_flags (call) & (ECF_PURE | ECF_CONST))
    3129       635759 :     return true;
    3130              :   /* Should extend this to have a nonbarrier_fn flag, just as above in
    3131              :      the nonfreeing case.  */
    3132              :   return false;
    3133              : }
    3134              : 
    3135              : /* Callback for walk_stmt_load_store_ops.
    3136              : 
    3137              :    Return TRUE if OP will dereference the tree stored in DATA, FALSE
    3138              :    otherwise.
    3139              : 
    3140              :    This routine only makes a superficial check for a dereference.  Thus
    3141              :    it must only be used if it is safe to return a false negative.  */
    3142              : static bool
    3143     78139672 : check_loadstore (gimple *stmt, tree op, tree, void *data)
    3144              : {
    3145    156279344 :   if (TREE_CODE (op) == MEM_REF
    3146     78139672 :       || (TREE_CODE (op) == TARGET_MEM_REF
    3147      1378842 :           && !TMR_INDEX2 (op)
    3148      1362815 :           && (!TMR_INDEX (op)
    3149       649892 :               || (TMR_STEP (op)
    3150       590378 :                   && expr_not_equal_to (TMR_STEP (op),
    3151     78730050 :                                         wi::one (TYPE_PRECISION (TREE_TYPE
    3152              :                                                         (TMR_STEP (op)))),
    3153              :                                         stmt)))))
    3154              :     {
    3155              :       /* Some address spaces may legitimately dereference zero.  */
    3156     40363057 :       addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (op));
    3157     40363057 :       if (targetm.addr_space.zero_address_valid (as))
    3158              :         return false;
    3159              : 
    3160     40361951 :       return operand_equal_p (TREE_OPERAND (op, 0), (tree)data, 0);
    3161              :     }
    3162              :   return false;
    3163              : }
    3164              : 
    3165              : 
    3166              : /* Return true if OP can be inferred to be non-NULL after STMT executes,
    3167              :    either by using a pointer dereference or attributes.  */
    3168              : bool
    3169            0 : infer_nonnull_range (gimple *stmt, tree op)
    3170              : {
    3171            0 :   return (infer_nonnull_range_by_dereference (stmt, op)
    3172            0 :           || infer_nonnull_range_by_attribute (stmt, op));
    3173              : }
    3174              : 
    3175              : /* Return true if OP can be inferred to be non-NULL after STMT
    3176              :    executes by using a pointer dereference.  */
    3177              : bool
    3178    347352472 : infer_nonnull_range_by_dereference (gimple *stmt, tree op)
    3179              : {
    3180              :   /* We can only assume that a pointer dereference will yield
    3181              :      non-NULL if -fdelete-null-pointer-checks is enabled.  */
    3182    347352472 :   if (!flag_delete_null_pointer_checks
    3183    347138252 :       || !POINTER_TYPE_P (TREE_TYPE (op))
    3184    347138252 :       || gimple_code (stmt) == GIMPLE_ASM
    3185    694063550 :       || gimple_clobber_p (stmt))
    3186              :     return false;
    3187              : 
    3188    339392974 :   if (walk_stmt_load_store_ops (stmt, (void *)op,
    3189              :                                 check_loadstore, check_loadstore))
    3190              :     return true;
    3191              : 
    3192              :   return false;
    3193              : }
    3194              : 
    3195              : /* Return true if OP can be inferred to be a non-NULL after STMT
    3196              :    executes by using attributes.  If OP2 and OP3 are non-NULL and
    3197              :    nonnull_if_nonzero is the only attribute implying OP being non-NULL
    3198              :    and the corresponding argument(s) aren't non-zero INTEGER_CST, set *OP2
    3199              :    and *OP3 to the corresponding arguments and return true (in that case
    3200              :    returning true doesn't mean OP can be unconditionally inferred to be
    3201              :    non-NULL, but conditionally).  */
    3202              : bool
    3203     78391192 : infer_nonnull_range_by_attribute (gimple *stmt, tree op, tree *op2, tree *op3)
    3204              : {
    3205     78391192 :   if (op2)
    3206              :     {
    3207         3934 :       *op2 = NULL_TREE;
    3208         3934 :       *op3 = NULL_TREE;
    3209              :     }
    3210              : 
    3211              :   /* We can only assume that a pointer dereference will yield
    3212              :      non-NULL if -fdelete-null-pointer-checks is enabled.  */
    3213     78391192 :   if (!flag_delete_null_pointer_checks
    3214     78362437 :       || !POINTER_TYPE_P (TREE_TYPE (op))
    3215    156753629 :       || gimple_code (stmt) == GIMPLE_ASM)
    3216              :     return false;
    3217              : 
    3218     78311668 :   if (is_gimple_call (stmt) && !gimple_call_internal_p (stmt))
    3219              :     {
    3220      4498421 :       tree fntype = gimple_call_fntype (stmt);
    3221      4498421 :       tree attrs = TYPE_ATTRIBUTES (fntype);
    3222      4596552 :       for (; attrs; attrs = TREE_CHAIN (attrs))
    3223              :         {
    3224      1170435 :           attrs = lookup_attribute ("nonnull", attrs);
    3225              : 
    3226              :           /* If "nonnull" wasn't specified, we know nothing about
    3227              :              the argument, unless "nonnull_if_nonzero" attribute is
    3228              :              present.  */
    3229      1170435 :           if (attrs == NULL_TREE)
    3230              :             break;
    3231              : 
    3232              :           /* If "nonnull" applies to all the arguments, then ARG
    3233              :              is non-null if it's in the argument list.  */
    3234       256584 :           if (TREE_VALUE (attrs) == NULL_TREE)
    3235              :             {
    3236       460817 :               for (unsigned int i = 0; i < gimple_call_num_args (stmt); i++)
    3237              :                 {
    3238       311190 :                   if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt, i)))
    3239       303464 :                       && operand_equal_p (op, gimple_call_arg (stmt, i), 0))
    3240              :                     return true;
    3241              :                 }
    3242              :               return false;
    3243              :             }
    3244              : 
    3245              :           /* Now see if op appears in the nonnull list.  */
    3246       248031 :           for (tree t = TREE_VALUE (attrs); t; t = TREE_CHAIN (t))
    3247              :             {
    3248       149900 :               unsigned int idx = TREE_INT_CST_LOW (TREE_VALUE (t)) - 1;
    3249       149900 :               if (idx < gimple_call_num_args (stmt))
    3250              :                 {
    3251       149899 :                   tree arg = gimple_call_arg (stmt, idx);
    3252       149899 :                   if (operand_equal_p (op, arg, 0))
    3253              :                     return true;
    3254              :                 }
    3255              :             }
    3256              :         }
    3257              : 
    3258      4339968 :       for (attrs = TYPE_ATTRIBUTES (fntype);
    3259      4537062 :            (attrs = lookup_attribute ("nonnull_if_nonzero", attrs));
    3260       197094 :            attrs = TREE_CHAIN (attrs))
    3261              :         {
    3262       197905 :           tree args = TREE_VALUE (attrs);
    3263       197905 :           unsigned int idx = TREE_INT_CST_LOW (TREE_VALUE (args)) - 1;
    3264       197905 :           unsigned int idx2
    3265       197905 :             = TREE_INT_CST_LOW (TREE_VALUE (TREE_CHAIN (args))) - 1;
    3266       197905 :           unsigned int idx3 = idx2;
    3267       197905 :           if (tree chain2 = TREE_CHAIN (TREE_CHAIN (args)))
    3268         4348 :             idx3 = TREE_INT_CST_LOW (TREE_VALUE (chain2)) - 1;
    3269       197905 :           if (idx < gimple_call_num_args (stmt)
    3270       197893 :               && idx2 < gimple_call_num_args (stmt)
    3271       197882 :               && idx3 < gimple_call_num_args (stmt)
    3272       395787 :               && operand_equal_p (op, gimple_call_arg (stmt, idx), 0))
    3273              :             {
    3274          811 :               tree arg2 = gimple_call_arg (stmt, idx2);
    3275          811 :               tree arg3 = gimple_call_arg (stmt, idx3);
    3276         1622 :               if (!INTEGRAL_TYPE_P (TREE_TYPE (arg2))
    3277         1622 :                   || !INTEGRAL_TYPE_P (TREE_TYPE (arg3)))
    3278              :                 return false;
    3279          811 :               if (integer_nonzerop (arg2) && integer_nonzerop (arg3))
    3280              :                 return true;
    3281          589 :               if (integer_zerop (arg2) || integer_zerop (arg3))
    3282              :                 return false;
    3283          499 :               if (op2)
    3284              :                 {
    3285              :                   /* This case is meant for ubsan instrumentation.
    3286              :                      The caller can check at runtime if *OP2 and *OP3 are
    3287              :                      non-zero and OP is null.  */
    3288          132 :                   *op2 = arg2;
    3289          132 :                   *op3 = arg3;
    3290          132 :                   return true;
    3291              :                 }
    3292          367 :               return tree_expr_nonzero_p (arg2) && tree_expr_nonzero_p (arg3);
    3293              :             }
    3294              :         }
    3295              :     }
    3296              : 
    3297              :   /* If this function is marked as returning non-null, then we can
    3298              :      infer OP is non-null if it is used in the return statement.  */
    3299     78152404 :   if (greturn *return_stmt = dyn_cast <greturn *> (stmt))
    3300       965519 :     if (gimple_return_retval (return_stmt)
    3301       556240 :         && operand_equal_p (gimple_return_retval (return_stmt), op, 0)
    3302      1059547 :         && lookup_attribute ("returns_nonnull",
    3303        94028 :                              TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
    3304              :       return true;
    3305              : 
    3306              :   return false;
    3307              : }
    3308              : 
    3309              : /* Compare two case labels.  Because the front end should already have
    3310              :    made sure that case ranges do not overlap, it is enough to only compare
    3311              :    the CASE_LOW values of each case label.  */
    3312              : 
    3313              : static int
    3314     43835769 : compare_case_labels (const void *p1, const void *p2)
    3315              : {
    3316     43835769 :   const_tree const case1 = *(const_tree const*)p1;
    3317     43835769 :   const_tree const case2 = *(const_tree const*)p2;
    3318              : 
    3319              :   /* The 'default' case label always goes first.  */
    3320     43835769 :   if (!CASE_LOW (case1))
    3321              :     return -1;
    3322     43835769 :   else if (!CASE_LOW (case2))
    3323              :     return 1;
    3324              :   else
    3325     43835769 :     return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
    3326              : }
    3327              : 
    3328              : /* Sort the case labels in LABEL_VEC in place in ascending order.  */
    3329              : 
    3330              : void
    3331        72191 : sort_case_labels (vec<tree> &label_vec)
    3332              : {
    3333        72191 :   label_vec.qsort (compare_case_labels);
    3334        72191 : }
    3335              : 
    3336              : /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
    3337              : 
    3338              :    LABELS is a vector that contains all case labels to look at.
    3339              : 
    3340              :    INDEX_TYPE is the type of the switch index expression.  Case labels
    3341              :    in LABELS are discarded if their values are not in the value range
    3342              :    covered by INDEX_TYPE.  The remaining case label values are folded
    3343              :    to INDEX_TYPE.
    3344              : 
    3345              :    If a default case exists in LABELS, it is removed from LABELS and
    3346              :    returned in DEFAULT_CASEP.  If no default case exists, but the
    3347              :    case labels already cover the whole range of INDEX_TYPE, a default
    3348              :    case is returned pointing to one of the existing case labels.
    3349              :    Otherwise DEFAULT_CASEP is set to NULL_TREE.
    3350              : 
    3351              :    DEFAULT_CASEP may be NULL, in which case the above comment doesn't
    3352              :    apply and no action is taken regardless of whether a default case is
    3353              :    found or not.  */
    3354              : 
    3355              : void
    3356        62609 : preprocess_case_label_vec_for_gimple (vec<tree> &labels,
    3357              :                                       tree index_type,
    3358              :                                       tree *default_casep)
    3359              : {
    3360        62609 :   tree min_value, max_value;
    3361        62609 :   tree default_case = NULL_TREE;
    3362        62609 :   size_t i, len;
    3363              : 
    3364        62609 :   i = 0;
    3365        62609 :   min_value = TYPE_MIN_VALUE (index_type);
    3366        62609 :   max_value = TYPE_MAX_VALUE (index_type);
    3367      1160152 :   while (i < labels.length ())
    3368              :     {
    3369      1097543 :       tree elt = labels[i];
    3370      1097543 :       tree low = CASE_LOW (elt);
    3371      1097543 :       tree high = CASE_HIGH (elt);
    3372      1097543 :       bool remove_element = false;
    3373              : 
    3374      1097543 :       if (low)
    3375              :         {
    3376      1061852 :           gcc_checking_assert (TREE_CODE (low) == INTEGER_CST);
    3377      1061852 :           gcc_checking_assert (!high || TREE_CODE (high) == INTEGER_CST);
    3378              : 
    3379              :           /* This is a non-default case label, i.e. it has a value.
    3380              : 
    3381              :              See if the case label is reachable within the range of
    3382              :              the index type.  Remove out-of-range case values.  Turn
    3383              :              case ranges into a canonical form (high > low strictly)
    3384              :              and convert the case label values to the index type.
    3385              : 
    3386              :              NB: The type of gimple_switch_index() may be the promoted
    3387              :              type, but the case labels retain the original type.  */
    3388              : 
    3389        12824 :           if (high)
    3390              :             {
    3391              :               /* This is a case range.  Discard empty ranges.
    3392              :                  If the bounds or the range are equal, turn this
    3393              :                  into a simple (one-value) case.  */
    3394        12824 :               int cmp = tree_int_cst_compare (high, low);
    3395        12824 :               if (cmp < 0)
    3396              :                 remove_element = true;
    3397        12824 :               else if (cmp == 0)
    3398              :                 high = NULL_TREE;
    3399              :             }
    3400              : 
    3401      1050703 :           if (! high)
    3402              :             {
    3403              :               /* If the simple case value is unreachable, ignore it.  */
    3404      1060177 :               if ((TREE_CODE (min_value) == INTEGER_CST
    3405      1060177 :                    && tree_int_cst_compare (low, min_value) < 0)
    3406      2120311 :                   || (TREE_CODE (max_value) == INTEGER_CST
    3407      1060134 :                       && tree_int_cst_compare (low, max_value) > 0))
    3408              :                 remove_element = true;
    3409              :               else
    3410      1060016 :                 low = fold_convert (index_type, low);
    3411              :             }
    3412              :           else
    3413              :             {
    3414              :               /* If the entire case range is unreachable, ignore it.  */
    3415         1675 :               if ((TREE_CODE (min_value) == INTEGER_CST
    3416         1675 :                    && tree_int_cst_compare (high, min_value) < 0)
    3417         3338 :                   || (TREE_CODE (max_value) == INTEGER_CST
    3418         1663 :                       && tree_int_cst_compare (low, max_value) > 0))
    3419              :                 remove_element = true;
    3420              :               else
    3421              :                 {
    3422              :                   /* If the lower bound is less than the index type's
    3423              :                      minimum value, truncate the range bounds.  */
    3424         1663 :                   if (TREE_CODE (min_value) == INTEGER_CST
    3425         1663 :                       && tree_int_cst_compare (low, min_value) < 0)
    3426              :                     low = min_value;
    3427         1663 :                   low = fold_convert (index_type, low);
    3428              : 
    3429              :                   /* If the upper bound is greater than the index type's
    3430              :                      maximum value, truncate the range bounds.  */
    3431         1663 :                   if (TREE_CODE (max_value) == INTEGER_CST
    3432         1663 :                       && tree_int_cst_compare (high, max_value) > 0)
    3433              :                     high = max_value;
    3434         1663 :                   high = fold_convert (index_type, high);
    3435              : 
    3436              :                   /* We may have folded a case range to a one-value case.  */
    3437         1663 :                   if (tree_int_cst_equal (low, high))
    3438            0 :                     high = NULL_TREE;
    3439              :                 }
    3440              :             }
    3441              : 
    3442      1061852 :           CASE_LOW (elt) = low;
    3443      1061852 :           CASE_HIGH (elt) = high;
    3444              :         }
    3445              :       else
    3446              :         {
    3447        35691 :           gcc_assert (!default_case);
    3448        35691 :           default_case = elt;
    3449              :           /* The default case must be passed separately to the
    3450              :              gimple_build_switch routine.  But if DEFAULT_CASEP
    3451              :              is NULL, we do not remove the default case (it would
    3452              :              be completely lost).  */
    3453        35691 :           if (default_casep)
    3454              :             remove_element = true;
    3455              :         }
    3456              : 
    3457      1061852 :       if (remove_element)
    3458        35864 :         labels.ordered_remove (i);
    3459              :       else
    3460      1061679 :         i++;
    3461              :     }
    3462        62609 :   len = i;
    3463              : 
    3464        62609 :   if (!labels.is_empty ())
    3465        61729 :     sort_case_labels (labels);
    3466              : 
    3467        62609 :   if (default_casep && !default_case)
    3468              :     {
    3469              :       /* If the switch has no default label, add one, so that we jump
    3470              :          around the switch body.  If the labels already cover the whole
    3471              :          range of the switch index_type, add the default label pointing
    3472              :          to one of the existing labels.  */
    3473        15116 :       if (len
    3474        14635 :           && TYPE_MIN_VALUE (index_type)
    3475        14635 :           && TYPE_MAX_VALUE (index_type)
    3476        29751 :           && tree_int_cst_equal (CASE_LOW (labels[0]),
    3477        14635 :                                  TYPE_MIN_VALUE (index_type)))
    3478              :         {
    3479         4442 :           tree low, high = CASE_HIGH (labels[len - 1]);
    3480         4442 :           if (!high)
    3481         4399 :             high = CASE_LOW (labels[len - 1]);
    3482         4442 :           if (tree_int_cst_equal (high, TYPE_MAX_VALUE (index_type)))
    3483              :             {
    3484           62 :               tree widest_label = labels[0];
    3485          131 :               for (i = 1; i < len; i++)
    3486              :                 {
    3487           83 :                   high = CASE_LOW (labels[i]);
    3488           83 :                   low = CASE_HIGH (labels[i - 1]);
    3489           83 :                   if (!low)
    3490           53 :                     low = CASE_LOW (labels[i - 1]);
    3491              : 
    3492           83 :                   if (CASE_HIGH (labels[i]) != NULL_TREE
    3493          114 :                       && (CASE_HIGH (widest_label) == NULL_TREE
    3494           26 :                           || (wi::gtu_p
    3495           52 :                               (wi::to_wide (CASE_HIGH (labels[i]))
    3496           78 :                                - wi::to_wide (CASE_LOW (labels[i])),
    3497           26 :                                wi::to_wide (CASE_HIGH (widest_label))
    3498          161 :                                - wi::to_wide (CASE_LOW (widest_label))))))
    3499           17 :                     widest_label = labels[i];
    3500              : 
    3501           83 :                   if (wi::to_wide (low) + 1 != wi::to_wide (high))
    3502              :                     break;
    3503              :                 }
    3504           62 :               if (i == len)
    3505              :                 {
    3506              :                   /* Designate the label with the widest range to be the
    3507              :                      default label.  */
    3508           48 :                   tree label = CASE_LABEL (widest_label);
    3509           48 :                   default_case = build_case_label (NULL_TREE, NULL_TREE,
    3510              :                                                    label);
    3511              :                 }
    3512              :             }
    3513              :         }
    3514              :     }
    3515              : 
    3516        62609 :   if (default_casep)
    3517        50807 :     *default_casep = default_case;
    3518        62609 : }
    3519              : 
    3520              : /* Set the location of all statements in SEQ to LOC.  */
    3521              : 
    3522              : void
    3523      1064856 : gimple_seq_set_location (gimple_seq seq, location_t loc)
    3524              : {
    3525      2162051 :   for (gimple_stmt_iterator i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
    3526      1097195 :     gimple_set_location (gsi_stmt (i), loc);
    3527      1064856 : }
    3528              : 
    3529              : /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements.  */
    3530              : 
    3531              : void
    3532    804347999 : gimple_seq_discard (gimple_seq seq)
    3533              : {
    3534    804347999 :   gimple_stmt_iterator gsi;
    3535              : 
    3536    804923292 :   for (gsi = gsi_start (seq); !gsi_end_p (gsi); )
    3537              :     {
    3538       387898 :       gimple *stmt = gsi_stmt (gsi);
    3539       387898 :       gsi_remove (&gsi, true);
    3540       387898 :       release_defs (stmt);
    3541       387898 :       ggc_free (stmt);
    3542              :     }
    3543    804347999 : }
    3544              : 
    3545              : /* See if STMT now calls function that takes no parameters and if so, drop
    3546              :    call arguments.  This is used when devirtualization machinery redirects
    3547              :    to __builtin_unreachable or __cxa_pure_virtual.  */
    3548              : 
    3549              : void
    3550      1151714 : maybe_remove_unused_call_args (struct function *fn, gimple *stmt)
    3551              : {
    3552      1151714 :   tree decl = gimple_call_fndecl (stmt);
    3553      1151714 :   if (TYPE_ARG_TYPES (TREE_TYPE (decl))
    3554      1150876 :       && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))) == void_type_node
    3555      1388293 :       && gimple_call_num_args (stmt))
    3556              :     {
    3557       120804 :       gimple_set_num_ops (stmt, 3);
    3558       120804 :       update_stmt_fn (fn, stmt);
    3559              :     }
    3560      1151714 : }
    3561              : 
    3562              : /* Return false if STMT will likely expand to real function call.  */
    3563              : 
    3564              : bool
    3565      3411882 : gimple_inexpensive_call_p (gcall *stmt)
    3566              : {
    3567      3411882 :   if (gimple_call_internal_p (stmt))
    3568              :     return true;
    3569      3352851 :   tree decl = gimple_call_fndecl (stmt);
    3570      3352851 :   if (decl && is_inexpensive_builtin (decl))
    3571              :     return true;
    3572              :   return false;
    3573              : }
    3574              : 
    3575              : /* Return a non-artificial location for STMT.  If STMT does not have
    3576              :    location information, get the location from EXPR.  */
    3577              : 
    3578              : location_t
    3579       119359 : gimple_or_expr_nonartificial_location (gimple *stmt, tree expr)
    3580              : {
    3581       119359 :   location_t loc = gimple_nonartificial_location (stmt);
    3582       119359 :   if (loc == UNKNOWN_LOCATION && EXPR_HAS_LOCATION (expr))
    3583           46 :     loc = tree_nonartificial_location (expr);
    3584       119359 :   return expansion_point_location_if_in_system_header (loc);
    3585              : }
    3586              : 
    3587              : 
    3588              : #if CHECKING_P
    3589              : 
    3590              : namespace selftest {
    3591              : 
    3592              : /* Selftests for core gimple structures.  */
    3593              : 
    3594              : /* Verify that STMT is pretty-printed as EXPECTED.
    3595              :    Helper function for selftests.  */
    3596              : 
    3597              : static void
    3598           20 : verify_gimple_pp (const char *expected, gimple *stmt)
    3599              : {
    3600           20 :   pretty_printer pp;
    3601           20 :   pp_gimple_stmt_1 (&pp, stmt, 0 /* spc */, TDF_NONE /* flags */);
    3602           20 :   ASSERT_STREQ (expected, pp_formatted_text (&pp));
    3603           20 : }
    3604              : 
    3605              : /* Build a GIMPLE_ASSIGN equivalent to
    3606              :      tmp = 5;
    3607              :    and verify various properties of it.  */
    3608              : 
    3609              : static void
    3610            4 : test_assign_single ()
    3611              : {
    3612            4 :   tree type = integer_type_node;
    3613            4 :   tree lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
    3614              :                          get_identifier ("tmp"),
    3615              :                          type);
    3616            4 :   tree rhs = build_int_cst (type, 5);
    3617            4 :   gassign *stmt = gimple_build_assign (lhs, rhs);
    3618            4 :   verify_gimple_pp ("tmp = 5;", stmt);
    3619              : 
    3620            4 :   ASSERT_TRUE (is_gimple_assign (stmt));
    3621            4 :   ASSERT_EQ (lhs, gimple_assign_lhs (stmt));
    3622            4 :   ASSERT_EQ (lhs, gimple_get_lhs (stmt));
    3623            4 :   ASSERT_EQ (rhs, gimple_assign_rhs1 (stmt));
    3624            4 :   ASSERT_EQ (NULL, gimple_assign_rhs2 (stmt));
    3625            4 :   ASSERT_EQ (NULL, gimple_assign_rhs3 (stmt));
    3626            4 :   ASSERT_TRUE (gimple_assign_single_p (stmt));
    3627            8 :   ASSERT_EQ (INTEGER_CST, gimple_assign_rhs_code (stmt));
    3628            4 : }
    3629              : 
    3630              : /* Build a GIMPLE_ASSIGN equivalent to
    3631              :      tmp = a * b;
    3632              :    and verify various properties of it.  */
    3633              : 
    3634              : static void
    3635            4 : test_assign_binop ()
    3636              : {
    3637            4 :   tree type = integer_type_node;
    3638            4 :   tree lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
    3639              :                          get_identifier ("tmp"),
    3640              :                          type);
    3641            4 :   tree a = build_decl (UNKNOWN_LOCATION, VAR_DECL,
    3642              :                        get_identifier ("a"),
    3643              :                        type);
    3644            4 :   tree b = build_decl (UNKNOWN_LOCATION, VAR_DECL,
    3645              :                        get_identifier ("b"),
    3646              :                        type);
    3647            4 :   gassign *stmt = gimple_build_assign (lhs, MULT_EXPR, a, b);
    3648            4 :   verify_gimple_pp ("tmp = a * b;", stmt);
    3649              : 
    3650            4 :   ASSERT_TRUE (is_gimple_assign (stmt));
    3651            4 :   ASSERT_EQ (lhs, gimple_assign_lhs (stmt));
    3652            4 :   ASSERT_EQ (lhs, gimple_get_lhs (stmt));
    3653            4 :   ASSERT_EQ (a, gimple_assign_rhs1 (stmt));
    3654            8 :   ASSERT_EQ (b, gimple_assign_rhs2 (stmt));
    3655            4 :   ASSERT_EQ (NULL, gimple_assign_rhs3 (stmt));
    3656            4 :   ASSERT_FALSE (gimple_assign_single_p (stmt));
    3657            4 :   ASSERT_EQ (MULT_EXPR, gimple_assign_rhs_code (stmt));
    3658            4 : }
    3659              : 
    3660              : /* Verify that GIMPLE trap queries distinguish a register definition and a
    3661              :    trapping store from their nontrapping right-hand sides.  */
    3662              : 
    3663              : static void
    3664            4 : test_could_trap ()
    3665              : {
    3666            4 :   tree reg_lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
    3667              :                              get_identifier ("readonly_reg"),
    3668              :                              integer_type_node);
    3669            4 :   TREE_READONLY (reg_lhs) = 1;
    3670            4 :   gassign *stmt = gimple_build_assign (reg_lhs, integer_one_node);
    3671              : 
    3672            4 :   ASSERT_FALSE (gimple_store_p (stmt));
    3673            4 :   ASSERT_FALSE (gimple_could_trap_p (stmt));
    3674            4 :   ASSERT_FALSE (gimple_assign_rhs_could_trap_p (stmt));
    3675              : 
    3676            4 :   tree mem_lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
    3677              :                              get_identifier ("readonly_mem"),
    3678              :                              integer_type_node);
    3679            4 :   TREE_READONLY (mem_lhs) = 1;
    3680            4 :   TREE_STATIC (mem_lhs) = 1;
    3681            4 :   TREE_ADDRESSABLE (mem_lhs) = 1;
    3682            4 :   stmt = gimple_build_assign (mem_lhs, integer_one_node);
    3683              : 
    3684            4 :   ASSERT_TRUE (gimple_store_p (stmt));
    3685            4 :   ASSERT_TRUE (gimple_could_trap_p (stmt));
    3686            4 :   ASSERT_FALSE (gimple_assign_rhs_could_trap_p (stmt));
    3687              : 
    3688            4 :   tree record_type = make_node (RECORD_TYPE);
    3689            4 :   tree field = build_decl (UNKNOWN_LOCATION, FIELD_DECL,
    3690              :                            get_identifier ("value"), integer_type_node);
    3691            4 :   DECL_CONTEXT (field) = record_type;
    3692            4 :   TYPE_FIELDS (record_type) = field;
    3693            4 :   layout_type (record_type);
    3694              : 
    3695            4 :   tree call_lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
    3696              :                               get_identifier ("readonly_call_mem"),
    3697              :                               record_type);
    3698            4 :   TREE_READONLY (call_lhs) = 1;
    3699            4 :   TREE_STATIC (call_lhs) = 1;
    3700            4 :   TREE_ADDRESSABLE (call_lhs) = 1;
    3701              : 
    3702            4 :   tree fn_type = build_function_type_list (record_type, NULL_TREE);
    3703            4 :   tree fn = build_fn_decl ("nothrow_call", fn_type);
    3704            4 :   gcall *call = gimple_build_call (fn, 0);
    3705            4 :   gimple_call_set_lhs (call, call_lhs);
    3706            4 :   gimple_call_set_nothrow (call, true);
    3707              : 
    3708            4 :   ASSERT_TRUE (gimple_store_p (call));
    3709            4 :   ASSERT_TRUE (gimple_could_trap_p (call));
    3710            4 :   ASSERT_FALSE (gimple_could_trap_p_1 (call, true, false));
    3711              : 
    3712            4 :   gimple_call_set_return_slot_opt (call, true);
    3713            4 :   ASSERT_TRUE (gimple_could_trap_p (call));
    3714            4 :   ASSERT_FALSE (gimple_could_trap_p_1 (call, true, false));
    3715            4 : }
    3716              : 
    3717              : /* Build a GIMPLE_NOP and verify various properties of it.  */
    3718              : 
    3719              : static void
    3720            4 : test_nop_stmt ()
    3721              : {
    3722            4 :   gimple *stmt = gimple_build_nop ();
    3723            4 :   verify_gimple_pp ("GIMPLE_NOP", stmt);
    3724            4 :   ASSERT_EQ (GIMPLE_NOP, gimple_code (stmt));
    3725            4 :   ASSERT_EQ (NULL, gimple_get_lhs (stmt));
    3726            4 :   ASSERT_FALSE (gimple_assign_single_p (stmt));
    3727            4 : }
    3728              : 
    3729              : /* Build a GIMPLE_RETURN equivalent to
    3730              :      return 7;
    3731              :    and verify various properties of it.  */
    3732              : 
    3733              : static void
    3734            4 : test_return_stmt ()
    3735              : {
    3736            4 :   tree type = integer_type_node;
    3737            4 :   tree val = build_int_cst (type, 7);
    3738            4 :   greturn *stmt = gimple_build_return (val);
    3739            4 :   verify_gimple_pp ("return 7;", stmt);
    3740              : 
    3741            4 :   ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt));
    3742            4 :   ASSERT_EQ (NULL, gimple_get_lhs (stmt));
    3743            4 :   ASSERT_EQ (val, gimple_return_retval (stmt));
    3744            4 :   ASSERT_FALSE (gimple_assign_single_p (stmt));
    3745            4 : }
    3746              : 
    3747              : /* Build a GIMPLE_RETURN equivalent to
    3748              :      return;
    3749              :    and verify various properties of it.  */
    3750              : 
    3751              : static void
    3752            4 : test_return_without_value ()
    3753              : {
    3754            4 :   greturn *stmt = gimple_build_return (NULL);
    3755            4 :   verify_gimple_pp ("return;", stmt);
    3756              : 
    3757            4 :   ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt));
    3758            4 :   ASSERT_EQ (NULL, gimple_get_lhs (stmt));
    3759            4 :   ASSERT_EQ (NULL, gimple_return_retval (stmt));
    3760            4 :   ASSERT_FALSE (gimple_assign_single_p (stmt));
    3761            4 : }
    3762              : 
    3763              : /* Run all of the selftests within this file.  */
    3764              : 
    3765              : void
    3766            4 : gimple_cc_tests ()
    3767              : {
    3768            4 :   test_assign_single ();
    3769            4 :   test_assign_binop ();
    3770            4 :   test_could_trap ();
    3771            4 :   test_nop_stmt ();
    3772            4 :   test_return_stmt ();
    3773            4 :   test_return_without_value ();
    3774            4 : }
    3775              : 
    3776              : } // namespace selftest
    3777              : 
    3778              : 
    3779              : #endif /* CHECKING_P */
        

Generated by: LCOV version 2.5.0-beta

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,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.